RequestTest.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
namespace ILIAS\MetaData\OERExposer\OAIPMH\Requests;
 
use PHPUnit\Framework\TestCase;
use ILIAS\MetaData\OERExposer\OAIPMH\Requests\Verb;
use ILIAS\MetaData\OERExposer\OAIPMH\Requests\Argument;
use ILIAS\Data\URI;
 
class RequestTest extends TestCase
{
    protected function getURI(): URI
    {
        return $this->createMock(URI::class);
    }
 
    protected function getEmptyRequest(): Request
    {
        return new Request($this->getURI(), Verb::NULL);
    }
 
    public function testVerbAndBaseURL(): void
    {
        $url = $this->getURI();
        $request = new Request($url, Verb::LIST_IDENTIFIERS);
 
        $this->assertSame($url, $request->baseURL());
        $this->assertSame(Verb::LIST_IDENTIFIERS, $request->verb());
    }
 
    public function testNoArgument(): void
    {
        $request = $this->getEmptyRequest();
 
        foreach (Argument::cases() as $argument) {
            $this->assertFalse($request->hasArgument($argument));
            $this->assertSame('', $request->argumentValue($argument));
        }
    }
 
    public function testSingleArgument(): void
    {
        $request = $this->getEmptyRequest()
                        ->withArgument(Argument::FROM_DATE, 'today');
 
        foreach (Argument::cases() as $argument) {
            if ($argument === Argument::FROM_DATE) {
                continue;
            }
            $this->assertFalse($request->hasArgument($argument));
            $this->assertSame('', $request->argumentValue($argument));
        }
 
        $this->assertTrue($request->hasArgument(Argument::FROM_DATE));
        $this->assertSame('today', $request->argumentValue(Argument::FROM_DATE));
    }
 
    public function testMultipleDifferentArguments(): void
    {
        $request = $this->getEmptyRequest()
                        ->withArgument(Argument::FROM_DATE, 'today')
                        ->withArgument(Argument::RESUMPTION_TOKEN, 'resume!');
 
        foreach (Argument::cases() as $argument) {
            if (
                $argument === Argument::FROM_DATE ||
                $argument === Argument::RESUMPTION_TOKEN
            ) {
                continue;
            }
            $this->assertFalse($request->hasArgument($argument));
            $this->assertSame('', $request->argumentValue($argument));
        }
 
        $this->assertTrue($request->hasArgument(Argument::FROM_DATE));
        $this->assertSame('today', $request->argumentValue(Argument::FROM_DATE));
        $this->assertTrue($request->hasArgument(Argument::RESUMPTION_TOKEN));
        $this->assertSame('resume!', $request->argumentValue(Argument::RESUMPTION_TOKEN));
    }
 
    public function testArgumentKeysNoArgument(): void
    {
        $request = $this->getEmptyRequest();
 
        $this->assertNull($request->argumentKeys()->current());
    }
 
    public function testArgumentKeys(): void
    {
        $request = $this->getEmptyRequest();
 
        $request = $request->withArgument(Argument::IDENTIFIER, 'some identifier');
        $request = $request->withArgument(Argument::UNTIL_DATE, 'some date');
 
        $argument_keys = iterator_to_array($request->argumentKeys());
        $this->assertCount(2, $argument_keys);
        $this->assertContains(Argument::IDENTIFIER, $argument_keys);
        $this->assertContains(Argument::UNTIL_DATE, $argument_keys);
    }
 
    public function testHasCorrectArguments(): void
    {
        $expect_true = [];
        $expect_false = [];
 
        $expect_true[] = $this->getEmptyRequest()
                              ->withArgument(Argument::IDENTIFIER, 'some identifier');
 
        $expect_true[] = $this->getEmptyRequest()
                              ->withArgument(Argument::IDENTIFIER, 'some identifier')
                              ->withArgument(Argument::RESUMPTION_TOKEN, 'token');
 
        $expect_true[] = $this->getEmptyRequest()
                              ->withArgument(Argument::IDENTIFIER, 'some identifier')
                              ->withArgument(Argument::RESUMPTION_TOKEN, 'token')
                              ->withArgument(Argument::FROM_DATE, 'date');
 
        $expect_true[] = $this->getEmptyRequest()
                              ->withArgument(Argument::MD_PREFIX, 'prefix');
 
        $expect_false[] = $this->getEmptyRequest();
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::UNTIL_DATE, 'date');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::FROM_DATE, 'date');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::IDENTIFIER, 'some identifier')
                               ->withArgument(Argument::UNTIL_DATE, 'date');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::IDENTIFIER, 'some identifier')
                               ->withArgument(Argument::MD_PREFIX, 'prefix');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::FROM_DATE, 'date')
                               ->withArgument(Argument::MD_PREFIX, 'prefix');
 
        foreach ($expect_true as $request) {
            $this->assertTrue($request->hasCorrectArguments(
                [Argument::IDENTIFIER],
                [Argument::RESUMPTION_TOKEN, Argument::FROM_DATE],
                [Argument::MD_PREFIX]
            ));
        }
        foreach ($expect_false as $request) {
            $this->assertFalse($request->hasCorrectArguments(
                [Argument::IDENTIFIER],
                [Argument::RESUMPTION_TOKEN, Argument::FROM_DATE],
                [Argument::MD_PREFIX]
            ));
        }
    }
 
    public function testHasCorrectArgumentsNoArguments(): void
    {
        $request_no_arguments = $this->getEmptyRequest();
 
        $request_one_argument = $this->getEmptyRequest()
                                     ->withArgument(Argument::IDENTIFIER, 'some identifier');
 
        $request_two_arguments = $this->getEmptyRequest()
                                      ->withArgument(Argument::IDENTIFIER, 'some identifier')
                                      ->withArgument(Argument::UNTIL_DATE, 'some date');
 
        $this->assertTrue($request_no_arguments->hasCorrectArguments([], [], []));
        $this->assertFalse($request_one_argument->hasCorrectArguments([], [], []));
        $this->assertFalse($request_two_arguments->hasCorrectArguments([], [], []));
    }
 
    public function testHasCorrectArgumentsRequired(): void
    {
        $request_no_arguments = $this->getEmptyRequest();
 
        $request_one_argument = $this->getEmptyRequest()
                                     ->withArgument(Argument::IDENTIFIER, 'some identifier');
 
        $request_two_arguments = $this->getEmptyRequest()
                                      ->withArgument(Argument::IDENTIFIER, 'some identifier')
                                      ->withArgument(Argument::UNTIL_DATE, 'some date');
 
        $this->assertFalse($request_no_arguments->hasCorrectArguments([Argument::IDENTIFIER], [], []));
        $this->assertTrue($request_one_argument->hasCorrectArguments([Argument::IDENTIFIER], [], []));
        $this->assertFalse($request_two_arguments->hasCorrectArguments([Argument::IDENTIFIER], [], []));
    }
 
    public function testHasCorrectArgumentsOptional(): void
    {
        $request_no_arguments = $this->getEmptyRequest();
 
        $request_one_argument = $this->getEmptyRequest()
                                     ->withArgument(Argument::IDENTIFIER, 'some identifier');
 
        $request_two_arguments = $this->getEmptyRequest()
                                      ->withArgument(Argument::IDENTIFIER, 'some identifier')
                                      ->withArgument(Argument::UNTIL_DATE, 'some date');
 
        $this->assertTrue($request_no_arguments->hasCorrectArguments([], [Argument::IDENTIFIER], []));
        $this->assertTrue($request_one_argument->hasCorrectArguments([], [Argument::IDENTIFIER], []));
        $this->assertFalse($request_two_arguments->hasCorrectArguments([], [Argument::IDENTIFIER], []));
    }
 
    public function testHasCorrectArgumentsExclusive(): void
    {
        $expect_true = [];
        $expect_false = [];
 
        $expect_false[] = $this->getEmptyRequest();
 
        $expect_true[] = $this->getEmptyRequest()
                              ->withArgument(Argument::IDENTIFIER, 'some identifier');
 
        $expect_true[] = $this->getEmptyRequest()
                              ->withArgument(Argument::UNTIL_DATE, 'some date');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::FROM_DATE, 'some date');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::IDENTIFIER, 'some identifier')
                               ->withArgument(Argument::UNTIL_DATE, 'some date');
 
        $expect_false[] = $this->getEmptyRequest()
                               ->withArgument(Argument::FROM_DATE, 'some date')
                               ->withArgument(Argument::UNTIL_DATE, 'some date');
 
        foreach ($expect_true as $request) {
            $this->assertTrue($request->hasCorrectArguments(
                [Argument::UNTIL_DATE],
                [],
                [Argument::IDENTIFIER]
            ));
        }
        foreach ($expect_false as $request) {
            $this->assertFalse($request->hasCorrectArguments(
                [Argument::UNTIL_DATE],
                [],
                [Argument::IDENTIFIER]
            ));
        }
    }
}