Single responsibility per test in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why keep one assertion per test?

Why is it best to have only one assertion in a test function?

A It makes it easier to find the exact cause when a test fails.

B It reduces the total number of tests needed.

C It allows multiple features to be tested together efficiently.

D It speeds up test execution by combining checks.

💡 Hint

Think about how you find problems quickly when something breaks.

Having one assertion per test helps quickly identify what exactly failed. If multiple assertions are in one test, you might not know which part caused the failure without extra debugging.

❓ Predict Output

intermediate

Output of pytest with multiple assertions

What will pytest report when running this test?

PyTest

def test_numbers():
    assert 2 + 2 == 4
    assert 3 * 3 == 10
    assert 5 - 2 == 3

A Test fails at first assertion with AssertionError.

B Test passes because only one assertion needs to be true.

C Test fails at second assertion with AssertionError.

D Test fails at third assertion with AssertionError.

💡 Hint

Remember pytest stops at the first failed assertion in a test.

The first assertion passes, but the second assertion (3 * 3 == 10) is false, so pytest stops and reports failure there.

❓ assertion

advanced

Choose the best single responsibility test assertion

Which assertion best follows the single responsibility principle for testing a function is_even(n) that returns True if n is even?

PyTest

def is_even(n):
    return n % 2 == 0

A assert is_even(2) is True

B assert is_even(2) is True and is_even(3) is False

C assert is_even(3) is False

D assert is_even(2) == True or is_even(3) == False

💡 Hint

Focus on testing one behavior per test.

Option A tests only one case (2 is even), keeping the test focused. Option A tests two cases in one assertion, which breaks single responsibility. Option A tests a different case and should be a separate test. Option A uses 'or' which can hide failures.

🔧 Debug

advanced

Identify the problem with this test function

What is the main issue with this pytest test function?

PyTest

def test_user_profile():
    assert user.name == 'Alice'
    assert user.age == 30
    assert user.email == '[e-mail]'

A The test has multiple assertions, making it hard to know which failed.

B The assertions use wrong syntax for equality check.

C The test function name does not start with 'test_'.

D The test is missing a setup for the user object.

💡 Hint

Check if all variables used are defined or initialized.

The test uses 'user' without defining or initializing it, so it will raise a NameError before assertions run. Multiple assertions are allowed but setup is required.

❓ framework

expert

Best pytest structure for single responsibility tests

Which pytest structure best supports single responsibility per test for a function add(a, b)?

PyTest

def add(a, b):
    return a + b

A One test function with multiple assertions for all input cases.

B Separate test functions each with one assertion for different input cases.

C One test function with a loop and assertions inside for all cases.

D One test function that asserts the output type only.

💡 Hint

Think about clarity and easy failure detection.

Separate test functions with one assertion each make it clear which input case fails. Multiple assertions or loops in one test hide which case caused failure. Testing only output type is insufficient.

Practice

1. What is the main reason to write a test with a single responsibility in pytest?

easy

A. To run all tests faster at once

B. To make the test easier to understand and fix when it fails

C. To combine many checks in one test for efficiency

D. To avoid writing multiple test functions

Solution

1. Step 1: Understand test clarity

   Tests with one responsibility focus on one behavior, making it clear what failed.

2. Step 2: Benefits of single responsibility

   This clarity helps developers quickly find and fix issues without confusion.

3. Final Answer:

   To make the test easier to understand and fix when it fails -> Option B

4. Quick Check:

   Single responsibility = clarity and easier fixes [OK]

Hint: One test, one check, easy to read and fix [OK]

Common Mistakes:

• Trying to test many things in one test
• Ignoring test readability
• Using unclear test names

2. Which of the following pytest test function names best follows the single responsibility principle?

easy

A. test_user_login_and_profile_update

B. test_all_user_functions

C. test_user_login_with_valid_credentials

D. test_user_actions

Solution

1. Step 1: Analyze test names for specificity

   Names should describe one clear behavior or feature being tested.

2. Step 2: Compare options

   test_user_login_with_valid_credentials clearly states it tests login with valid credentials only, so it has a single responsibility.

3. Final Answer:

   test_user_login_with_valid_credentials -> Option C

4. Quick Check:

   Clear, specific test name = single responsibility [OK]

Hint: Pick the test name that describes one clear action [OK]

Common Mistakes:

• Using vague or combined test names
• Testing multiple features in one test
• Ignoring descriptive naming

3. Given this pytest code, what will be the test result?

def test_example():
    x = 5
    assert x == 5
    assert x > 0

medium

A. Test passes because both assertions are true

B. Test fails because multiple assertions are not allowed

C. Test fails because x is not defined

D. Test passes but only the first assertion is checked

Solution

1. Step 1: Check variable and assertions

   Variable x is set to 5, which satisfies both assertions: x == 5 and x > 0.

2. Step 2: Understand pytest assertion behavior

   Pytest allows multiple assertions; all are checked unless one fails first. Here both pass.

3. Final Answer:

   Test passes because both assertions are true -> Option A

4. Quick Check:

   All assertions true = test passes [OK]

Hint: Check each assertion truth; all must pass for test pass [OK]

Common Mistakes:

• Thinking multiple assertions cause failure
• Assuming only first assertion runs
• Confusing variable scope

4. Identify the problem in this pytest test function that violates single responsibility:

def test_user():
    assert login('user') == True
    assert update_profile('user', 'new info') == True

medium

A. The test has syntax errors

B. The test uses invalid function calls

C. The test misses setup code

D. The test checks two different features in one function

Solution

1. Step 1: Review test actions

   The test checks login and profile update in the same function, two separate features.

2. Step 2: Understand single responsibility principle

   Each test should check only one behavior to keep tests clear and focused.

3. Final Answer:

   The test checks two different features in one function -> Option D

4. Quick Check:

   Multiple features in one test = violation [OK]

Hint: One test, one feature; multiple features break single responsibility [OK]

Common Mistakes:

• Ignoring multiple assertions as multiple responsibilities
• Assuming syntax errors cause failure here
• Confusing setup with test logic

5. You have a test that checks user registration, login, and logout all in one function. How should you refactor it to follow single responsibility in pytest?

hard

A. Split the test into three separate tests: one for registration, one for login, and one for logout

B. Keep all checks in one test but add comments to separate them

C. Remove login and logout checks and test only registration

D. Combine registration and login in one test, logout in another

Solution

1. Step 1: Identify responsibilities in the test

   The test currently checks three different user actions: registration, login, and logout.

2. Step 2: Apply single responsibility principle

   Each test should focus on one action to improve clarity and maintainability.

3. Step 3: Refactor approach

   Splitting into three tests ensures each test checks only one feature clearly.

4. Final Answer:

   Split the test into three separate tests: one for registration, one for login, and one for logout -> Option A

5. Quick Check:

   One test per feature = better clarity and easier fixes [OK]

Hint: Split combined tests into single-feature tests [OK]

Common Mistakes:

• Keeping multiple features in one test with comments
• Removing features instead of splitting
• Partially splitting tests inconsistently