Shift-left testing in Testing Fundamentals - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

When is shift-left testing typically introduced in the software development lifecycle?

Shift-left testing means moving testing activities earlier in the development process. At which phase is shift-left testing ideally started?

A After the software is fully developed and ready for release

B During the requirements and design phases before coding begins

C Only during the final system testing phase

D After deployment to production

💡 Hint

Think about catching defects as early as possible to save time and cost.

Shift-left testing encourages starting testing activities early, such as during requirements and design, to find defects sooner and reduce costly fixes later.

❓ Predict Output

intermediate

What is the output of this test coverage print statement in shift-left testing?

Given this Python snippet simulating test coverage percentages at different phases, what will be printed?

Testing Fundamentals

requirements_coverage = 80
unit_test_coverage = 90
integration_test_coverage = 70
print(f"Shift-left test coverage: {requirements_coverage}% requirements, {unit_test_coverage}% unit, {integration_test_coverage}% integration")

A Shift-left test coverage: 90% requirements, 70% unit, 80% integration

B Shift-left test coverage: 70% requirements, 80% unit, 90% integration

C Shift-left test coverage: 80% requirements, 90% unit, 70% integration

D Shift-left test coverage: 80% unit, 90% integration, 70% requirements

💡 Hint

Check the variable names and their values carefully.

The print statement uses the variables in order: requirements_coverage=80, unit_test_coverage=90, integration_test_coverage=70.

❓ assertion

advanced

Which assertion correctly verifies that defects found during shift-left testing are fewer than defects found later?

You have two variables: defects_shift_left = 5 and defects_late = 15. Which assertion correctly tests that shift-left testing finds fewer defects?

Testing Fundamentals

defects_shift_left = 5
defects_late = 15

A assert defects_shift_left < defects_late, "Shift-left defects should be fewer"

B assert defects_shift_left == defects_late, "Defects count should be equal"

C assert defects_shift_left > defects_late, "Shift-left defects should be fewer"

D assert defects_shift_left >= defects_late, "Shift-left defects should be fewer"

💡 Hint

Remember, fewer means less than.

The assertion must check defects_shift_left < defects_late to confirm fewer defects found early.

🔧 Debug

advanced

Identify the bug in this test automation code snippet related to shift-left testing

This Python code is meant to run unit tests early (shift-left). What is the bug that will cause it to fail?

Testing Fundamentals

def run_unit_tests(tests):
    for test in tests:
        result = test()
        if not result:
            print("Test failed")
            return False
    return True

unit_tests = [lambda: True, lambda: False, lambda: True]
run_unit_tests(unit_tests)

A Missing colon after for loop declaration causes SyntaxError

B The print statement syntax is incorrect

C The function returns True even if a test fails

D The lambda functions do not return boolean values

💡 Hint

Check the for loop syntax carefully.

The for loop line is missing a colon at the end, causing a SyntaxError.

❓ framework

expert

Which testing framework feature best supports shift-left testing automation?

You want to automate tests early in development and get fast feedback. Which feature of a testing framework helps most with shift-left testing?

A Support for manual exploratory testing sessions

B Ability to generate detailed final test reports after all tests complete

C Integration with production monitoring tools for live error tracking

D Support for parallel test execution to reduce test run time

💡 Hint

Think about speeding up early test feedback.

Parallel test execution allows running many tests quickly, enabling fast feedback early in development, which is key for shift-left testing.

Practice

1. What is the main idea behind shift-left testing?

easy

A. Testing only the user interface at the end

B. Testing early in the software development process

C. Testing only after the software is fully developed

D. Testing only by the quality assurance team

Solution

1. Step 1: Understand the term 'shift-left'

   Shift-left means moving testing activities to earlier stages in development.

2. Step 2: Compare options with the definition

   Only Testing early in the software development process describes testing early, others describe late or limited testing.

3. Final Answer:

   Testing early in the software development process -> Option B

4. Quick Check:

   Shift-left = Early testing [OK]

Hint: Shift-left means test early, not late [OK]

Common Mistakes:

• Thinking testing happens only after coding
• Confusing shift-left with testing only UI
• Believing only QA team tests

2. Which of the following is a common practice that supports shift-left testing?

easy

A. Writing tests after the product release

B. Performing only manual testing at the end

C. Test-driven development (TDD)

D. Skipping code reviews

Solution

1. Step 1: Identify practices that enable early testing

   TDD means writing tests before or during coding, supporting early testing.

2. Step 2: Eliminate options that delay or skip testing

   Options A, B, and C delay or reduce testing, not shift it left.

3. Final Answer:

   Test-driven development (TDD) -> Option C

4. Quick Check:

   TDD = Early testing practice [OK]

Hint: TDD means write tests first, fits shift-left [OK]

Common Mistakes:

• Thinking tests come only after release
• Ignoring code reviews as testing support
• Believing manual testing only is enough

3. Consider this code snippet representing a testing timeline:

Development Start -> Code Review -> Unit Testing -> Integration Testing -> Release

Which step best represents the shift-left testing approach?

medium

A. Unit Testing

B. Release

C. Code Review

D. Integration Testing

Solution

1. Step 1: Understand shift-left means testing early

   Shift-left moves testing activities closer to development start.

2. Step 2: Identify earliest testing-related step

   Unit Testing is the earliest formal testing phase after code review, which is a review step but not a testing activity.

3. Final Answer:

   Unit Testing -> Option A

4. Quick Check:

   Shift-left = Early testing phases like unit testing [OK]

Hint: Shift-left means test as early as possible [OK]

Common Mistakes:

• Choosing testing steps that happen later
• Confusing release with testing
• Ignoring code review as testing support

4. A team claims they follow shift-left testing but only start testing after full coding is done. What is the main problem in their approach?

medium

A. They are not testing early enough

B. They are testing too early

C. They are using too many automated tests

D. They are skipping integration testing

Solution

1. Step 1: Recall shift-left means testing early

   Testing after full coding is late, not early.

2. Step 2: Identify the problem with their timing

   The team delays testing, so they miss shift-left benefits.

3. Final Answer:

   They are not testing early enough -> Option A

4. Quick Check:

   Shift-left = test early, not late [OK]

Hint: Shift-left means test early, not after coding done [OK]

Common Mistakes:

• Thinking testing too early is a problem
• Confusing automation with timing
• Ignoring integration testing relevance

5. A project uses shift-left testing by integrating automated unit tests early. However, bugs still appear late in integration testing. What is a likely cause?

hard

A. Manual testing should replace automated tests

B. Automated tests are run too early in development

C. Shift-left testing means skipping integration tests

D. Unit tests do not cover integration points between modules

Solution

1. Step 1: Understand shift-left testing scope

   Shift-left encourages early testing but does not replace integration testing.

2. Step 2: Analyze why bugs appear late despite early unit tests

   Unit tests check individual parts but may miss how parts work together.

3. Step 3: Identify the cause of late bugs

   Missing coverage of integration points causes bugs to appear late.

4. Final Answer:

   Unit tests do not cover integration points between modules -> Option D

5. Quick Check:

   Early unit tests ≠ full integration coverage [OK]

Hint: Unit tests check parts, integration tests check connections [OK]

Common Mistakes:

• Thinking shift-left skips integration testing
• Believing running tests early causes bugs
• Replacing automated tests with manual only