Faking it with Mockolate

Transcript

1. FAKING IT WITH MOCKOLATE @drewbourne
2. LAZINESS IMPATIENCE HUBRIS
3. The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labour saving programs that other people find useful, and document what you wrote so that you don’t have to answer so many questions about it. LAZINESS
4. The anger you feel when the computer is being lazy. This makes you write programs that don’t react to your needs, but actually anticipates them. Or at least pretends to. IMPATIENCE
5. Excessive pride, the sort of thing Zeus zaps you for. Also the quality that makes you write (and maintain) programs that other people won’t want to say bad things about. HUBRIS
7. I use tools.
8. Flash Builder IntelliJ IDEA TextMate
9. Code Libraries are tools too.
10. Flex RobotLegs Mate Swiz Away3D Flixel Starling Signals
12. what are we using the tools for?
13. Great Software Happy Customers Make Profit
14. what is our software doing?
15. ?
16. TESTS FUDGE YEAH!
18. what should the tests be doing?
19. FUNCTIONAL INTEGRATION UNIT
20. Test Driven Test After Test OMGBBQRIBS!!!!!!
22. [Test] public function test_should_be_short():void { assertThat(test.lines, lessThan(20)); } [Test] public function test_should_choose_the_right_assertions():void { assertThat(test.assertions, use("hamcrest")); } [Test] public function test_should_use_the_same_level_of_abstraction ():void { assertThat(test.subject, didNotExposePrivates()); assertThat(test.collaborators, didNotViolateDemeter()); } [Test] public function test_should_not_repeat_previous_assertions():void { assertThat(test.assertionCount, between(1,3)); assertThat(test.assertions, everyItem(hasProperties({ description: not(emptyString()) })))); }
23. [Test] public function test_colloborators_should_not_be_modified_for_testing():void { var component:UIComponentForTesting = new UIComponentForTesting (); var container:Container = new Container(); container.addChild(component); assertThat(component.invalidatePropertiesWasCalled, isTrue()); } internal class UIComponentForTesting extends UIComponent { public var invalidatePropertiesWasCalled:Boolean; override public function invalidateProperties():void { invalidatePropertiesWasCalled = true; super.invalidateProperties(); } }
24. NEED MOAR TOOLS NOW!
25. I build tools.
26. Hamcrest
27. Mockolate
30. DUMMY FAKE STUB SPY MOCK
31. DUMMY FAKE STUB SPY MOCK
32. [Test] public function dummy_value_example():void { const UNUSED:String = “unused”; const service:ExampleService = new ExampleService(UNUSED); assertThat(service.isAvailable, isTrue()); }
33. DUMMY FAKE STUB SPY MOCK
34. [Test] public function fake_example():void { var entityManager:IEntityManager = new FakeEntityManager(); var entity:IEntity = new Entity(); var cmd:SaveEntityCommand = new SaveEntityCommand(); cmd.entityManager = entityManager; cmd.entity = entity; cmd.execute(); } class FakeEntityManager implements IEntityManager { public function save(entity:IEntity):Boolean { if (entity.isModified) { entity.updated(); return true; } return false; } }
35. DUMMY FAKE STUB SPY MOCK
36. [Test] public function with_modified_entity_should_enable_saving():void { presenter.setEntity(new ModifiedEntityStub()); assertThat(presenter.saveEnabled, isTrue()); } [Test] public function with_unmodified_entity_should_disable_saving():void { presenter.setEntity(new UnmodifiedEntityStub()); assertThat(presenter.saveEnabled, isFalse()); } internal class ModifiedEntityStub extends Entity { override public function isModified():Boolean { return true; } } internal class UnmodifiedEntityStub extends Entity { override public function isModified():Boolean { return false; } }
37. DUMMY FAKE STUB SPY MOCK
38. [Test] public function when_disabled_should_not_dispatch_events():void { target.dispatcher = new SpyingEventDispatcher(); target.disable(); target.methodThatTriggersEvents(); assertThat(target.dispatcher.numEventsDispatched, equalTo(0)); } internal class SpyingEventDispatcher extends EventDispatcher { private var _numEventsDispatched:int = 0; public function get numEventsDispatched():int { return _numEventsDispatched } override public function dispatchEvent(event:Event):Boolean { _numEventsDispatched++; super.dispatchEvent(event); } }
39. DUMMY FAKE STUB SPY MOCK
40. [Before] public function setup():void { user = new User(); user.username = "TEST_USERNAME"; user.password = "TEST_PASSWORD"; service = nice(SignInService); token = nice(AsyncToken); command = new SignInCommand(); command.service = service; command.event = new SignInEvent(user); } [Test] public function execute_should_sign_in_to_service():void { expect( service.signin(user) ).returns( token ); command.execute(); verify( service ); }
41. Why Mock Objects?
42. Terminology Proxy Invocation Expectation
43. package mockolate.examples { public class Example { public function method(...args):Result { return new Result(); } } } package mockolate.examples.generated { public class ExampleProxy extends Example { private var _interceptor:Interceptor public function ExampleProxy(interceptor:Interceptor) { _interceptor = interceptor; } override public function method(...args):Result { return _interceptor.intercept( new Invocation(this, "method", args, super.method)); } } }
44. How Mock Objects Work Reflect Class Generate Proxy Forward Invocations Execute Specified Behaviour Verify Expected Behaviour
45. USING MOCKOLATE
46. Preparing Proxy Classes
47. prepare(...classes):IEventDispatcher
48. [Before(order=”1”, async, timeout=”10000”)] public function prepare_mocks():void { Async.proceedOnEvent(this, prepare(...classes), Event.COMPLETE, 10000); }
49. [Before(order=”1”, async, timeout=”10000”)] public function prepare_mocks():void { Async.proceedOnEvent(this, prepare( Bacon, Sandwich ), Event.COMPLETE, 10000); }
51. Don’t bother, Use the rule.
52. package mockolate.examples { public class ExampleTest { [Rule] public var mocks:MockolateRule = new MockolateRule(); } }
53. package mockolate.examples { public class ExampleTest { [Rule] public var mocks:MockolateRule = new MockolateRule(); [Mock] public var thing:IThing; } }
54. package mockolate.kitchen { public class KettleTest { [Rule] public var mocks:MockolateRule = new MockolateRule(); public var kettle:Kettle; [Mock] public var heatingElement:HeatingElement; [Mock] public var thermostat:Thermostat; [Before] public function prepareKettle():void { kettle = new Kettle(heatingElement, thermostat); } } }
55. package mockolate.kitchen { public class KettleTest { [Rule] public var mocks:MockolateRule; } }
56. Creating Instances nice, strict, partial
57. Kettle Heating Element Thermostat
58. package mockolate.kitchen { public class KettleTest { [Rule] public var mocks:MockolateRule; [Mock] public var heatingElement:HeatingElement; [Mock] public var thermostat:Thermostat; [Mock] public var dispatcher:EventDispatcher; } }
59. package mockolate.kitchen { public class KettleTest { [Rule] public var mocks:MockolateRule; [Mock(type=”nice”)] public var heatingElement:HeatingElement; [Mock(type=”strict”)] public var thermostat:Thermostat; [Mock(type=”partial”)] public var dispatcher:EventDispatcher; } }
60. [Before] public function setup():void { heatingElement = mocks.nice(HeatingElement); thermostat = mocks.strict(Thermostat); dispatcher = mocks.partial(EventDispatcher); }
61. Defining Expectations
62. expect( object.call(arg) ) expect( object.getter ) expect( object.setter = value ) allow( object.call(arg) ) allow( object.getter ) allow( object.setter = value )
63. [Test] public function switching_kettle_on_should_activate_heatingElement():void { mocks.expect(heatingElement.activate()).once(); kettle.switchOn(); } [Test] public function switching_kettle_on_should_activate_thermostat():void { mocks.expect(thermostat.activate()).once(); kettle.switchOn(); }
64. [Test] public function switching_kettle_off_should_deactivate_heatingElement():void { mocks.expect(heatingElement.deactivate()).once(); kettle.switchOn(); kettle.switchOff(); } [Test] public function switching_kettle_off_should_deactivate_thermostat ():void { mocks.expect(thermostat.deactivate()).once(); kettle.switchOn(); kettle.switchOff(); }
65. [Test] public function kettle_should_deactive_heatingElement_when_thermostat_is_too_hot ():void { mocks.expect(thermostat.activate()) .dispatches(new ThermostatTooHotEvent()); mocks.expect(heatingElement.deactivate()).once(); kettle.switchOn(); }
66. mock( object ).method(“call”).args(...args) mock( object ).getter(“property”) mock( object ).setter(“property”).arg(arg) mock( object ).methods(/regexp/).args(...args) mock( object ).getters(/regexp/) mock( object ).setters(/regexp/).arg(arg) stub( object ).method(“call”).args(...args) stub( object ).getter(“property”) stub( object ).setter(“property”).arg(arg) stub( object ).methods(/regexp/).args(...args) stub( object ).getters(/regexp/) stub( object ).setters(/regexp/).arg(arg)
67. Actions
68. .returns(value:*) .returns(...values)
69. [Test] public function kettle_should_indicate_heatingElements_current_temperature():void { mocks.expect(heatingElement.currentTemperature) .returns(25, 63, 102); assertThat(kettle.currentTemperature, equalTo(25)); assertThat(kettle.currentTemperature, equalTo(63)); assertThat(kettle.currentTemperature, equalTo(102)); assertThat(kettle.currentTemperature, equalTo(102)); }
70. .throws(error:Error)
71. [Test] public function kettle_with_faulty_thermostat_should_explode():void { mocks.expect(thermostat.activate()) .throws(new FaultyThermostatError()); assertThat(function():void { kettle.switchOn(); }, throws(ExplodingKettleError)); }
72. Side Effects
73. Toaster Heating Element Thermostat Timer
74. .dispatches(event:Event)
75. [Rule] public var events:EventRule = new EventRule(); [Test(async)] public function toaster_should_eject_toast_when_timer_completes ():void { mocks.expect(timer.start()) .dispatches(new TimerEvent(TimerEvent.TIMER_COMPLETE)); events.from(toaster).hasType(ToastEvent.COMPLETE); toaster.switchOn(); } [Test(async)] public function toaster_should_eject_toast_when_timer_completes ():void { mocks.expect(timer.start()) .dispatches(new TimerEvent(TimerEvent.TIMER)) .dispatches(new TimerEvent(TimerEvent.TIMER), 10) .dispatches(new TimerEvent(TimerEvent.TIMER), 20) .dispatches(new TimerEvent(TimerEvent.TIMER_COMPLETE), 30); events.from(toaster).hasType(ToastEvent.COMPLETE); toaster.switchOn(); }
76. .calls(fn:Function) .callsWithArguments(fn:Function) .callsWithInvocation(invocation:Function)
77. [Test] public function when_toaster_is_switched_on_bacon_appears():void { mocks.expect(timer.start()).calls(function():void { trace("BACON!"); }); toaster.switchOn(); }
78. Constraints
79. Blender Motor Control
80. .inSequence(sequence:Sequence)
81. [Test] public function blender_should_require_ingredients_added_in_correct_order():void { recipe = sequence("recipe"); expect( vessel.add( banana ) ).inSequence(recipe); expect( vessel.add( honey ) ).inSequence(recipe); expect( vessel.add( milk ) ).inSequence(recipe); expect( vessel.add( malt ) ).inSequence(recipe); blender = new Blender(motor, control, vessel); blender.add( banana, honey, milk, malt ); }
82. .when(state:State) .then(state:State)
83. [Test] public function blender_should_adjust_speed_of_motor_when_switched_on():void { power = states('power').startsAs('off'); expect( control.switchOn() ) .then( power.isStateOf('on') ).once(); expect( motor.adjustSpeed(1) ) .when( power.isNot('on') ).never(); expect( motor.adjustSpeed(1) ) .when( power.isStateOf('on') ).once(); expect( control.switchOff() ) .then( power.isStateOf('off') ).once(): expect( motor.adjustSpeed(0) ) .when( power.isStateOf('off') ).once(); blender = new Blender(motor, control); blender.switchOn(); }
84. Verifying Expectations
85. [Test] public function ():void { // define expectation // exercise system under test verify(target); }
86. Don’t bother, Use the rule.
87. package mockolate.examples { public class ExampleTest { [Rule] public var mocks:MockolateRule = new MockolateRule(); } }
88. package mockolate.examples { public class ExampleTest { [Rule] public var mocks:MockolateRule = new MockolateRule(); [Mock] public var thing:IThing; } }
89. package mockolate.kitchen { public class KettleTest { [Rule] public var mocks:MockolateRule = new MockolateRule(); public var kettle:Kettle; [Mock] public var heatingElement:HeatingElement; [Mock] public var thermostat:Thermostat; [Before] public function prepareKettle():void { kettle = new Kettle(heatingElement, thermostat); } } }
90. Spying with Mockolate
91. assertThat(object, received().method(“call”) ); assertThat(object, received().getter(“property”) ); assertThat(object, received().method(“property”) ); assertThat(object, received().methods(“call”) ); assertThat(object, received().getters(“property”) ); assertThat(object, received().methods(“property”) ); .args(...values) .never() .once() .twice() .thrice() .times(n) .atLeast(n)
92. Mock Object principles Only mock types you own Be explicit about things that should not happen Specify as little as possible in a test Don’t use mocks to test boundary objects Don’t add behaviour Only mock your immediate neighbours Avoid too many mocks Create objects indirectly
93. LAZINESS IMPATIENCE HUBRIS
94. THANKS! @drewbourne drew@firstbourne.com http://github/drewbourne/mockolate