Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

Data integrity checks in Testing Fundamentals - Build an Automation Script

Choose your learning style10 modes available
Verify data integrity after saving user profile information
Preconditions (2)
Step 1: Enter 'John' in the First Name field
Step 2: Enter 'Doe' in the Last Name field
Step 3: Enter 'john.doe@example.com' in the Email field
Step 4: Click the Save button
Step 5: Navigate to the profile view page
✅ Expected Result: The profile view page displays First Name as 'John', Last Name as 'Doe', and Email as 'john.doe@example.com' exactly as entered
Automation Requirements - Selenium with Python
Assertions Needed:
Verify that the First Name displayed matches the input 'John'
Verify that the Last Name displayed matches the input 'Doe'
Verify that the Email displayed matches the input 'john.doe@example.com'
Best Practices:
Use explicit waits to wait for elements to be visible before interacting
Use clear and maintainable locators like IDs or data-test attributes
Separate test logic and page interactions using the Page Object Model
Include meaningful assertion messages for easier debugging
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 ProfilePage:
    def __init__(self, driver):
        self.driver = driver
        self.first_name_input = (By.ID, 'firstName')
        self.last_name_input = (By.ID, 'lastName')
        self.email_input = (By.ID, 'email')
        self.save_button = (By.ID, 'saveProfile')
        self.first_name_display = (By.ID, 'displayFirstName')
        self.last_name_display = (By.ID, 'displayLastName')
        self.email_display = (By.ID, 'displayEmail')

    def enter_first_name(self, first_name):
        WebDriverWait(self.driver, 10).until(EC.visibility_of_element_located(self.first_name_input)).clear()
        self.driver.find_element(*self.first_name_input).send_keys(first_name)

    def enter_last_name(self, last_name):
        WebDriverWait(self.driver, 10).until(EC.visibility_of_element_located(self.last_name_input)).clear()
        self.driver.find_element(*self.last_name_input).send_keys(last_name)

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

    def click_save(self):
        WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable(self.save_button)).click()

    def get_displayed_first_name(self):
        return WebDriverWait(self.driver, 10).until(EC.visibility_of_element_located(self.first_name_display)).text

    def get_displayed_last_name(self):
        return WebDriverWait(self.driver, 10).until(EC.visibility_of_element_located(self.last_name_display)).text

    def get_displayed_email(self):
        return WebDriverWait(self.driver, 10).until(EC.visibility_of_element_located(self.email_display)).text

class TestDataIntegrity(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('https://example.com/profile/edit')
        self.profile_page = ProfilePage(self.driver)

    def test_data_integrity_after_save(self):
        # Enter user data
        self.profile_page.enter_first_name('John')
        self.profile_page.enter_last_name('Doe')
        self.profile_page.enter_email('john.doe@example.com')

        # Save the profile
        self.profile_page.click_save()

        # Navigate to profile view page
        self.driver.get('https://example.com/profile/view')

        # Verify data integrity
        self.assertEqual(self.profile_page.get_displayed_first_name(), 'John', 'First Name does not match')
        self.assertEqual(self.profile_page.get_displayed_last_name(), 'Doe', 'Last Name does not match')
        self.assertEqual(self.profile_page.get_displayed_email(), 'john.doe@example.com', 'Email does not match')

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

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

This test script uses Selenium with Python and the unittest framework.

The ProfilePage class follows the Page Object Model. It stores locators and methods to interact with the profile page fields and buttons. This keeps the test code clean and easy to maintain.

Explicit waits ensure elements are visible or clickable before interacting, avoiding timing issues.

The test test_data_integrity_after_save enters the user data, clicks save, then navigates to the profile view page to verify the displayed data matches exactly what was entered.

Assertions include messages to help understand failures.

The setUp and tearDown methods handle browser start and close for each test run.

Common Mistakes - 4 Pitfalls
Using time.sleep() instead of explicit waits
Using brittle XPath locators that depend on page structure
Mixing test logic and page interaction code
Not verifying the displayed data after saving
Bonus Challenge

Now add data-driven testing with 3 different sets of user profile inputs to verify data integrity for each.

Show Hint

Practice

(1/5)
1. What is the main purpose of data integrity checks in software testing?
easy
A. To ensure data remains accurate and unchanged during processing
B. To improve the speed of the software
C. To add new features to the software
D. To change data formats automatically

Solution

  1. Step 1: Understand the meaning of data integrity

    Data integrity means data is accurate, consistent, and unchanged during operations.
  2. Step 2: Identify the goal of data integrity checks

    These checks confirm that data stays correct and unaltered through software processes.
  3. Final Answer:

    To ensure data remains accurate and unchanged during processing -> Option A
  4. Quick Check:

    Data integrity = data accuracy and consistency [OK]
Hint: Data integrity means data stays correct and unchanged [OK]
Common Mistakes:
  • Confusing data integrity with performance improvements
  • Thinking data integrity changes data formats
  • Assuming data integrity adds new features
2. Which of the following is the correct way to assert that two data values are equal in a test?
easy
A. assertEqual(expected, actual)
B. assertEquals(expected, actual)
C. assertEqual(actual, expected)
D. assertEqual(actual == expected)

Solution

  1. Step 1: Recall the correct syntax for equality assertion

    The common syntax is assertEqual(expected, actual) to compare values.
  2. Step 2: Check each option for syntax correctness

    assertEqual(expected, actual) matches the correct order and syntax; others have wrong order or wrong method name.
  3. Final Answer:

    assertEqual(expected, actual) -> Option A
  4. Quick Check:

    assertEqual(expected, actual) is correct [OK]
Hint: Remember: expected value first, actual second in assertEqual [OK]
Common Mistakes:
  • Swapping expected and actual parameters
  • Using wrong assertion method names
  • Passing a boolean expression instead of two values
3. Given the following test code snippet:
expected_data = {'id': 101, 'name': 'Alice'}
actual_data = {'id': 101, 'name': 'Alice'}
assert expected_data == actual_data, 'Data mismatch!'

What will be the test result?
medium
A. Test fails with 'Data mismatch!' error
B. SyntaxError due to wrong assertion
C. Test passes with no error
D. Test passes but prints 'Data mismatch!'

Solution

  1. Step 1: Compare expected and actual data dictionaries

    Both dictionaries have the same keys and values, so they are equal.
  2. Step 2: Understand assertion behavior

    Since the condition is true, the assertion passes without raising an error.
  3. Final Answer:

    Test passes with no error -> Option C
  4. Quick Check:

    Equal data means assertion passes [OK]
Hint: Assert passes if expected equals actual data [OK]
Common Mistakes:
  • Assuming assertion prints message on success
  • Confusing assertion syntax with function calls
  • Thinking assertion fails when data matches
4. Identify the error in this data integrity check code:
expected = {'user': 'bob', 'age': 30}
actual = {'user': 'bob', 'age': '30'}
assert expected == actual, 'Mismatch found!'
medium
A. No error, the test will pass
B. The age values have different data types causing assertion failure
C. The dictionary keys are different
D. The assertion syntax is incorrect

Solution

  1. Step 1: Compare dictionary keys and values

    Keys are the same, but 'age' values differ: integer 30 vs string '30'.
  2. Step 2: Understand assertion behavior with type differences

    Since values differ in type, the assertion fails and raises 'Mismatch found!'.
  3. Final Answer:

    The age values have different data types causing assertion failure -> Option B
  4. Quick Check:

    Different types cause assertion failure [OK]
Hint: Check data types carefully when comparing values [OK]
Common Mistakes:
  • Ignoring type differences in values
  • Assuming assertion syntax is wrong
  • Thinking keys differ when they don't
5. You have a list of user records with possible duplicate IDs:
users = [
  {'id': 1, 'name': 'Anna'},
  {'id': 2, 'name': 'Ben'},
  {'id': 1, 'name': 'Anna'},
  {'id': 3, 'name': 'Cara'}
]

Which data integrity check best detects duplicate user IDs?
hard
A. Verify all user IDs are integers
B. Compare user names directly for duplicates
C. Sort users by name and check order
D. Check if length of user list equals length of set of user IDs

Solution

  1. Step 1: Understand the problem of duplicate IDs

    Duplicates mean some IDs appear more than once in the list.
  2. Step 2: Use set to find unique IDs and compare lengths

    Convert IDs to a set (unique values). If set length is less than list length, duplicates exist.
  3. Final Answer:

    Check if length of user list equals length of set of user IDs -> Option D
  4. Quick Check:

    Set length < list length means duplicates [OK]
Hint: Use set to find unique IDs and compare lengths [OK]
Common Mistakes:
  • Checking names instead of IDs for duplicates
  • Sorting without checking duplicates
  • Only verifying data types, not duplicates
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