OpenParable
Skip to content
← Back to skills

Mockito

Testing & Quality
mockito

Mockito is an Agent Skill for testing & quality published in the evanca/flutter-ai-rules repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Use when generating mocks, stubbing methods, verifying interactions, capturing arguments, or choosing between mocks, fakes, and real objects (Mockito).

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/evanca/flutter-ai-rules/blob/HEAD/skills/mockito/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/mockito, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Mockito Skill

This skill defines how to correctly use the mockito package for mocking in Dart and Flutter tests.


1. Mock vs. Fake vs. Real Object

UseWhen
Real objectPrefer over mocks when practical.
Fake (extends Fake)Lightweight custom implementation; override only the methods you need. Prefer over mocks when you don't need interaction verification.
Mock (extends Mock)Only when you need to verify interactions (call counts, arguments) or stub dynamic responses.
  • Data models should not be mocked if they can be constructed with stubbed data.
  • Only use mocks if your test has verify assertions; otherwise prefer real or fake objects.

2. Generating Mocks

@GenerateMocks([MyClass])
// or for nice mocks (return simple legal values for missing stubs):
@GenerateNiceMocks([MockSpec<MyClass>()])
void main() { ... }
dart run build_runner build
  • Only annotate files under test/ for mock generation by default.
  • Use a build.yaml if you need to generate mocks outside of test/.
  • Never add @override methods or implementations to a class extending Mock.
  • Never stub responses in a mock's constructor or inside the mock class — always stub in your tests.

3. Stubbing

final mock = MockCat();

// Return a value
when(mock.sound()).thenReturn('Meow');

// Throw an error
when(mock.sound()).thenThrow(Exception('No sound'));

// Calculate response at call time
when(mock.sound()).thenAnswer((_) => computedValue);

// Return values in sequence
when(mock.sound()).thenReturnInOrder(['Meow', 'Purr']);
  • Always stub methods/getters before using them if you need specific return values.
  • Missing stub behavior: @GenerateMocks → throws; @GenerateNiceMocks → returns a simple legal value.
  • Use throwOnMissingStub(mock) to throw on any unstubbed call.

4. Verification

verify(mock.sound());                  // called at least once
verifyNever(mock.eat(any));            // never called
verify(mock.sound()).called(2);        // called exactly twice

Async:

await untilCalled(mock.sound());       // wait for the interaction

5. Argument Matchers

// Flexible stubbing
when(mock.eat(any)).thenReturn(true);
when(mock.eat(argThat(isNotNull))).thenReturn(true);

// Named arguments
when(mock.fetch(any, headers: any)).thenReturn(response);
  • Do not use null as an argument adjacent to an argument matcher.
  • For named arguments, use any or argThat as values, not as argument names.

6. Capturing Arguments

final captured = verify(mock.eat(captureAny)).captured;
print(captured.last); // last captured argument

Use captureThat for conditional capturing.


7. Resetting Mocks

reset(mock);                  // clear all stubs AND interactions
clearInteractions(mock);      // clear only recorded interactions

8. Mocking Function Types

To mock a function type (e.g., a callback), define an abstract class with the required signature and generate mocks for it:

abstract class Callback {
  void call(String value);
}

@GenerateMocks([Callback])

9. Debugging

logInvocations([mock1, mock2]); // print all collected invocations

References