check example

$this->policy = new ChainRequestPolicy();
    $this->request = new Request();
  }

  /** * Asserts that check() returns NULL if the chain is empty. * * @covers ::check */
  public function testEmptyChain() {
    $result = $this->policy->check($this->request);
    $this->assertNull($result);
  }

  /** * Asserts that check() returns NULL if a rule returns NULL. * * @covers ::check */
  public function testNullRuleChain() {
    $rule = $this->createMock('Drupal\Core\PageCache\RequestPolicyInterface');
    $rule->expects($this->once())
      

public function setExistingPassword(#[\SensitiveParameter] $password) {     $this->get('pass')->existing = $password;
    return $this;
  }

  /** * {@inheritdoc} */
  public function checkExistingPassword(UserInterface $account_unchanged) {
    $existing = $this->get('pass')->existing;
    return $existing !== NULL && strlen($existing) > 0 &&
      \Drupal::service('password')->check(trim($existing), $account_unchanged->getPassword());
  }

  /** * Returns an anonymous user entity. * * @return \Drupal\user\UserInterface * An anonymous user entity. */
  public static function getAnonymousUser() {
    if (!isset(static::$anonymousUser)) {

      

  /** * Tests a vertical tab 'Workflow' summary. */
  public function testWorkflowSummary() {
    $this->drupalGet('admin/structure/types/manage/test');
    $page = $this->getSession()->getPage();
    $page->find('css', 'a[href="#edit-workflow"]')->click();
    $this->assertSession()->waitForElementVisible('css', '[name="options[status]"]');
    $page->findField('options[status]')->uncheck();
    $page->findField('options[sticky]')->check();
    $page->findField('options[promote]')->check();
    $page->findField('options[revision]')->check();
    $locator = '[href="#edit-workflow"] .vertical-tabs__menu-item-summary';
    $this->assertTrue($page->waitFor(10, function D) use ($page, $locator) {
      $summary = $page->find('css', $locator)->getText();
      return str_contains($summary, 'Not published');
    }));
    $summary = $page->find('css', $locator)->getText();
    $this->assertEquals('Not published, Promoted to front page, Sticky at top of lists, Create new revision', $summary);
  }

}

if (version_compare($this->shopwareVersion, $updates->version, '>=')) {
            return new JsonResponse();
        }

        return new JsonResponse($updates);
    }

    #[Route(path: '/api/_action/update/check-requirements', name: 'api.custom.update.check_requirements', defaults: ['_acl' => ['system:core:update']], methods: ['GET'])]     public function checkRequirements(): JsonResponse
    {
        return new JsonResponse([
            $this->writeableCheck->check(),
            $this->licenseCheck->check(),
        ]);
    }

    #[Route('/api/_action/update/extension-compatibility', name: 'api.custom.updateapi.extension_compatibility', defaults: ['_acl' => ['system:core:update', 'system_config:read']], methods: ['GET'])]     public function extensionCompatibility(Context $context): JsonResponse
    {
        $update = $this->apiClient->checkForUpdates();

        return new JsonResponse($this->extensionCompatibility->getExtensionCompatibilities($update, $context));
    }

    

  public function testActionConfigurationWithAjax() {
    $url = Url::fromRoute('action.admin_add', ['action_id' => 'action_form_ajax_test']);
    $this->drupalGet($url);
    $page = $this->getSession()->getPage();

    $id = 'test_plugin';
    $this->assertSession()->waitForElementVisible('named', ['button', 'Edit'])->press();
    $this->assertSession()->waitForElementVisible('css', '[name="id"]')->setValue($id);

    $page->find('css', '[name="having_a_party"]')
      ->check();
    $this->assertSession()->waitForElementVisible('css', '[name="party_time"]');

    $party_time = 'Evening';
    $page->find('css', '[name="party_time"]')
      ->setValue($party_time);

    $page->find('css', '[value="Save"]')
      ->click();

    $url = Url::fromRoute('entity.action.collection');
    $this->assertSession()->pageTextContains('The action has been successfully saved.');
    

  protected function validateSchema($schema, $response_data) {
    $this->validator->check($response_data, $schema);
    $is_valid = $this->validator->isValid();
    if (!$is_valid) {
      $this->logger->debug("Response failed validation.\nResponse:\n@data\n\nErrors:\n@errors", [
        '@data' => Json::encode($response_data),
        '@errors' => Json::encode($this->validator->getErrors()),
      ]);
    }
    return $is_valid;
  }

}

$this->service = $this->container->get($this->drupalProxyOriginalServiceId);
            }

            return $this->service;
        }

        /** * {@inheritdoc} */
        public function check(\Symfony\Component\HttpFoundation\Response $response, \Symfony\Component\HttpFoundation\Request $request)
        {
            return $this->lazyLoadItself()->check($response, $request);
        }

        /** * {@inheritdoc} */
        public function addPolicy(\Drupal\Core\PageCache\ResponsePolicyInterface $policy)
        {
            return $this->lazyLoadItself()->addPolicy($policy);
        }

    }

}

$shopwareSystemCheck = $container->offsetGet('install.requirements');
    $systemCheckResults = $shopwareSystemCheck->toArray();

    $app->view()->setData('warning', (bool) $systemCheckResults['hasWarnings']);
    $app->view()->setData('error', (bool) $systemCheckResults['hasErrors']);
    $app->view()->setData('systemError', (bool) $systemCheckResults['hasErrors']);
    $app->view()->setData('phpVersionNotSupported', $systemCheckResults['phpVersionNotSupported']);

    // Check file & directory permissions     /** @var RequirementsPath $shopwareSystemCheckPath */
    $shopwareSystemCheckPath = $container->offsetGet('install.requirementsPath');
    $shopwareSystemCheckPathResult = $shopwareSystemCheckPath->check();

    $app->view()->setData('pathError', false);

    if ($shopwareSystemCheckPathResult->hasError()) {
        $app->view()->setData('error', true);
        $app->view()->setData('pathError', true);
    }

    if ($app->request()->isPost() && $app->view()->getData('error') == false) {
        // No errors and submitted form - proceed with next-step         $app->redirect($menuHelper->getNextUrl());
    }

// Check the baseURL in .env         if (is_file(HOMEPATH . '.env')) {
            $env = preg_grep('/^app\.baseURL = ./', file(HOMEPATH . '.env')) !== false;
        }

        if ($env) {
            // BaseURL in .env is a valid URL?             // phpunit.xml.dist sets app.baseURL in $_SERVER             // So if you set app.baseURL in .env, it takes precedence             $config = new App();
            $this->assertTrue(
                $validation->check($config->baseURL, 'valid_url'),
                'baseURL "' . $config->baseURL . '" in .env is not valid URL'
            );
        }

        // Get the baseURL in app/Config/App.php         // You can't use Config\App, because phpunit.xml.dist sets app.baseURL         $reader = new ConfigReader();

        // BaseURL in app/Config/App.php is a valid URL?         $this->assertTrue(
            $validation->check($reader->baseURL, 'valid_url'),
            

$this->policy = new AllowToolbarPath();
  }

  /** * Asserts that caching is allowed if the request goes to toolbar subtree. * * @dataProvider providerTestAllowToolbarPath * @covers ::check */
  public function testAllowToolbarPath($expected_result, $path) {
    $request = Request::create($path);
    $result = $this->policy->check($request);
    $this->assertSame($expected_result, $result);
  }

  /** * Provides data and expected results for the test method. * * @return array * Data and expected results. */
  public function providerTestAllowToolbarPath() {
    return [
      [

    $front = $this->config->get('page.front');
    $exclude[$front] = TRUE;
    // /user is just a redirect, so skip it.     // @todo Find a better way to deal with /user.     $exclude['/user'] = TRUE;
    while (count($path_elements) > 1) {
      array_pop($path_elements);
      // Copy the path elements for up-casting.       $route_request = $this->getRequestForPath('/' . implode('/', $path_elements), $exclude);
      if ($route_request) {
        $route_match = RouteMatch::createFromRequest($route_request);
        $access = $this->accessManager->check($route_match, $this->currentUser, NULL, TRUE);
        // The set of breadcrumb links depends on the access result, so merge         // the access result's cacheability metadata.         $breadcrumb = $breadcrumb->addCacheableDependency($access);
        if ($access->isAllowed()) {
          $title = $this->titleResolver->getTitle($route_request, $route_match->getRouteObject());
          if (!isset($title)) {
            // Fallback to using the raw path component as the title if the             // route is missing a _title or _title_callback attribute.             $title = str_replace(['-', '_'], ' ', Unicode::ucfirst(end($path_elements)));
          }
          $url = Url::fromRouteMatch($route_match);
          

  protected $rules = [];

  /** * {@inheritdoc} */
  public function check(Request $request) {
    $final_result = NULL;

    foreach ($this->rules as $rule) {
      $result = $rule->check($request);
      if ($result === static::DENY) {
        return $result;
      }
      elseif ($result === static::ALLOW) {
        $final_result = $result;
      }
      elseif (isset($result)) {
        throw new \UnexpectedValueException('Return value of RequestPolicyInterface::check() must be one of RequestPolicyInterface::ALLOW, RequestPolicyInterface::DENY or NULL');
      }
    }

    

  public function testHttpMethod($expected_result, $method) {
    $this->policy->expects($this->once())
      ->method('isCli')
      ->willReturn(FALSE);

    $request = Request::create('/', $method);
    $actual_result = $this->policy->check($request);
    $this->assertSame($expected_result, $actual_result);
  }

  /** * Provides test data and expected results for the HTTP method test. * * @return array * Test data and expected results. */
  public function providerTestHttpMethod() {
    return [
      [

    public static function check($file)
    {
        if (file_exists($file)) {
            if (!is_writable($file)) {
                return $file;
            }

            return true;
        }

        return self::check(\dirname($file));
    }

    /** * @param string $xmlPath * * @return array */
    public static function getPaths($xmlPath)
    {
        $paths = [];
        $xml = simplexml_load_file($xmlPath);

        

/** * Selects an item in the media library modal. * * @param int $index * The zero-based index of the item to select. * @param string $expected_selected_count * (optional) The expected text of the selection counter. */
  protected function selectMediaItem($index, $expected_selected_count = NULL) {
    $checkboxes = $this->getCheckboxes();
    $this->assertGreaterThan($index, count($checkboxes));
    $checkboxes[$index]->check();

    if ($expected_selected_count) {
      $this->assertSelectedMediaCount($expected_selected_count);
    }
  }

  /** * De-selects an item in the media library modal. * * @param int $index * The zero-based index of the item to unselect. */