Comments on: Unit Testing Flex – Alerts

By: Brian

Brian — Thu, 03 Sep 2009 19:42:47 +0000

@Shanon – I agree with you, when you pass functions around, testing becomes limited to what executes the code, rather than what the code itself does. If this is the case, why not just utilize a method from the scope chain that can be mocked on an object. This way you guarantee the same behavior on each call because you’re using a predefined method.

By: Shanon

Shanon — Tue, 25 Aug 2009 06:09:37 +0000

I apologize for not making myself clear. In my previous posts I am talking about my dislike for this piece of code:

  mock.method(”confirm”).calls(
    function () : void {
      wasDeleted = true;
    }
  ).once;
  mock.verify();

My problem is that this does not provide adequate coverage of the production code. It tests a copy of the production code. The reason this is a problem is that I could change my production code to look like this....

  public function deleteCustomer(customer:Customer): void {
    confirmer.confirm(
      function(): void {
        throw new Error('My production code is broken');
      }
    );
  }

And my test would still pass.

By: Brian

Brian — Mon, 24 Aug 2009 19:01:09 +0000

@Shannon – In your example, you’re testing CustomerListModelTest. The mocking framwork is useful to emulate dependencies on the class you’re testing. If you wanted to test AlertConfirmer, you’d have to write a separate test (e.g. – AlertConfirmerTest). If you find a mocking framework that supports static method mocking, then you can mock Alert.show() in that AlertConfirmerTest. From there no need to test Alert.show() it’s a framework method for which you’re not responsible.

You can still practice TDD this way. Once you saw the need for the AlertConfirmer, you could have written the test for AlertConfirmer and then implemented it. In fact the mocking framework allows you to mock AlertConfirmer so you can finish the test for CustomerListModelTest before you even tackle implementing CustomerListModel and then you could go on to write AlertConfirmerTest and then AlertConfirmer.

In terms of a unit testing guide, I’d suggest checking out the wiki for the fluint testing framework and flexunit4. THere are a lot of great examples showing how to perform Theory and DataPoint tests, SequenceSteppers, Async testing, etc. Best of luck on the endeavor.

By: Shanon

Shanon — Sun, 23 Aug 2009 10:19:37 +0000

I guess the only concern regarding that approach is that if I stub the confirm method/function then I would never actually test the real implementation. I’m really into TDD so I try my hardest to have a failing test in front of me before I write any production code. In any case I accept that the majority of times using a mocking framework is a preferable approach.

I’m currently looking at putting together a small sample application to serve as a guide for those interesting in unit testing flex code. I’m looking at getting stuck into that this week, time permitting. If you have any ideas or thoughts on what should be included or you would like to get involved, send me an email @ shanonmcquay@gmail.com.

By: Brian

Brian — Fri, 21 Aug 2009 19:48:13 +0000

@Shanon – If you use a mocking framework and set an expectation that confirm() should be called, you can verify that the method was called by deleteCustomer using expectations and feel good that your class is interacting with its dependencies correctly. The anonymous function is just help to stub the confirm method, so don’t feel dirty for using it, all you care about is that confirm is being called correctly. In mock-as3, this would be written something like:

mock.method(“confirm”).calls(function () : void {
wasDeleted = true;
}).once;
mock.verify();

The idea of using a mock object framework is not only to stub the return value or error being thrown, but set expectations on how the dependencies should be used using withArgs() and methods to determine the # of calls for a method/properties on a dependency (once/twice/exactly).

Hope you enjoy FlexUnit4.

By: Shanon

Shanon — Thu, 20 Aug 2009 23:17:27 +0000

Hi Brian,

Glad that you pulled me up on not using a mocking framework. I’m actually using mockito-flex in my day to day work and really liking it! The main problem with auto mocking in the example is the fact that I’m passing an anonymous function to the confirmer:

function(): void {
wasDeleted = true;
}

As part of my test I need to make sure this function is invoked to verify that it works. I couldn’t find a way to do this with mockito-flex.

Just for you I’ll have a go using FlexUnit 4 for my next flex post

Thanks,
Shanon

By: Brian

Brian — Thu, 20 Aug 2009 17:08:10 +0000

Just a note, decoupling the Alert code from the CustomerListModel is a good step, but there are tools out there that can be used to avoid you having to create an interface and 2 implementations classes just to support testing. mock-as3, asmock, and mockito-flex all support type-safe object mocking. In this example, you could just create AlertConfirmer alone and then stub out the behavior of the confirm() method for testing.

I personally prefer using mock-as3 since it’s extremely simple to use; the type-safe mocking version hasn’t been officially released as of yet, so you can find a copy of it in this sample project I did for a demo:

http://svn.adogo.us/200908/SampleTestsUsingFU4MockAs3/libs/

Also you should look into using flexunit4 instead of the original flexunit. The async support is much more robust and there are more tools to do integration testing ala what was in the fluint library. FlexUnit4 is in beta2 now and it’s quite stable.

Keep pushing the Flex unit testing love, the community needs more great examples.