Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

Test prioritization in Testing Fundamentals - Build an Automation Script

Choose your learning style10 modes available
Prioritize test cases based on risk and impact
Preconditions (1)
Step 1: Review the list of test cases with their risk and impact levels
Step 2: Sort the test cases so that those with highest risk and impact come first
Step 3: Select the top 3 test cases from the sorted list
Step 4: Execute the selected test cases
Step 5: Verify that the test cases executed are indeed the highest priority ones
✅ Expected Result: The test cases executed are the top 3 with the highest combined risk and impact scores
Automation Requirements - Python unittest
Assertions Needed:
Verify the test cases are sorted correctly by risk and impact
Verify only the top 3 test cases are selected for execution
Best Practices:
Use clear and descriptive variable names
Separate test data setup from test logic
Use assertions to validate sorting and selection
Keep test methods small and focused
Automated Solution
Testing Fundamentals
import unittest

class TestPrioritization(unittest.TestCase):
    def setUp(self):
        # Each test case is a dict with name, risk (1-5), impact (1-5)
        self.test_cases = [
            {'name': 'Login Test', 'risk': 5, 'impact': 4},
            {'name': 'Signup Test', 'risk': 3, 'impact': 3},
            {'name': 'Payment Test', 'risk': 4, 'impact': 5},
            {'name': 'Profile Update Test', 'risk': 2, 'impact': 2},
            {'name': 'Logout Test', 'risk': 1, 'impact': 1}
        ]

    def test_prioritize_and_select_top_three(self):
        # Sort test cases by combined risk and impact descending
        sorted_tests = sorted(
            self.test_cases,
            key=lambda x: x['risk'] + x['impact'],
            reverse=True
        )

        # Select top 3
        top_three = sorted_tests[:3]

        # Assert sorting correctness
        combined_scores = [tc['risk'] + tc['impact'] for tc in sorted_tests]
        self.assertEqual(combined_scores, sorted(combined_scores, reverse=True))

        # Assert top three length
        self.assertEqual(len(top_three), 3)

        # Assert top three are highest scoring
        max_scores = sorted(combined_scores, reverse=True)[:3]
        top_three_scores = [tc['risk'] + tc['impact'] for tc in top_three]
        self.assertEqual(top_three_scores, max_scores)

        # Print selected test case names (simulate execution)
        for test in top_three:
            print(f"Executing: {test['name']}")

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

The setUp method prepares a list of test cases with risk and impact scores.

The test method test_prioritize_and_select_top_three sorts the test cases by the sum of risk and impact in descending order. It then selects the top three test cases.

Assertions check that the sorting is correct, the top three are selected, and these top three have the highest combined scores.

Finally, it prints the names of the selected test cases to simulate execution.

This approach keeps test data separate, uses clear variable names, and validates the prioritization logic with assertions.

Common Mistakes - 4 Pitfalls
Not sorting test cases correctly by combined risk and impact
Hardcoding the top test cases without sorting
Not using assertions to verify sorting and selection
Mixing test data setup inside test logic
Bonus Challenge

Now add data-driven testing with 3 different sets of test cases having different risk and impact values

Show Hint

Practice

(1/5)
1. What is the main goal of test prioritization in software testing?
easy
A. To run the most important tests first to find bugs faster
B. To run all tests in alphabetical order
C. To skip tests that are easy to pass
D. To run tests only after the software is released

Solution

  1. Step 1: Understand the purpose of test prioritization

    Test prioritization means deciding which tests to run first based on their importance or likelihood to find bugs.
  2. Step 2: Identify the correct goal

    The goal is to save time and find bugs faster by running important tests first.
  3. Final Answer:

    To run the most important tests first to find bugs faster -> Option A
  4. Quick Check:

    Test prioritization = run important tests first [OK]
Hint: Remember: prioritize tests that catch bugs quickly [OK]
Common Mistakes:
  • Thinking test order is random
  • Believing all tests have equal priority
  • Skipping tests without reason
2. Which of the following is a good factor to consider when prioritizing tests?
easy
A. The number of testers available
B. The color of the test case document
C. The font size used in test descriptions
D. Recent changes in the code

Solution

  1. Step 1: Identify relevant factors for test prioritization

    Good factors include recent code changes, past failures, and test importance.
  2. Step 2: Choose the factor related to code changes

    Recent changes in code can introduce new bugs, so tests covering those areas should run first.
  3. Final Answer:

    Recent changes in the code -> Option D
  4. Quick Check:

    Prioritize tests by recent code changes [OK]
Hint: Focus on code changes, not irrelevant details [OK]
Common Mistakes:
  • Choosing unrelated factors like document color
  • Ignoring recent code updates
  • Confusing tester count with test priority
3. Given the following test cases and their last failure dates, which test should be run first based on test prioritization?
Test A: failed 2 days ago
Test B: passed last run
Test C: failed 10 days ago
Test D: never failed
medium
A. Test B
B. Test D
C. Test A
D. Test C

Solution

  1. Step 1: Analyze failure recency

    Tests that failed recently are more likely to find bugs again, so they get higher priority.
  2. Step 2: Compare failure dates

    Test A failed 2 days ago, which is more recent than Test C (10 days ago). Tests B and D did not fail recently.
  3. Final Answer:

    Test A -> Option C
  4. Quick Check:

    Run tests with recent failures first [OK]
Hint: Pick tests with the most recent failures first [OK]
Common Mistakes:
  • Choosing tests that never failed
  • Ignoring failure dates
  • Picking tests that passed last run
4. You have a test suite with 4 tests. The priority order should be based on recent code changes and past failures. The current order is:
1. Test X (no recent changes, no failures)
2. Test Y (recent changes, no failures)
3. Test Z (no recent changes, failed last run)
4. Test W (recent changes, failed last run)

Which test should be run first to follow best test prioritization?
medium
A. Test W
B. Test X
C. Test Z
D. Test Y

Solution

  1. Step 1: Combine recent changes and past failures

    Tests with both recent changes and past failures have highest priority.
  2. Step 2: Identify test with both factors

    Test W has recent changes and failed last run, so it should run first.
  3. Final Answer:

    Test W -> Option A
  4. Quick Check:

    Prioritize tests with recent changes and failures [OK]
Hint: Pick tests with both recent changes and failures first [OK]
Common Mistakes:
  • Ignoring one of the prioritization factors
  • Running tests without recent changes first
  • Choosing tests that never failed
5. A team has 5 tests with these details:
Test 1: covers critical feature, no recent changes, failed last run
Test 2: covers minor feature, recent changes, passed last run
Test 3: covers critical feature, recent changes, passed last run
Test 4: covers minor feature, no recent changes, never failed
Test 5: covers critical feature, recent changes, failed last run

Which order best follows test prioritization principles?
hard
A. Test 1, Test 5, Test 3, Test 2, Test 4
B. Test 5, Test 1, Test 3, Test 2, Test 4
C. Test 5, Test 3, Test 1, Test 2, Test 4
D. Test 4, Test 2, Test 3, Test 1, Test 5

Solution

  1. Step 1: Identify highest priority tests

    Tests covering critical features with recent changes and failures have highest priority. Test 5 fits all three.
  2. Step 2: Order remaining tests by priority

    Next is Test 1 (critical, failed but no recent changes), then Test 3 (critical, recent changes, passed), followed by Test 2 and Test 4 (minor features, lower priority).
  3. Final Answer:

    Test 5, Test 1, Test 3, Test 2, Test 4 -> Option B
  4. Quick Check:

    Prioritize critical, recent changes, failures first [OK]
Hint: Order by criticality, recent changes, then failures [OK]
Common Mistakes:
  • Ignoring feature criticality
  • Not combining multiple factors
  • Running low priority tests first
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