Deterministic tests in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to make the test deterministic by fixing the seed.

PyTest

import random

def test_random_number():
    random.seed([1])
    num = random.randint(1, 10)
    assert num == 7

Drag options to blanks, or click blank then click option'

A0

Brandom

C42

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using random.seed(None) which makes the test non-deterministic.

Setting the seed to a fixed number like 42 makes the random number generation deterministic.

2fill in blank

medium

Complete the code to ensure the test always checks the same output from a function using a fixed seed.

PyTest

import random

def get_random_choice():
    random.seed([1])
    return random.choice(['apple', 'banana', 'cherry'])

def test_choice():
    assert get_random_choice() == 'banana'

Drag options to blanks, or click blank then click option'

A42

B100

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Not setting the seed inside the function, causing different outputs.

Using seed 42 ensures the choice is always 'banana' for this test.

3fill in blank

hard

Fix the error in the test to make it deterministic by setting the seed correctly.

PyTest

import random

def test_sum():
    random.seed([1])
    values = [random.randint(1, 5) for _ in range(3)]
    assert sum(values) == 7

Drag options to blanks, or click blank then click option'

Arandom

B42

C'seed'

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using None or a string as seed, which does not fix randomness.

Setting the seed to 42 ensures the random values are the same every time, making the sum predictable.

4fill in blank

hard

Fill both blanks to create a deterministic test that filters even numbers from a random list.

PyTest

import random

def test_even_numbers():
    random.seed([1])
    numbers = [random.randint(1, 10) for _ in range(5)]
    evens = [num for num in numbers if num [2] 2 == 0]
    assert evens == [4, 10]

Drag options to blanks, or click blank then click option'

A123

B!=

C%

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '%' causes wrong filtering.

Seed 123 fixes the random numbers. Using '%' checks for even numbers correctly.

5fill in blank

hard

Fill all three blanks to create a deterministic test that maps uppercase keys to values greater than 5.

PyTest

import random

def test_filtered_dict():
    random.seed([1])
    data = {chr(97 + i): random.randint(1, 10) for i in range(4)}
    filtered = {k[2]: v for k, v in data.items() if v [3] 5}
    assert filtered == {'A': 7, 'D': 6}

Drag options to blanks, or click blank then click option'

A7

B>

C.upper()

D42

Attempts:

3 left

💡 Hint

Common Mistakes

Not converting keys to uppercase or using wrong comparison operator.

Seed 42 fixes random values. Using .upper() converts keys to uppercase. '>' filters values greater than 5.

Practice

1. What does it mean for a test to be deterministic in pytest?

easy

A. The test depends on external services to pass.

B. The test always produces the same result given the same inputs.

C. The test uses random data every time it runs.

D. The test runs faster than non-deterministic tests.

Solution

1. Step 1: Understand the meaning of deterministic tests

   Deterministic tests produce consistent results every time they run with the same inputs.

2. Step 2: Compare options with this definition

   Only The test always produces the same result given the same inputs. states that the test always produces the same result given the same inputs, matching the definition.

3. Final Answer:

   The test always produces the same result given the same inputs. -> Option B

4. Quick Check:

   Deterministic = Same result every time [OK]

Hint: Deterministic means repeatable results every run [OK]

Common Mistakes:

• Confusing deterministic with fast tests
• Thinking randomness is allowed in deterministic tests
• Assuming external dependencies make tests deterministic

2. Which of the following is the correct way to fix randomness in a pytest test to make it deterministic?

easy

A. Use a fixed seed for the random number generator.

B. Remove all assertions from the test.

C. Run the test multiple times and average the results.

D. Use random data without controlling it.

Solution

1. Step 1: Identify how to control randomness

   Setting a fixed seed for the random number generator ensures the same random values each run.

2. Step 2: Evaluate options for fixing randomness

   Only Use a fixed seed for the random number generator. uses a fixed seed, which makes the test deterministic. Other options do not control randomness properly.

3. Final Answer:

   Use a fixed seed for the random number generator. -> Option A

4. Quick Check:

   Fixed seed = deterministic randomness [OK]

Hint: Fix random seed to control randomness [OK]

Common Mistakes:

• Removing assertions does not fix randomness
• Averaging results does not make test deterministic
• Using uncontrolled random data causes flaky tests

3. Given this pytest test code, what will be the output when run twice?

import random

def test_random_number():
    random.seed(42)
    num = random.randint(1, 10)
    assert num == 2

medium

A. The test will pass both times because the seed fixes the random number.

B. The test will fail both times because 2 is not the generated number.

C. The test will pass the first time and fail the second time.

D. The test will fail the first time and pass the second time.

Solution

1. Step 1: Understand the effect of setting random.seed(42)

   Setting the seed to 42 makes random.randint(1, 10) produce the same number every run.

2. Step 2: Check the generated number and assertion

   With seed 42, random.randint(1, 10) returns 2, so the assertion num == 2 passes every time.

3. Final Answer:

   The test will pass both times because the seed fixes the random number. -> Option A

4. Quick Check:

   Seed 42 -> randint = 2 == 2 -> assert passes [OK]

Hint: Seed fixes random output to 2, so assertion num==2 passes consistently [OK]

Common Mistakes:

• Thinking the test passes because of seed (but checks wrong number)
• Assuming random changes every run despite seed
• Not verifying that seed(42) produces 2 for randint(1,10)

4. This pytest test sometimes fails randomly. What is the main issue?

import random

def test_random_fail():
    num = random.randint(1, 10)
    assert num == 5

medium

A. The test function name is invalid.

B. The assertion syntax is incorrect.

C. The test does not fix the random seed, causing non-deterministic results.

D. The random module is not imported.

Solution

1. Step 1: Identify randomness control in the test

   The test uses random.randint without setting a seed, so output varies each run.

2. Step 2: Understand why this causes test failure

   Because the number is random, the assertion num == 5 sometimes fails, making the test flaky.

3. Final Answer:

   The test does not fix the random seed, causing non-deterministic results. -> Option C

4. Quick Check:

   No seed -> random output varies -> flaky test [OK]

Hint: No seed means random output, causing flaky tests [OK]

Common Mistakes:

• Thinking assertion syntax is wrong
• Assuming test name affects determinism
• Ignoring that random module is correctly imported

5. You want to write a deterministic pytest test that checks if a function returns the current date. Which approach ensures determinism?

hard

A. Call the function without any changes and assert the result.

B. Run the test only once to avoid variability.

C. Use the actual current date and accept test failures on different days.

D. Mock the current date to a fixed value during the test.

Solution

1. Step 1: Understand why current date causes non-determinism

   The current date changes every day, so tests using it without control will fail on different days.

2. Step 2: Identify how to fix the date for deterministic testing

   Mocking the current date to a fixed value ensures the test always sees the same date and passes consistently.

3. Final Answer:

   Mock the current date to a fixed value during the test. -> Option D

4. Quick Check:

   Mock date -> fixed input -> deterministic test [OK]

Hint: Mock changing data like dates for stable tests [OK]

Common Mistakes:

• Using real current date causes flaky tests
• Ignoring mocking leads to non-deterministic results
• Running test once does not guarantee determinism