def test_assertSpyLastRaised_with_expected_exception(self): """Testing SpyAgency.assertSpyLastRaised with expected exception raised """ def _do_math(_self, a, *args, **kwargs): if a == 1: raise KeyError elif a == 2: raise ValueError obj = MathClass() self.spy_on(obj.do_math, call_fake=_do_math) try: obj.do_math(1) except KeyError: pass try: obj.do_math(2) except ValueError: pass # These should not fail. self.assertSpyLastRaised(obj.do_math, ValueError) self.assertSpyLastRaised(obj.do_math.spy, ValueError)
def test_with_unexpected_call(self): """Testing SpyOpMatchInOrder with unexpected call""" obj = MathClass() self.agency.spy_on( obj.do_math, op=SpyOpMatchInOrder([ { 'kwargs': { 'a': 4, 'b': 7, }, }, ])) expected_message = re.escape( "This call to do_math was not passed args=(), " "kwargs={'a': 4, 'b': 7}.\n" "\n" "It was called with:\n" "\n" "args=()\n" "kwargs={'a': 4, 'b': 9}" ) with self.assertRaisesRegexp(AssertionError, expected_message): obj.do_math(a=4, b=9)
def test_assertSpyLastRaised_without_expected_exception(self): """Testing SpyAgency.assertSpyLastRaised without expected exception raised """ def _do_math(_self, a, *args, **kwargs): if a == 1: raise KeyError elif a == 2: raise ValueError obj = MathClass() self.spy_on(obj.do_math, call_fake=_do_math) try: obj.do_math(1) except KeyError: pass try: obj.do_math(2) except ValueError: pass msg = ('The last call to do_math did not raise KeyError. It last ' 'raised ValueError.') with self._check_assertion(msg): self.assertSpyLastRaised(obj.do_math, KeyError) with self._check_assertion(msg): self.assertSpyLastRaised(obj.do_math.spy, KeyError)
def test_assertSpyNotCalledWith_without_unexpected_arguments(self): """Testing SpyAgency.assertSpyNotCalledWith without unexpected arguments """ obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) msg = ("A call to do_math was unexpectedly passed args=(), " "kwargs={'a': 1, 'b': 4}.\n" "\n" "The following calls were recorded:\n" "\n" "Call 0:\n" " args=()\n" " kwargs={'a': 1, 'b': 4}\n" "\n" "Call 1:\n" " args=()\n" " kwargs={'a': 2, 'b': 9}") with self._check_assertion(msg): self.assertSpyNotCalledWith(obj.do_math, a=1, b=4) with self._check_assertion(msg): self.assertSpyNotCalledWith(obj.do_math.spy, a=1, b=4) msg = ("This call to do_math was unexpectedly passed args=()," " kwargs={'a': 2, 'b': 9}.") with self._check_assertion(msg): self.assertSpyNotCalledWith(obj.do_math.spy.calls[1], a=2, b=9)
def test_assertSpyLastRaisedMessage_with_expected(self): """Testing SpyAgency.assertSpyLastRaised with expected exception and message raised """ def _do_math(_self, a, *args, **kwargs): if a == 1: raise AttributeError('Bad key!') elif a == 2: raise ValueError('Bad value!') obj = MathClass() self.spy_on(obj.do_math, call_fake=_do_math) try: obj.do_math(1) except AttributeError: pass try: obj.do_math(2) except ValueError: pass # These should not fail. self.assertSpyLastRaisedMessage(obj.do_math, ValueError, 'Bad value!') self.assertSpyLastRaisedMessage(obj.do_math.spy, ValueError, 'Bad value!')
def test_assertSpyReturned_without_expected_return(self): """Testing SpyAgency.assertSpyReturned without expected return value""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) msg = ('No call to do_math returned 100.\n' '\n' 'The following values have been returned:\n' '\n' 'Call 0:\n' ' 5\n' '\n' 'Call 1:\n' ' 11') with self._check_assertion(msg): self.assertSpyReturned(obj.do_math, 100) with self._check_assertion(msg): self.assertSpyReturned(obj.do_math.spy, 100) msg = ('This call to do_math did not return 100.\n' '\n' 'It returned:\n' '\n' '5') with self._check_assertion(msg): self.assertSpyReturned(obj.do_math.calls[0], 100)
def test_assertSpyRaisedMessage_without_expected(self): """Testing SpyAgency.assertSpyRaisedMessage without expected exception and message raised """ def _do_math(_self, a, *args, **kwargs): if a == 1: raise AttributeError('Bad key!') elif a == 2: raise ValueError('Bad value!') obj = MathClass() self.spy_on(obj.do_math, call_fake=_do_math) try: obj.do_math(1) except AttributeError: pass try: obj.do_math(2) except ValueError: pass # Note that we may end up with different string types with different # prefixes on different versions of Python, so we need to repr these. msg = ('No call to do_math raised AttributeError with message %r.\n' '\n' 'The following exceptions have been raised:\n' '\n' 'Call 0:\n' ' exception=AttributeError\n' ' message=%r\n' '\n' 'Call 1:\n' ' exception=ValueError\n' ' message=%r' % ('Bad key...', str('Bad key!'), str('Bad value!'))) with self._check_assertion(msg): self.assertSpyRaisedMessage(obj.do_math, AttributeError, 'Bad key...') with self._check_assertion(msg): self.assertSpyRaisedMessage(obj.do_math.spy, AttributeError, 'Bad key...') msg = ('This call to do_math did not raise AttributeError with message' ' %r.\n' '\n' 'It raised:\n' '\n' 'exception=AttributeError\n' 'message=%r' % ('Bad key...', str('Bad key!'))) with self._check_assertion(msg): self.assertSpyRaisedMessage(obj.do_math.calls[0], AttributeError, 'Bad key...')
def test_with_unbound_method(self): """Testing SpyOpRaise with unbound method""" self.agency.spy_on(MathClass.do_math, owner=MathClass, op=SpyOpRaise(ValueError('foo'))) obj = MathClass() with self.assertRaisesRegexp(ValueError, 'foo'): obj.do_math(a=4, b=3)
def test_assertSpyCalled_with_called(self): """Testing SpyAgency.assertSpyCalled with spy called""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math() # These should not fail. self.assertSpyCalled(obj.do_math) self.assertSpyCalled(obj.do_math.spy)
def test_called(self): """Testing FunctionSpy.called""" obj = MathClass() self.agency.spy_on(obj.do_math) self.assertFalse(obj.do_math.called) obj.do_math(10, 20) self.assertTrue(obj.do_math.called)
def test_repr_and_bound_method(self): """Testing FunctionSpy.__repr__ and bound method""" obj = MathClass() self.agency.spy_on(obj.do_math) obj.do_math() self.assertEqual(repr(obj.do_math.spy), '<Spy for bound method MathClass.do_math ' 'of %r (1 call)>' % obj)
def test_raised(self): """Testing FunctionSpy.raised""" obj = MathClass() self.agency.spy_on(obj.do_math) with self.assertRaises(TypeError): obj.do_math(1, 'a') self.assertTrue(obj.do_math.raised(TypeError)) self.assertFalse(obj.do_math.raised(ValueError)) self.assertFalse(obj.do_math.raised(None))
def test_assertSpyCallCount_with_expected_count(self): """Testing SpyAgency.assertSpyCallCount with expected call count""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math() obj.do_math() # These should not fail. self.assertSpyCallCount(obj.do_math, 2) self.assertSpyCallCount(obj.do_math.spy, 2)
def test_last_returned(self): """Testing FunctionSpy.last_returned""" obj = MathClass() self.agency.spy_on(obj.do_math) obj.do_math(1, 2) obj.do_math(3, 4) self.assertFalse(obj.do_math.last_returned(3)) self.assertTrue(obj.do_math.last_returned(7)) self.assertFalse(obj.do_math.last_returned(None))
def test_assertSpyLastCalledWith_with_expected_arguments(self): """Testing SpyAgency.assertSpyLastCalledWith with expected arguments""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) # These should not fail. self.assertSpyLastCalledWith(obj.do_math, a=2, b=9) self.assertSpyLastCalledWith(obj.do_math.spy, a=2, b=9)
def test_raised(self): """Testing SpyCall.raised""" obj = MathClass() self.agency.spy_on(obj.do_math) with self.assertRaises(TypeError): obj.do_math(1, 'a') call = obj.do_math.calls[0] self.assertTrue(call.raised(TypeError)) self.assertFalse(call.raised(ValueError)) self.assertFalse(call.raised(None))
def test_assertSpyLastReturned_with_expected_return(self): """Testing SpyAgency.assertSpyLastReturned with expected return value """ obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) # These should not fail. self.assertSpyLastReturned(obj.do_math, 11) self.assertSpyLastReturned(obj.do_math.spy, 11)
def test_last_raised_with_message(self): """Testing FunctionSpy.last_raised_with_message""" obj = MathClass() self.agency.spy_on(obj.do_math) with self.assertRaises(TypeError): obj.do_math(1, 'a') self.assertTrue(obj.do_math.last_raised_with_message( TypeError, "unsupported operand type(s) for +: 'int' and '%s'" % text_type.__name__)) self.assertFalse(obj.do_math.last_raised_with_message(TypeError, None))
def test_last_call(self): """Testing FunctionSpy.last_call""" obj = MathClass() self.agency.spy_on(obj.do_math) obj.do_math(10, 20) obj.do_math(20, 30) self.assertEqual(len(obj.do_math.calls), 2) last_call = obj.do_math.last_call self.assertNotEqual(last_call, None) self.assertTrue(last_call.called_with(a=20, b=30))
def test_assertSpyLastRaised_with_expected_no_exception(self): """Testing SpyAgency.assertSpyLastRaised with expected completion without raising """ obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1) obj.do_math(2) # These should not fail. self.assertSpyLastRaised(obj.do_math, None) self.assertSpyLastRaised(obj.do_math.spy, None)
def test_reset_calls(self): """Testing FunctionSpy.reset_calls""" obj = MathClass() self.agency.spy_on(obj.do_math) obj.do_math(1, 2) self.assertEqual(len(obj.do_math.calls), 1) self.assertEqual(obj.do_math.last_call, obj.do_math.calls[-1]) self.assertTrue(obj.do_math.called) obj.do_math.reset_calls() self.assertEqual(len(obj.do_math.calls), 0) self.assertIsNone(obj.do_math.last_call) self.assertFalse(obj.do_math.called)
def test_assertSpyNotCalledWith_with_unexpected_arguments(self): """Testing SpyAgency.assertSpyNotCalledWith with unexpected arguments """ obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) # These should not fail. self.assertSpyNotCalledWith(obj.do_math, a=1, b=3) self.assertSpyNotCalledWith(obj.do_math.calls[0], a=1, b=3) self.assertSpyNotCalledWith(obj.do_math.spy, a=1, b=9) self.assertSpyNotCalledWith(obj.do_math.spy.calls[1], a=1, b=9)
def test_assertSpyCallCount_without_expected_count(self): """Testing SpyAgency.assertSpyCallCount without expected call count""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math() with self._check_assertion('do_math was called 1 time, not 2.'): self.assertSpyCallCount(obj.do_math, 2) # Let's bump and test a plural result. obj.do_math() with self._check_assertion('do_math was called 2 times, not 3.'): self.assertSpyCallCount(obj.do_math.spy, 3)
def test_assertSpyLastRaised_without_raised(self): """Testing SpyAgency.assertSpyLastRaised without exception raised""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1) obj.do_math(2) msg = 'The last call to do_math did not raise an exception.' with self._check_assertion(msg): self.assertSpyLastRaised(obj.do_math, KeyError) with self._check_assertion(msg): self.assertSpyLastRaised(obj.do_math.spy, KeyError)
def test_assertSpyRaisedMessage_without_raised(self): """Testing SpyAgency.assertSpyRaisedMessage without exception raised """ obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1) obj.do_math(2) msg = 'No call to do_math raised an exception.' with self._check_assertion(msg): self.assertSpyRaisedMessage(obj.do_math, KeyError, '...') with self._check_assertion(msg): self.assertSpyRaisedMessage(obj.do_math.spy, KeyError, '...')
def test_with_unbound_method_and_op(self): """Testing SpyOpMatchAny with unbound method and op""" self.agency.spy_on(MathClass.do_math, owner=MathClass, op=SpyOpMatchAny([ { 'kwargs': { 'a': 4, 'b': 3, }, 'op': SpyOpMatchInOrder([ { 'kwargs': { 'a': 4, 'b': 3, 'x': 1, }, 'op': SpyOpReturn(123), }, { 'kwargs': { 'a': 4, 'b': 3, 'x': 2, }, 'op': SpyOpReturn(456), }, ]), }, ])) obj = MathClass() self.assertEqual(obj.do_math(a=4, b=3, x=1), 123) self.assertEqual(obj.do_math(a=4, b=3, x=2), 456)
def test_setup_with_instance_and_op(self): """Testing SpyOpMatchAny set up with op=SpyOpMatchAny([...]) and op""" obj = MathClass() self.agency.spy_on(obj.do_math, op=SpyOpMatchAny([ { 'kwargs': { 'a': 1, 'b': 2, }, 'op': SpyOpMatchInOrder([ { 'kwargs': { 'a': 1, 'b': 2, 'x': 1, }, 'op': SpyOpReturn(123), }, { 'kwargs': { 'a': 1, 'b': 2, 'x': 2, }, 'op': SpyOpReturn(456), }, ]), }, ])) self.assertEqual(obj.do_math(a=1, b=2, x=1), 123) self.assertEqual(obj.do_math(a=1, b=2, x=2), 456)
def test_with_expected_calls(self): """Testing SpyOpMatchInOrder with all expected calls""" obj = MathClass() self.agency.spy_on(obj.do_math, op=SpyOpMatchInOrder([ { 'kwargs': { 'a': 4, 'b': 7, }, }, { 'kwargs': { 'a': 2, 'b': 8, }, 'call_original': False, }, { 'kwargs': { 'a': 100, 'b': 200, }, 'op': SpyOpReturn(123), }, { 'kwargs': { 'a': 5, 'b': 9, }, 'call_fake': lambda a, b: a + b + 10, }, { 'call_fake': lambda a, b: 1001, }, ])) values = [ obj.do_math(4, 7), obj.do_math(a=2, b=8), obj.do_math(a=100, b=200), obj.do_math(5, b=9), obj.do_math(a=1, b=1), ] self.assertEqual(values, [11, None, 123, 24, 1001])
def test_assertSpyCalledWith_with_expected_arguments(self): """Testing SpyAgency.assertSpyCalledWith with expected arguments""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) # These should not fail. self.assertSpyCalledWith(obj.do_math, a=1, b=4) self.assertSpyCalledWith(obj.do_math.calls[0], a=1, b=4) self.assertSpyCalledWith(obj.do_math.spy, a=2, b=9) self.assertSpyCalledWith(obj.do_math.spy.calls[1], a=2, b=9) # Check the aliases. self.assert_spy_called_with(obj.do_math, a=1, b=4) kgb.asserts.assert_spy_called_with(obj.do_math, a=1, b=4)
def test_assertSpyReturned_with_expected_return(self): """Testing SpyAgency.assertSpyReturned with expected return value""" obj = MathClass() self.spy_on(obj.do_math) obj.do_math(1, b=4) obj.do_math(2, b=9) # These should not fail. self.assertSpyReturned(obj.do_math, 5) self.assertSpyReturned(obj.do_math.calls[0], 5) self.assertSpyReturned(obj.do_math.spy, 11) self.assertSpyReturned(obj.do_math.spy.calls[1], 11) # Check the aliases. self.assert_spy_returned(obj.do_math, 5) kgb.asserts.assert_spy_returned(obj.do_math, 5)
def test_with_unbound_method(self): """Testing SpyOpReturn with unbound method""" self.agency.spy_on(MathClass.do_math, owner=MathClass, op=SpyOpReturn('abc123')) obj = MathClass() self.assertEqual(obj.do_math(a=4, b=3), 'abc123')
def test_spy_on(self): """Testing SpyAgency mixed in with spy_on""" obj = MathClass() self.spy_on(obj.do_math) self.assertTrue(hasattr(obj.do_math, 'spy')) result = obj.do_math() self.assertEqual(result, 3)
def test_raised_with_message(self): """Testing SpyCall.raised_with_message""" obj = MathClass() self.agency.spy_on(obj.do_math) with self.assertRaises(TypeError): obj.do_math(1, 'a') call = obj.do_math.calls[0] self.assertTrue(call.raised_with_message( TypeError, "unsupported operand type(s) for +: 'int' and '%s'" % text_type.__name__)) self.assertFalse(call.raised_with_message( ValueError, "unsupported operand type(s) for +: 'int' and '%s'" % text_type.__name__)) self.assertFalse(call.raised_with_message(TypeError, None))
def test_assertSpyRaised_without_expected_exception(self): """Testing SpyAgency.assertSpyRaised without expected exception raised """ def _do_math(_self, a, *args, **kwargs): if a == 1: raise KeyError elif a == 2: raise ValueError obj = MathClass() self.spy_on(obj.do_math, call_fake=_do_math) # First test without any exceptions raised try: obj.do_math(1) except KeyError: pass try: obj.do_math(2) except ValueError: pass msg = ('No call to do_math raised AttributeError.\n' '\n' 'The following exceptions have been raised:\n' '\n' 'Call 0:\n' ' KeyError\n' '\n' 'Call 1:\n' ' ValueError') with self._check_assertion(msg): self.assertSpyRaised(obj.do_math, AttributeError) with self._check_assertion(msg): self.assertSpyRaised(obj.do_math.spy, AttributeError) msg = ('This call to do_math did not raise AttributeError. It raised ' 'KeyError.') with self._check_assertion(msg): self.assertSpyRaised(obj.do_math.calls[0], AttributeError)
def test_call_with_original_true_and_bound_method(self): """Testing FunctionSpy calls with call_original=True and bound method""" obj = MathClass() self.agency.spy_on(obj.do_math, call_original=True) result = obj.do_math() self.assertEqual(result, 3) self.assertEqual(len(obj.do_math.calls), 1) self.assertTrue(obj.do_math.last_called_with(a=1, b=2))
def test_with_unexpected_call(self): """Testing SpyOpMatchAny with unexpected call""" obj = MathClass() self.agency.spy_on(obj.do_math, op=SpyOpMatchAny([ { 'kwargs': { 'a': 4, 'b': 7, }, }, ])) expected_message = re.escape( 'do_math was not called with any expected arguments.') with self.assertRaisesRegexp(AssertionError, expected_message): obj.do_math(a=4, b=9)
def test_call_with_original_false(self): """Testing FunctionSpy calls with call_original=False""" obj = MathClass() self.agency.spy_on(obj.do_math, call_original=False) result = obj.do_math() self.assertIsNone(result) self.assertEqual(len(obj.do_math.calls), 1) self.assertTrue(obj.do_math.last_called_with(a=1, b=2))
def test_spy_on(self): """Testing spy_on context manager""" obj = MathClass() with spy_on(obj.do_math): self.assertTrue(hasattr(obj.do_math, 'spy')) result = obj.do_math() self.assertEqual(result, 3) self.assertFalse(hasattr(obj.do_math, 'spy'))
def test_expose_spy(self): """Testing spy_on exposes `spy` via context manager""" obj = MathClass() with spy_on(obj.do_math) as spy: self.assertTrue(hasattr(obj.do_math, 'spy')) self.assertIs(obj.do_math.spy, spy) result = obj.do_math() self.assertEqual(result, 3) self.assertFalse(hasattr(obj.do_math, 'spy'))
def test_call_with_original_true_and_unbound_method_args_for_kwargs(self): """Testing FunctionSpy calls with call_original=True and unbound method with all positional arguments in place of keyword arguments """ self.agency.spy_on(MathClass.do_math, call_original=True) obj = MathClass() result = obj.do_math(10, 20) self.assertEqual(result, 30) self.assertEqual(len(MathClass.do_math.calls), 1) self.assertTrue(MathClass.do_math.last_called_with(a=10, b=20))
def test_call_with_fake_and_unbound_method(self): """Testing FunctionSpy calls with call_fake and unbound method""" self.agency.spy_on(MathClass.do_math, call_fake=fake_do_math) obj = MathClass() result = obj.do_math() self.assertEqual(result, -1) self.assertEqual(len(obj.do_math.calls), 1) self.assertTrue(obj.do_math.last_called_with( a=1, b=2))
def test_call_with_original_false_and_kwargs(self): """Testing FunctionSpy calls with call_original=False and keyword arguments""" obj = MathClass() self.agency.spy_on(obj.do_math, call_original=False) result = obj.do_math(a=10, b=20) self.assertEqual(result, None) self.assertEqual(len(obj.do_math.calls), 1) self.assertEqual(len(obj.do_math.calls[0].args), 0) self.assertEqual(obj.do_math.calls[0].kwargs, { 'a': 10, 'b': 20 })
def test_call_with_fake_and_kwargs(self): """Testing FunctionSpy calls with call_fake and keyword arguments""" obj = MathClass() self.agency.spy_on(obj.do_math, call_fake=fake_do_math) result = obj.do_math(a=10, b=20) print(obj.do_math.calls) self.assertEqual(result, -10) self.assertEqual(len(obj.do_math.calls), 1) self.assertEqual(len(obj.do_math.calls[0].args), 0) self.assertEqual(obj.do_math.calls[0].kwargs, { 'a': 10, 'b': 20, })
def test_call_with_original_true_and_bound_method_kwargs(self): """Testing FunctionSpy calls with call_original=True and bound method with all keyword arguments """ obj = MathClass() self.agency.spy_on(obj.do_math, call_original=True) result = obj.do_math(a=10, b=20) self.assertEqual(result, 30) self.assertEqual(len(obj.do_math.calls), 1) self.assertEqual(len(obj.do_math.calls[0].args), 0) self.assertEqual(obj.do_math.calls[0].kwargs, { 'a': 10, 'b': 20 })
def test_call_with_all_original_false_and_args_for_kwargs(self): """Testing FunctionSpy calls with call_original=False and positional arguments in place of keyword arguments """ obj = MathClass() self.agency.spy_on(obj.do_math, call_original=False) result = obj.do_math(10, 20) self.assertEqual(result, None) self.assertEqual(len(obj.do_math.calls), 1) self.assertEqual(obj.do_math.calls[0].args, ()) self.assertEqual(obj.do_math.calls[0].kwargs, { 'a': 10, 'b': 20, })