@pytest.mark.xfail for expected failures - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does @pytest.mark.xfail do in a pytest test?

It marks a test as an expected failure. If the test fails, pytest reports it as an expected failure, not a test failure.

intermediate

How does pytest report a test marked with @pytest.mark.xfail when it actually passes?

Pytest reports it as an unexpected pass because the test was expected to fail but passed.

beginner

Why would you use @pytest.mark.xfail in your test suite?

To acknowledge known bugs or incomplete features without failing the whole test suite, allowing progress while tracking issues.

intermediate

What happens if a test marked with @pytest.mark.xfail(strict=True) unexpectedly passes?

The test suite will fail because strict mode treats unexpected passes as errors.

beginner

Show a simple example of using @pytest.mark.xfail in a test function.

import pytest

@pytest.mark.xfail
def test_example():
    assert 1 == 2  # This test is expected to fail

What does @pytest.mark.xfail indicate about a test?

A The test should be skipped

B The test is expected to fail

C The test must always pass

D The test is ignored

@pytest.mark.xfail marks a test as expected to fail due to known issues.

If a test marked with @pytest.mark.xfail passes, how does pytest report it by default?

A Unexpected pass

B Pass

C Fail

D Skipped

Pytest reports it as an unexpected pass because it was expected to fail.

What does adding strict=True to @pytest.mark.xfail do?

A Fails the test suite if the test unexpectedly passes

B Runs the test twice

C Ignores the test result

D Skips the test

Strict mode makes pytest fail the suite if an expected failure test passes unexpectedly.

Which of these is a good reason to use @pytest.mark.xfail?

A To hide all test failures

B To speed up test execution

C To skip tests permanently

D To document known bugs without failing the suite

It helps track known bugs while allowing the test suite to run smoothly.

What happens if you do not mark a failing test with @pytest.mark.xfail?

A The test passes anyway

B The test is ignored

C The test suite fails

D The test is skipped

Unmarked failing tests cause the test suite to fail.

Explain how @pytest.mark.xfail helps manage tests with known bugs.

Think about how you handle bugs that are not fixed yet but don't want to block progress.

Describe the difference between @pytest.mark.xfail with and without strict=True.

Consider how strict mode changes the test suite behavior when a test passes unexpectedly.

Practice

1. What is the main purpose of using @pytest.mark.xfail in a test?

easy

A. To mark tests that are expected to fail due to known issues

B. To skip tests that are not ready to run

C. To mark tests that should always pass

D. To run tests multiple times automatically

Solution

1. Step 1: Understand the purpose of @pytest.mark.xfail

   This decorator is used to mark tests that are expected to fail because of known bugs or unfinished features.

2. Step 2: Differentiate from other decorators

   Unlike skipping tests, xfail runs the test but expects failure. It does not mark tests to always pass or run multiple times.

3. Final Answer:

   To mark tests that are expected to fail due to known issues -> Option A

4. Quick Check:

   @pytest.mark.xfail = expected failure [OK]

Hint: xfail means test expected to fail, not skip or pass [OK]

Common Mistakes:

• Confusing xfail with skip
• Thinking xfail forces test to pass
• Assuming xfail reruns tests

2. Which of the following is the correct syntax to mark a test as expected to fail with strict checking in pytest?

easy

A. @pytest.mark.skip(strict=True)
def test_example(): pass

B. @pytest.mark.xfail(strict=True)
def test_example(): pass

C. @pytest.xfail(strict=True)
def test_example(): pass

D. @pytest.mark.xfail(strict=False)
def test_example(): pass

Solution

1. Step 1: Recall correct decorator usage

   The correct decorator is @pytest.mark.xfail with parentheses for parameters.

2. Step 2: Understand strict parameter

   Setting strict=True means pytest will fail the test if it unexpectedly passes.

3. Final Answer:

   @pytest.mark.xfail(strict=True)\ndef test_example(): pass -> Option B

4. Quick Check:

   Correct syntax uses @pytest.mark.xfail(strict=True) [OK]

Hint: Use @pytest.mark.xfail(strict=True) with parentheses [OK]

Common Mistakes:

• Using @pytest.xfail instead of @pytest.mark.xfail
• Confusing skip with xfail
• Omitting parentheses for parameters

3. Consider this pytest code snippet:

@pytest.mark.xfail(strict=True)
def test_divide():
    assert 1 / 0 == 0

What will be the test result when running pytest?

medium

A. Test passes because failure is expected

B. Test fails because division by zero raises an error

C. Test is skipped due to xfail

D. Test fails because strict=True causes failure on error

Solution

1. Step 1: Analyze the test code

   The test asserts 1 divided by 0 equals 0, which raises a ZeroDivisionError, causing failure.

2. Step 2: Understand xfail with strict=True

   Since failure is expected, the test is marked as xfail and will pass the test suite. strict=True only fails if the test unexpectedly passes.

3. Final Answer:

   Test passes because failure is expected -> Option A

4. Quick Check:

   xfail with error = pass test [OK]

Hint: xfail passes if test fails; strict=True fails only if test passes [OK]

Common Mistakes:

• Thinking strict=True fails on error
• Confusing xfail with skip
• Expecting test to fail pytest run

4. You wrote this test:

@pytest.mark.xfail(strict=True)
def test_sum():
    assert sum([1, 2, 3]) == 5

When you run pytest, the test fails. What is the most likely reason?

medium

A. The test unexpectedly passed, causing failure due to strict=True

B. The xfail decorator was not applied correctly

C. The test failed because the assertion is incorrect

D. The test was skipped accidentally

Solution

1. Step 1: Check the assertion logic

   The sum of [1, 2, 3] is 6, but the test asserts it equals 5, so the assertion fails.

2. Step 2: Understand strict=True effect

   strict=True causes failure only if the test unexpectedly passes, but here the test fails as expected.

3. Final Answer:

   The test failed because the assertion is incorrect -> Option C

4. Quick Check:

   Wrong assertion causes failure, not strict=True [OK]

Hint: Check assertion values carefully; strict=True fails only on unexpected pass [OK]

Common Mistakes:

• Assuming strict=True causes failure on test fail
• Thinking test was skipped
• Believing decorator syntax is wrong

5. You have a test that sometimes passes and sometimes fails due to a flaky external API. You want pytest to mark it as expected failure but fail the test run if it unexpectedly passes. Which is the best way to write this?

hard

A. @pytest.mark.xfail()
def test_api():
assert call_api() == 'OK'

B. @pytest.mark.skip(reason='Flaky API')
def test_api():
assert call_api() == 'OK'

C. @pytest.mark.xfail(strict=False, reason='Flaky API')
def test_api():
assert call_api() == 'OK'

D. @pytest.mark.xfail(strict=True, reason='Flaky API')
def test_api():
assert call_api() == 'OK'

Solution

1. Step 1: Identify requirement for strict checking

   You want pytest to fail the test run if the test unexpectedly passes, so strict=True is needed.

2. Step 2: Use xfail with reason for clarity

   Marking the test with @pytest.mark.xfail(strict=True, reason='Flaky API') clearly documents the expected failure and enforces strict checking.

3. Final Answer:

   @pytest.mark.xfail(strict=True, reason='Flaky API')\ndef test_api():\n assert call_api() == 'OK' -> Option D

4. Quick Check:

   xfail with strict=True and reason = best practice [OK]

Hint: Use strict=True to catch unexpected passes on flaky tests [OK]

Common Mistakes:

• Using skip instead of xfail
• Omitting strict=True when needed
• Not providing reason for clarity