Fake objects in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a JUnit test using a fake object

Consider the following JUnit test using a fake object to simulate a database. What will be the test result when running this code?

JUnit

public class UserServiceTest {
    static class FakeDatabase implements Database {
        public boolean saveUser(String user) {
            return true; // Always succeeds
        }
    }

    @org.junit.Test
    public void testSaveUser() {
        Database db = new FakeDatabase();
        UserService service = new UserService(db);
        boolean result = service.registerUser("Alice");
        org.junit.Assert.assertTrue(result);
    }
}

interface Database {
    boolean saveUser(String user);
}

class UserService {
    private final Database db;
    public UserService(Database db) {
        this.db = db;
    }
    public boolean registerUser(String user) {
        return db.saveUser(user);
    }
}

A Test fails because the fake database returns false

B Test passes because the fake database always returns true

C Test fails with NullPointerException due to uninitialized database

D Test fails with AssertionError because assertTrue is false

💡 Hint

Look at what the fake database's saveUser method returns.

The fake database's saveUser method always returns true, so the UserService's registerUser method returns true. The assertion assertTrue(result) passes, so the test passes.

❓ assertion

intermediate

Correct assertion for a fake object interaction

You have a fake object that records how many times a method was called. Which assertion correctly verifies that the method was called exactly 3 times?

JUnit

class FakeLogger {
    private int callCount = 0;
    public void log(String message) {
        callCount++;
    }
    public int getCallCount() {
        return callCount;
    }
}

@org.junit.Test
public void testLogging() {
    FakeLogger logger = new FakeLogger();
    logger.log("start");
    logger.log("process");
    logger.log("end");
    // Which assertion is correct here?
    org.junit.Assert.assertEquals(3, logger.getCallCount());
}

A assertEquals(3, logger.getCallCount());

B assertTrue(logger.getCallCount() > 3);

C assertFalse(logger.getCallCount() == 3);

D assertNull(logger.getCallCount());

💡 Hint

Check the exact number of times the log method was called.

The log method was called exactly 3 times, so the call count is 3. The assertion assertEquals(3, logger.getCallCount()) correctly verifies this.

🔧 Debug

advanced

Identify the bug in this fake object usage

This JUnit test uses a fake object to simulate a payment gateway. The test always fails with a NullPointerException. What is the cause?

JUnit

class FakePaymentGateway implements PaymentGateway {
    public boolean processPayment(double amount) {
        return true;
    }
}

@org.junit.Test
public void testPayment() {
    PaymentService service = new PaymentService(null);
    boolean success = service.pay(100.0);
    org.junit.Assert.assertTrue(success);
}

interface PaymentGateway {
    boolean processPayment(double amount);
}

class PaymentService {
    private PaymentGateway gateway;
    public PaymentService(PaymentGateway gateway) {
        this.gateway = gateway;
    }
    public boolean pay(double amount) {
        return gateway.processPayment(amount);
    }
}

A The PaymentGateway interface is missing the processPayment method

B The fake object does not implement the processPayment method

C The test assertion is incorrect and causes the failure

D The PaymentService is created with null instead of the fake object

💡 Hint

Check what object is passed to PaymentService constructor.

The PaymentService is constructed with null instead of the fake payment gateway, so calling gateway.processPayment causes a NullPointerException.

🧠 Conceptual

advanced

Purpose of fake objects in unit testing

Which statement best describes the main purpose of using fake objects in unit testing?

A To replace real dependencies with simplified implementations for controlled testing

B To automatically generate test cases without writing code

C To measure the performance of the real system under load

D To permanently store test data in a database

💡 Hint

Think about why we avoid using real dependencies in unit tests.

Fake objects provide simplified, controllable versions of real dependencies to isolate the unit under test and avoid side effects.

❓ framework

expert

Using a fake object with JUnit and Mockito

Given the following JUnit test using Mockito, what will be the output of the assertion?

JUnit

import static org.mockito.Mockito.*;
import org.junit.Test;
import static org.junit.Assert.*;

public class OrderServiceTest {
    @Test
    public void testOrderProcessing() {
        PaymentGateway fakeGateway = mock(PaymentGateway.class);
        when(fakeGateway.processPayment(anyDouble())).thenReturn(false);

        OrderService service = new OrderService(fakeGateway);
        boolean result = service.placeOrder(50.0);

        assertFalse(result);
    }
}

interface PaymentGateway {
    boolean processPayment(double amount);
}

class OrderService {
    private final PaymentGateway gateway;
    public OrderService(PaymentGateway gateway) {
        this.gateway = gateway;
    }
    public boolean placeOrder(double amount) {
        return gateway.processPayment(amount);
    }
}

A Test fails with NullPointerException due to uninitialized mock

B Test fails because the fake returns true but assertion expects false

C Test passes because the fake returns false and assertFalse matches

D Test fails with AssertionError because assertFalse is true

💡 Hint

Check what the mock is configured to return and what the assertion expects.

The mock PaymentGateway is set to return false for any payment amount. The OrderService returns this value, so assertFalse(result) passes.