Bird
Raised Fist0
Selenium Pythontesting~15 mins

Why CI integration enables continuous testing in Selenium Python - Automation Benefits in Action

Choose your learning style10 modes available
Verify login functionality with CI integration for continuous testing
Preconditions (3)
Step 1: Open the login page URL in a browser
Step 2: Enter 'testuser@example.com' in the email input field
Step 3: Enter 'TestPass123!' in the password input field
Step 4: Click the login button
Step 5: Wait for the dashboard page to load
Step 6: Verify the URL contains '/dashboard'
Step 7: Verify the welcome message 'Welcome, Test User!' is displayed
✅ Expected Result: User is successfully logged in, dashboard page loads with correct URL and welcome message, and test passes automatically in CI pipeline on code push
Automation Requirements - Selenium with Python
Assertions Needed:
Verify current URL contains '/dashboard'
Verify welcome message text is 'Welcome, Test User!'
Best Practices:
Use explicit waits to wait for elements
Use Page Object Model to separate page locators and actions
Use assertions from unittest or pytest
Integrate test script with CI pipeline to run on code push
Automated Solution
Selenium Python
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 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 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 get_welcome_text(self):
        return WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(self.welcome_message)
        ).text

class TestLogin(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('https://example.com/login')

    def test_login_success(self):
        login_page = LoginPage(self.driver)
        login_page.enter_email('testuser@example.com')
        login_page.enter_password('TestPass123!')
        login_page.click_login()

        WebDriverWait(self.driver, 10).until(
            EC.url_contains('/dashboard')
        )

        self.assertIn('/dashboard', self.driver.current_url)

        dashboard_page = DashboardPage(self.driver)
        welcome_text = dashboard_page.get_welcome_text()
        self.assertEqual(welcome_text, 'Welcome, Test User!')

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

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

This script uses Selenium with Python's unittest framework to automate the login test.

Page Object Model: We created LoginPage and DashboardPage classes to keep locators and actions organized. This makes maintenance easier.

Explicit waits: We wait for elements to be visible or clickable before interacting. This avoids flaky tests.

Assertions: We check that the URL contains '/dashboard' and the welcome message text matches exactly.

Setup and teardown: The browser opens before each test and closes after to keep tests isolated.

This test can be integrated into a CI pipeline to run automatically on every code push, enabling continuous testing by catching issues early.

Common Mistakes - 3 Pitfalls
{'mistake': 'Using time.sleep() instead of explicit waits', 'why_bad': 'It makes tests slower and flaky because it waits fixed time regardless of element readiness.', 'correct_approach': "Use Selenium's explicit waits like WebDriverWait with expected_conditions."}
Hardcoding XPath selectors that are brittle
Not closing the browser after tests
Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials (valid and invalid).

Show Hint

Practice

(1/5)
1. What is the main benefit of integrating Selenium tests with a Continuous Integration (CI) system?
easy
A. Tests run slower because of extra CI overhead
B. Tests run only when manually triggered by developers
C. Tests run automatically on every code change, catching bugs early
D. Tests require manual approval before running

Solution

  1. Step 1: Understand CI integration purpose

    CI systems automatically run tests whenever code changes are pushed.
  2. Step 2: Identify benefit of automatic test runs

    This automation helps catch bugs early without manual effort.
  3. Final Answer:

    Tests run automatically on every code change, catching bugs early -> Option C
  4. Quick Check:

    CI auto-runs tests = Early bug detection [OK]
Hint: CI runs tests on code changes automatically [OK]
Common Mistakes:
  • Thinking tests run only manually
  • Assuming CI slows down tests
  • Believing manual approval is needed
2. Which of the following is the correct way to trigger Selenium tests in a CI pipeline using Python?
easy
A. Add sleep(10) to delay tests
B. Manually open browser and run tests
C. Use print('run tests') in the test file
D. Run pytest tests/ command in the CI script

Solution

  1. Step 1: Identify how tests run in CI

    CI pipelines run commands like pytest tests/ to execute tests automatically.
  2. Step 2: Evaluate options for triggering tests

    Manual browser opening or print statements do not trigger automated CI tests.
  3. Final Answer:

    Run pytest tests/ command in the CI script -> Option D
  4. Quick Check:

    CI runs test commands like pytest [OK]
Hint: CI runs shell commands to execute tests [OK]
Common Mistakes:
  • Confusing manual test runs with CI automation
  • Using print statements expecting test execution
  • Adding delays instead of running tests
3. Given this CI pipeline snippet running Selenium tests:
steps:
  - name: Run tests
    run: pytest tests/

What is the expected outcome when a test fails?
medium
A. The CI pipeline stops and reports failure immediately
B. The pipeline ignores failures and continues
C. The tests rerun automatically until they pass
D. The pipeline deletes the test files

Solution

  1. Step 1: Understand CI pipeline behavior on test failure

    When a test fails, the pytest command returns a failure code, causing the CI pipeline to stop and report failure.
  2. Step 2: Check other options for correctness

    CI does not ignore failures, rerun tests automatically, or delete files on failure.
  3. Final Answer:

    The CI pipeline stops and reports failure immediately -> Option A
  4. Quick Check:

    Test fail = CI fail and stop [OK]
Hint: Failed tests cause CI to stop and report failure [OK]
Common Mistakes:
  • Thinking CI ignores test failures
  • Assuming tests rerun automatically without config
  • Believing CI deletes files on failure
4. You added Selenium tests to your CI pipeline, but tests never run after code pushes. What is the most likely cause?
medium
A. The tests are written in Python instead of Java
B. The CI configuration file does not include the test run command
C. The Selenium WebDriver is not installed on the developer's machine
D. The browser is not open on the developer's local computer

Solution

  1. Step 1: Check CI configuration for test commands

    If the CI config file lacks the command to run tests, tests won't execute on code pushes.
  2. Step 2: Evaluate other options

    Test language, developer machine setup, or local browser state do not affect CI test runs on the server.
  3. Final Answer:

    The CI configuration file does not include the test run command -> Option B
  4. Quick Check:

    Missing test command in CI config = no tests run [OK]
Hint: Check CI config includes test run command [OK]
Common Mistakes:
  • Blaming test language instead of CI config
  • Assuming local machine affects CI server runs
  • Thinking browser must be open locally for CI
5. How does integrating Selenium tests with CI pipelines improve software release quality?
hard
A. By running automated tests on every code change, catching bugs early and ensuring reliability
B. By requiring manual test approval before each release
C. By delaying test runs until after software is released
D. By running tests only on developer machines

Solution

  1. Step 1: Understand CI and Selenium integration benefits

    Automated tests run on every code change in CI, catching bugs early and preventing faulty code from releasing.
  2. Step 2: Compare with other options

    Manual approvals, delayed tests, or local-only tests do not improve release quality as effectively.
  3. Final Answer:

    By running automated tests on every code change, catching bugs early and ensuring reliability -> Option A
  4. Quick Check:

    CI + Selenium = Early bug catch & reliable releases [OK]
Hint: CI auto-tests catch bugs early, improving release quality [OK]
Common Mistakes:
  • Thinking manual approval improves quality more
  • Believing tests run after release
  • Assuming tests only run locally
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard