Question 1

What is Unit Testing, and why is it important?

Accepted Answer

Unit Testing is a software testing method where the smallest testable parts of an application, called units (typically functions, methods, or classes), are individually and isolatedly scrutinized for proper operation. It is important because it catches bugs early, simplifies debugging, facilitates refactoring, and acts as living documentation.

Question 2

Explain the F.I.R.S.T. principles of Unit Testing.

Accepted Answer

The F.I.R.S.T principles are:
1. Fast: Tests should run quickly so developers can run them frequently.
2. Independent: Tests must not depend on each other's execution order or state.
3. Repeatable: Tests must yield the same result in any environment (local, CI).
4. Self-Validating: Tests should have binary outcomes (pass or fail) with no manual interpretation.
5. Timely: Tests should ideally be written before or alongside the code (TDD).

Question 3

What is the AAA (Arrange-Act-Assert) pattern?

Accepted Answer

AAA is a structural pattern for writing readable unit tests:
1. Arrange: Set up the test requirements, initialize variables, and mock objects.
2. Act: Execute the unit function/method under test.
3. Assert: Verify that the output or state matches expectations.
Code Example:
// AAA example in Jest
test('adds 1 + 2 to equal 3', () => {
  // Arrange
  const a = 1;
  const b = 2;

// Act
  const result = sum(a, b);

// Assert
  expect(result).toBe(3);
});

Question 4

Explain the differences between Dummy, Mock, Stub, Spy, and Fake (Test Doubles).

Accepted Answer

- **Dummy**: Objects passed around but never actually used, typically just to fill parameter lists.
- **Stub**: Provides canned/pre-programmed answers to method calls made during the test.
- **Spy**: A stub that also records details of how it was called (arguments, call counts).
- **Mock**: Objects pre-programmed with expectations about calls they should receive. If expectations aren't met, the test fails.
- **Fake**: Has a working implementation but uses a shortcut (like an in-memory database) which makes it unsuitable for production.

Question 5

What is Test-Driven Development (TDD), and what is the Red-Green-Refactor cycle?

Accepted Answer

TDD is a software development methodology where you write tests *before* writing application code. The Red-Green-Refactor cycle is:
1. Red: Write a unit test for a feature before it exists; run it and watch it fail.
2. Green: Write the minimum amount of code required to make the test pass.
3. Refactor: Clean up and optimize the code while ensuring all tests continue to pass.

Question 6

What is Code Coverage, and what are its different metrics?

Accepted Answer

Code Coverage is a measurement of the percentage of source code executed during testing. Key metrics include:
1. Line/Statement Coverage: Has every single line of code been run?
2. Branch/Decision Coverage: Have all branches of control structures (like both the true and false conditions of an `if` block) been evaluated?
3. Function Coverage: Has every declared function been called?
4. Path Coverage: Have all possible execution paths through the code been tested?

Question 7

Does 100% Code Coverage mean code is bug-free?

Accepted Answer

No. 100% code coverage simply means every line of code was executed at least once during tests. It does not guarantee logic correctness, does not check edge cases (like null/undefined inputs), and does not verify that the code satisfies the user requirements.

Question 8

What is the Testing Pyramid?

Accepted Answer

The Testing Pyramid is a conceptual model grouping tests by scope and cost. It suggests writing a large volume of fast, cheap **Unit Tests** at the base, a moderate number of **Integration/Service Tests** in the middle, and a very small number of slow, expensive **End-to-End (E2E) Tests** at the top.

Question 9

What is the difference between a Unit Test and an Integration Test?

Accepted Answer

A Unit Test isolates a single class or function, mocking all external dependencies (databases, networks, APIs). An Integration Test verifies that multiple modules or systems work together correctly (e.g. testing database read/write queries or API endpoint integrations).

Question 10

What is Mutation Testing?

Accepted Answer

Mutation Testing is a method to evaluate the quality/strength of your unit tests. A mutation tool automatically introduces minor modifications (mutations) into your source code (e.g. changing `>` to `<`). If your unit tests fail when running on mutated code, the mutant is 'killed' (tests are strong). If tests still pass, the mutant 'survives' (signaling weak test coverage).

Question 11

What is Mocking, and why should we avoid over-mocking?

Accepted Answer

Mocking replaces real dependencies with simulated objects to isolate the unit under test. Over-mocking occurs when you mock too many internal implementation details of a class. This makes tests brittle; refactoring internal code structure breaks tests even if the public output remains correct.

Question 12

Explain Behavior-Driven Development (BDD).

Accepted Answer

BDD is an extension of TDD that focuses on writing tests from the user's perspective, using natural language. It utilizes the **Given-When-Then** format (Given some context, When an action is taken, Then an outcome should occur) to align developers, testers, and business managers.

Question 13

What is regression testing?

Accepted Answer

Regression testing is running your suite of existing tests after code changes, updates, or refactoring to ensure that existing features have not been broken (regressed) by the modifications.

Question 14

What is a test runner vs a test assertion library?

Accepted Answer

A Test Runner is a tool that locates tests, executes them, and displays results in the console (e.g. Karma, Jest runner). An Assertion Library provides functions to verify that outputs match expectations (e.g. Chai, Assert).

Question 15

Explain Parameterized Tests.

Accepted Answer

Parameterized (data-driven) tests allow running the same test multiple times using different input datasets, avoiding duplicate code loops.
Code Example:
// Parameterized test concept
test.each([
  [1, 1, 2],
  [2, 3, 5],
  [0, 5, 5]
])('adds %i + %i to equal %i', (a, b, expected) => {
  expect(sum(a, b)).toBe(expected);
});

Question 16

What is Hermetic testing?

Accepted Answer

Hermetic testing is a design pattern where tests are run in a completely isolated environment, containing all the resources they need to run (e.g., spinning up isolated Docker containers for dependencies). Hermetic tests eliminate flaky test runs caused by external network lags.

Question 17

How do you test private methods in a class?

Accepted Answer

As a best practice, you should **never** test private methods directly. Private methods are implementation details. You should test them indirectly by asserting the outputs of the public methods that call them. If a private method is so complex that it needs direct tests, it should be extracted into a separate public class.

Question 18

What is a flaky test, and how do you resolve it?

Accepted Answer

A flaky test is a test that passes or fails unpredictably without any changes to the source code. Common causes include: race conditions in asynchronous actions, relying on shared database states, or external network dependencies. Resolve them by ensuring test isolation, proper async waiting hooks, and stubbing network requests.

Question 19

Explain code-first vs test-first development.

Accepted Answer

Code-first development is when you write the implementation code first, and then write tests afterwards. Test-first (TDD) is when you write tests first to define the specifications, and write code afterwards to pass those tests.

Question 20

How do you handle testing systems that depend on current system time?

Accepted Answer

Testing time-dependent logic (like checkouts or coupon expirations) can be resolved by **mocking the system clock** (using libraries like Sinon.js or Jest's `jest.useFakeTimers()`). This locks the date object to a specific timestamp during test runs.
Code Example:
// Lock time in Jest
jest.useFakeTimers().setSystemTime(new Date('2026-01-01'));

Unit Testing Interview Master

Difficulty Filters

Tools & Options

What is Unit Testing, and why is it important?

Explain the F.I.R.S.T. principles of Unit Testing.

What is the AAA (Arrange-Act-Assert) pattern?

Explain the differences between Dummy, Mock, Stub, Spy, and Fake (Test Doubles).

What is Test-Driven Development (TDD), and what is the Red-Green-Refactor cycle?

What is Code Coverage, and what are its different metrics?

Does 100% Code Coverage mean code is bug-free?

What is the Testing Pyramid?

What is the difference between a Unit Test and an Integration Test?

What is Mutation Testing?

What is Mocking, and why should we avoid over-mocking?

Explain Behavior-Driven Development (BDD).

What is regression testing?

What is a test runner vs a test assertion library?

Explain Parameterized Tests.

What is Hermetic testing?

How do you test private methods in a class?

What is a flaky test, and how do you resolve it?

Explain code-first vs test-first development.

How do you handle testing systems that depend on current system time?

Explore Related Tools

AI Blog Title Generator

ASCII to Text Converter

Aspect Ratio Calculator

Aws Interview Questions

Base64 to HEX Converter

Binary to Hex Converter

Follow Us

Our Tools

Our Company

Special Tools