tmp_path and tmp_path_factory in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use the pytest fixture that provides a temporary directory as a pathlib.Path object.

PyTest

def test_create_file([1]):
    file = [1] / "test.txt"
    file.write_text("hello")
    assert file.read_text() == "hello"

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

Atmpdir

Btmp_path_factory

Ctmp_path

Dtmpfile

Attempts:

3 left

💡 Hint

Common Mistakes

Using tmp_path_factory directly in the test function instead of tmp_path.

Using tmpdir which returns a py.path.local object, not pathlib.Path.

The tmp_path fixture provides a temporary directory as a pathlib.Path object for the test.

2fill in blank

medium

Complete the code to create a new temporary directory inside the base temporary directory using tmp_path_factory.

PyTest

def test_new_temp_dir(tmp_path_factory):
    new_dir = tmp_path_factory.[1]("mydir")
    assert new_dir.exists() and new_dir.is_dir()

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

Amktemp

Bmkdir

Cmakedir

Dnewdir

Attempts:

3 left

💡 Hint

Common Mistakes

Using mkdir which is a pathlib method, not a tmp_path_factory method.

Trying to create the directory manually instead of using mktemp.

The mktemp method of tmp_path_factory creates a new temporary directory with the given name.

3fill in blank

hard

Fix the error in the test code to correctly create a file inside the temporary directory provided by tmp_path.

PyTest

def test_write_file(tmp_path):
    file_path = tmp_path / "data.txt"
    with open([1], "w") as f:
        f.write("data")
    assert file_path.read_text() == "data"

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

Atmp_path

Bfile_path

C"data.txt"

Dtmp_path / "data.txt"

Attempts:

3 left

💡 Hint

Common Mistakes

Passing just the directory path tmp_path to open().

Passing the filename string instead of the full path.

The variable file_path holds the full path to the file and should be used in open().

4fill in blank

hard

Fill both blanks to create a new temporary directory and a file inside it using tmp_path_factory.

PyTest

def test_tmp_path_factory(tmp_path_factory):
    temp_dir = tmp_path_factory.[1]("session")
    file = temp_dir / [2]
    file.write_text("hello")
    assert file.read_text() == "hello"

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

Amktemp

B"test.txt"

C"data.log"

Dmkdir

Attempts:

3 left

💡 Hint

Common Mistakes

Using mkdir instead of mktemp for tmp_path_factory.

Using a method name instead of a string for the filename.

Use mktemp to create the directory and a string filename like "test.txt" for the file.

5fill in blank

hard

Fill all three blanks to create a temporary directory, a file inside it, and assert the file content using tmp_path_factory.

PyTest

def test_full_tmp_path_factory(tmp_path_factory):
    dir_path = tmp_path_factory.[1]("run")
    file_path = dir_path / [2]
    file_path.write_text([3])
    assert file_path.read_text() == "pytest rocks"

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

Amktemp

B"output.txt"

C"pytest rocks"

Dmkdir

Attempts:

3 left

💡 Hint

Common Mistakes

Using mkdir instead of mktemp.

Passing a variable instead of a string for filename or content.

Use mktemp to create the directory, a filename string for the file, and the string content to write.

Practice

1. What is the main purpose of the tmp_path fixture in pytest?

easy

A. To provide a unique temporary directory for each test function

B. To create multiple temporary directories during a single test

C. To permanently store test files after tests finish

D. To mock file system calls without creating real files

Solution

1. Step 1: Understand the role of tmp_path

   The tmp_path fixture gives each test a fresh temporary directory to use.

2. Step 2: Compare with other options

   It does not create multiple directories per test (that's tmp_path_factory), nor does it store files permanently or mock file calls.

3. Final Answer:

   To provide a unique temporary directory for each test function -> Option A

4. Quick Check:

   tmp_path = unique temp folder per test [OK]

Hint: Remember: tmp_path = one temp folder per test [OK]

Common Mistakes:

• Confusing tmp_path with tmp_path_factory
• Thinking tmp_path stores files permanently
• Assuming tmp_path mocks file system calls

2. Which of the following is the correct way to use tmp_path_factory to create a new temporary directory named 'data' inside a test?

easy

A. new_dir = tmp_path_factory.make_directory('data')

B. new_dir = tmp_path_factory.create_temp('data')

C. new_dir = tmp_path_factory.tempdir('data')

D. new_dir = tmp_path_factory.mktemp('data')

Solution

1. Step 1: Recall the correct method name

   The method to create a new temporary directory with tmp_path_factory is mktemp().

2. Step 2: Verify method usage

   Calling tmp_path_factory.mktemp('data') creates a temp directory named 'data'. Other options are not valid pytest methods.

3. Final Answer:

   new_dir = tmp_path_factory.mktemp('data') -> Option D

4. Quick Check:

   mktemp() creates temp dirs [OK]

Hint: Use mktemp() method to create temp dirs with tmp_path_factory [OK]

Common Mistakes:

• Using incorrect method names like create_temp or tempdir
• Trying to call make_directory which doesn't exist
• Confusing tmp_path and tmp_path_factory usage

3. Given the following pytest test code, what will be the output of the assertion?

def test_create_file(tmp_path):
    file = tmp_path / 'test.txt'
    file.write_text('hello')
    content = file.read_text()
    assert content == 'hello'

medium

A. Test fails because read_text() returns bytes, not string

B. Test fails because the file is not created

C. Test passes because the file content matches 'hello'

D. Test raises an exception due to invalid file path

Solution

1. Step 1: Analyze file creation and writing

   The code creates a file 'test.txt' in the temporary directory and writes the string 'hello' to it.

2. Step 2: Check reading and assertion

   Reading the file with read_text() returns the string 'hello', which matches the assertion.

3. Final Answer:

   Test passes because the file content matches 'hello' -> Option C

4. Quick Check:

   write_text/read_text with tmp_path works [OK]

Hint: write_text and read_text handle strings correctly [OK]

Common Mistakes:

• Assuming read_text returns bytes instead of string
• Thinking file is not created automatically
• Expecting exceptions from valid path operations

4. Identify the error in this pytest test using tmp_path_factory:

def test_dir_creation(tmp_path_factory):
    dir1 = tmp_path_factory.mktemp('dir')
    dir2 = tmp_path_factory.mktemp('dir')
    assert dir1 != dir2

medium

A. Error because mktemp cannot create directories with the same name

B. No error; test passes because mktemp creates unique dirs

C. Error because tmp_path_factory is not a valid fixture

D. Error because assert compares directory contents, not paths

Solution

1. Step 1: Understand mktemp behavior

   Each call to mktemp('dir') creates a unique temporary directory, even if the name is the same.

2. Step 2: Check assertion validity

   The assertion compares the two directory paths and expects them to be different, which is true.

3. Final Answer:

   No error; test passes because mktemp creates unique dirs -> Option B

4. Quick Check:

   mktemp creates unique dirs even with same name [OK]

Hint: mktemp always creates unique dirs, names can repeat [OK]

Common Mistakes:

• Thinking mktemp fails on duplicate names
• Confusing fixture names or usage
• Assuming assert compares contents, not paths

5. You want to write a pytest test that creates two temporary directories: one shared across multiple tests and one unique per test. Which combination of fixtures should you use?

hard

A. Use tmp_path_factory to create the shared directory and tmp_path for the unique per-test directory

B. Use tmp_path for both shared and unique directories

C. Use tmp_path_factory for both shared and unique directories

D. Use tmp_path to create the shared directory and tmp_path_factory for unique directories

Solution

1. Step 1: Identify fixture roles

   tmp_path provides a fresh temp directory unique to each test. tmp_path_factory can create directories shared or reused across tests.

2. Step 2: Match requirements to fixtures

   For a shared directory across tests, use tmp_path_factory. For unique per-test directories, use tmp_path.

3. Final Answer:

   Use tmp_path_factory to create the shared directory and tmp_path for the unique per-test directory -> Option A

4. Quick Check:

   tmp_path unique per test, tmp_path_factory for shared [OK]

Hint: tmp_path unique per test; tmp_path_factory for shared dirs [OK]

Common Mistakes:

• Using tmp_path for shared directories
• Using tmp_path_factory only for unique per-test dirs
• Mixing up fixture purposes