Cleanup phpunit configs and PSR-4 autoloading and namespaces for tests

tests/Unit/FFProbe/DataMapping/AbstractDataTest.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\FFProbe\DataMapping;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\FFProbe\DataMapping\AbstractData;
+
+class AbstractDataTest extends TestCase
+{
+    public function testHas()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $this->assertTrue($imp->has('key1'));
+        $this->assertTrue($imp->has('key2'));
+        $this->assertFalse($imp->has('value1'));
+        $this->assertFalse($imp->has('key3'));
+    }
+
+    public function testGet()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $this->assertEquals('value1', $imp->get('key1'));
+        $this->assertEquals('value2', $imp->get('key2'));
+    }
+
+    public function testGetDefault()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+        $this->assertSame('yololo', $imp->get('key3', 'yololo'));
+    }
+
+    public function testKeys()
+    {
+        $imp = new Implementation(array('key1' => 'value1', 'key2' => 'value2'));
+
+        $this->assertEquals(array('key1', 'key2'), $imp->keys());
+    }
+
+    public function testAll()
+    {
+        $values = array('key1' => 'value1', 'key2' => 'value2');
+        $imp = new Implementation($values);
+
+        $this->assertEquals($values, $imp->all());
+    }
+}
+
+class Implementation extends AbstractData
+{
+}

tests/Unit/FFProbe/DataMapping/StreamCollectionTest.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\FFProbe\DataMapping;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+
+class StreamCollectionTest extends TestCase
+{
+    public function testAdd()
+    {
+        $stream = $this->getStreamMock();
+
+        $collection = new StreamCollection();
+        $this->assertEquals(array(), $collection->all());
+        $collection->add($stream);
+        $this->assertEquals(array($stream), $collection->all());
+        $collection->add($stream);
+        $this->assertEquals(array($stream, $stream), $collection->all());
+    }
+
+    public function testVideos()
+    {
+        $audio = $this->getStreamMock();
+        $audio->expects($this->once())
+            ->method('isVideo')
+            ->will($this->returnValue(false));
+
+        $video = $this->getStreamMock();
+        $video->expects($this->once())
+            ->method('isVideo')
+            ->will($this->returnValue(true));
+
+        $collection = new StreamCollection(array($audio, $video));
+        $videos = $collection->videos();
+
+        $this->assertInstanceOf('FFMpeg\FFProbe\DataMapping\StreamCollection', $videos);
+        $this->assertCount(1, $videos);
+        $this->assertEquals(array($video), $videos->all());
+    }
+
+    public function testAudios()
+    {
+        $audio = $this->getStreamMock();
+        $audio->expects($this->once())
+            ->method('isAudio')
+            ->will($this->returnValue(true));
+
+        $video = $this->getStreamMock();
+        $video->expects($this->once())
+            ->method('isAudio')
+            ->will($this->returnValue(false));
+
+        $collection = new StreamCollection(array($audio, $video));
+        $audios = $collection->audios();
+
+        $this->assertInstanceOf('FFMpeg\FFProbe\DataMapping\StreamCollection', $audios);
+        $this->assertCount(1, $audios);
+        $this->assertEquals(array($audio), $audios->all());
+    }
+
+    public function testCount()
+    {
+        $stream = $this->getStreamMock();
+
+        $collection = new StreamCollection(array($stream));
+        $this->assertCount(1, $collection);
+    }
+
+    public function testGetIterator()
+    {
+        $audio = $this->getStreamMock();
+        $video = $this->getStreamMock();
+
+        $collection = new StreamCollection(array($audio, $video));
+        $this->assertInstanceOf('\Iterator', $collection->getIterator());
+        $this->assertCount(2, $collection->getIterator());
+    }
+
+    public function testFirst()
+    {
+        $stream1 = $this->getStreamMock();
+        $stream2 = $this->getStreamMock();
+
+        $coll = new StreamCollection(array($stream1, $stream2));
+
+        $this->assertSame($stream1, $coll->first());
+    }
+}

tests/Unit/FFProbe/DataMapping/StreamTest.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\FFProbe\DataMapping;
+
+use FFMpeg\Coordinate\Dimension;
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\FFProbe\DataMapping\Stream;
+
+class StreamTest extends TestCase
+{
+    /**
+     * @dataProvider provideAudioCases
+     */
+    public function testIsAudio($isAudio, $properties)
+    {
+        $stream = new Stream($properties);
+        $this->assertTrue($isAudio === $stream->isAudio());
+    }
+
+    public function provideAudioCases()
+    {
+        return array(
+            array(true, array('codec_type' => 'audio')),
+            array(false, array('codec_type' => 'video')),
+        );
+    }
+
+    /**
+     * @dataProvider provideVideoCases
+     */
+    public function testIsVideo($isVideo, $properties)
+    {
+        $stream = new Stream($properties);
+        $this->assertTrue($isVideo === $stream->isVideo());
+    }
+
+    public function provideVideoCases()
+    {
+        return array(
+            array(true, array('codec_type' => 'video')),
+            array(false, array('codec_type' => 'audio')),
+        );
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\LogicException
+     * @expectedExceptionMessage Dimensions can only be retrieved from video streams.
+     */
+    public function testGetDimensionsFromAudio()
+    {
+        $stream = new Stream(array('codec_type' => 'audio'));
+        $stream->getDimensions();
+    }
+
+    public function testGetDimensionsFromVideo()
+    {
+        $stream = new Stream(array('codec_type' => 'video', 'width' => 960, 'height' => 720));
+        $this->assertEquals(new Dimension(960, 720), $stream->getDimensions());
+    }
+
+    /**
+     * @dataProvider provideInvalidPropertiesForDimensionsExtraction
+     * @expectedException FFMpeg\Exception\RuntimeException
+     * @expectedExceptionMessage Unable to extract dimensions.
+     */
+    public function testUnableToGetDimensionsFromVideo($properties)
+    {
+        $stream = new Stream(array('codec_type' => 'video', 'width' => 960));
+        $stream->getDimensions();
+    }
+
+    public function provideInvalidPropertiesForDimensionsExtraction()
+    {
+        return array(
+            array('codec_type' => 'video', 'width' => 960),
+            array('codec_type' => 'video', 'height' => 960),
+        );
+    }
+
+    /**
+     * @dataProvider providePropertiesForDimensionsExtraction
+     */
+    public function testGetDimensionsFromVideoWithDisplayRatio($data)
+    {
+        $stream = new Stream(array(
+            'codec_type' => 'video',
+            'width' => $data['width'],
+            'height' =>  $data['height'],
+            'sample_aspect_ratio' =>  $data['sar'],
+            'display_aspect_ratio' =>  $data['dar']
+        ));
+        $this->assertEquals(new Dimension($data['result_width'], $data['result_height']), $stream->getDimensions());
+    }
+
+    /**
+     * @dataProvider provideInvalidRatios
+     */
+    public function testGetDimensionsFromVideoWithInvalidDisplayRatio($invalidRatio)
+    {
+        $stream = new Stream(array('codec_type' => 'video', 'width' => 960, 'height' => 720, 'sample_aspect_ratio' => $invalidRatio, 'display_aspect_ratio' => '16:9'));
+        $this->assertEquals(new Dimension(960, 720), $stream->getDimensions());
+    }
+
+    public function provideInvalidRatios()
+    {
+        return array(array('0:1'), array('2:1:3'));
+    }
+
+    public function providePropertiesForDimensionsExtraction()
+    {
+        return array(
+            array(
+                array('width' => '960', 'height' => '720',
+                'sar' => '4:3', 'dar' => '16:9',
+                'result_width' => '1280', 'result_height' => '720'),
+            ),
+            array(
+                array('width' => '1920', 'height' => '1080',
+                'sar' => '1:1', 'dar' => '16:9',
+                'result_width' => '1920', 'result_height' => '1080'),
+            ),
+            array(
+                array('width' => '640', 'height' => '480',
+                'sar' => '75:74', 'dar' => '50:37',
+                'result_width' => '649', 'result_height' => '480'),
+            ),
+            array(
+                array('width' => '720', 'height' => '576',
+                  'sar' => '52:28', 'dar' => '16:9',
+                  'result_width' => '1337', 'result_height' => '752'),
+            ),
+        );
+    }
+}

tests/Unit/FFProbe/MapperTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\FFProbe;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\FFProbe\Mapper;
+use FFMpeg\FFProbe;
+use FFMpeg\FFProbe\DataMapping\Format;
+use FFMpeg\FFProbe\DataMapping\Stream;
+use FFMpeg\FFProbe\DataMapping\StreamCollection;
+
+class MapperTest extends TestCase
+{
+    /**
+     * @dataProvider provideMappings
+     */
+    public function testMap($type, $data, $expected)
+    {
+        $mapper = new Mapper();
+        $this->assertEquals($expected, $mapper->map($type, $data));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testMapInvalidArgument()
+    {
+        $mapper = new Mapper();
+        $mapper->map('cool type', 'data');
+    }
+
+    public function provideMappings()
+    {
+        $format = json_decode(file_get_contents(__DIR__ . '/../../fixtures/ffprobe/show_format.json'), true);
+        $streams = json_decode(file_get_contents(__DIR__ . '/../../fixtures/ffprobe/show_streams.json'), true);
+
+        return array(
+            array(FFProbe::TYPE_FORMAT, $format, new Format($format['format'])),
+            array(FFProbe::TYPE_STREAMS, $streams, new StreamCollection(array_map(function ($streamData) {
+                return new Stream($streamData);
+            }, $streams['streams']))),
+        );
+    }
+}

tests/Unit/FFProbe/OptionsTesterTest.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\FFProbe;
+
+use Alchemy\BinaryDriver\Exception\ExecutionFailureException;
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\FFProbe\OptionsTester;
+
+class OptionsTesterTest extends TestCase
+{
+    /**
+     * @expectedException FFMpeg\Exception\RuntimeException
+     * @expectedExceptionMessage Your FFProbe version is too old and does not support `-help` option, please upgrade.
+     */
+    public function testHasOptionWithOldFFProbe()
+    {
+        $cache = $this->getCacheMock();
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->once())
+            ->method('command')
+            ->with(array('-help', '-loglevel', 'quiet'))
+            ->will($this->throwException(new ExecutionFailureException('Failed to execute')));
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $tester->has('-print_format');
+    }
+
+    /**
+     * @dataProvider provideOptions
+     */
+    public function testHasOptionWithCacheEmpty($isPresent, $data, $optionName)
+    {
+        $cache = $this->getCacheMock();
+
+        $cache->expects($this->never())
+            ->method('fetch');
+
+        $cache->expects($this->exactly(2))
+            ->method('contains')
+            ->will($this->returnValue(false));
+
+        $cache->expects($this->exactly(2))
+            ->method('save');
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->once())
+            ->method('command')
+            ->with(array('-help', '-loglevel', 'quiet'))
+            ->will($this->returnValue($data));
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $this->assertTrue($isPresent === $tester->has($optionName));
+    }
+
+    public function provideOptions()
+    {
+        $data = file_get_contents(__DIR__ . '/../../fixtures/ffprobe/help.raw');
+
+        return array(
+            array(true, $data, '-print_format'),
+            array(false, $data, '-another_print_format'),
+        );
+    }
+
+    /**
+     * @dataProvider provideOptions
+     */
+    public function testHasOptionWithHelpCacheLoaded($isPresent, $data, $optionName)
+    {
+        $cache = $this->getCacheMock();
+
+        $cache->expects($this->once())
+            ->method('fetch')
+            ->will($this->returnValue($data));
+
+        $cache->expects($this->at(0))
+            ->method('contains')
+            ->will($this->returnValue(false));
+
+        $cache->expects($this->at(1))
+            ->method('contains')
+            ->will($this->returnValue(true));
+
+        $cache->expects($this->once())
+            ->method('save');
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->never())
+            ->method('command');
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $this->assertTrue($isPresent === $tester->has($optionName));
+    }
+
+    /**
+     * @dataProvider provideOptions
+     */
+    public function testHasOptionWithCacheFullyLoaded($isPresent, $data, $optionName)
+    {
+        $cache = $this->getCacheMock();
+
+        $cache->expects($this->once())
+            ->method('fetch')
+            ->with('option-' . $optionName)
+            ->will($this->returnValue($isPresent));
+
+        $cache->expects($this->once())
+            ->method('contains')
+            ->with('option-' . $optionName)
+            ->will($this->returnValue(true));
+
+        $ffprobe = $this->getFFProbeDriverMock();
+        $ffprobe->expects($this->never())
+            ->method('command');
+
+        $tester = new OptionsTester($ffprobe, $cache);
+        $this->assertTrue($isPresent === $tester->has($optionName));
+    }
+}

tests/Unit/FFProbe/OutputParserTest.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Tests\FFMpeg\Unit\FFProbe;
+
+use Tests\FFMpeg\Unit\TestCase;
+use FFMpeg\FFProbe\OutputParser;
+use FFMpeg\FFProbe;
+
+class OutputParserTest extends TestCase
+{
+    /**
+     * @dataProvider provideTypeDataAndOutput
+     */
+    public function testParse($type, $data, $expectedOutput)
+    {
+        $parser = new OutputParser();
+        $this->assertEquals($expectedOutput, $parser->parse($type, $data));
+    }
+
+    /**
+     * @expectedException FFMpeg\Exception\InvalidArgumentException
+     */
+    public function testParseWithInvalidArgument()
+    {
+        $parser = new OutputParser();
+        $parser->parse('comme ca', 'data');
+    }
+
+    public function provideTypeDataAndOutput()
+    {
+        $expectedFormat = json_decode(file_get_contents(__DIR__ . '/../../fixtures/ffprobe/show_format.json'), true);
+        $expectedStreams = json_decode(file_get_contents(__DIR__ . '/../../fixtures/ffprobe/show_streams.json'), true);
+
+        $rawFormat = file_get_contents(__DIR__ . '/../../fixtures/ffprobe/show_format.raw');
+        $rawStreams = file_get_contents(__DIR__ . '/../../fixtures/ffprobe/show_streams.raw');
+
+        return array(
+            array(FFProbe::TYPE_FORMAT, $rawFormat, $expectedFormat),
+            array(FFProbe::TYPE_STREAMS, $rawStreams, $expectedStreams),
+        );
+    }
+}