Mockatoo is a Haxe library for mocks creation, verification and stubbing.
Uses Haxe macros to generated mock implementations of classes and interfaces for testing.
Mockatoo is inspired by Mockito's public API http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html
Disambiguation: The Mockatoo belongs to the bird family Cacatuidae and look suspiciously like a taxidermied Cockatoo with fake plumage. They are mostly found nesting within testing habitats and like to repeat what you say (like a parrot). A Mockatoo may turn violent if mistaken for a MockingBird :)
Mockatoo supports Haxe 3.1.x across most platforms (AVM2, JavaScript, Neko, C++, etc)
Install current official release from haxelib (3.x)
haxelib install mockatoo
Install the latest directly from github:
haxelib git mockatoo https://github.com/misprintt/mockatoo.git src
Or point to your local fork:
haxelib dev mockatoo /ABSOLUTE_PATH_TO_REPO/src
For Legacy Haxe 2.10 refer to the haxe2 branch
Please refer to the Developer Guide for detailed documentation
The following examples assume you have imported the static methods of Mockatoo and are using the `using mixin.
import mockatoo.Mockatoo.*;
using mockatoo.Mockatoo;
Mock any class or interface, including typedef aliases and types with generics (type paramaters)
var mockedClass = mock(SomeClass);
var mockedInterface = mock(SomeInterface);
var mockedClassWithTypeParams = mock(Foo,[Bar]); //e.g. Foo<Bar>
Verify a method has been called with specific paramaters
mock.someMethod().verify();
mock.someMethod("foo", "bar").verify();
Define a stub response when a method is invoked
mock.foo("bar").returns("hello");
mock.someMethod("foo", "bar").throws(new Exception("error"));
Custom argument matchers and wildcards
mock.foo(cast anyString).returns("hello");
mock.foo(cast anyString).verify();
mock.foo().returns("hello"); // automatically injects `any` matcher for missing arguments
Verify exact number of invocations
mock.foo().verify(2);
mock.foo().verify(times(2));
mock.foo().verify(atLeast(2));
mock.foo().verify(atLeastOnce);
mock.foo().verify(never);
Verify there are no redundant invocations. This is the equivalent of running
verify(never) on all methods in a mock.
mock.verifyZeroInteractions();
Spying on real objects
var spy = spy(SomeClass);//creates instance where all methods are real (not stubbed)
spy.foo(); // calls real method;
spy.foo().stub();
spy.foo(); //calls default stub;
spy.foo().returns("hello");
spy.foo(); //calls custom stub;
Partial Mocking
var mock = mock(SomeClass);
mock.foo().callsRealMethod();
mock.foo();//calls out to real method
Mock properties that are read or write only
mock.someProperty.returns("hello");
mock.someSetter.throws("exception");
mock.someGetter.throws("exception");
mock.someGetter.calls(function(){return "foo"});
Generate mocks via metadata by implementing Mockatoo.MockTest (requires munit)
class SomeTest implements mockatoo.MockTest
{
@:mock var mock:SomeClass;
@:spy var spy:SomeSpy;
@Test
public function someTestCase()
{
mock.something().returns("hello");
...
}
}
Mockatoo generates a sub class of the target class (or an instance of an interface) that implements the mockatoo.Mock.
Each method (including getter/setter) is overriden to prevent the underlying functionality from being executed (by default). Methods requireing a return type will always return the default ‘null’ value associated with that type (e.g. an Int will return 0 on static targets like flash or cpp, and null on dynamic targets like js or neko).
Click here for detailed documentation and examples
- added support for generating mocks using @:mock and @:spy metadata.
- issue #21 automatic injection of
Matcher.anyfor missing arguments on stubs - issue #26 add mock.verifyZeroInteractions();
Added the ability to verify that no other methods have been called. This is the equivalent of running verify(never) on all methods in a mock.
mock.verifyZeroInteractions();
This changes the underlying mechanics of verification - each time a
verifyis made the matching invocation is now removed for future verifications.
- added support for Haxe 3.1
- removed dependency on tink_macros
- removed support for haxe 2.x
- Haxe 3 support
- Changes to use static imports (see below)
- Changes to referencing Matchers (see below)
Due to a limitations in Haxe 3.0 with using + macro on class references, developers should use static importing avoid explicit references to Mockatoo.mock and Mockatoo.spy.
In Haxe 3 the recommended approach is:
import mockatoo.Mockatoo.*;
using mockatoo.Mockatoo;
...
var mock = mock(SomeClass);
var spy = spy(SomeClass);
Allows flexible verification or stubbing of arguments based on type.
Note: When using 'using', you will need to cast the matcher to avoid a false compilation error
mock.someMethod(cast any).verify();
mock.someMethod(cast anyString).returns("foo");
- Haxe 3 RC1 support
Fixed issues preventing mocking of interface properties (getter/setters)
Mockatoo 1.3.0 provides a simplified, smarter, macro enhanced API when using Haxe's 'using' mixin (and is still fully backwards compatible with existing API).
using mockatoo.Mockatoo;
...
var mock = mock(SomeClass);
var mock = mock(SomeInterface);
var spy = spy(SomeClass); // partial mock that calls real methods unless stubbed
New macros have been added for simplified stubbing with 'using':
mock.someMethod().returns("foo");
mock.someMethod("foo").throws("some error");
mock.someMethod("bar").calls(function(args){return "bar";});
mock.someMethod().callsRealMethod();
mock.someMethod().stub(); // resets to default stub value (i.e. null)
You can allso stub properties and getter setters (since 1.2.0)
mock.someProperty.returns("some value");
Verifications now also support raw integer counts
mock.someMethod().verify(1); //converted to verify(times(1))
Verfifying and stubbing mock fields are now validated at compile time to prevent runtime exceptions caused by out of date field references.
mock.someMethodThatDoesNotExist().verify(); //causes compilation error
The syntax for wildcard Matchers has been updated to be compiler-safe when using 'using'
mock.someMethod(Mockatoo.anyString()).returns("foo");
Mockatoo is heavily inspired by Mockito's public API http://docs.mockito.googlecode.com/hg/latest/org/mockito/Mockito.html