testtools: Merge in new upstream.
[nivanova/samba-autobuild/.git] / lib / testtools / testtools / tests / test_matchers.py
1 # Copyright (c) 2008-2010 Jonathan M. Lange. See LICENSE for details.
2
3 """Tests for matchers."""
4
5 import doctest
6 import sys
7
8 from testtools import (
9     Matcher, # check that Matcher is exposed at the top level for docs.
10     TestCase,
11     )
12 from testtools.matchers import (
13     Annotate,
14     Equals,
15     DocTestMatches,
16     DoesNotEndWith,
17     DoesNotStartWith,
18     EndsWith,
19     KeysEqual,
20     Is,
21     LessThan,
22     MatchesAny,
23     MatchesAll,
24     MatchesException,
25     Mismatch,
26     Not,
27     NotEquals,
28     Raises,
29     raises,
30     StartsWith,
31     )
32
33 # Silence pyflakes.
34 Matcher
35
36
37 class TestMismatch(TestCase):
38
39     def test_constructor_arguments(self):
40         mismatch = Mismatch("some description", {'detail': "things"})
41         self.assertEqual("some description", mismatch.describe())
42         self.assertEqual({'detail': "things"}, mismatch.get_details())
43
44     def test_constructor_no_arguments(self):
45         mismatch = Mismatch()
46         self.assertThat(mismatch.describe,
47             Raises(MatchesException(NotImplementedError)))
48         self.assertEqual({}, mismatch.get_details())
49
50
51 class TestMatchersInterface(object):
52
53     def test_matches_match(self):
54         matcher = self.matches_matcher
55         matches = self.matches_matches
56         mismatches = self.matches_mismatches
57         for candidate in matches:
58             self.assertEqual(None, matcher.match(candidate))
59         for candidate in mismatches:
60             mismatch = matcher.match(candidate)
61             self.assertNotEqual(None, mismatch)
62             self.assertNotEqual(None, getattr(mismatch, 'describe', None))
63
64     def test__str__(self):
65         # [(expected, object to __str__)].
66         examples = self.str_examples
67         for expected, matcher in examples:
68             self.assertThat(matcher, DocTestMatches(expected))
69
70     def test_describe_difference(self):
71         # [(expected, matchee, matcher), ...]
72         examples = self.describe_examples
73         for difference, matchee, matcher in examples:
74             mismatch = matcher.match(matchee)
75             self.assertEqual(difference, mismatch.describe())
76
77     def test_mismatch_details(self):
78         # The mismatch object must provide get_details, which must return a
79         # dictionary mapping names to Content objects.
80         examples = self.describe_examples
81         for difference, matchee, matcher in examples:
82             mismatch = matcher.match(matchee)
83             details = mismatch.get_details()
84             self.assertEqual(dict(details), details)
85
86
87 class TestDocTestMatchesInterface(TestCase, TestMatchersInterface):
88
89     matches_matcher = DocTestMatches("Ran 1 test in ...s", doctest.ELLIPSIS)
90     matches_matches = ["Ran 1 test in 0.000s", "Ran 1 test in 1.234s"]
91     matches_mismatches = ["Ran 1 tests in 0.000s", "Ran 2 test in 0.000s"]
92
93     str_examples = [("DocTestMatches('Ran 1 test in ...s\\n')",
94         DocTestMatches("Ran 1 test in ...s")),
95         ("DocTestMatches('foo\\n', flags=8)", DocTestMatches("foo", flags=8)),
96         ]
97
98     describe_examples = [('Expected:\n    Ran 1 tests in ...s\nGot:\n'
99         '    Ran 1 test in 0.123s\n', "Ran 1 test in 0.123s",
100         DocTestMatches("Ran 1 tests in ...s", doctest.ELLIPSIS))]
101
102
103 class TestDocTestMatchesSpecific(TestCase):
104
105     def test___init__simple(self):
106         matcher = DocTestMatches("foo")
107         self.assertEqual("foo\n", matcher.want)
108
109     def test___init__flags(self):
110         matcher = DocTestMatches("bar\n", doctest.ELLIPSIS)
111         self.assertEqual("bar\n", matcher.want)
112         self.assertEqual(doctest.ELLIPSIS, matcher.flags)
113
114
115 class TestEqualsInterface(TestCase, TestMatchersInterface):
116
117     matches_matcher = Equals(1)
118     matches_matches = [1]
119     matches_mismatches = [2]
120
121     str_examples = [("Equals(1)", Equals(1)), ("Equals('1')", Equals('1'))]
122
123     describe_examples = [("1 != 2", 2, Equals(1))]
124
125
126 class TestNotEqualsInterface(TestCase, TestMatchersInterface):
127
128     matches_matcher = NotEquals(1)
129     matches_matches = [2]
130     matches_mismatches = [1]
131
132     str_examples = [
133         ("NotEquals(1)", NotEquals(1)), ("NotEquals('1')", NotEquals('1'))]
134
135     describe_examples = [("1 == 1", 1, NotEquals(1))]
136
137
138 class TestIsInterface(TestCase, TestMatchersInterface):
139
140     foo = object()
141     bar = object()
142
143     matches_matcher = Is(foo)
144     matches_matches = [foo]
145     matches_mismatches = [bar, 1]
146
147     str_examples = [("Is(2)", Is(2))]
148
149     describe_examples = [("1 is not 2", 2, Is(1))]
150
151
152 class TestLessThanInterface(TestCase, TestMatchersInterface):
153
154     matches_matcher = LessThan(4)
155     matches_matches = [-5, 3]
156     matches_mismatches = [4, 5, 5000]
157
158     str_examples = [
159         ("LessThan(12)", LessThan(12)),
160         ]
161
162     describe_examples = [('4 is >= 4', 4, LessThan(4))]
163
164
165 def make_error(type, *args, **kwargs):
166     try:
167         raise type(*args, **kwargs)
168     except type:
169         return sys.exc_info()
170
171
172 class TestMatchesExceptionInstanceInterface(TestCase, TestMatchersInterface):
173
174     matches_matcher = MatchesException(ValueError("foo"))
175     error_foo = make_error(ValueError, 'foo')
176     error_bar = make_error(ValueError, 'bar')
177     error_base_foo = make_error(Exception, 'foo')
178     matches_matches = [error_foo]
179     matches_mismatches = [error_bar, error_base_foo]
180
181     str_examples = [
182         ("MatchesException(Exception('foo',))",
183          MatchesException(Exception('foo')))
184         ]
185     describe_examples = [
186         ("%r is not a %r" % (Exception, ValueError),
187          error_base_foo,
188          MatchesException(ValueError("foo"))),
189         ("ValueError('bar',) has different arguments to ValueError('foo',).",
190          error_bar,
191          MatchesException(ValueError("foo"))),
192         ]
193
194
195 class TestMatchesExceptionTypeInterface(TestCase, TestMatchersInterface):
196
197     matches_matcher = MatchesException(ValueError)
198     error_foo = make_error(ValueError, 'foo')
199     error_sub = make_error(UnicodeError, 'bar')
200     error_base_foo = make_error(Exception, 'foo')
201     matches_matches = [error_foo, error_sub]
202     matches_mismatches = [error_base_foo]
203
204     str_examples = [
205         ("MatchesException(%r)" % Exception,
206          MatchesException(Exception))
207         ]
208     describe_examples = [
209         ("%r is not a %r" % (Exception, ValueError),
210          error_base_foo,
211          MatchesException(ValueError)),
212         ]
213
214
215 class TestNotInterface(TestCase, TestMatchersInterface):
216
217     matches_matcher = Not(Equals(1))
218     matches_matches = [2]
219     matches_mismatches = [1]
220
221     str_examples = [
222         ("Not(Equals(1))", Not(Equals(1))),
223         ("Not(Equals('1'))", Not(Equals('1')))]
224
225     describe_examples = [('1 matches Equals(1)', 1, Not(Equals(1)))]
226
227
228 class TestMatchersAnyInterface(TestCase, TestMatchersInterface):
229
230     matches_matcher = MatchesAny(DocTestMatches("1"), DocTestMatches("2"))
231     matches_matches = ["1", "2"]
232     matches_mismatches = ["3"]
233
234     str_examples = [(
235         "MatchesAny(DocTestMatches('1\\n'), DocTestMatches('2\\n'))",
236         MatchesAny(DocTestMatches("1"), DocTestMatches("2"))),
237         ]
238
239     describe_examples = [("""Differences: [
240 Expected:
241     1
242 Got:
243     3
244
245 Expected:
246     2
247 Got:
248     3
249
250 ]""",
251         "3", MatchesAny(DocTestMatches("1"), DocTestMatches("2")))]
252
253
254 class TestMatchesAllInterface(TestCase, TestMatchersInterface):
255
256     matches_matcher = MatchesAll(NotEquals(1), NotEquals(2))
257     matches_matches = [3, 4]
258     matches_mismatches = [1, 2]
259
260     str_examples = [
261         ("MatchesAll(NotEquals(1), NotEquals(2))",
262          MatchesAll(NotEquals(1), NotEquals(2)))]
263
264     describe_examples = [("""Differences: [
265 1 == 1
266 ]""",
267                           1, MatchesAll(NotEquals(1), NotEquals(2)))]
268
269
270 class TestKeysEqual(TestCase, TestMatchersInterface):
271
272     matches_matcher = KeysEqual('foo', 'bar')
273     matches_matches = [
274         {'foo': 0, 'bar': 1},
275         ]
276     matches_mismatches = [
277         {},
278         {'foo': 0},
279         {'bar': 1},
280         {'foo': 0, 'bar': 1, 'baz': 2},
281         {'a': None, 'b': None, 'c': None},
282         ]
283
284     str_examples = [
285         ("KeysEqual('foo', 'bar')", KeysEqual('foo', 'bar')),
286         ]
287
288     describe_examples = [
289         ("['bar', 'foo'] does not match {'baz': 2, 'foo': 0, 'bar': 1}: "
290          "Keys not equal",
291          {'foo': 0, 'bar': 1, 'baz': 2}, KeysEqual('foo', 'bar')),
292         ]
293
294
295 class TestAnnotate(TestCase, TestMatchersInterface):
296
297     matches_matcher = Annotate("foo", Equals(1))
298     matches_matches = [1]
299     matches_mismatches = [2]
300
301     str_examples = [
302         ("Annotate('foo', Equals(1))", Annotate("foo", Equals(1)))]
303
304     describe_examples = [("1 != 2: foo", 2, Annotate('foo', Equals(1)))]
305
306
307 class TestRaisesInterface(TestCase, TestMatchersInterface):
308
309     matches_matcher = Raises()
310     def boom():
311         raise Exception('foo')
312     matches_matches = [boom]
313     matches_mismatches = [lambda:None]
314
315     # Tricky to get function objects to render constantly, and the interfaces
316     # helper uses assertEqual rather than (for instance) DocTestMatches.
317     str_examples = []
318
319     describe_examples = []
320
321
322 class TestRaisesExceptionMatcherInterface(TestCase, TestMatchersInterface):
323
324     matches_matcher = Raises(
325         exception_matcher=MatchesException(Exception('foo')))
326     def boom_bar():
327         raise Exception('bar')
328     def boom_foo():
329         raise Exception('foo')
330     matches_matches = [boom_foo]
331     matches_mismatches = [lambda:None, boom_bar]
332
333     # Tricky to get function objects to render constantly, and the interfaces
334     # helper uses assertEqual rather than (for instance) DocTestMatches.
335     str_examples = []
336
337     describe_examples = []
338
339
340 class TestRaisesBaseTypes(TestCase):
341
342     def raiser(self):
343         raise KeyboardInterrupt('foo')
344
345     def test_KeyboardInterrupt_matched(self):
346         # When KeyboardInterrupt is matched, it is swallowed.
347         matcher = Raises(MatchesException(KeyboardInterrupt))
348         self.assertThat(self.raiser, matcher)
349
350     def test_KeyboardInterrupt_propogates(self):
351         # The default 'it raised' propogates KeyboardInterrupt.
352         match_keyb = Raises(MatchesException(KeyboardInterrupt))
353         def raise_keyb_from_match():
354             matcher = Raises()
355             matcher.match(self.raiser)
356         self.assertThat(raise_keyb_from_match, match_keyb)
357
358     def test_KeyboardInterrupt_match_Exception_propogates(self):
359         # If the raised exception isn't matched, and it is not a subclass of
360         # Exception, it is propogated.
361         match_keyb = Raises(MatchesException(KeyboardInterrupt))
362         def raise_keyb_from_match():
363             if sys.version_info > (2, 5):
364                 matcher = Raises(MatchesException(Exception))
365             else:
366                 # On Python 2.4 KeyboardInterrupt is a StandardError subclass
367                 # but should propogate from less generic exception matchers
368                 matcher = Raises(MatchesException(EnvironmentError))
369             matcher.match(self.raiser)
370         self.assertThat(raise_keyb_from_match, match_keyb)
371
372
373 class TestRaisesConvenience(TestCase):
374
375     def test_exc_type(self):
376         self.assertThat(lambda: 1/0, raises(ZeroDivisionError))
377
378     def test_exc_value(self):
379         e = RuntimeError("You lose!")
380         def raiser():
381             raise e
382         self.assertThat(raiser, raises(e))
383
384
385 class DoesNotStartWithTests(TestCase):
386
387     def test_describe(self):
388         mismatch = DoesNotStartWith("fo", "bo")
389         self.assertEqual("'fo' does not start with 'bo'.", mismatch.describe())
390
391
392 class StartsWithTests(TestCase):
393
394     def test_str(self):
395         matcher = StartsWith("bar")
396         self.assertEqual("Starts with 'bar'.", str(matcher))
397
398     def test_match(self):
399         matcher = StartsWith("bar")
400         self.assertIs(None, matcher.match("barf"))
401
402     def test_mismatch_returns_does_not_start_with(self):
403         matcher = StartsWith("bar")
404         self.assertIsInstance(matcher.match("foo"), DoesNotStartWith)
405
406     def test_mismatch_sets_matchee(self):
407         matcher = StartsWith("bar")
408         mismatch = matcher.match("foo")
409         self.assertEqual("foo", mismatch.matchee)
410
411     def test_mismatch_sets_expected(self):
412         matcher = StartsWith("bar")
413         mismatch = matcher.match("foo")
414         self.assertEqual("bar", mismatch.expected)
415
416
417 class DoesNotEndWithTests(TestCase):
418
419     def test_describe(self):
420         mismatch = DoesNotEndWith("fo", "bo")
421         self.assertEqual("'fo' does not end with 'bo'.", mismatch.describe())
422
423
424 class EndsWithTests(TestCase):
425
426     def test_str(self):
427         matcher = EndsWith("bar")
428         self.assertEqual("Ends with 'bar'.", str(matcher))
429
430     def test_match(self):
431         matcher = EndsWith("arf")
432         self.assertIs(None, matcher.match("barf"))
433
434     def test_mismatch_returns_does_not_end_with(self):
435         matcher = EndsWith("bar")
436         self.assertIsInstance(matcher.match("foo"), DoesNotEndWith)
437
438     def test_mismatch_sets_matchee(self):
439         matcher = EndsWith("bar")
440         mismatch = matcher.match("foo")
441         self.assertEqual("foo", mismatch.matchee)
442
443     def test_mismatch_sets_expected(self):
444         matcher = EndsWith("bar")
445         mismatch = matcher.match("foo")
446         self.assertEqual("bar", mismatch.expected)
447
448
449 def test_suite():
450     from unittest import TestLoader
451     return TestLoader().loadTestsFromName(__name__)