class UserLoginTest

Same name in other branches
  1. 9 core/modules/user/tests/src/Functional/UserLoginTest.php \Drupal\Tests\user\Functional\UserLoginTest
  2. 8.9.x core/modules/user/tests/src/Functional/UserLoginTest.php \Drupal\Tests\user\Functional\UserLoginTest
  3. 11.x core/modules/user/tests/src/Functional/UserLoginTest.php \Drupal\Tests\user\Functional\UserLoginTest

Ensure that login works as expected.

@group user

Hierarchy

Expanded class hierarchy of UserLoginTest

File

core/modules/user/tests/src/Functional/UserLoginTest.php, line 18

Namespace

Drupal\Tests\user\Functional
View source
class UserLoginTest extends BrowserTestBase {
    use AssertMailTrait {
        getMails as drupalGetMails;
    }
    
    /**
     * {@inheritdoc}
     */
    protected $defaultTheme = 'stark';
    
    /**
     * {@inheritdoc}
     */
    protected static $modules = [
        'dblog',
    ];
    
    /**
     * Tests login with destination.
     */
    public function testLoginCacheTagsAndDestination() : void {
        $this->drupalGet('user/login');
        // The user login form says "Enter your <site name> username.", hence it
        // depends on config:system.site, and its cache tags should be present.
        $this->assertSession()
            ->responseHeaderContains('X-Drupal-Cache-Tags', 'config:system.site');
        $user = $this->drupalCreateUser([]);
        $this->drupalGet('user/login', [
            'query' => [
                'destination' => 'foo',
            ],
        ]);
        $edit = [
            'name' => $user->getAccountName(),
            'pass' => $user->passRaw,
        ];
        $this->submitForm($edit, 'Log in');
        $this->assertSession()
            ->addressEquals('foo');
    }
    
    /**
     * Tests the global login flood control.
     */
    public function testGlobalLoginFloodControl() : void {
        $this->config('user.flood')
            ->set('ip_limit', 10)
            ->set('user_limit', 4000)
            ->save();
        $user1 = $this->drupalCreateUser([]);
        $incorrect_user1 = clone $user1;
        $incorrect_user1->passRaw .= 'incorrect';
        // Try 2 failed logins.
        for ($i = 0; $i < 2; $i++) {
            $this->assertFailedLogin($incorrect_user1);
        }
        // A successful login will not reset the IP-based flood control count.
        $this->drupalLogin($user1);
        $this->drupalLogout();
        // Try 8 more failed logins, they should not trigger the flood control
        // mechanism.
        for ($i = 0; $i < 8; $i++) {
            $this->assertFailedLogin($incorrect_user1);
        }
        // The next login trial should result in an IP-based flood error message.
        $this->assertFailedLogin($incorrect_user1, 'ip');
        // A login with the correct password should also result in a flood error
        // message.
        $this->assertFailedLogin($user1, 'ip');
        // A login attempt after resetting the password should still fail, since the
        // IP-based flood control count is not cleared after a password reset.
        $this->resetUserPassword($user1);
        $this->drupalLogout();
        $this->assertFailedLogin($user1, 'ip');
        $this->assertSession()
            ->responseContains('Too many failed login attempts from your IP address.');
    }
    
    /**
     * Tests the per-user login flood control.
     */
    public function testPerUserLoginFloodControl() : void {
        $this->config('user.flood')
            ->set('ip_limit', 4000)
            ->set('user_limit', 3)
            ->save();
        $user1 = $this->drupalCreateUser([]);
        $incorrect_user1 = clone $user1;
        $incorrect_user1->passRaw .= 'incorrect';
        $user2 = $this->drupalCreateUser([]);
        // Try 2 failed logins.
        for ($i = 0; $i < 2; $i++) {
            $this->assertFailedLogin($incorrect_user1);
        }
        // We're not going to test resetting the password which should clear the
        // flood table and allow the user to log in again.
        $this->drupalLogin($user1);
        $this->drupalLogout();
        // Try 3 failed logins for user 1, they will not trigger flood control.
        for ($i = 0; $i < 3; $i++) {
            $this->assertFailedLogin($incorrect_user1);
        }
        // Try one successful attempt for user 2, it should not trigger any
        // flood control.
        $this->drupalLogin($user2);
        $this->drupalLogout();
        // Try one more attempt for user 1, it should be rejected, even if the
        // correct password has been used.
        $this->assertFailedLogin($user1, 'user');
        $this->resetUserPassword($user1);
        $this->drupalLogout();
        // Try to log in as user 1, it should be successful.
        $this->drupalLogin($user1);
        $this->assertSession()
            ->responseContains('Member for');
    }
    
    /**
     * Tests user password is re-hashed upon login after changing $count_log2.
     */
    public function testPasswordRehashOnLogin() : void {
        // Retrieve instance of password hashing algorithm.
        $password_hasher = $this->container
            ->get('password');
        // Create a new user and authenticate.
        $account = $this->drupalCreateUser([]);
        $password = $account->passRaw;
        $this->drupalLogin($account);
        $this->drupalLogout();
        // Load the stored user. The password hash shouldn't need a rehash.
        $user_storage = $this->container
            ->get('entity_type.manager')
            ->getStorage('user');
        $account = User::load($account->id());
        // Check that the stored password doesn't need rehash.
        $this->assertFalse($password_hasher->needsRehash($account->getPassword()));
        // The current hashing cost is set to 10 in the container. Increase cost by
        // one, by enabling a module containing the necessary container changes.
        \Drupal::service('module_installer')->install([
            'user_custom_pass_hash_params_test',
        ]);
        $this->resetAll();
        // Reload the hashing service after container changes.
        $password_hasher = $this->container
            ->get('password');
        // Check that the stored password does need rehash.
        $this->assertTrue($password_hasher->needsRehash($account->getPassword()));
        $account->passRaw = $password;
        $this->drupalGet('user/login');
        $edit = [
            'name' => $account->getAccountName(),
            'pass' => $account->passRaw,
        ];
        $this->submitForm($edit, 'Log in');
        // Load the stored user, which should have a different password hash now.
        $user_storage->resetCache([
            $account->id(),
        ]);
        $account = $user_storage->load($account->id());
        // Check that the stored password doesn't need rehash.
        $this->assertFalse($password_hasher->needsRehash($account->getPassword()));
        $this->assertTrue($password_hasher->check($password, $account->getPassword()));
    }
    
    /**
     * Tests log in with a maximum length and a too long password.
     */
    public function testPasswordLengthLogin() : void {
        // Create a new user and authenticate.
        $account = $this->drupalCreateUser([]);
        $current_password = $account->passRaw;
        $this->drupalLogin($account);
        // Use the length specified in
        // \Drupal\Core\Render\Element\Password::getInfo().
        $length = 128;
        $current_password = $this->doPasswordLengthLogin($account, $current_password, $length);
        $this->assertSession()
            ->pageTextNotContains('Password cannot be longer than');
        $this->assertSession()
            ->pageTextContains('Member for');
        $this->doPasswordLengthLogin($account, $current_password, $length + 1);
        $this->assertSession()
            ->pageTextContains('Password cannot be longer than ' . $length . ' characters but is currently ' . ($length + 1) . ' characters long.');
        $this->assertSession()
            ->pageTextNotContains('Member for');
    }
    
    /**
     * Helper to test log in with a maximum length password.
     *
     * @param \Drupal\user\UserInterface $account
     *   An object containing the user account.
     * @param string $current_password
     *   The current password associated with the user.
     * @param int $length
     *   The length of the password.
     *
     * @return string
     *   The new password associated with the user.
     */
    public function doPasswordLengthLogin(UserInterface $account, string $current_password, int $length) {
        $new_password = \Drupal::service('password_generator')->generate($length);
        $uid = $account->id();
        $edit = [
            'current_pass' => $current_password,
            'mail' => $account->getEmail(),
            'pass[pass1]' => $new_password,
            'pass[pass2]' => $new_password,
        ];
        // Change the password.
        $this->drupalGet("user/{$uid}/edit");
        $this->submitForm($edit, 'Save');
        $this->assertSession()
            ->pageTextContains('The changes have been saved.');
        $this->drupalLogout();
        // Login with new password.
        $this->drupalGet('user/login');
        $edit = [
            'name' => $account->getAccountName(),
            'pass' => $new_password,
        ];
        $this->submitForm($edit, 'Log in');
        return $new_password;
    }
    
    /**
     * Tests with a browser that denies cookies.
     */
    public function testCookiesNotAccepted() : void {
        $this->drupalGet('user/login');
        $form_build_id = $this->getSession()
            ->getPage()
            ->findField('form_build_id');
        $account = $this->drupalCreateUser([]);
        $post = [
            'form_id' => 'user_login_form',
            'form_build_id' => $form_build_id,
            'name' => $account->getAccountName(),
            'pass' => $account->passRaw,
            'op' => 'Log in',
        ];
        $url = $this->buildUrl(Url::fromRoute('user.login'));
        
        /** @var \Psr\Http\Message\ResponseInterface $response */
        $response = $this->getHttpClient()
            ->post($url, [
            'form_params' => $post,
            'http_errors' => FALSE,
            'cookies' => FALSE,
            'allow_redirects' => FALSE,
        ]);
        // Follow the location header.
        $this->drupalGet($response->getHeader('location')[0]);
        $this->assertSession()
            ->statusCodeEquals(403);
        $this->assertSession()
            ->pageTextContains('To log in to this site, your browser must accept cookies from the domain');
    }
    
    /**
     * Make an unsuccessful login attempt.
     *
     * @param \Drupal\user\Entity\User $account
     *   A user object with name and passRaw attributes for the login attempt.
     * @param string $flood_trigger
     *   (optional) Whether or not to expect that the flood control mechanism
     *    will be triggered. Defaults to NULL.
     *   - Set to 'user' to expect a 'too many failed logins error.
     *   - Set to any value to expect an error for too many failed logins per IP.
     *   - Set to NULL to expect a failed login.
     *
     * @internal
     */
    public function assertFailedLogin(User $account, ?string $flood_trigger = NULL) : void {
        $database = \Drupal::database();
        $edit = [
            'name' => $account->getAccountName(),
            'pass' => $account->passRaw,
        ];
        $this->drupalGet('user/login');
        $this->submitForm($edit, 'Log in');
        if (isset($flood_trigger)) {
            $this->assertSession()
                ->statusCodeEquals(403);
            $this->assertSession()
                ->fieldNotExists('pass');
            $last_log = $database->select('watchdog', 'w')
                ->fields('w', [
                'message',
            ])
                ->condition('type', 'user')
                ->orderBy('wid', 'DESC')
                ->range(0, 1)
                ->execute()
                ->fetchField();
            if ($flood_trigger == 'user') {
                $this->assertSession()
                    ->pageTextMatches("/There (has|have) been more than \\w+ failed login attempt.* for this account. It is temporarily blocked. Try again later or request a new password./");
                $this->assertSession()
                    ->elementExists('css', 'body.maintenance-page');
                $this->assertSession()
                    ->linkExists("request a new password");
                $this->assertSession()
                    ->linkByHrefExists(Url::fromRoute('user.pass')->toString());
                $this->assertEquals('Flood control blocked login attempt for uid %uid from %ip', $last_log, 'A watchdog message was logged for the login attempt blocked by flood control per user.');
            }
            else {
                // No uid, so the limit is IP-based.
                $this->assertSession()
                    ->pageTextContains("Too many failed login attempts from your IP address. This IP address is temporarily blocked. Try again later or request a new password.");
                $this->assertSession()
                    ->elementExists('css', 'body.maintenance-page');
                $this->assertSession()
                    ->linkExists("request a new password");
                $this->assertSession()
                    ->linkByHrefExists(Url::fromRoute('user.pass')->toString());
                $this->assertEquals('Flood control blocked login attempt from %ip', $last_log, 'A watchdog message was logged for the login attempt blocked by flood control per IP.');
            }
        }
        else {
            $this->assertSession()
                ->statusCodeEquals(200);
            $this->assertSession()
                ->fieldValueEquals('pass', '');
            $this->assertSession()
                ->pageTextContains('Unrecognized username or password. Forgot your password?');
        }
    }
    
    /**
     * Reset user password.
     *
     * @param object $user
     *   A user object.
     */
    public function resetUserPassword($user) {
        $this->drupalGet('user/password');
        $edit['name'] = $user->getDisplayName();
        $this->submitForm($edit, 'Submit');
        $_emails = $this->drupalGetMails();
        $email = end($_emails);
        $urls = [];
        preg_match('#.+user/reset/.+#', $email['body'], $urls);
        $resetURL = $urls[0];
        $this->drupalGet($resetURL);
        $this->submitForm([], 'Log in');
    }
    
    /**
     * Tests that user login form has the autocomplete attributes.
     */
    public function testAutocompleteHtmlAttributes() : void {
        $this->drupalGet('user/login');
        $name_field = $this->getSession()
            ->getPage()
            ->findField('name');
        $pass_field = $this->getSession()
            ->getPage()
            ->findField('pass');
        $this->assertEquals('username', $name_field->getAttribute('autocomplete'));
        $this->assertEquals('current-password', $pass_field->getAttribute('autocomplete'));
    }

}

Members

Title Sort descending Deprecated Modifiers Object type Summary Member alias Overriden Title Overrides
AssertMailTrait::assertMail protected function Asserts that the most recently sent email message has the given value.
AssertMailTrait::assertMailPattern protected function Asserts that the most recently sent email message has the pattern in it.
AssertMailTrait::assertMailString protected function Asserts that the most recently sent email message has the string in it.
AssertMailTrait::getMails protected function Gets an array containing all emails sent during this test case. Aliased as: drupalGetMails
BlockCreationTrait::placeBlock protected function Creates a block instance based on default settings. Aliased as: drupalPlaceBlock
BrowserHtmlDebugTrait::$htmlOutputBaseUrl protected property The Base URI to use for links to the output files.
BrowserHtmlDebugTrait::$htmlOutputClassName protected property Class name for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputCounter protected property Counter for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputCounterStorage protected property Counter storage for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputDirectory protected property Directory name for HTML output logging.
BrowserHtmlDebugTrait::$htmlOutputEnabled protected property HTML output enabled.
BrowserHtmlDebugTrait::$htmlOutputFile protected property The file name to write the list of URLs to.
BrowserHtmlDebugTrait::$htmlOutputTestId protected property HTML output test ID.
BrowserHtmlDebugTrait::formatHtmlOutputHeaders protected function Formats HTTP headers as string for HTML output logging.
BrowserHtmlDebugTrait::getHtmlOutputHeaders protected function Returns headers in HTML output format. 1
BrowserHtmlDebugTrait::getResponseLogHandler protected function Provides a Guzzle middleware handler to log every response received.
BrowserHtmlDebugTrait::htmlOutput protected function Logs a HTML output message in a text file.
BrowserHtmlDebugTrait::initBrowserOutputFile protected function Creates the directory to store browser output.
BrowserTestBase::$baseUrl protected property The base URL.
BrowserTestBase::$configImporter protected property The config importer that can be used in a test.
BrowserTestBase::$customTranslations protected property An array of custom translations suitable for SettingsEditor::rewrite().
BrowserTestBase::$mink protected property Mink session manager.
BrowserTestBase::$minkDefaultDriverArgs protected property Mink default driver params.
BrowserTestBase::$minkDefaultDriverClass protected property Mink class for the default driver to use. 1
BrowserTestBase::$originalContainer protected property The original container.
BrowserTestBase::$originalShutdownCallbacks protected property The original array of shutdown function callbacks.
BrowserTestBase::$preserveGlobalState protected property
BrowserTestBase::$profile protected property The profile to install as a basis for testing. 40
BrowserTestBase::$runTestInSeparateProcess protected property Browser tests are run in separate processes to prevent collisions between
code that may be loaded by tests.
BrowserTestBase::$timeLimit protected property Time limit in seconds for the test.
BrowserTestBase::$translationFilesDirectory protected property The translation file directory for the test environment.
BrowserTestBase::cleanupEnvironment protected function Clean up the test environment.
BrowserTestBase::config protected function Configuration accessor for tests. Returns non-overridden configuration.
BrowserTestBase::filePreDeleteCallback public static function Ensures test files are deletable.
BrowserTestBase::getDefaultDriverInstance protected function Gets an instance of the default Mink driver.
BrowserTestBase::getDrupalSettings protected function Gets the JavaScript drupalSettings variable for the currently-loaded page. 1
BrowserTestBase::getHttpClient protected function Obtain the HTTP client for the system under test.
BrowserTestBase::getMinkDriverArgs protected function Gets the Mink driver args from an environment variable. 1
BrowserTestBase::getOptions protected function Helper function to get the options of select field.
BrowserTestBase::getSession public function Returns Mink session.
BrowserTestBase::getSessionCookies protected function Get session cookies from current session.
BrowserTestBase::getTestMethodCaller protected function Retrieves the current calling line in the class under test. Overrides BrowserHtmlDebugTrait::getTestMethodCaller
BrowserTestBase::initFrontPage protected function Visits the front page when initializing Mink. 3
BrowserTestBase::initMink protected function Initializes Mink sessions. 1
BrowserTestBase::installDrupal public function Installs Drupal into the test site. 2
BrowserTestBase::registerSessions protected function Registers additional Mink sessions.
BrowserTestBase::setUp protected function 544
BrowserTestBase::setUpAppRoot protected function Sets up the root application path.
BrowserTestBase::setUpBeforeClass public static function 1
BrowserTestBase::tearDown protected function 3
BrowserTestBase::translatePostValues protected function Transforms a nested array into a flat array suitable for submitForm().
BrowserTestBase::xpath protected function Performs an xpath search on the contents of the internal browser.
BrowserTestBase::__get public function
BrowserTestBase::__sleep public function Prevents serializing any properties.
ConfigTestTrait::configImporter protected function Returns a ConfigImporter object to import test configuration.
ConfigTestTrait::copyConfig protected function Copies configuration objects from source storage to target storage.
ContentTypeCreationTrait::createContentType protected function Creates a custom content type based on default settings. Aliased as: drupalCreateContentType 1
ExtensionListTestTrait::getModulePath protected function Gets the path for the specified module.
ExtensionListTestTrait::getThemePath protected function Gets the path for the specified theme.
FunctionalTestSetupTrait::$apcuEnsureUniquePrefix protected property The flag to set &#039;apcu_ensure_unique_prefix&#039; setting. 1
FunctionalTestSetupTrait::$classLoader protected property The class loader to use for installation and initialization of setup.
FunctionalTestSetupTrait::$rootUser protected property The &quot;#1&quot; admin user.
FunctionalTestSetupTrait::$usesSuperUserAccessPolicy protected property Set to TRUE to make user 1 a super user. 10
FunctionalTestSetupTrait::doInstall protected function Execute the non-interactive installer. 2
FunctionalTestSetupTrait::getDatabaseTypes protected function Returns all supported database driver installer objects.
FunctionalTestSetupTrait::initConfig protected function Initialize various configurations post-installation. 1
FunctionalTestSetupTrait::initKernel protected function Initializes the kernel after installation.
FunctionalTestSetupTrait::initSettings protected function Initialize settings created during install.
FunctionalTestSetupTrait::initUserSession protected function Initializes user 1 for the site to be installed.
FunctionalTestSetupTrait::installDefaultThemeFromClassProperty protected function Installs the default theme defined by `static::$defaultTheme` when needed. 1
FunctionalTestSetupTrait::installModulesFromClassProperty protected function Install modules defined by `static::$modules`. 1
FunctionalTestSetupTrait::installParameters protected function Returns the parameters that will be used when the test installs Drupal. 8
FunctionalTestSetupTrait::prepareEnvironment protected function Prepares the current environment for running the test. 28
FunctionalTestSetupTrait::prepareRequestForGenerator protected function Creates a mock request and sets it on the generator.
FunctionalTestSetupTrait::prepareSettings protected function Prepares site settings and services before installation. 4
FunctionalTestSetupTrait::rebuildAll protected function Resets and rebuilds the environment after setup.
FunctionalTestSetupTrait::rebuildContainer protected function Rebuilds \Drupal::getContainer().
FunctionalTestSetupTrait::resetAll protected function Resets all data structures after having enabled new modules.
FunctionalTestSetupTrait::setContainerParameter protected function Changes parameters in the services.yml file.
FunctionalTestSetupTrait::setupBaseUrl protected function Sets up the base URL based upon the environment variable.
FunctionalTestSetupTrait::writeSettings protected function Rewrites the settings.php file of the test site. 1
NodeCreationTrait::createNode protected function Creates a node based on default settings. Aliased as: drupalCreateNode
NodeCreationTrait::getNodeByTitle public function Get a node from the database based on its title. Aliased as: drupalGetNodeByTitle
PhpUnitWarnings::$deprecationWarnings private static property Deprecation warnings from PHPUnit to raise with @trigger_error().
PhpUnitWarnings::addWarning public function Converts PHPUnit deprecation warnings to E_USER_DEPRECATED.
RandomGeneratorTrait::getRandomGenerator protected function Gets the random generator for the utility methods.
RandomGeneratorTrait::randomMachineName protected function Generates a unique random string containing letters and numbers.
RandomGeneratorTrait::randomObject public function Generates a random PHP object.
RandomGeneratorTrait::randomString public function Generates a pseudo-random string of ASCII characters of codes 32 to 126.
RandomGeneratorTrait::randomStringValidate Deprecated public function Callback for random string validation.
RefreshVariablesTrait::refreshVariables protected function Refreshes in-memory configuration and state information. 2
SessionTestTrait::$sessionName protected property The name of the session cookie.
SessionTestTrait::generateSessionName protected function Generates a session cookie name.
SessionTestTrait::getSessionName protected function Returns the session name in use on the child site.
StorageCopyTrait::replaceStorageContents protected static function Copy the configuration from one storage to another and remove stale items.
TestRequirementsTrait::checkModuleRequirements Deprecated private function Checks missing module requirements.
TestRequirementsTrait::checkRequirements Deprecated protected function Check module requirements for the Drupal use case.
TestRequirementsTrait::getDrupalRoot protected static function Returns the Drupal root directory.
TestSetupTrait::$configSchemaCheckerExclusions protected static property An array of config object names that are excluded from schema checking. 2
TestSetupTrait::$container protected property The dependency injection container used in the test.
TestSetupTrait::$databasePrefix protected property The database prefix of this test run.
TestSetupTrait::$kernel protected property The DrupalKernel instance used in the test.
TestSetupTrait::$originalSite protected property The site directory of the original parent site.
TestSetupTrait::$privateFilesDirectory protected property The private file directory for the test environment.
TestSetupTrait::$publicFilesDirectory protected property The public file directory for the test environment.
TestSetupTrait::$root protected property The app root.
TestSetupTrait::$siteDirectory protected property The site directory of this test run.
TestSetupTrait::$strictConfigSchema protected property Set to TRUE to strict check all configuration saved. 4
TestSetupTrait::$tempFilesDirectory protected property The temporary file directory for the test environment.
TestSetupTrait::$testId protected property The test run ID.
TestSetupTrait::changeDatabasePrefix protected function Changes the database connection to the prefixed one.
TestSetupTrait::getConfigSchemaExclusions protected function Gets the config schema exclusions for this test.
TestSetupTrait::getDatabaseConnection Deprecated public static function Returns the database connection to the site under test.
TestSetupTrait::prepareDatabasePrefix protected function Generates a database prefix for running tests. 1
UiHelperTrait::$loggedInUser protected property The current user logged in using the Mink controlled browser.
UiHelperTrait::$maximumMetaRefreshCount protected property The number of meta refresh redirects to follow, or NULL if unlimited.
UiHelperTrait::$metaRefreshCount protected property The number of meta refresh redirects followed during ::drupalGet().
UiHelperTrait::$useOneTimeLoginLinks protected property Use one-time login links instead of submitting the login form. 3
UiHelperTrait::assertSession public function Returns WebAssert object. 1
UiHelperTrait::buildUrl protected function Builds an absolute URL from a system path or a URL object.
UiHelperTrait::checkForMetaRefresh protected function Checks for meta refresh tag and if found call drupalGet() recursively.
UiHelperTrait::click protected function Clicks the element with the given CSS selector.
UiHelperTrait::clickLink protected function Follows a link by complete name.
UiHelperTrait::cssSelect protected function Searches elements using a CSS selector in the raw content.
UiHelperTrait::cssSelectToXpath protected function Translates a CSS expression to its XPath equivalent.
UiHelperTrait::drupalGet protected function Retrieves a Drupal path or an absolute path. 3
UiHelperTrait::drupalLogin protected function Logs in a user using the Mink controlled browser.
UiHelperTrait::drupalLogout protected function Logs a user out of the Mink controlled browser and confirms.
UiHelperTrait::drupalResetSession protected function Resets the current active session back to Anonymous session.
UiHelperTrait::drupalUserIsLoggedIn protected function Returns whether a given user account is logged in.
UiHelperTrait::getAbsoluteUrl protected function Takes a path and returns an absolute path.
UiHelperTrait::getTextContent protected function Retrieves the plain-text content from the current page.
UiHelperTrait::getUrl protected function Get the current URL from the browser.
UiHelperTrait::isTestUsingGuzzleClient protected function Determines if test is using DrupalTestBrowser.
UiHelperTrait::prepareRequest protected function Prepare for a request to testing site. 1
UiHelperTrait::submitForm protected function Fills and submits a form.
UserCreationTrait::checkPermissions protected function Checks whether a given list of permission names is valid.
UserCreationTrait::createAdminRole protected function Creates an administrative role.
UserCreationTrait::createRole protected function Creates a role with specified permissions. Aliased as: drupalCreateRole
UserCreationTrait::createUser protected function Create a user with a given set of permissions. Aliased as: drupalCreateUser
UserCreationTrait::grantPermissions protected function Grant permissions to a user role.
UserCreationTrait::setCurrentUser protected function Switch the current logged in user.
UserCreationTrait::setUpCurrentUser protected function Creates a random user account and sets it as current user.
UserLoginTest::$defaultTheme protected property The theme to install as the default for testing. Overrides BrowserTestBase::$defaultTheme
UserLoginTest::$modules protected static property Modules to install. Overrides BrowserTestBase::$modules 1
UserLoginTest::assertFailedLogin public function Make an unsuccessful login attempt.
UserLoginTest::doPasswordLengthLogin public function Helper to test log in with a maximum length password.
UserLoginTest::resetUserPassword public function Reset user password.
UserLoginTest::testAutocompleteHtmlAttributes public function Tests that user login form has the autocomplete attributes.
UserLoginTest::testCookiesNotAccepted public function Tests with a browser that denies cookies.
UserLoginTest::testGlobalLoginFloodControl public function Tests the global login flood control.
UserLoginTest::testLoginCacheTagsAndDestination public function Tests login with destination.
UserLoginTest::testPasswordLengthLogin public function Tests log in with a maximum length and a too long password.
UserLoginTest::testPasswordRehashOnLogin public function Tests user password is re-hashed upon login after changing $count_log2.
UserLoginTest::testPerUserLoginFloodControl public function Tests the per-user login flood control.
XdebugRequestTrait::extractCookiesFromRequest protected function Adds xdebug cookies, from request setup.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.