Mockito for Flutter: Simplifying Unit Testing with Mocks & Stubs

Unit testing is an important part of development for maintainability, avoiding regression of code. When it comes to Flutter, Mockito is one of the best plugins that helps in mocking dependencies and writing test cases.

This blog will guide you and your team through the fundamentals of Mockito, with real-world examples to get started with mocking, verifying interactions, and stubbing responses. When you think about testing in Flutter, test cases are usually written using the basic “Arrange-Act-Assert” (AAA) pattern.

group('Calculator Tests', () {
  test('should return correct sum when adding two numbers', () {
   final calculator = Calculator();
   const num1 = 5;
   const num2 = 3;

   final result = calculator.add(num1, num2);

   expect(result, 8);
 });
});

But when it comes to complex methods, future responses, api calls etc, that’s where mockito comes into the picture.

What is Mockito?

Mockito is a testing framework that allows you to replace real implementations of dependencies with mock objects. This is useful when you want to test a class that depends on external services like databases, APIs, or local storage.

Why Use Mockito?

▪️Isolates the unit of code from dependencies
▪️Helps test edge cases without modifying the actual implementation
▪️Makes tests faster by avoiding real database/API calls
▪️Simplifies verifying method calls and expected outputs

Mocking an API Call in Flutter

Let’s mock an API call using the http package.

Service Class

class MockAuthenticationRepository {
Future<ApiResult> createAccount(SignupRequest signupRequest) async {
  ApiResult apiResult = await dioRequest(ApiRequest(
    url: ApiEndPoints.createAccount,
    method: HttpMethods.post,
    body: signupRequest.toJson()));


  return apiResult;
 }
}

Unit Test

@GenerateMocks([AuthenticationRepository])
void main() {
 late MockAuthenticationRepository authRepo;
 late SigninRequest signinRequest;
 late SignupRequest signupRequest;


setUpAll(() {
  signupRequest = SignupRequest(
    firstName: "user",
    lastName: "demo",
    email: "user@gmail.com",
    gender: null,
    password: "123456",
  );
});

Verifying Method Calls

Mockito allows you to verify if a method was called with expected arguments.

test("Register success", () async {
  final mockResponse = signupResponse.SignupResponse(
    id: 163,
    email: user@gmail.com',
    firstName: User,
    lastName: 'demo',
    gender: null,
    spiders: [],
    token: signupResponse.TokenBean(refresh: "refresh", access: "access"),
 );


 when(authRepo.createAccount(signupRequest))
     .thenAnswer((_) async => ApiResult.success(data: mockResponse));


final result = await authRepo.createAccount(signupRequest);


expect(result, isA<Success>());
final data = (result as Success).data as signupResponse.SignupResponse; });

Handling Exceptions in Tests

You can test error handling by simulating exceptions:

test("Register failure", () async {
  when(authRepo.createAccount(signupRequest))
     .thenAnswer((_) async => const ApiResult.failure(
         statusCode: 401,
         errors: ["Invalid email or password"],
       ));


  final result = await authRepo.createAccount(signupRequest);
  verifyNever(authRepo.login(any));
});

Related read: The Ultimate Guide to Mastering Unit Testing in Flutter

Explore Our Flutter Development Services for Scalable Mobile Apps

Advantages of Using Mockito

▪️Simplifies Unit Testing: It eliminates the need for setting up real dependencies, making unit tests faster and more focused.

▪️Flexible Stubbing: Developers can define expected responses for method calls, making it easy to simulate different scenarios, including edge cases and failures.

▪️Verification of Interactions: Mockito enables verification of method calls, ensuring that the correct methods are invoked with expected parameters.

▪️Improved Test Maintainability: By using mocks, tests remain stable even when external dependencies change, reducing the need for frequent test modifications.

▪️Enhances Code Quality: Writing testable code using Mockito promotes better software design, including dependency injection and separation of concerns.

Key Takeaways

▪️Use @GenerateMocks to create mocks, stub responses using when().thenReturn(), verify method calls using verify(), and handle exceptions using throwsException.

▪️Start incorporating Mockito in your Flutter projects today and improve your test coverage!

coma

Conclusion

Mockito simplifies unit testing in Flutter by letting you mock dependencies and test logic without real API or database calls. It helps write faster, more focused tests while ensuring better code quality through clear verification and stubbing. This makes your testing process efficient and reliable.

As your Flutter projects grow, Mockito keeps tests maintainable and scalable. It supports clean architecture and reduces the risk of bugs or regressions. Start using Mockito to boost test coverage and ship stable, high-quality apps with confidence.

Keep Reading

Keep Reading

  • Service
  • Career
  • Let's create something together!

  • We’re looking for the best. Are you in?