Overview

Mocking external dependencies in JUnit tests is crucial for isolating the system under test, ensuring that tests run quickly, and that they are deterministic. External dependencies could include things like web services, databases, or any other external system. By mocking these dependencies, you can simulate their behavior without needing to interact with them directly, which makes your tests more reliable and easier to execute.

Key Concepts

1. Mocking Frameworks: Tools like Mockito or EasyMock that allow for creating mock objects in your tests.
2. Dependency Injection: A technique that facilitates injecting mock objects into the class under test.
3. Behavior Verification: Ensuring that the system under test interacts with its dependencies in the expected manner.

Common Interview Questions

Basic Level

1. What is the purpose of mocking in unit testing?
2. How do you create a simple mock object using Mockito?

Intermediate Level

3. How can you verify that a method on a mock object was called exactly once?

Advanced Level

4. Describe how to mock a static method using Mockito.

Detailed Answers

1. What is the purpose of mocking in unit testing?

Answer: Mocking in unit testing is used to simulate the behavior of real objects in a controlled way. By using mock objects, you can isolate the system under test, eliminate external dependencies, and focus on the behavior of the system itself. This approach helps in writing tests that are fast, reliable, and repeatable.

Key Points:
- Isolates the system under test.
- Eliminates external dependencies.
- Ensures tests run quickly and are deterministic.

Example:

// C# example using NUnit and Moq (as JUnit and Mockito are Java-based, but the concept applies across languages)

public interface IExternalDependency
{
    int CalculateValue();
}

[TestFixture]
public class MyTestClass
{
    [Test]
    public void TestMethod_WithMock()
    {
        // Arrange
        var mockDependency = new Mock<IExternalDependency>();
        mockDependency.Setup(x => x.CalculateValue()).Returns(42);

        var myObject = new MyClassUnderTest(mockDependency.Object);

        // Act
        int result = myObject.PerformCalculation();

        // Assert
        Assert.AreEqual(42, result);
    }
}

2. How do you create a simple mock object using Mockito?

Answer: To create a simple mock object using Mockito, you can use the mock() method provided by the Mockito framework. This method allows you to create a mock object of any class or interface, which can then be configured to behave in a specific way when its methods are called.

Key Points:
- Use mock() method from Mockito.
- Configure behavior using when() and thenReturn() methods.
- Inject the mock into the system under test.

Example:

// Example not applicable in C# for Mockito. Providing a conceptual example instead.

// Assume a Java interface
public interface ExternalService {
    int retrieveData();
}

// JUnit test class
public class MyServiceTest {

    @Test
    public void testService() {
        // Creating a mock of ExternalService
        ExternalService mockService = Mockito.mock(ExternalService.class);

        // Configuring the mock to return specific value
        Mockito.when(mockService.retrieveData()).thenReturn(100);

        // System under Test (SUT)
        MyService myService = new MyService(mockService);

        // Asserting the behavior
        assertEquals(100, myService.fetchData());
    }
}

3. How can you verify that a method on a mock object was called exactly once?

Answer: To verify that a method on a mock object was called exactly once, you can use the verify() method in Mockito. This method allows you to check how many times a mocked method has been called, with an ability to specify that it should have been called exactly once.

Key Points:
- Use verify() method from Mockito.
- Specify the method call you want to verify.
- Assert that it was called exactly once.

Example:

// Example not applicable in C# for Mockito. Providing a conceptual example instead.

// Assume a Java interface
public interface ExternalService {
    void performAction();
}

// JUnit test class
public class MyServiceTest {

    @Test
    public void testAction() {
        ExternalService mockService = Mockito.mock(ExternalService.class);

        MyService myService = new MyService(mockService);
        myService.executeAction();

        // Verify that performAction was called exactly once
        Mockito.verify(mockService, Mockito.times(1)).performAction();
    }
}

4. Describe how to mock a static method using Mockito.

Answer: Starting from Mockito 3.4.0, you can mock static methods by using the mockStatic method. This feature is part of the Mockito inline mocking. To use it, you'll need to open a static mock scope, within which you can mock static methods. After the scope is closed, the original behavior of the static methods is restored.

Key Points:
- Use mockStatic from Mockito inline mocking.
- Open and close the static mock scope.
- Within the scope, configure behavior for static methods.

Example:

// Example not applicable in C# for Mockito. Providing a conceptual example instead.

// Assume a Java class with a static method
public class UtilityClass {
    public static int staticMethod() {
        return 0;
    }
}

// JUnit test class
public class MyServiceTest {

    @Test
    public void testStaticMethod() {
        try (MockedStatic<UtilityClass> mockedStatic = Mockito.mockStatic(UtilityClass.class)) {
            mockedStatic.when(UtilityClass::staticMethod).thenReturn(100);

            // Your test code here, which calls UtilityClass.staticMethod()

            // Verify that the static method was called
            mockedStatic.verify(() -> UtilityClass.staticMethod());

            // Assert based on your test scenario
        }
    }
}

Note: The above examples are conceptual and demonstrate how the concepts would be applied in Java using Mockito and JUnit. C# equivalents would involve using frameworks like Moq and NUnit or xUnit.