-
readRdf('/foaf.rdf', $format)); ?>
+
readRdf('/foaf.rdf', $format, \Pdsinterop\Rdf\Enum\Rdf::EMPTY_NODE)) ?>
diff --git a/tests/integration/FilesystemTest.php b/tests/integration/FilesystemTest.php
index 19d2004..308b08a 100644
--- a/tests/integration/FilesystemTest.php
+++ b/tests/integration/FilesystemTest.php
@@ -17,8 +17,10 @@ class FilesystemTest extends TestCase
* @param $expected
*
* @dataProvider provideFormatResult
+ *
+ * @coversNothing
*/
- public function test_($format, $expected) : void
+ public function test_($format, $expected): void
{
$filesystem = new Filesystem(new Local(__DIR__ . '/../fixtures/'));
$filesystem->addPlugin(new ReadRdf(new EasyRdf_Graph()));
@@ -29,7 +31,7 @@ public function test_($format, $expected) : void
self::assertEquals($expected, $actual);
}
- public function provideFormatResult() : array
+ public function provideFormatResult(): array
{
return [
'json-ld' => [
diff --git a/tests/unit/Enum/FormatTest.php b/tests/unit/Enum/FormatTest.php
new file mode 100644
index 0000000..a5a9768
--- /dev/null
+++ b/tests/unit/Enum/FormatTest.php
@@ -0,0 +1,72 @@
+assertTrue($actual);
+ }
+
+ /**
+ * @testdox Enum should return `false` when asked if it has a `guess` format
+ *
+ * @covers ::has
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format::keys
+ */
+ public function testHasForGuess(): void
+ {
+ $actual = Format::has('guess');
+
+ $this->assertFalse($actual);
+ }
+
+ /**
+ * @testdox Enum should return supported formats when asked for all is keys
+ *
+ * @covers ::keys
+ */
+ public function testKeys(): void
+ {
+ $actual = Format::keys();
+
+ $expected = [
+ 'JSON_LD' => 'jsonld',
+ 'N_TRIPLES' => 'ntriples',
+ 'NOTATION_3' => 'n3',
+ 'RDF_XML' => 'rdfxml',
+ 'TURTLE' => 'turtle',
+ ];
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ public function provideFormats(): array
+ {
+ return [
+ 'jsonld' => ['jsonld'],
+ 'ntriples' => ['ntriples'],
+ 'n3' => ['n3'],
+ 'rdfxml' => ['rdfxml'],
+ 'turtle' => ['turtle'],
+ ];
+ }
+}
diff --git a/tests/unit/Flysystem/Adapter/RdfTest.php b/tests/unit/Flysystem/Adapter/RdfTest.php
new file mode 100644
index 0000000..3d8c21d
--- /dev/null
+++ b/tests/unit/Flysystem/Adapter/RdfTest.php
@@ -0,0 +1,627 @@
+
+ *
+ * @TODO: All long test names should be replaced by a short name and a @testdox annotation
+ */
+class RdfTest extends TestCase
+{
+ ////////////////////////////////// FIXTURES \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ private const MOCK_CONTENTS = 'mock contents';
+ private const MOCK_CONTENTS_RDF = "@prefix rdfs: <> .\n rdfs:comment '' .";
+ private const MOCK_MIME = 'mock mime';
+ private const MOCK_PATH = '/mock/path';
+ private const MOCK_URL = 'mock url';
+
+ /** @var AdapterInterface|MockObject */
+ private $mockAdapter;
+ /** @var Formats|MockObject */
+ private $mockFormats;
+ /** @var Graph|MockObject */
+ private $mockGraph;
+
+ private function createAdapter(): Rdf
+ {
+ $this->mockAdapter = $this->mockAdapter ?? $this->getMockBuilder(AdapterInterface::class)->getMock();
+ $this->mockGraph = $this->getMockBuilder(Graph::class)->getMock();
+ $this->mockFormats = $this->getMockBuilder(FormatsInterface::class)->getMock();
+
+ return new Rdf($this->mockAdapter, $this->mockGraph, $this->mockFormats, self::MOCK_URL);
+ }
+
+ ////////////////////////// TESTS WITHOUT FORMATTING \\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfAdapterShouldComplainWhenInstantiatedWithoutAdapter(): void
+ {
+ $this->expectException(ArgumentCountError::class);
+ $this->expectExceptionMessage('0 passed');
+
+ new Rdf();
+ }
+
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfAdapterShouldComplainWhenInstantiatedWithoutGraph(): void
+ {
+ $this->expectException(ArgumentCountError::class);
+ $this->expectExceptionMessage('1 passed');
+
+ $mockAdapter = $this->getMockBuilder(AdapterInterface::class)
+ ->getMock()
+ ;
+
+ new Rdf($mockAdapter);
+ }
+
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfAdapterShouldComplainWhenInstantiatedWithoutFormats(): void
+ {
+ $this->expectException(ArgumentCountError::class);
+ $this->expectExceptionMessage('2 passed');
+
+ $mockAdapter = $this->getMockBuilder(AdapterInterface::class)->getMock();
+ $mockGraph = $this->getMockBuilder(Graph::class)->getMock();
+
+ new Rdf($mockAdapter, $mockGraph);
+ }
+
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfAdapterShouldComplainWhenInstantiatedWithoutUrl(): void
+ {
+ $this->expectException(ArgumentCountError::class);
+ $this->expectExceptionMessage('3 passed');
+
+ $mockAdapter = $this->getMockBuilder(AdapterInterface::class)->getMock();
+ $mockGraph = $this->getMockBuilder(Graph::class)->getMock();
+ $mockFormats = $this->getMockBuilder(Formats::class)->getMock();
+
+ new Rdf($mockAdapter, $mockGraph, $mockFormats);
+ }
+
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfAdapterShouldBeInstantiatedWhenGivenExpectedDependencies(): void
+ {
+ $this->assertInstanceOf(Rdf::class, $this->createAdapter());
+ }
+
+ /**
+ * @covers ::copy
+ * @covers ::createDir
+ * @covers ::delete
+ * @covers ::getSize
+ * @covers ::deleteDir
+ * @covers ::getMetadata
+ * @covers ::getTimestamp
+ * @covers ::getVisibility
+ * @covers ::listContents
+ * @covers ::read
+ * @covers ::readStream
+ * @covers ::rename
+ * @covers ::setVisibility
+ * @covers ::update
+ * @covers ::updateStream
+ * @covers ::write
+ * @covers ::writeStream
+ *
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::getMimeType
+ *
+ * @dataProvider provideProxyMethods
+ */
+ public function testRdfAdapterShouldReturnInnerAdapterResultWhenProxyMethodsAreCalled($method, $parameters): void
+ {
+ $expected = self::MOCK_CONTENTS;
+
+ $adapterMethod = $method;
+
+ if ($method === 'read' || $method === 'readStream') {
+ $adapterMethod = 'read';
+ $expected = ['contents' => $expected];
+ } elseif ($method === 'getMimetype') {
+ $expected = ['mimetype' => self::MOCK_MIME];
+ } elseif ($method === 'getMetadata') {
+ $expected = [];
+ }
+
+ $adapter = $this->createAdapter();
+
+ if ($method === 'getMetadata' || $method === 'read' || $method === 'readStream') {
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+ }
+
+ $this->mockAdapter
+ ->method('has')
+ ->willReturn(false)
+ ;
+
+ $this->mockAdapter->expects($this->once())
+ ->method($adapterMethod)
+ ->willReturn($expected)
+ ;
+
+ $actual = $adapter->{$method}(...$parameters);
+
+ $this->assertSame($expected, $actual);
+ }
+
+ //////////////////////////// TESTS WITH FORMATTING \\\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @covers ::setFormat
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Exception
+ *
+ * @dataProvider provideUnsupportedFormats
+ */
+ public function testRdfAdapterShouldComplainWhenAskedToSetUnsupportedFormat($format): void
+ {
+ $adapter = $this->createAdapter();
+ $message = vsprintf($adapter::ERROR_UNSUPPORTED_FORMAT, [$format]);
+
+ $this->expectException(Exception::class);
+ $this->expectExceptionMessage($message);
+
+ $adapter->setFormat($format);
+ }
+
+ /**
+ * @covers ::getFormat
+ * @covers ::setFormat
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ *
+ * @dataProvider provideSupportedFormats
+ */
+ public function testRdfAdapterShouldSetFormatWhenAskedToSetSupportedFormat($expected): void
+ {
+ $adapter = $this->createAdapter();
+
+ $adapter->setFormat($expected);
+
+ $actual = $adapter->getFormat();
+
+ $this->assertSame($expected, $actual);
+ }
+
+ /**
+ * @covers ::getMimeType
+ * @covers ::getSize
+ * @covers ::has
+ * @covers ::read
+ * @covers ::readStream
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::getMetadata
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ * @uses \Pdsinterop\Rdf\Formats
+ *
+ * @dataProvider provideConvertingMethods
+ */
+ public function testRdfAdapterShouldCallInnerAdapterAndGraphWhenNonProxyMethodsAreCalledWithFormat($method): void
+ {
+ $formats = [
+ Format::JSON_LD,
+ Format::N_TRIPLES,
+ Format::NOTATION_3,
+ Format::RDF_XML,
+ Format::TURTLE,
+ ];
+
+ $formatCount = count($formats);
+
+ $adapterMethod = $method;
+
+ $adapter = $this->createAdapter();
+
+ if ($method === 'readStream') {
+ /*/ The `readStream` method is currently just a proxy for `read` /*/
+ $adapterMethod = 'read';
+ }
+
+ $this->mockAdapter->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS_RDF])
+ ;
+
+ $this->mockGraph->method('serialise')
+ ->willReturn('[]')
+ ;
+
+ $this->mockFormats->method('getMimeForFormat')
+ ->willReturn(self::MOCK_MIME)
+ ;
+
+ if ($method === 'getMimeType' || $method === 'getSize') {
+ /*/ These inner adapter method should *never* be called when working with converted (meta)data /*/
+ $this->mockAdapter->expects($this->never())
+ ->method($adapterMethod)
+ ;
+ } elseif ($method === 'has') {
+ $this->mockAdapter
+ ->method($adapterMethod)
+ ->willReturn(false)
+ ;
+ } elseif ($method === 'getMetadata' || $method === 'read' || $method === 'readStream') {
+ $this->mockAdapter->expects($this->exactly($formatCount))
+ ->method($adapterMethod)
+ ;
+ } else {
+ $this->fail('Do not know how to test for ' . $method);
+ }
+
+ $expected = [
+ 'contents' => '[]',
+ 'mimetype' => self::MOCK_MIME,
+ 'path' => self::MOCK_PATH,
+ 'size' => 2,
+ 'type' => 'file',
+ ];
+
+ if ($method === 'getMimeType') {
+ /*/ Mimetype does not require metadata or read to function.
+ Hence, it only returns one value.
+ /*/
+ $expected = ['mimetype' => self::MOCK_MIME];
+ }
+
+ foreach ($formats as $format) {
+ $adapter->setFormat($format);
+
+ $actual = $adapter->{$method}(self::MOCK_PATH);
+
+ $this->assertEquals($expected, $actual);
+ }
+ }
+
+ //////////////////////////// TESTS FOR METADATA \\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @covers ::getMetadata
+ */
+ public function testMetaDataShouldNotContainDescribedByWhenCalledForPathWithoutMetaFile(): void
+ {
+ $adapter = $this->createAdapter();
+
+ $this->mockAdapter->method('has')->willReturn(false);
+
+ $actual = $adapter->getMetadata(self::MOCK_PATH);
+
+ $this->assertArrayNotHasKey('describedby', $actual);
+ }
+
+ /**
+ * @covers ::getMetadata
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::read
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ */
+ public function testMetaDataShouldLookForMetaFileWhenCalled(): void
+ {
+ $adapter = $this->createAdapter();
+
+ /*/ This part of the test is only needed for conversion /*/
+ $adapter->setFormat('jsonld');
+
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+
+ /*/ This part is always needed /*/
+ $path = self::MOCK_PATH;
+
+ $this->mockAdapter
+ ->method('has')
+ ->willReturn(true)
+ ;
+
+ $actual = $adapter->getMetadata($path);
+
+ $this->assertArrayHasKey('describedby', $actual);
+ }
+
+ /**
+ * @covers ::getMetadata
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::read
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ */
+ public function testMetaDataShouldLookForMetaFileInDirectoryWhenCalledOnFileWithoutMetaFile(): void
+ {
+ $adapter = $this->createAdapter();
+
+ /*/ This part of the test is only needed for conversion /*/
+ $adapter->setFormat('jsonld');
+
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+
+ /*/ This part is always needed /*/
+ $expected = '/a/longer/path/to/.meta';
+
+
+ $this->mockAdapter->expects($this->exactly(3))
+ ->method('has')
+ ->withConsecutive(
+ ['/a/longer/path/to/file.ext.meta'],
+ [$expected],
+ )
+ ->willReturnOnConsecutiveCalls(false, true, true)
+ ;
+
+ $metadata = $adapter->getMetadata('/a/longer/path/to/file.ext');
+
+ $actual = $metadata['describedby'];
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getMetadata
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::read
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ */
+ public function testMetaDataShouldLookForMetaFileInParentDirectoriesWhenCalledOnFileWithoutMetaFileInCurrentDirectory(): void
+ {
+ $adapter = $this->createAdapter();
+
+ /*/ This part of the test is only needed for conversion /*/
+ $adapter->setFormat('jsonld');
+
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+
+ /*/ This part is always needed /*/
+ $expected = '/.meta';
+
+ $this->mockAdapter
+ ->method('has')
+ ->withConsecutive(
+ ['/a/longer/path/to/file.ext.meta'],
+ ['/a/longer/path/to/.meta'],
+ ['/a/longer/path/.meta'],
+ ['/a/longer/.meta'],
+ ['/a/.meta'],
+ ['/.meta'],
+ )
+ ->willReturnOnConsecutiveCalls(false, false, false, false, false, true, true)
+ ;
+
+ $metadata = $adapter->getMetadata('/a/longer/path/to/file.ext');
+
+ $actual = $metadata['describedby'];
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /////////////////////////////// TESTS FOR ACL \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @covers ::getMetadata
+ */
+ public function testMetaDataShouldNotContainAclWhenCalledForPathWithoutAclFile(): void
+ {
+ $adapter = $this->createAdapter();
+
+ $this->mockAdapter->method('has')->willReturn(false);
+
+ $actual = $adapter->getMetadata(self::MOCK_PATH);
+
+ $this->assertArrayNotHasKey('acl', $actual);
+ }
+
+ /**
+ * @covers ::getMetadata
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::read
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ */
+ public function testMetaDataShouldLookForAclFileWhenCalled(): void
+ {
+ $adapter = $this->createAdapter();
+
+ /*/ This part of the test is only needed for conversion /*/
+ $adapter->setFormat('jsonld');
+
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+
+ /*/ This part is always needed /*/
+ $path = self::MOCK_PATH;
+
+ $this->mockAdapter
+ ->method('has')
+ ->willReturn(true)
+ ;
+
+ $actual = $adapter->getMetadata($path);
+
+ $this->assertArrayHasKey('acl', $actual);
+ }
+
+ /**
+ * @covers ::getMetadata
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::read
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ */
+ public function testMetaDataShouldLookForAclFileInDirectoryWhenCalledOnFileWithoutAclFile(): void
+ {
+ $adapter = $this->createAdapter();
+
+ /*/ This part of the test is only needed for conversion /*/
+ $adapter->setFormat('jsonld');
+
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+
+ /*/ This part is always needed /*/
+ $expected = '/a/longer/path/to/.acl';
+
+
+ $this->mockAdapter->expects($this->exactly(3))
+ ->method('has')
+ ->withConsecutive(
+ ['/a/longer/path/to/file.ext.meta'],
+ ['/a/longer/path/to/file.ext.acl'],
+ [$expected],
+ )
+ ->willReturnOnConsecutiveCalls(true, false, true)
+ ;
+
+ $metadata = $adapter->getMetadata('/a/longer/path/to/file.ext');
+
+ $actual = $metadata['acl'];
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getMetadata
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::read
+ * @uses \Pdsinterop\Rdf\Flysystem\Adapter\Rdf::setFormat
+ */
+ public function testMetaDataShouldLookForAclFileInParentDirectoriesWhenCalledOnFileWithoutAclFileInCurrentDirectory(): void
+ {
+ $adapter = $this->createAdapter();
+
+ /*/ This part of the test is only needed for conversion /*/
+ $adapter->setFormat('jsonld');
+
+ $this->mockAdapter
+ ->method('read')
+ ->willReturn(['contents' => self::MOCK_CONTENTS])
+ ;
+
+ /*/ This part is always needed /*/
+ $expected = '/.acl';
+
+ $this->mockAdapter
+ ->method('has')
+ ->withConsecutive(
+ ['/a/longer/path/to/file.ext.meta'],
+ ['/a/longer/path/to/file.ext.acl'],
+ ['/a/longer/path/to/.acl'],
+ ['/a/longer/path/.acl'],
+ ['/a/longer/.acl'],
+ ['/a/.acl'],
+ [$expected],
+ )
+ ->willReturnOnConsecutiveCalls(true, false, false, false, false, false, true)
+ ;
+
+ $metadata = $adapter->getMetadata('/a/longer/path/to/file.ext');
+
+ $actual = $metadata['acl'];
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /////////////////////////////// DATAPROVIDERS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ public function provideProxyMethods(): array
+ {
+ $mockConfig = $this->getMockBuilder(Config::class)->getMock();
+ $mockContents = self::MOCK_CONTENTS;
+ $mockPath = self::MOCK_PATH;
+ $mockResource = fopen('php://temp', 'rb');
+
+ return [
+ 'copy' => ['copy', [$mockPath, $mockPath]],
+ 'createDir' => ['createDir', [$mockPath, $mockConfig]],
+ 'delete' => ['delete', [$mockPath]],
+ 'deleteDir' => ['deleteDir', [$mockPath]],
+ 'getMetadata' => ['getMetadata', [$mockPath]],
+ 'getMimetype' => ['getMimetype', [$mockPath]],
+ 'getSize' => ['getSize', [$mockPath]],
+ 'getVisibility' => ['getVisibility', [$mockPath]],
+ 'getTimestamp' => ['getTimestamp', [$mockPath]],
+ 'listContents' => ['listContents', []],
+ 'read' => ['read', [$mockPath]],
+ 'readStream' => ['readStream', [$mockPath]],
+ 'rename' => ['rename', [$mockPath, $mockPath]],
+ 'setVisibility' => ['setVisibility', [$mockPath, 'mock visibility']],
+ 'update' => ['update', [$mockPath, $mockContents, $mockConfig]],
+ 'updateStream' => ['updateStream', [$mockPath, $mockResource, $mockConfig]],
+ 'write' => ['write', [$mockPath, $mockContents, $mockConfig]],
+ 'writeStream' => ['writeStream', [$mockPath, $mockResource, $mockConfig]],
+ ];
+ }
+
+ public function provideConvertingMethods(): array
+ {
+ return [
+ 'getMetadata' => ['getMetadata'],
+ 'getSize' => ['getSize'],
+ 'has' => ['has'],
+ 'getMimeType' => ['getMimeType'],
+ 'read' => ['read'],
+ 'readStream' => ['readStream'],
+ ];
+ }
+
+ public function provideSupportedFormats(): array
+ {
+ return [
+ 'string: empty' => [''],
+ Format::JSON_LD => [Format::JSON_LD],
+ Format::N_TRIPLES => [Format::N_TRIPLES],
+ Format::NOTATION_3 => [Format::NOTATION_3],
+ Format::RDF_XML => [Format::RDF_XML],
+ Format::TURTLE => [Format::TURTLE],
+ ];
+ }
+
+ public function provideUnsupportedFormats(): array
+ {
+ return [
+ 'mock format' => ['mock format'],
+ Format::UNKNOWN => [Format::UNKNOWN],
+ ];
+ }
+}
diff --git a/tests/unit/Flysystem/Plugin/AsMimeTest.php b/tests/unit/Flysystem/Plugin/AsMimeTest.php
new file mode 100644
index 0000000..6eef03a
--- /dev/null
+++ b/tests/unit/Flysystem/Plugin/AsMimeTest.php
@@ -0,0 +1,239 @@
+
+ */
+class AsMimeTest extends TestCase
+{
+ ////////////////////////////////// FIXTURES \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ private const MOCK_MIME = 'mock mime';
+
+ private function createPlugin() : AsMime
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $mockFilesystem = $this->createMockFilesystem();
+
+ $plugin = new AsMime($mockFormats);
+
+ $plugin->setFilesystem($mockFilesystem);
+
+ return $plugin;
+ }
+
+ ////////////////////////////// CUSTOM ASSERTS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+ private function assertPropertyEquals($object, string $property, $expected): void
+ {
+ $reflector = new ReflectionObject($object);
+
+ $attribute = $reflector->getProperty($property);
+ $attribute->setAccessible(true);
+
+ $actual = $attribute->getValue($object);
+
+ $this->assertSame($expected, $actual);
+ }
+
+ /////////////////////////////////// TESTS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @covers ::__construct
+ */
+ public function testPluginShouldComplainWhenInstantiatedWithoutGraph(): void
+ {
+ $this->expectException(ArgumentCountError::class);
+
+ new AsMime();
+ }
+
+ /**
+ * @covers ::__construct
+ */
+ public function testPluginShouldReceiveEasyRdfGraphWhenInstantiated(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $actual = new AsMime($mockFormats);
+
+ $this->assertInstanceOf(AsMime::class, $actual);
+ }
+
+ /**
+ * @covers ::setFilesystem
+ */
+ public function testPluginShouldComplainWhenSetFilesystemCalledWithoutFilesystem(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $plugin = new AsMime($mockFormats);
+
+ $this->expectException(ArgumentCountError::class);
+
+ $plugin->setFilesystem();
+ }
+
+ /**
+ * @covers ::setFilesystem
+ */
+ public function testPluginShouldContainFilesystemWhenFilesystemGiven(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $plugin = new AsMime($mockFormats);
+
+ $expected = $this->createMockFilesystem();
+
+ $plugin->setFilesystem($expected);
+
+ $this->assertPropertyEquals($plugin, 'filesystem', $expected);
+ }
+
+ /**
+ * @covers ::getMethod
+ */
+ public function testPluginShouldReturnExpectedMethodNameWhenAskedForMethod(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $plugin = new AsMime($mockFormats);
+
+ $expected = 'asMime';
+
+ $actual = $plugin->getMethod();
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::handle
+ *
+ * @uses \Pdsinterop\Rdf\Flysystem\Exception::create
+ */
+ public function testPluginShouldComplainWhenHandleCalledWithoutFilesystem(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $plugin = new AsMime($mockFormats);
+
+ $this->expectException(Exception::class);
+ $this->expectExceptionMessage('can not be used before an adapter has been added to the filesystem');
+
+ $plugin->handle('');
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testPluginShouldComplainWhenHandleCalledWithoutMimetype(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $plugin = new AsMime($mockFormats);
+
+ $this->expectException(ArgumentCountError::class);
+ $this->expectExceptionMessage('Too few arguments to function Pdsinterop\Rdf\Flysystem\Plugin\AsMime::handle(), 0 passed');
+
+ $plugin->handle();
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testPluginShouldReturnFileSystemWhenHandleCalled(): void
+ {
+ $expected = $this->createMockFilesystem();
+
+ $mockFormats = $this->createMockFormats();
+
+ $plugin = new AsMime($mockFormats);
+ $plugin->setFilesystem($expected);
+
+ $this->assertPropertyEquals($plugin, 'filesystem', $expected);
+
+ $actual = $plugin->handle(self::MOCK_MIME);
+
+ $this->assertSame($expected, $actual);
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testPluginShouldNotSetFormatWhenAdapterIsNotRdfAdapter(): void
+ {
+ $plugin = $this->createPlugin();
+
+ $this->createMockFormats()->expects($this->never())
+ ->method('getFormatForMime')
+ ;
+
+ $plugin->handle(self::MOCK_MIME);
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testPluginShouldSetFormatWhenAdapterIsRdfAdapter(): void
+ {
+ $mockFormats = $this->createMockFormats();
+
+ $mockAdapter = $this->getMockBuilder(RdfAdapterInterface::class)->getMock();
+
+ $mockAdapter->expects($this->once())
+ ->method('setFormat')
+ ;
+
+ $mockFilesystem = $this->createMockFilesystem($mockAdapter);
+
+ $plugin = new AsMime($mockFormats);
+ $plugin->setFilesystem($mockFilesystem);
+
+ $plugin->handle(self::MOCK_MIME);
+ }
+
+ ////////////////////////////// MOCKS AND STUBS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @return FilesystemInterface | MockObject
+ */
+ private function createMockFilesystem($mockAdapter = null): FilesystemInterface
+ {
+ $mockFilesystem = $this->getMockBuilder(Filesystem::class)
+ ->disableOriginalConstructor()
+ ->getMock();
+
+ if ($mockAdapter === null) {
+ $mockAdapter = $this->getMockBuilder(AdapterInterface::class)->getMock();
+ }
+
+ $mockFilesystem->method('getAdapter')
+ ->willReturn($mockAdapter)
+ ;
+
+ return $mockFilesystem;
+ }
+
+ /**
+ * @return FormatsInterface | MockObject
+ */
+ private function createMockFormats()
+ {
+ return $this->getMockBuilder(FormatsInterface::class)
+ ->getMock();
+ }
+}
diff --git a/tests/unit/ReadRdfTest.php b/tests/unit/Flysystem/Plugin/ReadRdfTest.php
similarity index 54%
rename from tests/unit/ReadRdfTest.php
rename to tests/unit/Flysystem/Plugin/ReadRdfTest.php
index 469a01d..3120b1a 100644
--- a/tests/unit/ReadRdfTest.php
+++ b/tests/unit/Flysystem/Plugin/ReadRdfTest.php
@@ -3,19 +3,36 @@
namespace Pdsinterop\Rdf\Flysystem\Plugin;
use ArgumentCountError;
+use EasyRdf_Exception;
use EasyRdf_Graph;
use Error;
+use League\Flysystem\FileNotFoundException;
use League\Flysystem\FilesystemInterface;
use Pdsinterop\Rdf\Enum\Format;
+use Pdsinterop\Rdf\Flysystem\Exception;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use ReflectionObject;
+/**
+ * @coversDefaultClass \Pdsinterop\Rdf\Flysystem\Plugin\ReadRdf
+ * @covers ::__construct
+ * @covers ::
+ *
+ * @TODO: All long test names should be replaced by a short name and a @testdox annotation
+ */
class ReadRdfTest extends TestCase
{
+ ////////////////////////////////// FIXTURES \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ private const MOCK_CONTENTS = 'mock contents';
+ private const MOCK_FORMAT = 'mock format';
+ private const MOCK_PATH = 'mock path';
+ private const MOCK_URL = 'mock url';
+
////////////////////////////// CUSTOM ASSERTS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
- private static function assertPropertyEquals($object, string $property, $expected) : void
+ private static function assertPropertyEquals($object, string $property, $expected): void
{
$reflector = new ReflectionObject($object);
@@ -30,15 +47,22 @@ private static function assertPropertyEquals($object, string $property, $expecte
/////////////////////////////////// TESTS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
- public function testRdfPluginShouldComplainWhenInstantiatedWithoutGraph() : void
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfPluginShouldComplainWhenInstantiatedWithoutGraph(): void
{
$this->expectException(ArgumentCountError::class);
/** @noinspection PhpParamsInspection */
+ /** @noinspection PhpExpressionResultUnusedInspection */
new ReadRdf();
}
- public function testRdfPluginShouldReceiveEasyRdfGraphWhenInstantiated() : void
+ /**
+ * @covers ::__construct
+ */
+ public function testRdfPluginShouldReceiveEasyRdfGraphWhenInstantiated(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -47,7 +71,10 @@ public function testRdfPluginShouldReceiveEasyRdfGraphWhenInstantiated() : void
self::assertInstanceOf(ReadRdf::class, $actual);
}
- public function testRdfPluginShouldComplainWhenSetFilesystemCalledWithoutFilesystem() : void
+ /**
+ * @covers ::setFilesystem
+ */
+ public function testRdfPluginShouldComplainWhenSetFilesystemCalledWithoutFilesystem(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -59,7 +86,10 @@ public function testRdfPluginShouldComplainWhenSetFilesystemCalledWithoutFilesys
$plugin->setFilesystem();
}
- public function testRdfPluginShouldContainFilesystemWhenFilesystemGiven() : void
+ /**
+ * @covers ::setFilesystem
+ */
+ public function testRdfPluginShouldContainFilesystemWhenFilesystemGiven(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -72,7 +102,10 @@ public function testRdfPluginShouldContainFilesystemWhenFilesystemGiven() : void
self::assertPropertyEquals($plugin, 'filesystem', $expected);
}
- public function testRdfPluginShouldReturnExpectedMethodNameWhenAskedForMethod() : void
+ /**
+ * @covers ::getMethod
+ */
+ public function testRdfPluginShouldReturnExpectedMethodNameWhenAskedForMethod(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -84,7 +117,7 @@ public function testRdfPluginShouldReturnExpectedMethodNameWhenAskedForMethod()
self::assertEquals($expected, $actual);
}
- public function testRdfPluginShouldComplainWhenHandleCalledWithoutPath() : void
+ public function testRdfPluginShouldComplainWhenHandleCalledWithoutPath(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -97,7 +130,7 @@ public function testRdfPluginShouldComplainWhenHandleCalledWithoutPath() : void
$plugin->handle();
}
- public function testRdfPluginShouldComplainWhenHandleCalledWithoutFormat() : void
+ public function testRdfPluginShouldComplainWhenHandleCalledWithoutFormat(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -110,7 +143,7 @@ public function testRdfPluginShouldComplainWhenHandleCalledWithoutFormat() : voi
$plugin->handle('');
}
- public function testRdfPluginShouldComplainWhenHandleCalledWithoutUrl() : void
+ public function testRdfPluginShouldComplainWhenHandleCalledWithoutUrl(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -123,7 +156,10 @@ public function testRdfPluginShouldComplainWhenHandleCalledWithoutUrl() : void
$plugin->handle('', '');
}
- public function testRdfPluginShouldComplainWhenHandleCalledWithoutFilesystem() : void
+ /**
+ * @covers ::handle
+ */
+ public function testRdfPluginShouldComplainWhenHandleCalledWithoutFilesystem(): void
{
$mockGraph = $this->getMockEasyRdfGraph();
@@ -136,45 +172,122 @@ public function testRdfPluginShouldComplainWhenHandleCalledWithoutFilesystem() :
$plugin->handle('', '', '');
}
- public function testRdfPluginShouldSerialiseFileContentsWhenHandleCalledWithPathAndFormatAndUrl() : void
+ /**
+ * @covers ::handle
+ * @covers ::setFilesystem
+ */
+ public function testRdfPluginShouldSerialiseFileContentsWhenHandleCalledWithPathAndFormatAndUrl(): void
{
- $mockContents = 'mock contents';
- $mockFormat = 'mock format';
- $mockPath = 'mock path';
- $mockUrl = 'mock url';
-
$mockGraph = $this->getMockEasyRdfGraph();
- $mockFilesystem = $this->getMockFilesystem($mockPath, $mockContents);
+ $mockFilesystem = $this->getMockFilesystem(self::MOCK_PATH, self::MOCK_CONTENTS);
$mockGraph->method('parse')
- ->with($mockContents, Format::UNKNOWN, $mockUrl)
+ ->with(self::MOCK_CONTENTS, Format::UNKNOWN, self::MOCK_URL)
;
$mockGraph->method('serialise')
- ->with($mockFormat)
- ->willReturn($mockContents)
+ ->with(self::MOCK_FORMAT)
+ ->willReturn(self::MOCK_CONTENTS)
;
$plugin = new ReadRdf($mockGraph);
$plugin->setFilesystem($mockFilesystem);
/** @noinspection PhpUnhandledExceptionInspection */
- $actual = $plugin->handle($mockPath, $mockFormat, $mockUrl);
- $expected = $mockContents;
+ $actual = $plugin->handle(self::MOCK_PATH, self::MOCK_FORMAT, self::MOCK_URL);
+ $expected = self::MOCK_CONTENTS;
self::assertEquals($expected, $actual);
}
- // @TODO: Test for when $filesystem->read($path) returns false
- // @TODO: Test for when $converter->parse(...) throws EasyRdf_Exception
- // @TODO: Test for when $converter->parse(...) output is non-scalar
+ /**
+ * @covers ::handle
+ *
+ * @uses \Pdsinterop\Rdf\Flysystem\Exception
+ */
+ public function testRdfPluginShouldComplainWhenConverterCanNotParseFileContent(): void
+ {
+ $mockGraph = $this->getMockEasyRdfGraph();
+ $mockFilesystem = $this->getMockFilesystem(self::MOCK_PATH, self::MOCK_CONTENTS);
+
+ $mockGraph->method('parse')
+ ->willThrowException(new EasyRdf_Exception())
+ ;
+
+ $plugin = new ReadRdf($mockGraph);
+ $plugin->setFilesystem($mockFilesystem);
+
+ $this->expectException(Exception::class);
+
+ $plugin->handle(self::MOCK_PATH, self::MOCK_FORMAT, self::MOCK_URL);
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testRdfPluginShouldReturnStringWhenSerialiseResultIsNonScalar(): void
+ {
+ $mockGraph = $this->getMockEasyRdfGraph();
+ $mockFilesystem = $this->getMockFilesystem(self::MOCK_PATH, self::MOCK_CONTENTS);
+
+ $mockGraph->method('serialise')
+ ->willReturn(new \stdClass())
+ ;
+
+ $plugin = new ReadRdf($mockGraph);
+ $plugin->setFilesystem($mockFilesystem);
+
+ $actual = $plugin->handle(self::MOCK_PATH, self::MOCK_FORMAT, self::MOCK_URL);
+ $expected = "(object) array(\n)";
+
+ self::assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testRdfPluginShouldReturnFalseWhenRequestedPathCanNotBeRead(): void
+ {
+ $expected = false;
+
+ $mockGraph = $this->getMockEasyRdfGraph();
+ $mockFilesystem = $this->getMockFilesystem(self::MOCK_PATH, $expected);
+
+ $plugin = new ReadRdf($mockGraph);
+ $plugin->setFilesystem($mockFilesystem);
+
+ $actual = $plugin->handle(self::MOCK_PATH, self::MOCK_FORMAT, self::MOCK_URL);
+
+ self::assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::handle
+ */
+ public function testRdfPluginShouldComplainWhenRequestedPathDoesNotExist(): void
+ {
+ $mockGraph = $this->getMockEasyRdfGraph();
+
+ $mockFilesystem = $this->getMockBuilder(FilesystemInterface::class)
+ ->getMock();
+
+ $mockFilesystem->method('read')
+ ->willThrowException(new FileNotFoundException(self::MOCK_PATH));
+
+ $plugin = new ReadRdf($mockGraph);
+ $plugin->setFilesystem($mockFilesystem);
+
+ $this->expectException(FileNotFoundException::class);
+
+ $plugin->handle(self::MOCK_PATH, self::MOCK_FORMAT, self::MOCK_URL);
+ }
////////////////////////////// MOCKS AND STUBS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\
/**
* @return EasyRdf_Graph | MockObject
*/
- private function getMockEasyRdfGraph() : EasyRdf_Graph
+ private function getMockEasyRdfGraph(): EasyRdf_Graph
{
return $this->getMockBuilder(EasyRdf_Graph::class)
->disableOriginalConstructor()
@@ -183,11 +296,11 @@ private function getMockEasyRdfGraph() : EasyRdf_Graph
/**
* @param string $path
- * @param string $fileContents
+ * @param mixed $fileContents
*
* @return FilesystemInterface | MockObject
*/
- private function getMockFilesystem(string $path = '', string $fileContents = '') : FilesystemInterface
+ private function getMockFilesystem(string $path = '', $fileContents = ''): FilesystemInterface
{
$mockFilesystem = $this->getMockBuilder(FilesystemInterface::class)
->getMock();
diff --git a/tests/unit/FormatsTest.php b/tests/unit/FormatsTest.php
new file mode 100644
index 0000000..b895216
--- /dev/null
+++ b/tests/unit/FormatsTest.php
@@ -0,0 +1,258 @@
+
+ *
+ * @uses \Pdsinterop\Rdf\Enum\Format
+ */
+class FormatsTest extends TestCase
+{
+ /////////////////////////////////// TESTS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ /**
+ * @covers ::getAllExtensions
+ */
+ public function testGetAllExtensions(): void
+ {
+ $expected = [
+ 'jsonld' => ['jsonld', 'json'],
+ 'n3' => ['n3'],
+ 'ntriples' => ['nt'],
+ 'rdfxml' => ['rdf', 'xrdf', 'html'],
+ 'turtle' => ['ttl'],
+ ];
+
+ $formats = new Formats();
+ $actual = $formats->getAllExtensions();
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getAllMimeTypes
+ */
+ public function testGetAllMimeTypes(): void
+ {
+ $expected = [
+ 'jsonld' => ['application/ld+json'],
+ 'n3' => ['text/n3', 'text/rdf+n3'],
+ 'ntriples' => [
+ 'application/n-triples',
+ 'text/plain',
+ 'text/ntriples',
+ 'application/ntriples',
+ 'application/x-ntriples',
+ ],
+ 'rdfxml' => ['application/rdf+xml'],
+ 'turtle' => ['text/turtle', 'application/turtle', 'application/x-turtle'],
+ ];
+
+ $formats = new Formats();
+
+ $actual = $formats->getAllMimeTypes();
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getExtensionsForFormat
+ *
+ * @uses \Pdsinterop\Rdf\Formats::getAllExtensions
+ *
+ * @dataProvider provideExtensionsForFormat
+ */
+ public function testGetExtensionsForFormat($format, $expected): void
+ {
+ $formats = new Formats();
+
+ $actual = $formats->getExtensionsForFormat($format);
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getFormatForExtension
+ *
+ * @dataProvider provideFormatForExtension
+ *
+ * @uses \Pdsinterop\Rdf\Formats::getAllExtensions
+ */
+ public function testGetFormatForExtension($extension, $expected): void
+ {
+ $formats = new Formats();
+
+ $actual = $formats->getFormatForExtension($extension);
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getFormatForMime
+ *
+ * @dataProvider provideFormatForMime
+ *
+ * @uses \Pdsinterop\Rdf\Formats::getAllMimeTypes
+ */
+ public function testGetFormatForMime($mime, $expected): void
+ {
+ $formats = new Formats();
+
+ $actual = $formats->getFormatForMime($mime);
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getMimeForExtension
+ *
+ * @uses \Pdsinterop\Rdf\Formats
+ *
+ * @dataProvider provideMimeForExtension
+ */
+ public function testGetMimeForExtension($extension, $expected): void
+ {
+ $formats = new Formats();
+
+ $actual = $formats->getMimeForExtension($extension);
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getMimeForFormat
+ *
+ * @uses \Pdsinterop\Rdf\Formats::getAllMimeTypes
+ * @uses \Pdsinterop\Rdf\Formats::getMimesForFormat
+ *
+ * @dataProvider provideMimeForFormat
+ */
+ public function testGetMimeForFormat($format, $expected): void
+ {
+ $formats = new Formats();
+
+ $actual = $formats->getMimeForFormat($format);
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /**
+ * @covers ::getMimesForFormat
+ *
+ * @dataProvider provideMimesForFormat
+ *
+ * @uses \Pdsinterop\Rdf\Formats::getAllMimeTypes
+ */
+ public function testGetMimesForFormat($format, $expected): void
+ {
+ $formats = new Formats();
+
+ $actual = $formats->getMimesForFormat($format);
+
+ $this->assertEquals($expected, $actual);
+ }
+
+ /////////////////////////////// DATAPROVIDERS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+ public function provideExtensionsForFormat(): array
+ {
+ return [
+ 'jsonld' => ['jsonld', ['jsonld', 'json']],
+ 'n3' => ['n3', ['n3']],
+ 'ntriples' => ['ntriples', ['nt']],
+ 'rdfxml' => ['rdfxml', ['rdf', 'xrdf', 'html']],
+ 'turtle' => ['turtle', ['ttl']],
+ ];
+ }
+
+ public function provideFormatForExtension(): array
+ {
+ return [
+ 'jsonld (with leading dot)' => ['.jsonld', 'jsonld'],
+ 'jsonld' => ['jsonld', 'jsonld'],
+ 'jsonld:json (with leading dot)' => ['.json', 'jsonld'],
+ 'jsonld:json' => ['json', 'jsonld'],
+ 'n3 (with leading dot)' => ['.n3', 'n3'],
+ 'n3' => ['n3', 'n3'],
+ 'ntriples (with leading dot)' => ['.nt', 'ntriples'],
+ 'ntriples' => ['nt', 'ntriples'],
+ 'rdfxml:html (with leading dot)' => ['.html', 'rdfxml'],
+ 'rdfxml:html' => ['html', 'rdfxml'],
+ 'rdfxml:rdf (with leading dot)' => ['.rdf', 'rdfxml'],
+ 'rdfxml:rdf' => ['rdf', 'rdfxml'],
+ 'rdfxml:xrdf (with leading dot)' => ['.xrdf', 'rdfxml'],
+ 'rdfxml:xrdf' => ['xrdf', 'rdfxml'],
+ 'turtle (with leading dot)' => ['.ttl', 'turtle'],
+ 'turtle' => ['ttl', 'turtle'],
+ ];
+ }
+
+ public function provideFormatForMime(): array
+ {
+ return [
+ 'jsonld:1' => ['application/ld+json', 'jsonld'],
+ 'n3:1' => ['text/n3', 'n3'],
+ 'n3:2' => ['text/rdf+n3', 'n3'],
+ 'ntriples:1' => ['application/n-triples', 'ntriples'],
+ 'ntriples:2' => ['text/plain', 'ntriples'],
+ 'ntriples:3' => ['text/ntriples', 'ntriples'],
+ 'ntriples:4' => ['application/ntriples', 'ntriples'],
+ 'ntriples:5' => ['application/x-ntriples', 'ntriples'],
+ 'rdfxml:1' => ['application/rdf+xml', 'rdfxml'],
+ 'turtle:1' => ['text/turtle', 'turtle'],
+ 'turtle:2' => ['application/turtle', 'turtle'],
+ 'turtle:3' => ['application/x-turtle', 'turtle'],
+ ];
+ }
+
+ public function provideMimeForExtension(): array
+ {
+ return [
+ 'jsonld (with leading dot)' => ['.jsonld', 'application/ld+json'],
+ 'jsonld' => ['jsonld', 'application/ld+json'],
+ 'jsonld:json (with leading dot)' => ['.json', 'application/ld+json'],
+ 'jsonld:json' => ['json', 'application/ld+json'],
+ 'n3 (with leading dot)' => ['.n3', 'text/n3'],
+ 'n3' => ['n3', 'text/n3'],
+ 'ntriples (with leading dot)' => ['.nt', 'application/n-triples'],
+ 'ntriples' => ['nt', 'application/n-triples'],
+ 'rdfxml:html (with leading dot)' => ['.html', 'application/rdf+xml'],
+ 'rdfxml:html' => ['html', 'application/rdf+xml'],
+ 'rdfxml:rdf (with leading dot)' => ['.rdf', 'application/rdf+xml'],
+ 'rdfxml:rdf' => ['rdf', 'application/rdf+xml'],
+ 'rdfxml:xrdf (with leading dot)' => ['.xrdf', 'application/rdf+xml'],
+ 'rdfxml:xrdf' => ['xrdf', 'application/rdf+xml'],
+ 'turtle (with leading dot)' => ['.ttl', 'text/turtle'],
+ 'turtle' => ['ttl', 'text/turtle'],
+ ];
+ }
+
+ public function provideMimeForFormat(): array
+ {
+ return [
+ 'jsonld' =>['jsonld', 'application/ld+json'],
+ 'n3' =>['n3', 'text/n3'],
+ 'ntriples' =>['ntriples', 'application/n-triples'],
+ 'rdfxml' => ['rdfxml', 'application/rdf+xml'],
+ 'turtle' =>['turtle', 'text/turtle'],
+ ];
+ }
+
+ public function provideMimesForFormat(): array
+ {
+ return [
+ 'jsonld' =>['jsonld', ['application/ld+json']],
+ 'n3' =>['n3', ['text/n3', 'text/rdf+n3']],
+ 'ntriples' =>['ntriples', ['application/n-triples', 'text/plain', 'text/ntriples', 'application/ntriples', 'application/x-ntriples']],
+ 'rdfxml' => ['rdfxml', ['application/rdf+xml']],
+ 'turtle' =>['turtle', ['text/turtle', 'application/turtle', 'application/x-turtle']],
+
+ ];
+ }
+}