diff --git a/kgb/agency.py b/kgb/agency.py index b1e379f8774a0b9df7fddacb08bab6d1195145f7..8fd80673e34ac6f02ecd31cd61d277039443eab2 100644 --- a/kgb/agency.py +++ b/kgb/agency.py @@ -20,6 +20,11 @@ class SpyAgency(object): Every spy created through this agency will be tracked, and can be later be removed (individually or at once). + Version Changed: + 7.0: + Added ``assert_`` versions of all the assertion methods (e.g., + ``assert_spy_called_with`` as an alias of ``assertSpyCalledWith``. + Attributes: spies (set of kgb.spies.FunctionSpy): All spies currently registered with this agency. @@ -883,3 +888,20 @@ class SpyAgency(object): ] return '\n'.join(lines) + + # snake_case versions of the test functions. + # + # Useful for pytest and other uses. + assert_has_spy = assertHasSpy + assert_spy_called = assertSpyCalled + assert_spy_not_called = assertSpyNotCalled + assert_spy_call_count = assertSpyCallCount + assert_spy_called_with = assertSpyCalledWith + assert_spy_not_called_with = assertSpyNotCalledWith + assert_spy_last_called_with = assertSpyLastCalledWith + assert_spy_returned = assertSpyReturned + assert_spy_last_returned = assertSpyLastReturned + assert_spy_raised = assertSpyRaised + assert_spy_last_raised = assertSpyLastRaised + assert_spy_raised_message = assertSpyRaisedMessage + assert_spy_last_raised_message = assertSpyLastRaisedMessage diff --git a/kgb/asserts.py b/kgb/asserts.py new file mode 100644 index 0000000000000000000000000000000000000000..306e7230f65505205b11a0befd10a6df204a6610 --- /dev/null +++ b/kgb/asserts.py @@ -0,0 +1,23 @@ +"""Independent assertion functions. + +These assertion functions can be used in pytest or in other places where +:py:class:`kgb.SpyAgency` can't be mixed. + +Version Added: + 7.0 +""" + +from __future__ import unicode_literals + +from kgb.agency import SpyAgency + + +_agency = SpyAgency() + +__all__ = [] + + +for name in vars(SpyAgency): + if name.startswith('assert_'): + globals()[name] = getattr(_agency, name) + __all__.append(name) diff --git a/kgb/tests/test_spy_agency.py b/kgb/tests/test_spy_agency.py index 94f58753944a5042e8b6b39b5889e938c044f25c..a53cbe8c7676e49dd18e5ea437b9341fd433f86f 100644 --- a/kgb/tests/test_spy_agency.py +++ b/kgb/tests/test_spy_agency.py @@ -4,6 +4,7 @@ from __future__ import unicode_literals from contextlib import contextmanager +import kgb.asserts from kgb.agency import SpyAgency from kgb.signature import FunctionSig from kgb.tests.base import MathClass, TestCase @@ -131,6 +132,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertHasSpy(MathClass.do_math) self.assertHasSpy(MathClass.do_math.spy) + # Check the aliases. + self.assert_has_spy(MathClass.do_math) + kgb.asserts.assert_has_spy(MathClass.do_math) + def test_assertHasSpy_without_spy(self): """Testing SpyAgency.assertHasSpy without spy""" with self._check_assertion('do_math has not been spied on.'): @@ -147,6 +152,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyCalled(obj.do_math) self.assertSpyCalled(obj.do_math.spy) + # Check the aliases. + self.assert_spy_called(obj.do_math) + kgb.asserts.assert_spy_called(obj.do_math) + def test_assertSpyCalled_without_called(self): """Testing SpyAgency.assertSpyCalled without spy called""" obj = MathClass() @@ -169,6 +178,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyNotCalled(obj.do_math) self.assertSpyNotCalled(obj.do_math.spy) + # Check the aliases. + self.assert_spy_not_called(obj.do_math) + kgb.asserts.assert_spy_not_called(obj.do_math) + def test_assertSpyNotCalled_with_called(self): """Testing SpyAgency.assertSpyNotCalled with spy called""" obj = MathClass() @@ -207,6 +220,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyCallCount(obj.do_math, 2) self.assertSpyCallCount(obj.do_math.spy, 2) + # Check the aliases. + self.assert_spy_call_count(obj.do_math, 2) + kgb.asserts.assert_spy_call_count(obj.do_math, 2) + def test_assertSpyCallCount_without_expected_count(self): """Testing SpyAgency.assertSpyCallCount without expected call count""" obj = MathClass() @@ -237,6 +254,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): 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_assertSpyCalledWith_without_expected_arguments(self): """Testing SpyAgency.assertSpyCalledWith without expected arguments""" obj = MathClass() @@ -293,6 +314,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyNotCalledWith(obj.do_math.spy, a=1, b=9) self.assertSpyNotCalledWith(obj.do_math.spy.calls[1], a=1, b=9) + # Check the aliases. + self.assert_spy_not_called_with(obj.do_math, a=1, b=3) + kgb.asserts.assert_spy_not_called_with(obj.do_math, a=1, b=3) + def test_assertSpyNotCalledWith_without_unexpected_arguments(self): """Testing SpyAgency.assertSpyNotCalledWith without unexpected arguments @@ -344,6 +369,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyLastCalledWith(obj.do_math, a=2, b=9) self.assertSpyLastCalledWith(obj.do_math.spy, a=2, b=9) + # Check the aliases. + self.assert_spy_last_called_with(obj.do_math, a=2, b=9) + kgb.asserts.assert_spy_last_called_with(obj.do_math, a=2, b=9) + def test_assertSpyLastCalledWith_without_expected_arguments(self): """Testing SpyAgency.assertSpyLastCalledWith without expected arguments @@ -384,6 +413,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): 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_assertSpyReturned_without_expected_return(self): """Testing SpyAgency.assertSpyReturned without expected return value""" obj = MathClass() @@ -434,6 +467,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyLastReturned(obj.do_math, 11) self.assertSpyLastReturned(obj.do_math.spy, 11) + # Check the aliases. + self.assert_spy_last_returned(obj.do_math, 11) + kgb.asserts.assert_spy_last_returned(obj.do_math, 11) + def test_assertSpyLastReturned_without_expected_return(self): """Testing SpyAgency.assertSpyLastReturned without expected return value @@ -485,6 +522,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyRaised(obj.do_math.spy, ValueError) self.assertSpyRaised(obj.do_math.spy.calls[1], ValueError) + # Check the aliases. + self.assert_spy_raised(obj.do_math, KeyError) + kgb.asserts.assert_spy_raised(obj.do_math, KeyError) + def test_assertSpyRaised_with_expected_no_exception(self): """Testing SpyAgency.assertSpyRaised with expected completions without exceptions @@ -599,6 +640,10 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyLastRaised(obj.do_math, ValueError) self.assertSpyLastRaised(obj.do_math.spy, ValueError) + # Check the aliases. + self.assert_spy_last_raised(obj.do_math, ValueError) + kgb.asserts.assert_spy_last_raised(obj.do_math, ValueError) + def test_assertSpyLastRaised_with_expected_no_exception(self): """Testing SpyAgency.assertSpyLastRaised with expected completion without raising @@ -694,6 +739,11 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyRaisedMessage(obj.do_math.spy.calls[1], ValueError, 'Bad value!') + # Check the aliases. + self.assert_spy_raised_message(obj.do_math, AttributeError, 'Bad key!') + kgb.asserts.assert_spy_raised_message(obj.do_math, AttributeError, + 'Bad key!') + def test_assertSpyRaisedMessage_without_expected(self): """Testing SpyAgency.assertSpyRaisedMessage without expected exception and message raised @@ -802,9 +852,15 @@ class TestCaseMixinTests(SpyAgency, TestCase): self.assertSpyLastRaisedMessage(obj.do_math.spy, ValueError, 'Bad value!') + # Check the aliases. + self.assert_spy_last_raised_message(obj.do_math, ValueError, + 'Bad value!') + kgb.asserts.assert_spy_last_raised_message(obj.do_math, ValueError, + 'Bad value!') + def test_assertSpyLastRaisedMessage_without_expected(self): - """Testing SpyAgency.assertSpyLastRaisedMessage without expected exception - and message raised + """Testing SpyAgency.assertSpyLastRaisedMessage without expected + exception and message raised """ def _do_math(_self, a, *args, **kwargs): if a == 1: @@ -847,7 +903,8 @@ class TestCaseMixinTests(SpyAgency, TestCase): 'Bad key!') def test_assertSpyLastRaisedMessage_without_raised(self): - """Testing SpyAgency.assertSpyLastRaisedMessage without exception raised + """Testing SpyAgency.assertSpyLastRaisedMessage without exception + raised """ obj = MathClass() self.spy_on(obj.do_math)