Mocking Dependencies in Flutter Test with Mockito

Testing is a crucial part of developing robust Flutter applications, but what happens when your code depends on external services, APIs, or complex objects? This is where mocking comes into play, and Mockito is your best friend for handling these scenarios elegantly.

Understanding the Importance of Mocking

In real-world Flutter applications, we often work with dependencies like HTTP clients, databases, or platform-specific services. Testing these dependencies directly can be challenging because:

• They might be unreliable or slow
• They could cost money to use
• They might not be available in a test environment

Getting Started with Mockito

First, add the required dependencies to your pubspec.yaml:

dev_dependencies:
  mockito: ^5.4.0
  build_runner: ^2.4.0

Let’s say we have a simple weather service that fetches the current temperature:

class WeatherService {
  final HttpClient client;

  WeatherService(this.client);

  Future<double> getTemperature(String city) async {
    final response = await client.get('api.weather.com/temperature/$city');
    return response.data['temperature'];
  }
}

To test this service, we’ll create a mock of the HttpClient:

@GenerateMocks([HttpClient])
void main() {
  late MockHttpClient mockClient;
  late WeatherService weatherService;

  setUp(() {
    mockClient = MockHttpClient();
    weatherService = WeatherService(mockClient);
  });

  test('should return correct temperature', () async {
    // Arrange
    when(mockClient.get(any))
        .thenAnswer((_) async => Response(data: {'temperature': 25.0}));

    // Act
    final temperature = await weatherService.getTemperature('London');

    // Assert
    expect(temperature, 25.0);
    verify(mockClient.get('api.weather.com/temperature/London')).called(1);
  });
}

Best Practices for Mocking in Flutter

1. Mock at the Right Level: Mock at interface boundaries rather than mocking every small class. This makes your tests more maintainable and less brittle.

2. Verify Behavior: Don’t just test the output – verify that your mocks were called with the expected parameters using verify().

3. Use Meaningful Responses: When setting up mock responses, use realistic data that represents actual scenarios your app might encounter.

4. Keep it Simple: Don’t over-mock. If a dependency is simple and reliable (like basic calculations), use the real implementation.

Here’s how to handle more complex scenarios:

test('should handle errors gracefully', () async {
  // Arrange
  when(mockClient.get(any))
      .thenThrow(Exception('Network error'));

  // Act & Assert
  expect(
    () => weatherService.getTemperature('London'),
    throwsException,
  );
});

Conclusion

Mocking with Mockito is an essential skill for writing effective Flutter tests. It allows you to isolate the code you’re testing, make your tests more reliable, and ensure your app works correctly under various conditions.

Remember, the goal of mocking isn’t to test the mocks themselves, but to verify that your code interacts with its dependencies correctly.