From 8f9186c1070f245d4040d3ae97aa217f0a6eb08e Mon Sep 17 00:00:00 2001 From: "jpsoulsf@gmail.com" Date: Fri, 5 Dec 2008 02:06:47 +0000 Subject: [PATCH] Add mock in composition tests. Make expectedReturnFor() public. Refactor tests (a bit). git-svn-id: https://mock4as.googlecode.com/svn/trunk@21 faef3d04-e93e-0410-8cca-bf3cd97b13f1 --- org/mock4as/AllTests.as | 78 ++---- org/mock4as/Mock.as | 2 +- org/mock4as/MockTest.as | 62 +++-- .../mockInComposition/MockInComposition.as | 26 +- .../test/MockInCompositionTest.as | 224 ++++++++++++++++++ 5 files changed, 313 insertions(+), 79 deletions(-) create mode 100644 org/mock4as/samples/mockInComposition/test/MockInCompositionTest.as diff --git a/org/mock4as/AllTests.as b/org/mock4as/AllTests.as index f370fd6..4027fb8 100644 --- a/org/mock4as/AllTests.as +++ b/org/mock4as/AllTests.as @@ -5,6 +5,7 @@ package org.mock4as import org.mock4as.samples.bank.BankSystemTest; import org.mock4as.samples.greeting.GreetingTest; + import org.mock4as.samples.mockInComposition.test.MockInCompositionTest; import org.mock4as.samples.publisher.PublisherTest; public class AllTests extends TestCase @@ -13,63 +14,28 @@ package org.mock4as public function AllTests(methodName : String){ super(methodName); } - - public static function suite():TestSuite{ - var myTS:TestSuite = new TestSuite(); - myTS.addTest(new AllTests("testTheTruth")); - - // test negative scenarios - myTS.addTest(new MockTest("testWrongMethodName")); - myTS.addTest(new MockTest("testWrongFirstArg")); - myTS.addTest(new MockTest("testWrongSecondArg")); - myTS.addTest(new MockTest("testWrongThirdArg")); - myTS.addTest(new MockTest("testWrongArgNumberLessArgs")); - myTS.addTest(new MockTest("testMethodInvocationMoreTimesThanExpected")); - myTS.addTest(new MockTest("testMethodInvocationLessTimesThanExpected")); - - myTS.addTest(new MockTest("testFailsIfMethodNeverCalled")); - myTS.addTest(new MockTest("testFailsIfMoreMethodsAreCalledThanExpected")); - // teest positive scenario - myTS.addTest(new MockTest("testSuccessMethodInvocation")); - - - - // mock samples positive tests - myTS.addTest(new GreetingTest("testGreetingInAnyLanguage")); - myTS.addTest(new PublisherTest("testOneSubscriberReceivesAMessage")); - myTS.addTest(new BankSystemTest("testTheTruth")); - myTS.addTest(new BankSystemTest("testTransferSameCurrency")); - myTS.addTest(new BankSystemTest("testTransferDifferentCurrency")); - myTS.addTest(new BankSystemTest("testTransferInsufficientFunds")); - - // mock in composition - // If you don't want to subclass mock (mainly because you want to subclass another class) - // you can use mock in composition - // - myTS.addTest(new MockTest("testSuccess_forAClassUsingMockInComposition_whereExpectedCallsEqualActualCalls_shouldReturnTrue")); - myTS.addTest(new MockTest("testSuccess_forAClassUsingMockInComposition_whereExpectedCallsDoNotEqualActualCalls_shouldReturnFalse")); - - myTS.addTest( new MockTest("testSuccess_whenMoreMethodsAreCalledThanExpected_shouldReturnFalse")); - myTS.addTest( new MockTest("testSuccess_whenNoMethodsCalledButAtLeastOneExpected_shouldReturnFalse")); - myTS.addTest( new MockTest("testSuccess_whenExpectedCallsEqualActualCalls_shouldReturnTrue")); - myTS.addTest( new MockTest("testSuccess_whenExpectedCallsWithExpectedArgsEqualActualCallsWithActualArgs_shouldReturnTrue")); - myTS.addTest( new MockTest("testSuccess_whenExpectedArgDoesNotEqualActualArg_shouldReturnFalse")); - myTS.addTest( new MockTest("testSuccess_whenExpected2ndArgDoesNotEqualActual2ndArg_shouldReturnFalse")); - myTS.addTest( new MockTest("testWillReturn_shouldReturnValueDefinedByTest")); - myTS.addTest( new MockTest("testWillReturn_shouldReturnTheObjectForTheMethodWithTheExpectedArgs")); - myTS.addTest( new MockTest("testWillThrow_shouldThrowErrorObjectDefinedByTest")); - myTS.addTest( new MockTest("testSuccess_whenExpectedMethodIsCalledMultipleTimesWithAtLeastOneUnexpectedArg_shouldFail")); - myTS.addTest( new MockTest("testSuccess_whenMethodCalledTwiceWithSameExpectedArg_shouldReturnTrue")); - myTS.addTest( new MockTest("testSuccess_whenMethodNameCalledIsDifferentThanMethodNameExpected_shouldReturnFalse")); - myTS.addTest( new MockTest("testSuccess_whenMethodNameCalledWithSameArgsButDifferentNameAsMethodExpected_shouldReturnFalse")); - myTS.addTest( new MockTest("testSuccess_whenLessArgsArePassedThanExpected_shouldReturnFalse")); - myTS.addTest( new MockTest("testSuccess_whenErrorExpectedAndMethodsCalledAsExpected_shouldReturnTrue")); - return myTS; - } - public function testTheTruth():void{ - assertTrue(true); - } + public static function suite():TestSuite + { + var testSuite:TestSuite = new TestSuite(); + testSuite.addTest(new AllTests("testTheTruth")); + testSuite.addTest(new GreetingTest("testGreetingInAnyLanguage")); + testSuite.addTest(new PublisherTest("testOneSubscriberReceivesAMessage")); + testSuite.addTest(new BankSystemTest("testTheTruth")); + testSuite.addTest(new BankSystemTest("testTransferSameCurrency")); + testSuite.addTest(new BankSystemTest("testTransferDifferentCurrency")); + testSuite.addTest(new BankSystemTest("testTransferInsufficientFunds")); + testSuite.addTest(MockTest.suite()); + testSuite.addTest(MockInCompositionTest.suite()); + return testSuite; + } + + public function testTheTruth():void{ + assertTrue(true); + } + + + } } \ No newline at end of file diff --git a/org/mock4as/Mock.as b/org/mock4as/Mock.as index 8fd7063..94c25c6 100644 --- a/org/mock4as/Mock.as +++ b/org/mock4as/Mock.as @@ -82,7 +82,7 @@ package org.mock4as } } - protected function expectedReturnFor(methodName:String="Depricated"):Object + public function expectedReturnFor(methodName:String="Depricated"):Object { return currentReturnValue; } diff --git a/org/mock4as/MockTest.as b/org/mock4as/MockTest.as index 968ec41..ead4fe1 100644 --- a/org/mock4as/MockTest.as +++ b/org/mock4as/MockTest.as @@ -1,11 +1,11 @@ package org.mock4as { import flexunit.framework.TestCase; + import flexunit.framework.TestSuite; import org.mock4as.samples.MockSomeInterface; import org.mock4as.samples.greeting.Greeting; import org.mock4as.samples.greeting.ITranslator; - import org.mock4as.samples.mockInComposition.MockInComposition; public class MockTest extends TestCase { @@ -17,6 +17,46 @@ package org.mock4as public function MockTest(methodName : String){ super(methodName); } + + public static function suite():TestSuite + { + var testSuite:TestSuite = new TestSuite(); + + // test negative scenarios + testSuite.addTest(new MockTest("testWrongMethodName")); + testSuite.addTest(new MockTest("testWrongFirstArg")); + testSuite.addTest(new MockTest("testWrongSecondArg")); + testSuite.addTest(new MockTest("testWrongThirdArg")); + testSuite.addTest(new MockTest("testWrongArgNumberLessArgs")); + testSuite.addTest(new MockTest("testMethodInvocationMoreTimesThanExpected")); + testSuite.addTest(new MockTest("testMethodInvocationLessTimesThanExpected")); + + testSuite.addTest(new MockTest("testFailsIfMethodNeverCalled")); + testSuite.addTest(new MockTest("testFailsIfMoreMethodsAreCalledThanExpected")); + // teest positive scenario + testSuite.addTest(new MockTest("testSuccessMethodInvocation")); + // mock in composition + // If you don't want to subclass mock (mainly because you want to subclass another class) + // you can use mock in composition + // + testSuite.addTest( new MockTest("testSuccess_whenMoreMethodsAreCalledThanExpected_shouldReturnFalse")); + testSuite.addTest( new MockTest("testSuccess_whenNoMethodsCalledButAtLeastOneExpected_shouldReturnFalse")); + testSuite.addTest( new MockTest("testSuccess_whenExpectedCallsEqualActualCalls_shouldReturnTrue")); + testSuite.addTest( new MockTest("testSuccess_whenExpectedCallsWithExpectedArgsEqualActualCallsWithActualArgs_shouldReturnTrue")); + testSuite.addTest( new MockTest("testSuccess_whenExpectedArgDoesNotEqualActualArg_shouldReturnFalse")); + testSuite.addTest( new MockTest("testSuccess_whenExpected2ndArgDoesNotEqualActual2ndArg_shouldReturnFalse")); + testSuite.addTest( new MockTest("testWillReturn_shouldReturnValueDefinedByTest")); + testSuite.addTest( new MockTest("testWillReturn_shouldReturnTheObjectForTheMethodWithTheExpectedArgs")); + testSuite.addTest( new MockTest("testWillThrow_shouldThrowErrorObjectDefinedByTest")); + testSuite.addTest( new MockTest("testSuccess_whenExpectedMethodIsCalledMultipleTimesWithAtLeastOneUnexpectedArg_shouldFail")); + testSuite.addTest( new MockTest("testSuccess_whenMethodCalledTwiceWithSameExpectedArg_shouldReturnTrue")); + testSuite.addTest( new MockTest("testSuccess_whenMethodNameCalledIsDifferentThanMethodNameExpected_shouldReturnFalse")); + testSuite.addTest( new MockTest("testSuccess_whenMethodNameCalledWithSameArgsButDifferentNameAsMethodExpected_shouldReturnFalse")); + testSuite.addTest( new MockTest("testSuccess_whenLessArgsArePassedThanExpected_shouldReturnFalse")); + testSuite.addTest( new MockTest("testSuccess_whenErrorExpectedAndMethodsCalledAsExpected_shouldReturnTrue")); + return testSuite; + } + public function testFailsIfMethodNeverCalled():void { @@ -149,27 +189,7 @@ package org.mock4as assertFalse(mock.success()); } - public function testSuccess_forAClassUsingMockInComposition_whereExpectedCallsEqualActualCalls_shouldReturnTrue():void - { - var classWithMockInComposition:MockInComposition = new MockInComposition(); - var someStringArg:String = "someStringArg"; - classWithMockInComposition.expects("someMethod").times(1).withArg(someStringArg); - classWithMockInComposition.someMethod(someStringArg); - classWithMockInComposition.verify(); - assertTrue(classWithMockInComposition.errorMessage(), classWithMockInComposition.success()); - } - public function testSuccess_forAClassUsingMockInComposition_whereExpectedCallsDoNotEqualActualCalls_shouldReturnFalse():void - { - var classWithMockInComposition:MockInComposition = new MockInComposition(); - var someStringArg:String = "someStringArg"; - classWithMockInComposition.expects("someMethod").times(1).withArg(someStringArg); - // In this case, we never call the method on the mock - // but we are expecting someMethod to get called once with someStringArg - // so success should return false - classWithMockInComposition.verify(); - assertFalse(classWithMockInComposition.errorMessage(), classWithMockInComposition.success()); - } public function testSuccess_whenMoreMethodsAreCalledThanExpected_shouldReturnFalse():void diff --git a/org/mock4as/samples/mockInComposition/MockInComposition.as b/org/mock4as/samples/mockInComposition/MockInComposition.as index 7eae96f..1b2093d 100644 --- a/org/mock4as/samples/mockInComposition/MockInComposition.as +++ b/org/mock4as/samples/mockInComposition/MockInComposition.as @@ -1,8 +1,9 @@ package org.mock4as.samples.mockInComposition { import org.mock4as.Mock; + import org.mock4as.samples.ISomeInterface; - public class MockInComposition extends ClassWeWantToSubclass + public class MockInComposition extends ClassWeWantToSubclass implements ISomeInterface { private var mock:Mock; @@ -18,6 +19,29 @@ package org.mock4as.samples.mockInComposition super.someMethod(inSomeStringArg); } + public function doSomething():void + { + mock.record("doSomething"); + } + public function anotherMethodWithNoArgs():void + { + mock.record("anotherMethodWithNoArgs"); + } + public function doSomethingElse(someStringArg:String):void + { + mock.record("doSomethingElse", someStringArg); + } + + public function doSomethingWith2Args(firstArg:String, secondArg:XML):void + { + mock.record("doSomethingWith2Args", firstArg, secondArg); + } + public function doSomethingAndReturnXML(inNodeName:String):XML + { + mock.record("doSomethingAndReturnXML", inNodeName); + return mock.expectedReturnFor() as XML; + } + /* * If you want to use mock in composition, you will need to support the mock methods below diff --git a/org/mock4as/samples/mockInComposition/test/MockInCompositionTest.as b/org/mock4as/samples/mockInComposition/test/MockInCompositionTest.as new file mode 100644 index 0000000..4bf0d9c --- /dev/null +++ b/org/mock4as/samples/mockInComposition/test/MockInCompositionTest.as @@ -0,0 +1,224 @@ +package org.mock4as.samples.mockInComposition.test +{ + import flexunit.framework.TestCase; + import flexunit.framework.TestSuite; + + import org.mock4as.samples.mockInComposition.MockInComposition; + + public class MockInCompositionTest extends TestCase + { + public function MockInCompositionTest(methodName:String=null) + { + super(methodName); + } + + public static function suite():TestSuite + { + var testSuite:TestSuite = new TestSuite(); + testSuite.addTest(new MockInCompositionTest("testSuccess_whereExpectedCallsEqualActualCalls_shouldReturnTrue")); + testSuite.addTest(new MockInCompositionTest("testSuccess_whereExpectedCallsDoNotEqualActualCalls_shouldReturnFalse")); + + testSuite.addTest( new MockInCompositionTest("testSuccess_whenMoreMethodsAreCalledThanExpected_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenNoMethodsCalledButAtLeastOneExpected_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenExpectedCallsEqualActualCalls_shouldReturnTrue")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenExpectedCallsWithExpectedArgsEqualActualCallsWithActualArgs_shouldReturnTrue")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenExpectedArgDoesNotEqualActualArg_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenExpected2ndArgDoesNotEqualActual2ndArg_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testWillReturn_shouldReturnValueDefinedByTest")); + testSuite.addTest( new MockInCompositionTest("testWillReturn_shouldReturnTheObjectForTheMethodWithTheExpectedArgs")); + testSuite.addTest( new MockInCompositionTest("testWillThrow_shouldThrowErrorObjectDefinedByTest")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenExpectedMethodIsCalledMultipleTimesWithAtLeastOneUnexpectedArg_shouldFail")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenMethodCalledTwiceWithSameExpectedArg_shouldReturnTrue")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenMethodNameCalledIsDifferentThanMethodNameExpected_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenMethodNameCalledWithSameArgsButDifferentNameAsMethodExpected_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenLessArgsArePassedThanExpected_shouldReturnFalse")); + testSuite.addTest( new MockInCompositionTest("testSuccess_whenErrorExpectedAndMethodsCalledAsExpected_shouldReturnTrue")); + return testSuite; + } + + public function testSuccess_whereExpectedCallsEqualActualCalls_shouldReturnTrue():void + { + var classWithMockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + classWithMockInComposition.expects("someMethod").times(1).withArg(someStringArg); + classWithMockInComposition.someMethod(someStringArg); + classWithMockInComposition.verify(); + assertTrue(classWithMockInComposition.errorMessage(), classWithMockInComposition.success()); + } + + public function testSuccess_whereExpectedCallsDoNotEqualActualCalls_shouldReturnFalse():void + { + var classWithMockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + classWithMockInComposition.expects("someMethod").times(1).withArg(someStringArg); + // In this case, we never call the method on the mock + // but we are expecting someMethod to get called once with someStringArg + // so success should return false + classWithMockInComposition.verify(); + assertFalse(classWithMockInComposition.errorMessage(), classWithMockInComposition.success()); + } + + public function testSuccess_whenMoreMethodsAreCalledThanExpected_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + mockInComposition.expects("doSomething").times(1); + mockInComposition.doSomething(); + mockInComposition.doSomethingElse("someString"); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenNoMethodsCalledButAtLeastOneExpected_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + mockInComposition.expects("doSomething").times(1); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenExpectedCallsEqualActualCalls_shouldReturnTrue():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + mockInComposition.expects("doSomething").times(1); + mockInComposition.doSomething(); + assertTrue(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenExpectedCallsWithExpectedArgsEqualActualCallsWithActualArgs_shouldReturnTrue():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + mockInComposition.expects("doSomethingElse").times(1).withArg(someStringArg); + mockInComposition.doSomethingElse(someStringArg); + assertTrue(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenExpectedArgDoesNotEqualActualArg_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + mockInComposition.expects("doSomethingElse").times(1).withArg("someOtherStringArg"); + mockInComposition.doSomethingElse(someStringArg); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenExpected2ndArgDoesNotEqualActual2ndArg_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + var someUnexpectedStringArg:String = "someUnexpectedStringArg"; + var someXMLArg:XML = test; + var someUnexpectedXMLArg:XML = ; + mockInComposition.expects("doSomethingWith2Args").times(1).withArgs(someStringArg, someXMLArg); + mockInComposition.doSomethingWith2Args(someUnexpectedStringArg, someUnexpectedXMLArg); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + + public function testWillReturn_shouldReturnValueDefinedByTest():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someNodeName:String = "someNodeName"; + var expectedXMLReturnValue:XML = test; + mockInComposition.expects("doSomethingAndReturnXML").withArg(someNodeName).willReturn(expectedXMLReturnValue); + var actualXMLReturned:XML = mockInComposition.doSomethingAndReturnXML(someNodeName); + assertEquals("Expecting "+expectedXMLReturnValue+" but was: "+actualXMLReturned, expectedXMLReturnValue, actualXMLReturned); + } + + public function testWillReturn_shouldReturnTheObjectForTheMethodWithTheExpectedArgs():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var firstNodeName:String = "firstNodeName"; + var secondNodeName:String = "secondNodeName"; + var expectedXMLForFirstNodeName:XML = firstNodeName; + var expectedXMLForSecondNodeName:XML = secondNodeName + mockInComposition.expects("doSomethingAndReturnXML").withArg(firstNodeName).willReturn(expectedXMLForFirstNodeName); + mockInComposition.expects("doSomethingAndReturnXML").withArg(secondNodeName).willReturn(expectedXMLForSecondNodeName); + var actualXMLReturnedForFirstNodeName:XML = mockInComposition.doSomethingAndReturnXML(firstNodeName); + var actualXMLReturnedForSecondNodeName:XML = mockInComposition.doSomethingAndReturnXML(secondNodeName); + assertEquals("", expectedXMLForFirstNodeName, actualXMLReturnedForFirstNodeName); + assertEquals("", expectedXMLForSecondNodeName, actualXMLReturnedForSecondNodeName); + } + + public function testWillThrow_shouldThrowErrorObjectDefinedByTest():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someNodeName:String = "someNodeName"; + var expectedMessage:String = "Mock message thrown."; + mockInComposition.expects("doSomething").willThrow(new Error(expectedMessage)); + try + { + mockInComposition.doSomething(); + } + catch (e:Error) + { + assertEquals("Expecting "+expectedMessage+" but was: "+e.message, expectedMessage, e.message); + return; + } + fail("Expecting error to be thrown but none was thrown."); + } + + public function testSuccess_whenExpectedMethodIsCalledMultipleTimesWithAtLeastOneUnexpectedArg_shouldFail():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var firstArgValue:String = "firstArgValue"; + var secondArgValue:String = "secondArgValue"; + mockInComposition.expects("doSomethingElse").times(1).withArg(firstArgValue); + mockInComposition.expects("doSomethingElse").times(1).withArg(secondArgValue); + mockInComposition.doSomethingElse(firstArgValue); + mockInComposition.doSomethingElse("someUnexpectedArg"); + assertFalse("mockInComposition.success() should fail because the second time we called the method we passed an unexpected arg", mockInComposition.success()); + } + + public function testSuccess_whenMethodCalledTwiceWithSameExpectedArg_shouldReturnTrue():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var firstArgValue:String = "firstArgValue"; + var secondArgValue:String = "secondArgValue"; + mockInComposition.expects("doSomethingElse").times(2).withArg(firstArgValue); + mockInComposition.doSomethingElse(firstArgValue); + mockInComposition.doSomethingElse(firstArgValue); + assertTrue(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenMethodNameCalledIsDifferentThanMethodNameExpected_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + mockInComposition.expects("doSomething").times(1); + mockInComposition.anotherMethodWithNoArgs(); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenMethodNameCalledWithSameArgsButDifferentNameAsMethodExpected_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + mockInComposition.expects("doSomethingElse").times(1).withArg(someStringArg); + mockInComposition.doSomethingAndReturnXML("someStringArg"); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenLessArgsArePassedThanExpected_shouldReturnFalse():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + var someStringArg:String = "someStringArg"; + mockInComposition.expects("doSomethingAndReturnXML").times(1); + mockInComposition.doSomethingAndReturnXML("someStringArg"); + assertFalse(mockInComposition.errorMessage(), mockInComposition.success()); + } + + public function testSuccess_whenErrorExpectedAndMethodsCalledAsExpected_shouldReturnTrue():void + { + var mockInComposition:MockInComposition = new MockInComposition(); + mockInComposition.expects("doSomething").times(1).willThrow(new Error("customError")); + try + { + mockInComposition.doSomething(); + fail("expecting error but none was thrown"); + } + catch (e:Error) + { + assertTrue(mockInComposition.errorMessage(), mockInComposition.success()); + } + } + + } +} \ No newline at end of file