Authentication testing in Testing Fundamentals - Build an Automation Script

Verify user login with valid and invalid credentials

Preconditions (1)

Step 1: Enter '[e-mail]' in the email input field

Step 2: Enter 'ValidPass123' in the password input field

Step 3: Click the 'Login' button

Step 4: Verify that the user is redirected to the dashboard page

Step 5: Log out to return to the login page

Step 6: Enter '[e-mail]' in the email input field

Step 7: Enter 'WrongPass' in the password input field

Step 8: Click the 'Login' button

Step 9: Verify that an error message 'Invalid email or password' is displayed

✅ Expected Result: User successfully logs in with valid credentials and sees the dashboard. User cannot log in with invalid credentials and sees the correct error message.

Automation Requirements - Selenium with Python

Assertions Needed:

Verify current URL is dashboard URL after valid login

Verify error message text after invalid login

Best Practices:

Use explicit waits to wait for elements to be visible or clickable

Use meaningful locators like By.ID or By.NAME

Separate test logic and locators for maintainability

Clean up by logging out after valid login test

Automated Solution

Testing Fundamentals

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import unittest

class TestAuthentication(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('https://example.com/login')
        self.wait = WebDriverWait(self.driver, 10)

    def test_valid_and_invalid_login(self):
        driver = self.driver
        wait = self.wait

        # Valid login
        email_input = wait.until(EC.visibility_of_element_located((By.ID, 'email')))
        email_input.clear()
        email_input.send_keys('[e-mail]')

        password_input = driver.find_element(By.ID, 'password')
        password_input.clear()
        password_input.send_keys('ValidPass123')

        login_button = driver.find_element(By.ID, 'login-button')
        login_button.click()

        # Wait for dashboard URL
        wait.until(EC.url_contains('/dashboard'))
        self.assertIn('/dashboard', driver.current_url, 'Dashboard URL not loaded after valid login')

        # Log out to return to login page
        logout_button = wait.until(EC.element_to_be_clickable((By.ID, 'logout-button')))
        logout_button.click()

        wait.until(EC.url_contains('/login'))

        # Invalid login
        email_input = wait.until(EC.visibility_of_element_located((By.ID, 'email')))
        email_input.clear()
        email_input.send_keys('[e-mail]')

        password_input = driver.find_element(By.ID, 'password')
        password_input.clear()
        password_input.send_keys('WrongPass')

        login_button = driver.find_element(By.ID, 'login-button')
        login_button.click()

        # Verify error message
        error_message = wait.until(EC.visibility_of_element_located((By.ID, 'error-message')))
        self.assertEqual(error_message.text, 'Invalid email or password', 'Error message text mismatch')

    def tearDown(self):
        self.driver.quit()

if __name__ == '__main__':
    unittest.main()

The setUp method opens the browser and navigates to the login page before each test.

In test_valid_and_invalid_login, we first enter valid credentials and click login. We wait explicitly for the dashboard URL to load and assert the URL contains '/dashboard'.

Then we log out by clicking the logout button and wait to return to the login page.

Next, we enter invalid credentials and click login. We wait for the error message element to appear and assert its text matches the expected error.

The tearDown method closes the browser after the test finishes.

Explicit waits ensure the test waits for elements or page changes before interacting or asserting, making the test stable.

Using IDs for locators keeps selectors simple and reliable.

Common Mistakes - 4 Pitfalls

Using time.sleep() instead of explicit waits

Using brittle XPath locators that depend on page structure

Not clearing input fields before sending keys

Not verifying the correct page or element after login

Bonus Challenge

Now add data-driven testing with 3 different sets of credentials: one valid, two invalid.

Show Hint

Practice

1. What is the main goal of authentication testing in software testing?

easy

A. To verify that only valid users can access the system

B. To check the speed of the application

C. To test the user interface design

D. To validate database connections

Solution

1. Step 1: Understand authentication testing purpose

   Authentication testing focuses on verifying user identity before granting access.

2. Step 2: Compare options with this purpose

   Only To verify that only valid users can access the system matches this goal; others relate to different testing areas.

3. Final Answer:

   To verify that only valid users can access the system -> Option A

4. Quick Check:

   Authentication testing = verify valid users [OK]

Hint: Authentication = check valid user access [OK]

Common Mistakes:

• Confusing authentication with performance testing
• Thinking authentication tests UI elements
• Mixing authentication with database testing

2. Which of the following is the correct way to test a login form's authentication feature?

easy

A. Enter valid username and password, then check for successful login

B. Click random buttons without entering data

C. Only check if the login button is visible

D. Test the color of the login page background

Solution

1. Step 1: Identify valid test steps for authentication

   Testing authentication requires entering valid credentials and verifying access.

2. Step 2: Evaluate options for correctness

   Enter valid username and password, then check for successful login correctly describes this; others do not test authentication properly.

3. Final Answer:

   Enter valid username and password, then check for successful login -> Option A

4. Quick Check:

   Valid credentials test = successful login [OK]

Hint: Test with valid credentials for login success [OK]

Common Mistakes:

• Ignoring input fields and clicking randomly
• Testing only UI elements without input
• Confusing visual checks with authentication tests

3. Consider this test case for authentication:

Input: username='user1', password='wrongpass'
Expected: Login fails with error message 'Invalid credentials'

What will be the test result if the system allows login with these credentials?

medium

A. Test passes if error message is shown

B. Test passes because login is successful

C. Test is inconclusive without more data

D. Test fails because login should not succeed

Solution

1. Step 1: Analyze expected vs actual behavior

   The test expects login failure with an error message for wrong password.

2. Step 2: Compare actual system behavior

   If login succeeds with wrong password, it contradicts expected behavior, causing test failure.

3. Final Answer:

   Test fails because login should not succeed -> Option D

4. Quick Check:

   Wrong password login = test fail [OK]

Hint: Wrong password must fail login [OK]

Common Mistakes:

• Assuming any login success means pass
• Ignoring expected error messages
• Confusing test pass/fail logic

4. You wrote this test script for authentication:

def test_login():
    username = 'admin'
    password = 'admin123'
    result = login(username, password)
    assert result == False

What is the error in this test?

medium

A. The password variable is empty

B. The username variable is not defined

C. The assertion expects login to fail but credentials are valid

D. The login function is missing parentheses

Solution

1. Step 1: Understand test intent and data

   Username and password appear valid, so login should succeed (True).

2. Step 2: Check assertion correctness

   Assertion expects False (failure), which contradicts valid credentials, causing test error.

3. Final Answer:

   The assertion expects login to fail but credentials are valid -> Option C

4. Quick Check:

   Valid credentials expect True, not False [OK]

Hint: Match assertion with expected login result [OK]

Common Mistakes:

• Asserting wrong expected result
• Assuming variables undefined without checking
• Confusing function call syntax

5. You want to test a system that locks a user account after 3 failed login attempts. Which test case best verifies this feature?

hard

A. Login once with correct password and check access

B. Attempt login 3 times with wrong password, then check if account is locked

C. Try logging in with empty username and password

D. Check if password reset link is visible on login page

Solution

1. Step 1: Identify feature to test

   The feature locks account after 3 failed login attempts.

2. Step 2: Select test case matching feature

   Attempt login 3 times with wrong password, then check if account is locked tests exactly this by failing login 3 times and checking lock status.

3. Final Answer:

   Attempt login 3 times with wrong password, then check if account is locked -> Option B

4. Quick Check:

   3 failed attempts = account lock test [OK]

Hint: Test lock by 3 failed logins [OK]

Common Mistakes:

• Testing unrelated features like password reset
• Using correct password instead of failed attempts
• Ignoring the number of failed attempts