Subprocess testing in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to run a subprocess command that lists files.

PyTest

import subprocess

def test_list_files():
    result = subprocess.run(['ls', '[1]'], capture_output=True, text=True)
    assert result.returncode == 0

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

A-z

B-a

C-x

D-l

Attempts:

3 left

💡 Hint

Common Mistakes

Using an invalid option that causes the subprocess to fail.

Forgetting to capture output which is needed for assertions.

The -a option lists all files including hidden ones. It is a common flag for ls.

2fill in blank

medium

Complete the code to check that the subprocess output contains the word 'test'.

PyTest

import subprocess

def test_output_contains_test():
    result = subprocess.run(['echo', 'this is a test'], capture_output=True, text=True)
    assert [1] in result.stdout

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

A'test'

B'Test'

C'TEST'

D'testing'

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different case which causes the assertion to fail.

Checking for a substring not present in the output.

The output contains the exact word 'test' in lowercase, so the assertion checks for 'test'.

3fill in blank

hard

Fix the error in the subprocess call to correctly capture output as text.

PyTest

import subprocess

def test_capture_text():
    result = subprocess.run(['echo', 'hello'], [1]=True, capture_output=True)
    assert result.stdout.strip() == 'hello'

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

Atext

Bencoding

Cshell

Duniversal_newlines

Attempts:

3 left

💡 Hint

Common Mistakes

Using text=True in older Python versions where it is unsupported.

Not setting any argument, causing output to be bytes.

The universal_newlines=True argument makes stdout a string instead of bytes in Python 3.7+. Alternatively, text=True can be used in newer versions.

4fill in blank

hard

Fill both blanks to run a subprocess that checks Python version and asserts success.

PyTest

import subprocess

def test_python_version():
    result = subprocess.run(['[1]', '[2]'], capture_output=True, text=True)
    assert result.returncode == 0

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

Apython3

Bpython

C--version

D-V

Attempts:

3 left

💡 Hint

Common Mistakes

Using python3 when only python is available.

Using an invalid flag that causes the command to fail.

The command python -V prints the Python version and returns 0 on success.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension filtering files ending with '.py'.

PyTest

import subprocess

def test_list_python_files():
    result = subprocess.run(['ls'], capture_output=True, text=True)
    files = { [1]: True for [2] in result.stdout.splitlines() if [3].endswith('.py') }
    assert 'test_script.py' in files

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

Afile

Bf

Cfilename

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inconsistently causing NameError.

Not filtering files ending with '.py' correctly.

Using the same variable f for key, loop variable, and condition is correct and consistent.

Practice

1. What is the main purpose of subprocess testing in pytest?

easy

A. To measure the speed of your Python functions

B. To test user interface elements like buttons and forms

C. To check commands run by your program and verify their output

D. To check database connections and queries

Solution

1. Step 1: Understand subprocess testing

   Subprocess testing focuses on running external commands or programs from your code and checking their behavior.

2. Step 2: Identify the correct purpose

   Among the options, only checking commands run by your program matches subprocess testing.

3. Final Answer:

   To check commands run by your program and verify their output -> Option C

4. Quick Check:

   Subprocess testing = check commands run [OK]

Hint: Subprocess testing checks external commands run by your code [OK]

Common Mistakes:

• Confusing subprocess testing with UI testing
• Thinking it measures function speed
• Assuming it tests databases

2. Which of the following is the correct way to run a subprocess command in pytest and capture its output?

easy

A. subprocess.execute('ls', capture=True)

B. subprocess.run(['ls'], capture_output=True, text=True)

C. subprocess.call('ls', output=True)

D. subprocess.run('ls', capture=True)

Solution

1. Step 1: Recall subprocess.run syntax

   The correct function is subprocess.run with a list of command arguments and capture_output=True to capture output.

2. Step 2: Check options for correctness

   Only subprocess.run(['ls'], capture_output=True, text=True) uses subprocess.run with correct parameters and argument format.

3. Final Answer:

   subprocess.run(['ls'], capture_output=True, text=True) -> Option B

4. Quick Check:

   Use subprocess.run with capture_output=True [OK]

Hint: Use subprocess.run([...], capture_output=True) to capture output [OK]

Common Mistakes:

• Using subprocess.execute which does not exist
• Passing command as string without shell=True
• Using wrong parameter names like capture or output

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

import subprocess

def test_echo():
    result = subprocess.run(['echo', 'hello'], capture_output=True, text=True)
    assert result.stdout == 'hello\n'

medium

A. The test raises a runtime error

B. The test fails because stdout is empty

C. The test fails because stdout contains 'hello' without newline

D. The test passes because stdout contains 'hello\n'

Solution

1. Step 1: Understand subprocess.run output for echo

   The echo command outputs the string followed by a newline, so stdout will be 'hello\n'.

2. Step 2: Check the assertion

   The assertion compares result.stdout to 'hello\n', which matches exactly, so it passes.

3. Final Answer:

   The test passes because stdout contains 'hello\n' -> Option D

4. Quick Check:

   echo adds newline, assertion matches [OK]

Hint: Remember echo adds newline to output [OK]

Common Mistakes:

• Forgetting echo adds a newline
• Expecting stdout without newline
• Confusing stdout with stderr

4. Identify the error in this pytest subprocess test code:

import subprocess

def test_fail():
    result = subprocess.run(['false'], capture_output=True, text=True)
    assert result.returncode == 0

medium

A. The command 'false' returns a non-zero exit code, so assertion fails

B. Missing capture_output=True causes error

C. Using text=True is invalid here

D. subprocess.run requires shell=True for 'false'

Solution

1. Step 1: Understand the 'false' command behavior

   The 'false' command always returns exit code 1 (failure), not 0.

2. Step 2: Check the assertion on returncode

   The test asserts returncode == 0, which is false, so the assertion fails.

3. Final Answer:

   The command 'false' returns a non-zero exit code, so assertion fails -> Option A

4. Quick Check:

   'false' returns 1, assertion expects 0 [OK]

Hint: Check command return codes before asserting 0 [OK]

Common Mistakes:

• Assuming 'false' returns 0
• Thinking capture_output=True is mandatory for returncode
• Believing shell=True is needed for 'false'

5. You want to test a subprocess command that may output errors. Which pytest assertion correctly checks that the command failed and printed 'error' in stderr?

result = subprocess.run(['mycmd'], capture_output=True, text=True)

hard

A. assert result.returncode != 0 and 'error' in result.stderr

B. assert result.returncode == 0 and 'error' in result.stdout

C. assert result.returncode == 0 and 'error' in result.stderr

D. assert result.returncode != 0 and 'error' in result.stdout

Solution

1. Step 1: Understand failure and error output

   A failed command has returncode not zero and error messages appear in stderr.

2. Step 2: Match assertion to expected behavior

   assert result.returncode != 0 and 'error' in result.stderr asserts returncode != 0 and 'error' in stderr, which correctly tests failure and error output.

3. Final Answer:

   assert result.returncode != 0 and 'error' in result.stderr -> Option A

4. Quick Check:

   Failure means returncode != 0 and errors in stderr [OK]

Hint: Check returncode != 0 and error text in stderr [OK]

Common Mistakes:

• Checking error in stdout instead of stderr
• Expecting returncode == 0 for failure
• Mixing stdout and stderr in assertions