ValidateTest::testNotPositiveQuantity() - Code Metrics - Inspection of "Update dependencies" - simondubois/unsplash-downloader - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fe0371...1946fd )

by Simon

created 2016-03-15 12:39 UTC

ValidateTest::testNotPositiveQuantity() A

↳ Parent: ValidateTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	12
rs	9.4285
cc	2
eloc	8
nc	2
nop	0

<?php namespace Tests;

use Exception;
use InvalidArgumentException;
use org\bovigo\vfs\vfsStream;
use PHPUnit_Framework_TestCase;
use Simondubois\UnsplashDownloader\Validate;

class ValidateTest extends PHPUnit_Framework_TestCase
{
    /**
     * Test Simondubois\UnsplashDownloader\Validate::quantity()
     */
    public function testNotNumericQuantity() {
        $validate = new Validate();

        $exceptionCode = null;
        try {
            $validate->quantity('abc');
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_QUANTITY_NOTNUMERIC, $exceptionCode);
    }


    /**
     * Test Simondubois\UnsplashDownloader\Validate::quantity()
     */
    public function testNotPositiveQuantity() {
        $validate = new Validate();

        $exceptionCode = null;
        try {
            $validate->quantity('-1');
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_QUANTITY_NOTPOSITIVE, $exceptionCode);
    }


    /**
     * Test Simondubois\UnsplashDownloader\Validate::quantity()
     */
    public function testTooHighQuantity() {
        $validate = new Validate();

        $exceptionCode = null;
        try {
            $validate->quantity('101');
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_QUANTITY_TOOHIGH, $exceptionCode);
    }


    /**
     * Test Simondubois\UnsplashDownloader\Validate::quantity()
     */
    public function testValidQuantity() {
        $validate = new Validate();

        $this->assertEquals(1, $validate->quantity('1'));
        $this->assertEquals(10, $validate->quantity('10'));
        $this->assertEquals(100, $validate->quantity('100'));
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::destination()
     */
    public function testNotDirectoryDestination() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $existingFile = $root.'/existingFile';
        touch($existingFile);

        $exceptionCode = null;
        try {
            $validate->destination($existingFile);
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_DESTINATION_NOTDIR, $exceptionCode);
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::destination()
     */
    public function testMissingFolderDestination() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $missingFolder = $root.'/missingFolder';

        $exceptionCode = null;
        try {
            $validate->destination($missingFolder);
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_DESTINATION_NOTDIR, $exceptionCode);
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::destination()
     */
    public function testUnwritableDestination() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $unwritableFolder = $root.'/unwritableFolder';
        mkdir($unwritableFolder, 0000);

        $exceptionCode = null;
        try {
            $validate->destination($unwritableFolder);
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_DESTINATION_UNWRITABLE, $exceptionCode);
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::destination()
     */
    public function testSuccessfulDestination() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $existingFolder = $root.'/existingFolder';
        mkdir($existingFolder);

        $this->assertEquals($existingFolder, $validate->destination($existingFolder));
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::history()
     */
    public function testNotFileHistory() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $existingFolder = $root.'/existingFolder';
        mkdir($existingFolder);

        $exceptionCode = null;
        try {
            $validate->history($existingFolder);
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }
        $this->assertEquals(Validate::ERROR_HISTORY_NOTFILE, $exceptionCode);
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::history()
     */
    public function testUnwritableHistory() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $unwritableFolder = $root.'/unwritableFolder';
        mkdir($unwritableFolder, 0000);
        $unwritableFile = $unwritableFolder.'/unwritableFile';

        $exceptionCode = null;
        try {
            $validate->history($unwritableFile);
        } catch (InvalidArgumentException $exception) {
            $exceptionCode = $exception->getCode();
        }

        $this->assertEquals(Validate::ERROR_HISTORY_NOTRW, $exceptionCode);
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::history()
     */
    public function testValidHistory() {
        $validate = new Validate();

        $root = vfsStream::setup('test')->url();
        $existingFile = $root.'/existingFile';
        $missingFile = $root.'/missingFile';
        touch($existingFile);

        $this->assertNull($validate->history(null));
        $this->assertEquals($existingFile, $validate->history($existingFile));
        $this->assertEquals($missingFile, $validate->history($missingFile));
    }

    /**
     * Test Simondubois\UnsplashDownloader\Validate::category()
     */
    public function testValidCategory() {
        $validate = new Validate();

        $this->assertNull($validate->category(null));
        $this->assertEquals(1, $validate->category('1'));
        $this->assertEquals(0, $validate->category('abc'));
    }

}


1			<?php namespace Tests;
2
3			use Exception;
4			use InvalidArgumentException;
5			use org\bovigo\vfs\vfsStream;
6			use PHPUnit_Framework_TestCase;
7			use Simondubois\UnsplashDownloader\Validate;
8
9			class ValidateTest extends PHPUnit_Framework_TestCase
10			{
11			/**
12			* Test Simondubois\UnsplashDownloader\Validate::quantity()
13			*/
14			public function testNotNumericQuantity() {
15			$validate = new Validate();
16
17			$exceptionCode = null;
18			try {
19			$validate->quantity('abc');
20			} catch (InvalidArgumentException $exception) {
21			$exceptionCode = $exception->getCode();
22			}
23
24			$this->assertEquals(Validate::ERROR_QUANTITY_NOTNUMERIC, $exceptionCode);
25			}
26
27
28			/**
29			* Test Simondubois\UnsplashDownloader\Validate::quantity()
30			*/
31			public function testNotPositiveQuantity() {
32			$validate = new Validate();
33
34			$exceptionCode = null;
35			try {
36			$validate->quantity('-1');
37			} catch (InvalidArgumentException $exception) {
38			$exceptionCode = $exception->getCode();
39			}
40
41			$this->assertEquals(Validate::ERROR_QUANTITY_NOTPOSITIVE, $exceptionCode);
42			}
43
44
45			/**
46			* Test Simondubois\UnsplashDownloader\Validate::quantity()
47			*/
48			public function testTooHighQuantity() {
49			$validate = new Validate();
50
51			$exceptionCode = null;
52			try {
53			$validate->quantity('101');
54			} catch (InvalidArgumentException $exception) {
55			$exceptionCode = $exception->getCode();
56			}
57
58			$this->assertEquals(Validate::ERROR_QUANTITY_TOOHIGH, $exceptionCode);
59			}
60
61
62			/**
63			* Test Simondubois\UnsplashDownloader\Validate::quantity()
64			*/
65			public function testValidQuantity() {
66			$validate = new Validate();
67
68			$this->assertEquals(1, $validate->quantity('1'));
69			$this->assertEquals(10, $validate->quantity('10'));
70			$this->assertEquals(100, $validate->quantity('100'));
71			}
72
73			/**
74			* Test Simondubois\UnsplashDownloader\Validate::destination()
75			*/
76			public function testNotDirectoryDestination() {
77			$validate = new Validate();
78
79			$root = vfsStream::setup('test')->url();
80			$existingFile = $root.'/existingFile';
81			touch($existingFile);
82
83			$exceptionCode = null;
84			try {
85			$validate->destination($existingFile);
86			} catch (InvalidArgumentException $exception) {
87			$exceptionCode = $exception->getCode();
88			}
89
90			$this->assertEquals(Validate::ERROR_DESTINATION_NOTDIR, $exceptionCode);
91			}
92
93			/**
94			* Test Simondubois\UnsplashDownloader\Validate::destination()
95			*/
96			public function testMissingFolderDestination() {
97			$validate = new Validate();
98
99			$root = vfsStream::setup('test')->url();
100			$missingFolder = $root.'/missingFolder';
101
102			$exceptionCode = null;
103			try {
104			$validate->destination($missingFolder);
105			} catch (InvalidArgumentException $exception) {
106			$exceptionCode = $exception->getCode();
107			}
108
109			$this->assertEquals(Validate::ERROR_DESTINATION_NOTDIR, $exceptionCode);
110			}
111
112			/**
113			* Test Simondubois\UnsplashDownloader\Validate::destination()
114			*/
115			public function testUnwritableDestination() {
116			$validate = new Validate();
117
118			$root = vfsStream::setup('test')->url();
119			$unwritableFolder = $root.'/unwritableFolder';
120			mkdir($unwritableFolder, 0000);
121
122			$exceptionCode = null;
123			try {
124			$validate->destination($unwritableFolder);
125			} catch (InvalidArgumentException $exception) {
126			$exceptionCode = $exception->getCode();
127			}
128
129			$this->assertEquals(Validate::ERROR_DESTINATION_UNWRITABLE, $exceptionCode);
130			}
131
132			/**
133			* Test Simondubois\UnsplashDownloader\Validate::destination()
134			*/
135			public function testSuccessfulDestination() {
136			$validate = new Validate();
137
138			$root = vfsStream::setup('test')->url();
139			$existingFolder = $root.'/existingFolder';
140			mkdir($existingFolder);
141
142			$this->assertEquals($existingFolder, $validate->destination($existingFolder));
143			}
144
145			/**
146			* Test Simondubois\UnsplashDownloader\Validate::history()
147			*/
148			public function testNotFileHistory() {
149			$validate = new Validate();
150
151			$root = vfsStream::setup('test')->url();
152			$existingFolder = $root.'/existingFolder';
153			mkdir($existingFolder);
154
155			$exceptionCode = null;
156			try {
157			$validate->history($existingFolder);
158			} catch (InvalidArgumentException $exception) {
159			$exceptionCode = $exception->getCode();
160			}
161			$this->assertEquals(Validate::ERROR_HISTORY_NOTFILE, $exceptionCode);
162			}
163
164			/**
165			* Test Simondubois\UnsplashDownloader\Validate::history()
166			*/
167			public function testUnwritableHistory() {
168			$validate = new Validate();
169
170			$root = vfsStream::setup('test')->url();
171			$unwritableFolder = $root.'/unwritableFolder';
172			mkdir($unwritableFolder, 0000);
173			$unwritableFile = $unwritableFolder.'/unwritableFile';
174
175			$exceptionCode = null;
176			try {
177			$validate->history($unwritableFile);
178			} catch (InvalidArgumentException $exception) {
179			$exceptionCode = $exception->getCode();
180			}
181
182			$this->assertEquals(Validate::ERROR_HISTORY_NOTRW, $exceptionCode);
183			}
184
185			/**
186			* Test Simondubois\UnsplashDownloader\Validate::history()
187			*/
188			public function testValidHistory() {
189			$validate = new Validate();
190
191			$root = vfsStream::setup('test')->url();
192			$existingFile = $root.'/existingFile';
193			$missingFile = $root.'/missingFile';
194			touch($existingFile);
195
196			$this->assertNull($validate->history(null));
197			$this->assertEquals($existingFile, $validate->history($existingFile));
198			$this->assertEquals($missingFile, $validate->history($missingFile));
199			}
200
201			/**
202			* Test Simondubois\UnsplashDownloader\Validate::category()
203			*/
204			public function testValidCategory() {
205			$validate = new Validate();
206
207			$this->assertNull($validate->category(null));
208			$this->assertEquals(1, $validate->category('1'));
209			$this->assertEquals(0, $validate->category('abc'));
210			}
211
212			}
213

simondubois / unsplash-downloader

Push — master ( fe0371...1946fd )

ValidateTest::testNotPositiveQuantity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like