Mock dependencies in Flutter - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of mocking dependencies in Flutter testing?

Mocking dependencies allows you to replace real objects with fake ones to isolate the code under test. This helps test components without relying on external services or complex setups.

beginner

Which Flutter package is commonly used for creating mock classes?

The mockito package is commonly used in Flutter to create mock classes for testing purposes.

intermediate

How do you create a mock class using Mockito in Flutter?

You create a mock class by extending <code>Mock</code> and implementing the class you want to mock. For example: <pre>class MockService extends Mock implements Service {}</pre>

beginner

Why should you mock dependencies instead of using real ones in unit tests?

Mocking dependencies makes tests faster, more reliable, and focused on the unit being tested. It avoids side effects like network calls or database access.

intermediate

What is a common method to verify that a mocked method was called in Flutter tests?

You use verify() from Mockito to check if a mocked method was called with expected arguments.

Which package helps you create mock objects in Flutter?

A mockito

B http

C provider

D flutter_test

The mockito package is designed for creating mock objects in Flutter tests.

What is the main benefit of mocking dependencies in tests?

A To make tests slower

B To add UI animations

C To isolate the unit being tested

D To increase network calls

Mocking dependencies isolates the unit under test by replacing real dependencies with fake ones.

How do you verify a mocked method was called in Flutter tests?

A using <code>verify()</code>

B using <code>expect()</code>

C using <code>mock()</code>

D using <code>run()</code>

The verify() function from Mockito checks if a mocked method was called.

Which of these is NOT a reason to mock dependencies?

A Isolate code under test

B Avoid side effects

C Speed up tests

D Test UI animations

Mocking dependencies is not used to test UI animations.

What does this code do?

class MockApi extends Mock implements Api {}

A Creates a real Api instance

B Creates a mock class for Api

C Runs the Api service

D Imports the Api package

This code defines a mock class for Api using Mockito.

Explain why mocking dependencies is important in Flutter unit testing.

Think about how tests behave when they depend on real network or database.

Describe the steps to create and use a mock class with Mockito in Flutter.

Focus on how to define the mock and check its usage.

Practice

1. What is the main purpose of using mocks in Flutter testing?

easy

A. To write less code in the app

B. To speed up the app in production

C. To create UI components faster

D. To replace real services and control their behavior during tests

Solution

1. Step 1: Understand what mocks do

   Mocks replace real services or dependencies in tests to simulate their behavior.

2. Step 2: Identify the purpose in testing

   This helps tests run faster and more reliably by controlling external factors.

3. Final Answer:

   To replace real services and control their behavior during tests -> Option D

4. Quick Check:

   Mocks replace services = A [OK]

Hint: Mocks simulate services in tests to control behavior [OK]

Common Mistakes:

• Thinking mocks speed up production app
• Confusing mocks with UI widgets
• Believing mocks reduce app code size

2. Which of the following is the correct way to create a mock class using the mocktail package in Flutter?

easy

A. class MockService extends Service implements Mock {}

B. class MockService extends Mock implements Service {}

C. class MockService with Mock implements Service {}

D. class MockService implements Mock, Service {}

Solution

1. Step 1: Recall mocktail syntax

   In mocktail, a mock class extends Mock and implements the interface to mock.

2. Step 2: Match syntax to options

   class MockService extends Mock implements Service {} correctly extends Mock and implements Service.

3. Final Answer:

   class MockService extends Mock implements Service {} -> Option B

4. Quick Check:

   Extend Mock, implement interface = A [OK]

Hint: Mock classes extend Mock and implement the target interface [OK]

Common Mistakes:

• Swapping extends and implements order
• Using with instead of extends
• Not implementing the interface

3. Given the following code snippet using mocktail, what will be the output of print(service.getData())?

class MockService extends Mock implements Service {}

final service = MockService();
when(() => service.getData()).thenReturn('Mocked Data');
print(service.getData());

medium

A. Returns 'Mocked Data'

B. Throws an error because getData is not defined

C. Returns null

D. Returns the real data from Service

Solution

1. Step 1: Understand when-thenReturn usage

   The when() function sets up the mock to return 'Mocked Data' when getData() is called.

2. Step 2: Check the print statement

   Calling service.getData() returns the mocked value 'Mocked Data'.

3. Final Answer:

   Returns 'Mocked Data' -> Option A

4. Quick Check:

   when().thenReturn() sets output = B [OK]

Hint: when().thenReturn() sets mock return value [OK]

Common Mistakes:

• Expecting real method call instead of mock
• Thinking it returns null by default
• Confusing syntax causing runtime error

4. Identify the error in this mocktail test setup:

class MockService extends Mock implements Service {}

final service = MockService();
when(service.getData()).thenReturn('Data');

medium

A. Missing parentheses in when() argument

B. MockService should not implement Service

C. Incorrect use of when() without a lambda function

D. thenReturn() cannot return a string

Solution

1. Step 1: Check when() syntax

   when() requires a lambda function like () => service.getData(), not a direct call.

2. Step 2: Identify the error

   Passing service.getData() calls the method immediately, causing error.

3. Final Answer:

   Incorrect use of when() without a lambda function -> Option C

4. Quick Check:

   when() needs lambda = C [OK]

Hint: Use () => method() inside when() [OK]

Common Mistakes:

• Calling method directly inside when()
• Forgetting to implement interface
• Misusing thenReturn() with wrong types

5. You want to test a Flutter widget that depends on a service fetching user data. How do mocks help in this scenario?

hard

A. Mocks allow you to simulate user data responses without real network calls

B. Mocks automatically generate UI for the widget

C. Mocks replace the widget with a simpler version

D. Mocks speed up the app by caching data

Solution

1. Step 1: Understand widget dependency on service

   The widget depends on a service that fetches user data, usually from network.

2. Step 2: Role of mocks in testing

   Mocks simulate the service to provide controlled user data without real network calls.

3. Step 3: Benefits in testing

   This makes tests faster, reliable, and independent of external systems.

4. Final Answer:

   Mocks allow you to simulate user data responses without real network calls -> Option A

5. Quick Check:

   Mocks simulate data, no real calls = D [OK]

Hint: Mocks simulate service data to avoid real network calls [OK]

Common Mistakes:

• Thinking mocks generate UI automatically
• Confusing mocks with widget replacements
• Believing mocks cache data for performance