Code review as testing in Testing Fundamentals - Full Explanation

Introduction

Finding mistakes in code before it runs can save a lot of time and trouble. Code review helps catch errors and improve quality by having others look at the code carefully.

Explanation

Purpose of Code Review

Code review is a process where developers check each other's code to find mistakes, improve clarity, and ensure standards are met. It acts as a first line of defense before running tests or deploying software.

Code review helps catch errors early and improves code quality by involving multiple eyes.

How Code Review Supports Testing

By reviewing code, reviewers can spot logical errors, missing cases, or unclear parts that automated tests might miss. It complements automated testing by focusing on code structure and intent.

Code review complements automated tests by finding issues that tests alone may not detect.

Common Code Review Practices

Reviewers look for bugs, style consistency, readability, and adherence to requirements. They provide feedback and suggest improvements, which the author then applies before final approval.

Effective code reviews focus on correctness, clarity, and maintainability.

Benefits Beyond Bug Finding

Code review also shares knowledge among team members, helps maintain coding standards, and encourages better design decisions. It builds team collaboration and reduces future maintenance effort.

Code review improves team knowledge and long-term code health, not just bug detection.

Real World Analogy

Imagine writing a letter and asking a friend to read it before sending. They catch spelling mistakes, unclear sentences, and suggest better ways to express ideas. This helps you send a clearer, error-free letter.

Purpose of Code Review → Friend reading your letter to find mistakes and improve it

How Code Review Supports Testing → Friend noticing unclear parts that spell check might miss

Common Code Review Practices → Friend giving feedback on grammar, style, and clarity

Benefits Beyond Bug Finding → Friend helping you learn better writing and avoid future mistakes

Diagram

Diagram

┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│  Developer    │─────▶│  Code Review  │─────▶│  Improved     │
│  Writes Code  │      │  by Peers     │      │  Code Quality │
└───────────────┘      └───────────────┘      └───────────────┘
         │                                         │
         ▼                                         ▼
  ┌───────────────┐                         ┌───────────────┐
  │ Automated     │                         │ Testing &     │
  │ Tests Run     │                         │ Deployment    │
  └───────────────┘                         └───────────────┘

This diagram shows how developer code goes through review before automated tests and deployment, improving overall quality.

Key Facts

Code Review → A process where developers examine each other's code to find errors and improve quality.

Peer Review → Code review performed by colleagues or team members.

Bug Detection → Finding mistakes or errors in code before it runs.

Code Quality → How clear, correct, and maintainable the code is.

Complement to Testing → Code review finds issues that automated tests might miss.

Code Example

Testing Fundamentals

def add_numbers(a: int, b: int) -> int:
    # Adds two numbers and returns the result
    return a + b

# Reviewer suggests adding input validation

def add_numbers(a: int, b: int) -> int:
    if not isinstance(a, int) or not isinstance(b, int):
        raise ValueError("Inputs must be integers")
    return a + b

Common Confusions

Code review replaces automated testing.

Code review replaces automated testing. Code review <strong>does not replace</strong> automated tests; it works alongside them to catch different types of issues.

Code review is only about finding bugs.

Code review is only about finding bugs. Code review also improves readability, style, and knowledge sharing, not just bug detection.

Summary

Code review helps find mistakes and improve code before running tests or deploying.

It complements automated testing by catching issues tests might miss.

Code review also shares knowledge and improves long-term code quality.

Practice

1. What is the main purpose of code review in software testing?

easy

A. To find bugs and improve code quality before running the code

B. To write new features faster

C. To deploy code to production immediately

D. To replace automated testing completely

Solution

1. Step 1: Understand code review purpose

   Code review is done to check code manually for errors and improvements before execution.

2. Step 2: Compare options with purpose

   Only To find bugs and improve code quality before running the code matches the goal of finding bugs and improving quality before running code.

3. Final Answer:

   To find bugs and improve code quality before running the code -> Option A

4. Quick Check:

   Code review = find bugs early [OK]

Hint: Code review finds bugs before running code [OK]

Common Mistakes:

• Thinking code review replaces automated tests
• Believing code review speeds up deployment
• Confusing code review with coding new features

2. Which of the following is the correct way to give feedback during a code review?

easy

A. Provide clear, constructive comments with examples

B. Only comment if you find a syntax error

C. Ignore small mistakes to save time

D. Say 'This code is bad' without explanation

Solution

1. Step 1: Understand effective feedback

   Good feedback is clear, constructive, and helps improve code with examples.

2. Step 2: Evaluate options

   Provide clear, constructive comments with examples matches this approach; others are either rude, incomplete, or ignore issues.

3. Final Answer:

   Provide clear, constructive comments with examples -> Option A

4. Quick Check:

   Constructive feedback = clear + helpful [OK]

Hint: Be clear and helpful in feedback [OK]

Common Mistakes:

• Giving vague or rude comments
• Ignoring minor but important issues
• Only pointing out syntax errors

3. During a code review, you see this Python snippet:

def add_numbers(a, b):
    return a + b

result = add_numbers(2, '3')
print(result)

What will happen when this code runs?

medium

A. It will print 5

B. It will print 23

C. It will raise a TypeError

D. It will print null

Solution

1. Step 1: Analyze function call with mixed types

   The function adds an integer 2 and a string '3', which is invalid in Python.

2. Step 2: Understand Python behavior on adding int and str

   Python raises a TypeError when trying to add int and str directly.

3. Final Answer:

   It will raise a TypeError -> Option C

4. Quick Check:

   int + str = TypeError [OK]

Hint: Adding int and string causes TypeError in Python [OK]

Common Mistakes:

• Assuming Python converts string to int automatically
• Thinking it concatenates as strings
• Expecting numeric addition without error

4. You find this JavaScript code during review:

function multiply(x, y) {
  return x * y;
}

console.log(multiply(5));

What is the issue and how to fix it?

medium

A. multiply is missing one argument; fix by passing two arguments

B. multiply returns NaN; fix by setting default value for y

C. No issue; it prints 5

D. multiply throws error; fix by wrapping in try-catch

Solution

1. Step 1: Check function call with missing argument

   Calling multiply(5) passes only one argument; y is undefined.

2. Step 2: Understand JavaScript behavior multiplying number and undefined

   Multiplying number by undefined results in NaN (Not a Number).

3. Step 3: Fix by setting default value for y

   Use default parameter like function multiply(x, y = 1) to avoid NaN.

4. Final Answer:

   multiply returns NaN; fix by setting default value for y -> Option B

5. Quick Check:

   Missing arg causes NaN; default fixes [OK]

Hint: Missing JS args can cause NaN; use defaults [OK]

Common Mistakes:

• Assuming missing argument is zero
• Expecting error instead of NaN
• Ignoring default parameter usage

5. You review this Python code snippet:

data = [1, 2, 3, 4, 5]
result = {x: x*2 for x in data if x > 2}
result[3] = 10
print(result)

What is the final output and what does it teach about code review?

hard

A. {3: 6, 4: 8, 5: 10} - Code review helps spot logic and mutation issues

B. {1: 2, 2: 4, 3: 6, 4: 8, 5: 10} - Code review ensures all data processed

C. Error - Code review prevents runtime exceptions

D. {3: 10, 4: 8, 5: 10} - Code review helps catch unintended data changes

Solution

1. Step 1: Understand dictionary comprehension with condition

   Creates dict with keys 3,4,5 and values doubled: {3:6,4:8,5:10}.

2. Step 2: Note mutation of result[3]

   Code changes key 3's value from 6 to 10 explicitly.

3. Step 3: Final output and lesson

   Prints {3:10,4:8,5:10}. Code review helps catch such unintended mutations.

4. Final Answer:

   {3: 10, 4: 8, 5: 10} - Code review helps catch unintended data changes -> Option D

5. Quick Check:

   Mutation changes dict; review catches it [OK]

Hint: Check data changes carefully during review [OK]

Common Mistakes:

• Ignoring dictionary mutation after comprehension
• Assuming all data keys included
• Expecting error instead of changed output