def testExplicitGeneratorConvenienceFunctionUsage(self): """Check normal operation with explicit generators using """ c = Controller() x = c.mock() c.generator(x.g(8, 9), [10, 11]) c.replay() self.failUnless([k for k in x.g(8, 9)] == [10, 11])
def testExpectAndReturn(self): """Check expect and return""" c = Controller() x = c.mock() c.expectAndReturn(x.g(8, 9), 5) c.replay() self.failUnless(x.g(8, 9) == 5) c.verify()
def testExceptionRaisedByFunctions(self): """Ensure that function calls play back exceptions""" c = Controller() x = c.mock(KlassBeingMocked) x.g.h(3, 4) c.setException(Exception) c.replay() self.failUnlessRaises(Exception, x.g.h, 3, 4)
def testFunctionCallWithNoReturnValueSpecified(self): """Function call with no return value specified""" c = Controller() x = c.mock(KlassBeingMocked) x.g(3, 4) c.replay() x.g(3, 4) c.verify()
def testUnusedAttributeAssignmentCanBeVerified(self): """Ensure that unused calls cause verification failure""" c = Controller() x = c.mock(KlassBeingMocked) x.w = 5 c.replay() self.failUnlessRaises(RecordedCallsWereNotReplayedCorrectly, c.verify)
def testGetattrWithReturnValueSpecified(self): """Getattr with return value specified""" c = Controller() x = c.mock(KlassBeingMocked) x.g c.setReturn(8) c.replay() self.failUnless(x.g == 8)
def testSetItem(self): """Ensure that __setitem__ works""" c = Controller() x = c.mock(KlassBeingMocked) x.g[6] = 7 c.replay() x.g[6] = 7 c.verify()
def testGetItem(self): """Ensure that __getitem__ works""" c = Controller() x = c.mock(KlassBeingMocked) x.g[5] c.setReturn(6) c.replay() self.failUnless(x.g[5] == 6) c.verify()
def testIter(self): """Ensure that __iter__ records and replays values""" c = Controller() x = c.mock() x.__iter__() c.setReturn(1) c.setReturn(2) c.replay() self.assertTrue([k for k in x] == [1, 2])
def testIterDoesNotAllowRecordingAfterAnException(self): """Ensure that __iter__ records and replays exceptions""" c = Controller() x = c.mock() x.__iter__() c.setReturn(1) c.setException(Exception) self.failUnlessRaises(Exception, c.setReturn, 2) self.failUnlessRaises(Exception, c.setException, Exception)
def testExplicitGeneratorConvenienceFunctionExceptionUsage(self):
"""Check explicit generators using compact specification"""
c = Controller()
x = c.mock()
c.generator(x.g(8, 9), [10], Exception("bogus"))
c.replay()
g = x.g(8, 9)
self.failUnless(g.next() == 10)
self.failUnlessRaises(Exception, g.next)
def testAttributeAssignmentCanBePlayedBack(self): """Attibute assignment should be intercepted""" c = Controller() x = c.mock(KlassBeingMocked) x.w = 5 x.w = 6 c.replay() x.w = 5
def testLen(self): """Ensure that __len__ works""" c = Controller() x = c.mock(KlassBeingMocked) k = len(x) c.setReturn(5) c.replay() self.failUnless(len(x) == 5) c.verify()
def testUndefinedPlaybackRaisesException(self): """Playback failure should raise an exception""" c = Controller() x = c.mock(KlassBeingMocked) c.replay() try: x.w = 5 self.fail() except PlaybackFailure, e: pass
def testUsedAttributeAssignmentCanBeVerified(self): """Ensure that used calls will not cause verification failure""" c = Controller() x = c.mock(KlassBeingMocked) x.w = 5 x.h = 3 c.replay() x.h = 3 x.w = 5 c.verify()
def testExplicitGeneratorUsage(self): """Check operation of explicit generators using discrete settings""" c = Controller() x = c.mock() x.g(8, 9) c.generator() c.setReturn(10) c.setReturn(11) c.replay() self.failUnless([k for k in x.g(8, 9)] == [10, 11])
def testSetAttributeRecordsField(self): """Ensure setting an attribute is correctly recorded""" c = Controller() x = c.mock(KlassBeingMocked) x.w = 5 self.failUnless(len(c.actions) == 1) action = c.actions.get(BaseAction((x,'w'))) self.failUnless(action.field == 'w') self.failUnless(action.value == 5)
def testFunctionCallWithMismatchedArguments(self): """Function call with mismatched arguments""" c = Controller() x = c.mock(KlassBeingMocked) x.g(3, 4) x.h() x.i(8, v1=4, v2=3) c.replay() self.failUnlessRaises(PlaybackFailure, x.g, 5, 3) self.failUnlessRaises(PlaybackFailure, x.h, 2) self.failUnlessRaises(PlaybackFailure, x.i, 8, v1=4, v2=5)
def testExpectAndRaise(self): """Check expect and raise""" c = Controller() x = c.mock() c.expectAndRaise(x.g(8, 9), Exception()) c.replay() try: x.g(8, 9) self.fail() except Exception, e: pass
def testFunctionCalReturnValues(self): """Ensure function call return values get set""" c = Controller() x = c.mock(KlassBeingMocked) x.g.h(3, 4) c.setReturn(5) x.g.h(6, 7) c.setReturn(8) c.replay() self.failUnless(x.g.h(3, 4) == 5) self.failUnless(x.g.h(6, 7) == 8)
def testEnsureThatContainsWorks(self): """Verify that __contains__ is implemented""" c = Controller() x = c.mock() 1 in x c.setReturn(True) 2 in x c.setReturn(False) c.replay() self.failUnless(1 in x) self.failIf(2 in x)
def testAtLeastSetsLimit(self): """Ensure that setattr returns function calls""" c = Controller() x = c.mock(KlassBeingMocked) x.g = 6 c.atLeast(2) c.replay() x.g = 6 self.failUnlessRaises(Exception, c.verify) x.g = 6 c.verify()
def testIterWithException(self): """Ensure that __iter__ records and replays exceptions""" c = Controller() x = c.mock() x.__iter__() c.setReturn(1) c.setException(Exception) c.replay() i = x.__iter__() self.failUnless(i.next() == 1) self.failUnlessRaises(Exception, i.next)
def test__foo__MethodsWorkWithSyntacticalFormAndMethodCallInterchangably(self): """Ensure that __foo__ methods work with their special syntax forms interchangaly""" c = Controller() x = c.mock(KlassBeingMocked) x.g.__getitem__(5) c.setReturn(6) x.h.__getitem__(7) c.setReturn(8) c.replay() self.failUnless(x.g[5] == 6) self.failUnless(x.h.__getitem__(7) == 8)
def testSetCountOneOrMoreRaisesErrorOnNextRecord(self): """Setting an unlimited count causes subsequent records to fail""" c = Controller() x = c.mock(KlassBeingMocked) x.w = 5 c.oneOrMore() try: x.w = 6 self.fail() except IllegalPlaybackRecorded, e: pass
def testGetattrWithNoReturnValueSpecified(self): """Getattr with no return value specified""" c = Controller() x = c.mock(KlassBeingMocked) x.g c.replay() self.failIf(x.g == None) try: x.g self.fail() except PlaybackFailure, e: pass
def testAttributeAssignmentIsIntercepted(self): """Attibute assignment should be intercepted""" c = Controller() x = c.mock(KlassBeingMocked) x.w = 5 c.replay() try: x.w self.fail() except PlaybackFailure, e: pass
def testExceptionRaisedByGetattr(self): """Ensure that getattr plays back exceptions""" c = Controller() x = c.mock(KlassBeingMocked) x.g c.setException(Exception) c.replay() try: x.g self.fail() except Exception, e: pass
def testExceptionRaisedBySetattr(self): """Ensure that setattr returns function calls""" c = Controller() x = c.mock(KlassBeingMocked) x.g = 6 c.setException(Exception) c.replay() try: x.g = 6 self.fail() except Exception, e: pass
def testExplicitGeneratorExecptionUsage(self):
"""Check exception raising with explicit generators using discrete settings"""
c = Controller()
x = c.mock()
x.g(8, 9)
c.generator()
c.setReturn(10)
c.setException(Exception("bogus"))
c.replay()
g = x.g(8, 9)
self.failUnless(g.next() == 10)
self.failUnlessRaises(Exception, g.next)
