Automation framework types in Testing Fundamentals - Build an Automation Script

Verify login functionality using a modular automation framework

Preconditions (2)

Step 1: Open the login page URL

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

Step 3: Enter 'Password123' in the password input field

Step 4: Click the login button

Step 5: Wait for the dashboard page to load

✅ Expected Result: User is successfully logged in and dashboard page is displayed with URL containing '/dashboard'

Automation Requirements - Selenium with Python using modular framework design

Assertions Needed:

Verify current URL contains '/dashboard'

Verify presence of dashboard welcome message element

Best Practices:

Use Page Object Model to separate page locators and actions

Use explicit waits for elements to be visible or clickable

Keep test data separate from test scripts

Use clear and descriptive method names

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

class LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.email_input = (By.ID, 'email')
        self.password_input = (By.ID, 'password')
        self.login_button = (By.ID, 'login-btn')

    def open(self, url):
        self.driver.get(url)

    def enter_email(self, email):
        WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.email_input)
        ).send_keys(email)

    def enter_password(self, password):
        WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.password_input)
        ).send_keys(password)

    def click_login(self):
        WebDriverWait(self.driver, 10).until(
            EC.element_to_be_clickable(self.login_button)
        ).click()

class DashboardPage:
    def __init__(self, driver):
        self.driver = driver
        self.welcome_message = (By.ID, 'welcome-msg')

    def is_loaded(self):
        return WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.welcome_message)
        ) is not None

import unittest

class TestLogin(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.login_page = LoginPage(self.driver)
        self.dashboard_page = DashboardPage(self.driver)

    def test_valid_login(self):
        self.login_page.open('https://example.com/login')
        self.login_page.enter_email('[e-mail]')
        self.login_page.enter_password('Password123')
        self.login_page.click_login()

        self.assertIn('/dashboard', self.driver.current_url, 'URL does not contain /dashboard')
        self.assertTrue(self.dashboard_page.is_loaded(), 'Dashboard welcome message not found')

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

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

This code uses Selenium WebDriver with Python to automate the login test using a modular framework design called the Page Object Model (POM).

We created two classes: LoginPage and DashboardPage. Each class holds locators and methods related to that page.

The test class TestLogin uses unittest framework. It sets up the browser, uses the page objects to perform actions, and asserts the expected results.

Explicit waits ensure elements are ready before interacting.

This structure keeps code clean, reusable, and easy to maintain.

Common Mistakes - 3 Pitfalls

Hardcoding locators directly in test methods

Using implicit waits or no waits at all

Mixing test logic and UI interaction code

Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials

Show Hint

Practice

1. Which automation framework type is best described as a simple, step-by-step script without reusable modules?

easy

A. Linear automation framework

B. Modular automation framework

C. Data-driven automation framework

D. Keyword-driven automation framework

Solution

1. Step 1: Understand the framework types

   Linear framework runs tests in a sequential, simple script without reusable parts.

2. Step 2: Match description to framework

   Since the question describes a simple step-by-step script without modules, it matches the linear framework.

3. Final Answer:

   Linear automation framework -> Option A

4. Quick Check:

   Simple step-by-step = Linear [OK]

Hint: Simple scripts without reuse? Think linear [OK]

Common Mistakes:

• Confusing linear with modular frameworks
• Thinking data-driven means simple scripts
• Mixing keyword-driven with linear

2. Which of the following is the correct description of a data-driven automation framework?

easy

A. Tests are written using keywords representing actions

B. Tests are executed in a linear sequence without modules

C. Tests are divided into reusable modules

D. Test data is separated from scripts and stored externally

Solution

1. Step 1: Recall data-driven framework concept

   Data-driven frameworks separate test data from test scripts, often using external files like Excel or CSV.

2. Step 2: Match options to definition

   Test data is separated from scripts and stored externally correctly states that test data is stored externally and separated from scripts.

3. Final Answer:

   Test data is separated from scripts and stored externally -> Option D

4. Quick Check:

   Data separated from scripts = Data-driven [OK]

Hint: Data outside scripts? That's data-driven [OK]

Common Mistakes:

• Confusing keyword-driven with data-driven
• Thinking linear means data separation
• Mixing modular with data-driven

3. Consider this pseudocode snippet in a keyword-driven framework:

keywords = ["open_browser", "login", "click_button", "logout"]
for action in keywords:
    execute(action)

What is the main advantage of this approach?

medium

A. Test actions are represented by keywords making tests readable and reusable

B. Test logic is separated from test data

C. Test steps are hardcoded and not reusable

D. Test data is embedded inside the test scripts

Solution

1. Step 1: Understand keyword-driven framework

   Keyword-driven frameworks use keywords to represent test actions, making tests easy to read and reuse.

2. Step 2: Analyze the pseudocode

   The code loops through keywords and executes actions, showing separation of test logic using keywords.

3. Final Answer:

   Test actions are represented by keywords making tests readable and reusable -> Option A

4. Quick Check:

   Keywords for actions = Keyword-driven advantage [OK]

Hint: Keywords mean readable and reusable tests [OK]

Common Mistakes:

• Thinking test data is embedded in keywords
• Confusing keyword-driven with linear
• Assuming hardcoded steps mean keyword-driven

4. You have a modular automation framework but notice tests are failing because modules are not reusable. What is the likely error?

medium

A. Keywords are not defined properly

B. Modules are tightly coupled and not independent

C. Tests are written in a linear sequence

D. Test data is stored externally

Solution

1. Step 1: Understand modular framework principles

   Modular frameworks require modules to be independent and reusable.

2. Step 2: Identify cause of failure

   If modules are tightly coupled, they cannot be reused properly, causing test failures.

3. Final Answer:

   Modules are tightly coupled and not independent -> Option B

4. Quick Check:

   Coupled modules break reuse = Modular error [OK]

Hint: Modules must be independent to reuse [OK]

Common Mistakes:

• Blaming external test data for module reuse
• Confusing linear sequence with modular issues
• Assuming keyword problems cause module reuse failure

5. A hybrid automation framework combines features of multiple frameworks. Which combination below best describes a hybrid framework?

hard

A. Linear scripts with external test data files

B. Data-driven tests without reusable modules

C. Modular reusable components with keyword-driven test execution

D. Only keyword-driven tests without data separation

Solution

1. Step 1: Understand hybrid framework concept

   Hybrid frameworks mix features like modular design and keyword-driven execution for flexibility and reuse.

2. Step 2: Evaluate options for combined features

   Modular reusable components with keyword-driven test execution combines modular reusable components and keyword-driven execution, fitting hybrid framework definition.

3. Final Answer:

   Modular reusable components with keyword-driven test execution -> Option C

4. Quick Check:

   Hybrid = Modular + Keyword-driven mix [OK]

Hint: Hybrid mixes modular and keyword-driven [OK]

Common Mistakes:

• Thinking linear with data files is hybrid
• Ignoring modular or keyword features in hybrid
• Confusing data-driven only as hybrid