⚠

Privacy Notice: When you sign in with GitHub, your quiz attempts are stored in Google Firebase so you can track your progress. This data is only accessible to the course instructor, is not otherwise shared, and will be deleted at the end of the semester. For earlier deletion, contact the instructor. Prefer to stay anonymous? Use guest mode or a GitHub account without your real name.

● Progress is being saved

03 Exercise: Coverage Detective

Score: 0 / 10

Question Overview

Pending Correct Incorrect

Instructions

In this exercise, you’ll become a Coverage Detective. You’ll analyze real pytest-cov output, identify which code paths are untested, and design tests to cover the gaps.

Preparation: Read First

Before attempting this exercise, study the following lecture sections:

From Chapter 03 (TDD and CI): TDD and CI:

Part 3: Setting Up Coverage Reporting - Understanding --cov-report=term-missing

From Chapter 03 (Testing Theory and Coverage): Testing Theory & Coverage:

Section 5: Systematic Test Design - Designing tests for specific branches

Learning Objectives

Interpret pytest-cov output and identify missing lines
Understand why specific lines weren’t executed
Design test cases that cover specific branches
Write test functions that achieve target coverage

Structure

Part 1 (Questions 1-5): Analysis - Identify what’s missing and why
Part 2 (Questions 6-10): Design - Create tests to cover the gaps

Scoring Guide

9-10 correct: Excellent! Ready for the GitHub Classroom assignment
7-8 correct: Good understanding! Review the explanations
5-6 correct: Fair understanding. Revisit the lecture materials
Below 5: Please review the coverage concepts before continuing

GitHub Classroom Assignment

After completing this quiz, apply your skills in a real hands-on assignment:

Accept the Coverage Improvement Exercise

You’ll improve coverage from ~54% to 85%+ with immediate CI feedback!

Question1 Part 1: Analysis

Code: validate_age.py

def validate_age(age):
    if age < 0:
        return "invalid: negative"
    if age < 18:
        return "minor"
    if age < 65:
        return "adult"
    return "senior"

Tests:

def test_minor():
    assert validate_age(15) == "minor"

def test_adult():
    assert validate_age(30) == "adult"

Coverage Report: Missing: 3, 8

What conditions are NOT covered, and why?

A) age < 0 and age >= 65, because no test uses negative or senior ages B) age < 18 and age < 65, because those conditions always fail C) age < 0 and age < 18, because no test uses ages below 18 D) The report is wrong; all conditions should be covered

Question2 Part 1: Analysis

Code: format_name.py

def format_name(first, last, formal=False):
    if not first or not last:
        return "Invalid name"

    if formal:
        return f"Mr./Ms. {last}"
    return f"{first} {last}"

Tests:

def test_informal_name():
    assert format_name("John", "Doe") == "John Doe"

def test_formal_name():
    assert format_name("Jane", "Smith", formal=True) == "Mr./Ms. Smith"

Coverage Report: Missing: 3

Line 3 is return "Invalid name". Why is it NOT covered?

A) The `if formal` condition is never True B) The `not first or not last` condition is never True C) The `formal` parameter is always False D) The function has a syntax error

Question3 Part 1: Analysis

Code: check_access.py

 def check_access(user_role, resource_type, is_owner):
     # Admin can access anything
     if user_role == "admin":
         return True

     # Owner can access their own resources
     if is_owner:
         return True

    # Editors can access documents and images
    if user_role == "editor" and resource_type in ["document", "image"]:
        return True

    return False

Tests:

def test_admin_access():
    assert check_access("admin", "secret", False) == True

def test_owner_access():
    assert check_access("viewer", "document", True) == True

def test_editor_document():
    assert check_access("editor", "document", False) == True

def test_denied():
    assert check_access("viewer", "document", False) == False

Coverage Report: Missing: 12 (partial)

Line 11-12 is marked as partially covered. Why?

A) "editor" role was never tested B) "document" resource was never tested C) The "image" resource type was never tested (only "document" was) D) The `is_owner` parameter wasn't tested

Question4 Part 1: Analysis

Code: divide.py

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return None
    except TypeError:
        return "invalid input"
    return result

Tests:

def test_normal_division():
    assert safe_divide(10, 2) == 5.0

def test_divide_by_zero():
    assert safe_divide(10, 0) is None

Coverage Report: Missing: 7, 8

Lines 6-7 are the except TypeError block. What input would trigger this exception?

A) safe_divide("10", "2") - string division B) safe_divide(10, -1) - negative divisor C) safe_divide(0, 10) - zero dividend D) safe_divide(10, 0.0) - float zero

Question5 Part 1: Analysis

Code: find_max.py

def find_max(numbers):
    if not numbers:
        return None

    max_val = numbers[0]
    for num in numbers[1:]:
        if num > max_val:
            max_val = num
    return max_val

Tests:

def test_single_element():
    assert find_max([42]) == 42

def test_sorted_ascending():
    assert find_max([1, 2, 3, 4, 5]) == 5

Coverage Report: Missing: 3

Line 3 is return None. Why is the loop (lines 6-8) shown as covered but line 3 is not?

A) The loop was never executed B) The `if not numbers` condition was never True (no empty list test) C) The `num > max_val` condition was never True D) The function was never called

Question6 Part 2: Design Tests

Code: validate_password.py

 def validate_password(password):
     if len(password) < 8:
         return "too short"

     if len(password) > 128:
         return "too long"

     has_upper = any(c.isupper() for c in password)
     has_lower = any(c.islower() for c in password)
    has_digit = any(c.isdigit() for c in password)

    if not has_upper:
        return "needs uppercase"
    if not has_lower:
        return "needs lowercase"
    if not has_digit:
        return "needs digit"

    return "valid"

Coverage Report: Missing: 6, 15, 17

Which test would cover line 15 (return "needs lowercase")?

A) validate_password("lowercase1") - needs uppercase B) validate_password("UPPERCASE1") - needs lowercase C) validate_password("NoDigitsHere") - needs digit D) validate_password("A" * 129) - too long

Question7 Part 2: Design Tests

Code: shipping.py

 def calculate_shipping(weight, destination, express=False):
     if weight <= 0:
         raise ValueError("Weight must be positive")

     if destination not in ["domestic", "international"]:
         raise ValueError("Invalid destination")

     base_rate = 5.0 if destination == "domestic" else 15.0
     weight_charge = weight * 0.5

    subtotal = base_rate + weight_charge

    if express:
        subtotal *= 1.5

    if subtotal > 50:
        discount = subtotal * 0.1
        return subtotal - discount

    return subtotal

Coverage Report: Missing: 3, 6, 17, 18

To cover lines 17-18 (discount for subtotal > 50), what’s the MINIMUM weight for domestic non-express?

A) weight = 50 (subtotal = 30) B) weight = 90 (subtotal = 50, not greater) C) weight = 91 (subtotal = 50.5 > 50) D) weight = 100 (subtotal = 55 > 50)

Question8 Part 2: Design Tests

Code: config.py

 def parse_config(config_string):
     if not config_string:
         return {}

     result = {}
     lines = config_string.strip().split('\n')

     for line in lines:
         line = line.strip()

        if not line or line.startswith('#'):
            continue

        if '=' not in line:
            raise ValueError(f"Invalid config line: {line}")

        key, value = line.split('=', 1)
        key = key.strip()
        value = value.strip()

        if not key:
            raise ValueError("Empty key not allowed")

        result[key] = value

    return result

Coverage Report: Missing: 3, 12, 15, 22

Which input would cover line 22 (raise ValueError("Empty key not allowed"))?

A) parse_config("") B) parse_config("# comment") C) parse_config("invalid line without equals") D) parse_config(" =some_value")

Question9 Part 2: Design Tests

Code: discount.py

 def calculate_discount(amount, is_member, coupon_code):
     if amount <= 0:
         return 0

     discount = 0.0

     if is_member:
         discount += 0.10  # 10% member discount

    if coupon_code is not None:
        if coupon_code == "SAVE20":
            discount += 0.20
        elif coupon_code == "SAVE10":
            discount += 0.10
        elif coupon_code.startswith("VIP"):
            if is_member:
                discount += 0.30
            else:
                discount += 0.15

    # Cap discount at 50%
    if discount > 0.50:
        discount = 0.50

    return amount * discount

Coverage Report: Missing: 3, 14, 17, 19, 23

Can line 23 (discount cap = 0.50) ever be reached with this code?

A) Yes, member + SAVE20 = 30% discount B) Yes, member + VIP = 40% discount C) No, maximum possible is 40% (member 10% + VIP 30%) D) Yes, non-member + VIP + SAVE20 = 55%

Question10 Part 2: Design Tests

Code: process_order.py

 def process_order(items, customer_type, promo_code=None):
     if not items:
         return {"status": "error", "message": "No items"}

     subtotal = sum(item["price"] * item["quantity"] for item in items)

     if subtotal <= 0:
         return {"status": "error", "message": "Invalid total"}

    discount_rate = 0

    if customer_type == "premium":
        discount_rate = 0.15
    elif customer_type == "member":
        discount_rate = 0.05

    if promo_code == "FLASH50" and subtotal >= 100:
        discount_rate += 0.50
    elif promo_code == "FLASH25" and subtotal >= 50:
        discount_rate += 0.25

    if discount_rate > 0.60:
        discount_rate = 0.60

    discount = subtotal * discount_rate
    total = subtotal - discount

    return {"status": "success", ...}

To trigger line 23 (discount cap at 60%), which combination works?

A) premium customer (15%) + FLASH50 (50%) = 65% > 60% B) member customer (5%) + FLASH50 (50%) = 55% < 60% C) premium customer (15%) + FLASH25 (25%) = 40% < 60% D) regular customer (0%) + FLASH50 (50%) = 50% < 60%

03 Exercise: Coverage Detective

Instructions

Preparation: Read First

Learning Objectives

Structure

Scoring Guide

GitHub Classroom Assignment

Quiz Complete!