Data integrity checks in Testing Fundamentals - Full Explanation

Introduction

Imagine sending a message or saving important information, but it gets changed or corrupted without you knowing. Data integrity checks help catch these mistakes to keep information accurate and trustworthy.

Explanation

Purpose of Data Integrity Checks

Data integrity checks are used to verify that data remains accurate and unchanged during storage, transmission, or processing. They help detect errors or tampering that could cause incorrect results or system failures.

Data integrity checks ensure data stays correct and reliable throughout its lifecycle.

Common Methods of Checking Integrity

Some common methods include checksums, hashes, and parity bits. These methods create a small summary or code from the data that can be compared later to detect changes or errors.

Checksums and hashes create a unique code to spot any changes in data.

When Integrity Checks Are Used

Integrity checks happen during data transfer over networks, when saving files to disks, or in databases to prevent corruption. They are also used in software testing to confirm data correctness after operations.

Integrity checks are applied whenever data moves or is stored to catch errors early.

What Happens When a Check Fails

If the integrity check shows a mismatch, it means the data was altered or corrupted. Systems can then reject the data, request it again, or alert users to prevent using wrong information.

Failed checks trigger actions to avoid using corrupted or wrong data.

Real World Analogy

Think of sending a sealed letter with a wax stamp. The stamp shows if the letter was opened or changed during delivery. If the stamp is broken, you know the letter might not be safe.

Purpose of Data Integrity Checks → The wax stamp that proves the letter is untouched

Common Methods of Checking Integrity → The unique shape and pattern of the wax stamp

When Integrity Checks Are Used → Checking the stamp when the letter arrives or is stored

What Happens When a Check Fails → Not trusting the letter if the wax stamp is broken

Diagram

Diagram

┌─────────────────────────────┐
│       Original Data          │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│   Generate Integrity Code    │
│  (checksum, hash, parity)    │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│  Store or Transmit Data +    │
│     Integrity Code           │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│   Receive or Retrieve Data   │
└─────────────┬───────────────┘
              │
              ▼
┌─────────────────────────────┐
│  Recalculate Integrity Code  │
└─────────────┬───────────────┘
              │
              ▼
┌──────────────┬──────────────┐
│              │              │
│  Codes Match │  Codes Differ│
│   (Pass)     │    (Fail)    │
│              │              │
└──────┬───────┴──────┬───────┘
       │              │
       ▼              ▼
  Use Data       Reject or Request
                 Data Again

This diagram shows the flow of creating, storing, and verifying data integrity codes to detect errors.

Key Facts

Data Integrity → The accuracy and consistency of data over its lifecycle.

Checksum → A simple code calculated from data to detect errors.

Hash Function → A method that converts data into a fixed-size string unique to the data.

Integrity Check Failure → Occurs when the calculated code does not match the original, indicating data corruption.

Parity Bit → An extra bit added to data to help detect errors in transmission.

Code Example

Testing Fundamentals

import hashlib

def calculate_hash(data: str) -> str:
    return hashlib.sha256(data.encode()).hexdigest()

original_data = "Hello, world!"
hash_original = calculate_hash(original_data)

# Simulate data transmission
received_data = "Hello, world!"
hash_received = calculate_hash(received_data)

if hash_original == hash_received:
    print("Data integrity verified: no changes detected.")
else:
    print("Data integrity check failed: data was altered.")

Common Confusions

Believing data integrity checks can fix corrupted data automatically.

Believing data integrity checks can fix corrupted data automatically. Integrity checks only detect errors; they do not correct data unless combined with error-correcting methods.

Thinking all integrity checks are equally strong.

Thinking all integrity checks are equally strong. Different methods vary in strength; for example, hashes are more reliable than simple checksums.

Summary

Data integrity checks help ensure information stays accurate and unchanged during storage or transfer.

Common methods like checksums and hashes create codes that detect errors or tampering.

When a check fails, systems can reject corrupted data to prevent mistakes.

Practice

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