You are here

Home » API reference » Zircon Profile 8 » PathValidatorTest.php

class PathValidatorTest in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 core/tests/Drupal/Tests/Core/Path/PathValidatorTest.php \Drupal\Tests\Core\Path\PathValidatorTest

@coversDefaultClass \Drupal\Core\Path\PathValidator @group Routing

Hierarchy

Expanded class hierarchy of PathValidatorTest

File

core/tests/Drupal/Tests/Core/Path/PathValidatorTest.php, line 22
Contains \Drupal\Tests\Core\Path\PathValidatorTest.

Namespace

Drupal\Tests\Core\Path
View source 
class PathValidatorTest extends UnitTestCase {

  /**
   * The mocked access aware router.
   *
   * @var \Drupal\Core\Routing\AccessAwareRouterInterface|\PHPUnit_Framework_MockObject_MockObject
   */
  protected $accessAwareRouter;

  /**
   * The mocked access unaware router.
   * @var \Symfony\Component\Routing\Matcher\UrlMatcherInterface|\PHPUnit_Framework_MockObject_MockObject
   */
  protected $accessUnawareRouter;

  /**
   * The mocked account.
   *
   * @var \Drupal\Core\Session\AccountInterface|\PHPUnit_Framework_MockObject_MockObject
   */
  protected $account;

  /**
   * The path processor.
   *
   * @var \Drupal\Core\PathProcessor\InboundPathProcessorInterface|\PHPUnit_Framework_MockObject_MockObject
   */
  protected $pathProcessor;

  /**
   * The tested path validator.
   *
   * @var \Drupal\Core\Path\PathValidator
   */
  protected $pathValidator;

  /**
   * {@inheritdoc}
   */
  protected function setUp() {
    parent::setUp();
    $this->accessAwareRouter = $this
      ->getMock('Drupal\\Core\\Routing\\AccessAwareRouterInterface');
    $this->accessUnawareRouter = $this
      ->getMock('Symfony\\Component\\Routing\\Matcher\\UrlMatcherInterface');
    $this->account = $this
      ->getMock('Drupal\\Core\\Session\\AccountInterface');
    $this->pathProcessor = $this
      ->getMock('Drupal\\Core\\PathProcessor\\InboundPathProcessorInterface');
    $this->pathValidator = new PathValidator($this->accessAwareRouter, $this->accessUnawareRouter, $this->account, $this->pathProcessor);
  }

  /**
   * Tests the isValid() method for the frontpage.
   *
   * @covers ::isValid
   */
  public function testIsValidWithFrontpage() {
    $this->accessAwareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this
      ->assertTrue($this->pathValidator
      ->isValid('<front>'));
  }

  /**
   * Tests the isValid() method for <none> (used for jumplinks).
   *
   * @covers ::isValid
   */
  public function testIsValidWithNone() {
    $this->accessAwareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this
      ->assertTrue($this->pathValidator
      ->isValid('<none>'));
  }

  /**
   * Tests the isValid() method for an external URL.
   *
   * @covers ::isValid
   */
  public function testIsValidWithExternalUrl() {
    $this->accessAwareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this
      ->assertTrue($this->pathValidator
      ->isValid('https://www.drupal.org'));
  }

  /**
   * Tests the isValid() method with an invalid external URL.
   */
  public function testIsValidWithInvalidExternalUrl() {
    $this->accessAwareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this
      ->assertFalse($this->pathValidator
      ->isValid('http://'));
  }

  /**
   * Tests the isValid() method with a 'link to any page' permission.
   *
   * @covers ::isValid
   */
  public function testIsValidWithLinkToAnyPageAccount() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(TRUE);
    $this->accessAwareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessUnawareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path')
      ->willReturn([
      RouteObjectInterface::ROUTE_NAME => 'test_route',
      '_raw_variables' => new ParameterBag([
        'key' => 'value',
      ]),
    ]);
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $this
      ->assertTrue($this->pathValidator
      ->isValid('test-path'));
  }

  /**
   * Tests the isValid() method without the 'link to any page' permission.
   *
   * @covers ::isValid
   */
  public function testIsValidWithoutLinkToAnyPageAccount() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessUnawareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path')
      ->willReturn([
      RouteObjectInterface::ROUTE_NAME => 'test_route',
      '_raw_variables' => new ParameterBag([
        'key' => 'value',
      ]),
    ]);
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $this
      ->assertTrue($this->pathValidator
      ->isValid('test-path'));
  }

  /**
   * Tests the isValid() method with a path alias.
   *
   * @covers ::isValid
   */
  public function testIsValidWithPathAlias() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessUnawareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path')
      ->willReturn([
      RouteObjectInterface::ROUTE_NAME => 'test_route',
      '_raw_variables' => new ParameterBag([
        'key' => 'value',
      ]),
    ]);
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->with('/path-alias', $this
      ->anything())
      ->willReturn('/test-path');
    $this
      ->assertTrue($this->pathValidator
      ->isValid('path-alias'));
  }

  /**
   * Tests the isValid() method with a user without access to the path.
   *
   * @covers ::isValid
   */
  public function testIsValidWithAccessDenied() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessUnawareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path')
      ->willThrowException(new AccessDeniedHttpException());
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $this
      ->assertFalse($this->pathValidator
      ->isValid('test-path'));
  }

  /**
   * Tests the isValid() method with a not working param converting.
   *
   * @covers ::isValid
   */
  public function testIsValidWithFailingParameterConverting() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessUnawareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/entity-test/1')
      ->willThrowException(new ParamNotConvertedException());
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $this
      ->assertFalse($this->pathValidator
      ->isValid('entity-test/1'));
  }

  /**
   * Tests the isValid() method with a not existing path.
   *
   * @covers ::isValid
   */
  public function testIsValidWithNotExistingPath() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessUnawareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/not-existing-path')
      ->willThrowException(new ResourceNotFoundException());
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $this
      ->assertFalse($this->pathValidator
      ->isValid('not-existing-path'));
  }

  /**
   * Tests the getUrlIfValid() method when there is access.
   */
  public function testGetUrlIfValidWithAccess() {
    $this->account
      ->expects($this
      ->exactly(2))
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessAwareRouter
      ->expects($this
      ->exactly(2))
      ->method('match')
      ->with('/test-path')
      ->willReturn([
      RouteObjectInterface::ROUTE_NAME => 'test_route',
      '_raw_variables' => new ParameterBag([
        'key' => 'value',
      ]),
    ]);
    $this->pathProcessor
      ->expects($this
      ->exactly(2))
      ->method('processInbound')
      ->willReturnArgument(0);
    $url = $this->pathValidator
      ->getUrlIfValid('test-path');
    $this
      ->assertInstanceOf('Drupal\\Core\\Url', $url);
    $this
      ->assertEquals('test_route', $url
      ->getRouteName());
    $this
      ->assertEquals([
      'key' => 'value',
    ], $url
      ->getRouteParameters());

    // Test with leading /.
    $url = $this->pathValidator
      ->getUrlIfValid('/test-path');
    $this
      ->assertInstanceOf('Drupal\\Core\\Url', $url);
    $this
      ->assertEquals('test_route', $url
      ->getRouteName());
    $this
      ->assertEquals([
      'key' => 'value',
    ], $url
      ->getRouteParameters());
  }

  /**
   * Tests the getUrlIfValid() method with a query in the path.
   */
  public function testGetUrlIfValidWithQuery() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path?k=bar')
      ->willReturn([
      RouteObjectInterface::ROUTE_NAME => 'test_route',
      '_raw_variables' => new ParameterBag(),
    ]);
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $url = $this->pathValidator
      ->getUrlIfValid('test-path?k=bar');
    $this
      ->assertInstanceOf('Drupal\\Core\\Url', $url);
    $this
      ->assertEquals('test_route', $url
      ->getRouteName());
    $this
      ->assertEquals([
      'k' => 'bar',
    ], $url
      ->getOptions()['query']);
  }

  /**
   * Tests the getUrlIfValid() method where there is no access.
   */
  public function testGetUrlIfValidWithoutAccess() {
    $this->account
      ->expects($this
      ->once())
      ->method('hasPermission')
      ->with('link to any page')
      ->willReturn(FALSE);
    $this->accessAwareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path')
      ->willThrowException(new AccessDeniedHttpException());
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $url = $this->pathValidator
      ->getUrlIfValid('test-path');
    $this
      ->assertFalse($url);
  }

  /**
   * Tests the getUrlIfValid() method with a front page + query + fragments.
   */
  public function testGetUrlIfValidWithFrontPageAndQueryAndFragments() {
    $url = $this->pathValidator
      ->getUrlIfValid('<front>?hei=sen#berg');
    $this
      ->assertEquals('<front>', $url
      ->getRouteName());
    $this
      ->assertEquals([
      'hei' => 'sen',
    ], $url
      ->getOptions()['query']);
    $this
      ->assertEquals('berg', $url
      ->getOptions()['fragment']);
  }

  /**
   * Tests the getUrlIfValidWithoutAccessCheck() method.
   *
   * @covers ::getUrlIfValidWithoutAccessCheck
   */
  public function testGetUrlIfValidWithoutAccessCheck() {
    $this->account
      ->expects($this
      ->never())
      ->method('hasPermission')
      ->with('link to any page');
    $this->accessAwareRouter
      ->expects($this
      ->never())
      ->method('match');
    $this->accessUnawareRouter
      ->expects($this
      ->once())
      ->method('match')
      ->with('/test-path')
      ->willReturn([
      RouteObjectInterface::ROUTE_NAME => 'test_route',
      '_raw_variables' => new ParameterBag([
        'key' => 'value',
      ]),
    ]);
    $this->pathProcessor
      ->expects($this
      ->once())
      ->method('processInbound')
      ->willReturnArgument(0);
    $url = $this->pathValidator
      ->getUrlIfValidWithoutAccessCheck('test-path');
    $this
      ->assertInstanceOf('Drupal\\Core\\Url', $url);
    $this
      ->assertEquals('test_route', $url
      ->getRouteName());
    $this
      ->assertEquals([
      'key' => 'value',
    ], $url
      ->getRouteParameters());
  }

}

Members

Namesort descending Modifiers Type Description Overrides
PathValidatorTest::$accessAwareRouter protected property The mocked access aware router.
PathValidatorTest::$accessUnawareRouter protected property The mocked access unaware router.
PathValidatorTest::$account protected property The mocked account.
PathValidatorTest::$pathProcessor protected property The path processor.
PathValidatorTest::$pathValidator protected property The tested path validator.
PathValidatorTest::setUp protected function Overrides UnitTestCase::setUp
PathValidatorTest::testGetUrlIfValidWithAccess public function Tests the getUrlIfValid() method when there is access.
PathValidatorTest::testGetUrlIfValidWithFrontPageAndQueryAndFragments public function Tests the getUrlIfValid() method with a front page + query + fragments.
PathValidatorTest::testGetUrlIfValidWithoutAccess public function Tests the getUrlIfValid() method where there is no access.
PathValidatorTest::testGetUrlIfValidWithoutAccessCheck public function Tests the getUrlIfValidWithoutAccessCheck() method.
PathValidatorTest::testGetUrlIfValidWithQuery public function Tests the getUrlIfValid() method with a query in the path.
PathValidatorTest::testIsValidWithAccessDenied public function Tests the isValid() method with a user without access to the path.
PathValidatorTest::testIsValidWithExternalUrl public function Tests the isValid() method for an external URL.
PathValidatorTest::testIsValidWithFailingParameterConverting public function Tests the isValid() method with a not working param converting.
PathValidatorTest::testIsValidWithFrontpage public function Tests the isValid() method for the frontpage.
PathValidatorTest::testIsValidWithInvalidExternalUrl public function Tests the isValid() method with an invalid external URL.
PathValidatorTest::testIsValidWithLinkToAnyPageAccount public function Tests the isValid() method with a 'link to any page' permission.
PathValidatorTest::testIsValidWithNone public function Tests the isValid() method for <none> (used for jumplinks).
PathValidatorTest::testIsValidWithNotExistingPath public function Tests the isValid() method with a not existing path.
PathValidatorTest::testIsValidWithoutLinkToAnyPageAccount public function Tests the isValid() method without the 'link to any page' permission.
PathValidatorTest::testIsValidWithPathAlias public function Tests the isValid() method with a path alias.
UnitTestCase::$randomGenerator protected property The random generator.
UnitTestCase::$root protected property The app root.
UnitTestCase::assertArrayEquals protected function Asserts if two arrays are equal by sorting them first.
UnitTestCase::getBlockMockWithMachineName protected function Mocks a block with a block plugin.
UnitTestCase::getClassResolverStub protected function Returns a stub class resolver.
UnitTestCase::getConfigFactoryStub public function Returns a stub config factory that behaves according to the passed in array.
UnitTestCase::getConfigStorageStub public function Returns a stub config storage that returns the supplied configuration.
UnitTestCase::getContainerWithCacheTagsInvalidator protected function Sets up a container with a cache tags invalidator.
UnitTestCase::getRandomGenerator protected function Gets the random generator for the utility methods.
UnitTestCase::getStringTranslationStub public function Returns a stub translation manager that just returns the passed string.
UnitTestCase::randomMachineName public function Generates a unique random string containing letters and numbers.