class RoutePathGenerationTraitTest

class RoutePathGenerationTraitTest extends UnitTestCase {
  
  /**
   * The mock CSRF token generator.
   */
  protected CsrfTokenGenerator $csrfToken;
  
  /**
   * The request stack.
   */
  protected RequestStack $requestStack;
  
  /**
   * The route processor.
   */
  protected RouteProcessorCsrf $processor;
  
  /**
   * The CSRF access checker.
   */
  protected CsrfAccessCheck $accessCheck;
  
  /**
   * {@inheritdoc}
   */
  protected function setUp() : void {
    parent::setUp();
    $this->csrfToken = $this->getMockBuilder(CsrfTokenGenerator::class)
      ->disableOriginalConstructor()
      ->getMock();
    // Make CsrfTokenGenerator mock use a simple hash of the value passed as
    // parameter, as it is enough for the sake of our tests.
    $this->csrfToken
      ->method('get')
      ->willReturnCallback(function ($value) {
      return hash('sha256', $value);
    });
    $this->csrfToken
      ->method('validate')
      ->willReturnCallback(function ($token, $value) {
      return $token === hash('sha256', $value);
    });
    $this->requestStack = $this->createMock(RequestStack::class);
    $this->processor = new RouteProcessorCsrf($this->csrfToken, $this->requestStack);
    $this->accessCheck = new CsrfAccessCheck($this->csrfToken);
  }
  
  /**
   * Tests that CSRF token creation and validation is consistent.
   *
   * This checks that CsrfAccessCheck() and RouteProcessorCsrf() produce the
   * same results.
   *
   * Multiple cases are provided for an optional parameter (non-empty, empty,
   * null, undefined).
   *
   * @dataProvider providerTestCsrfTokenCompleteLifeCycle
   */
  public function testCsrfTokenCompleteLifeCycle($params) : void {
    // Mock a route.
    $route = $this->createMock(Route::class);
    $route->method('getPath')
      ->willReturn('test/example/{param}');
    $route->method('hasRequirement')
      ->with('_csrf_token')
      ->willReturn(TRUE);
    // Process the route so the "token" param is generated.
    $routeParams = $params;
    $this->processor
      ->processOutbound('test.example', $route, $routeParams);
    $requestParams = $params + [
      'token' => $routeParams['token'],
    ];
    // Mock Parameter bag.
    $parameterBag = $this->createMock(ParameterBagInterface::class);
    $parameterBag->method('get')
      ->willReturnCallback(function ($key, $default = NULL) use ($requestParams) {
      return $requestParams[$key] ?? $default;
    });
    $parameterBag->method('all')
      ->willReturn($requestParams);
    // Get a real InputBag because it is a final class.
    $inputBag = new InputBag($requestParams);
    // Mock Request.
    $request = $this->createMock(Request::class);
    $request->query = $inputBag;
    // Mock RouteMatch.
    $routeMatch = $this->createMock(RouteMatchInterface::class);
    $routeMatch->method('getRawParameters')
      ->willReturn($parameterBag);
    // Check for allowed access.
    $this->assertInstanceOf(AccessResultAllowed::class, $this->accessCheck
      ->access($route, $request, $routeMatch));
  }
  
  /**
   * Data provider for testCsrfTokenCompleteLifeCycle().
   *
   * @return array
   *   An array of route parameters.
   */
  public static function providerTestCsrfTokenCompleteLifeCycle() : array {
    return [
      [
        [
          'param' => 'value',
        ],
      ],
      [
        [
          'param' => '',
        ],
      ],
      [
        [
          'param' => NULL,
        ],
      ],
      [
        [],
      ],
    ];
  }

}