1import datetime
2
3import unittest2
4
5
6class Test_Assertions(unittest2.TestCase):
7
8    def test_AlmostEqual(self):
9        self.assertAlmostEqual(1.00000001, 1.0)
10        self.assertNotAlmostEqual(1.0000001, 1.0)
11        self.assertRaises(self.failureException,
12                          self.assertAlmostEqual, 1.0000001, 1.0)
13        self.assertRaises(self.failureException,
14                          self.assertNotAlmostEqual, 1.00000001, 1.0)
15
16        self.assertAlmostEqual(1.1, 1.0, places=0)
17        self.assertRaises(self.failureException,
18                          self.assertAlmostEqual, 1.1, 1.0, places=1)
19
20        self.assertAlmostEqual(0, .1 + .1j, places=0)
21        self.assertNotAlmostEqual(0, .1 + .1j, places=1)
22        self.assertRaises(self.failureException,
23                          self.assertAlmostEqual, 0, .1 + .1j, places=1)
24        self.assertRaises(self.failureException,
25                          self.assertNotAlmostEqual, 0, .1 + .1j, places=0)
26
27        try:
28            self.assertAlmostEqual(float('inf'), float('inf'))
29            self.assertRaises(self.failureException, self.assertNotAlmostEqual,
30                              float('inf'), float('inf'))
31        except ValueError:
32            # float('inf') is invalid on Windows in Python 2.4 / 2.5
33            x = object()
34            self.assertAlmostEqual(x, x)
35            self.assertRaises(self.failureException, self.assertNotAlmostEqual,
36                              x, x)
37
38    def test_AmostEqualWithDelta(self):
39        self.assertAlmostEqual(1.1, 1.0, delta=0.5)
40        self.assertAlmostEqual(1.0, 1.1, delta=0.5)
41        self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
42        self.assertNotAlmostEqual(1.0, 1.1, delta=0.05)
43
44        self.assertRaises(self.failureException, self.assertAlmostEqual,
45                          1.1, 1.0, delta=0.05)
46        self.assertRaises(self.failureException, self.assertNotAlmostEqual,
47                          1.1, 1.0, delta=0.5)
48
49        self.assertRaises(TypeError, self.assertAlmostEqual,
50                          1.1, 1.0, places=2, delta=2)
51        self.assertRaises(TypeError, self.assertNotAlmostEqual,
52                          1.1, 1.0, places=2, delta=2)
53
54        first = datetime.datetime.now()
55        second = first + datetime.timedelta(seconds=10)
56        self.assertAlmostEqual(first, second,
57                               delta=datetime.timedelta(seconds=20))
58        self.assertNotAlmostEqual(first, second,
59                                  delta=datetime.timedelta(seconds=5))
60
61    def testAssertNotRegexpMatches(self):
62        self.assertNotRegexpMatches('Ala ma kota', r'r+')
63        try:
64            self.assertNotRegexpMatches('Ala ma kota', r'k.t', 'Message')
65        except self.failureException as e:
66            self.assertIn("'kot'", e.args[0])
67            self.assertIn('Message', e.args[0])
68        else:
69            self.fail('assertNotRegexpMatches should have failed.')
70
71
72class TestLongMessage(unittest2.TestCase):
73    """Test that the individual asserts honour longMessage.
74    This actually tests all the message behaviour for
75    asserts that use longMessage."""
76
77    def setUp(self):
78        class TestableTestFalse(unittest2.TestCase):
79            longMessage = False
80            failureException = self.failureException
81
82            def testTest(self):
83                pass
84
85        class TestableTestTrue(unittest2.TestCase):
86            longMessage = True
87            failureException = self.failureException
88
89            def testTest(self):
90                pass
91
92        self.testableTrue = TestableTestTrue('testTest')
93        self.testableFalse = TestableTestFalse('testTest')
94
95    def testDefault(self):
96        self.assertTrue(unittest2.TestCase.longMessage)
97
98    def test_formatMsg(self):
99        self.assertEquals(
100            self.testableFalse._formatMessage(
101                None, "foo"), "foo")
102        self.assertEquals(
103            self.testableFalse._formatMessage(
104                "foo", "bar"), "foo")
105
106        self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
107        self.assertEquals(
108            self.testableTrue._formatMessage(
109                "foo", "bar"), "bar : foo")
110
111        # This blows up if _formatMessage uses string concatenation
112        self.testableTrue._formatMessage(object(), 'foo')
113
114    def assertMessages(self, methodName, args, errors):
115        def getMethod(i):
116            useTestableFalse = i < 2
117            if useTestableFalse:
118                test = self.testableFalse
119            else:
120                test = self.testableTrue
121            return getattr(test, methodName)
122
123        for i, expected_regexp in enumerate(errors):
124            testMethod = getMethod(i)
125            kwargs = {}
126            withMsg = i % 2
127            if withMsg:
128                kwargs = {"msg": "oops"}
129
130            self.assertRaisesRegexp(self.failureException,
131                                    expected_regexp,
132                                    lambda: testMethod(*args, **kwargs))
133
134    def testAssertTrue(self):
135        self.assertMessages('assertTrue', (False,),
136                            ["^False is not True$", "^oops$", "^False is not True$",
137                             "^False is not True : oops$"])
138
139    def testAssertFalse(self):
140        self.assertMessages('assertFalse', (True,),
141                            ["^True is not False$", "^oops$", "^True is not False$",
142                             "^True is not False : oops$"])
143
144    def testNotEqual(self):
145        self.assertMessages('assertNotEqual', (1, 1),
146                            ["^1 == 1$", "^oops$", "^1 == 1$",
147                             "^1 == 1 : oops$"])
148
149    def testAlmostEqual(self):
150        self.assertMessages('assertAlmostEqual',
151                            (1,
152                             2),
153                            ["^1 != 2 within 7 places$",
154                             "^oops$",
155                             "^1 != 2 within 7 places$",
156                             "^1 != 2 within 7 places : oops$"])
157
158    def testNotAlmostEqual(self):
159        self.assertMessages('assertNotAlmostEqual',
160                            (1,
161                             1),
162                            ["^1 == 1 within 7 places$",
163                             "^oops$",
164                             "^1 == 1 within 7 places$",
165                             "^1 == 1 within 7 places : oops$"])
166
167    def test_baseAssertEqual(self):
168        self.assertMessages(
169            '_baseAssertEqual', (1, 2), [
170                "^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
171
172    def testAssertSequenceEqual(self):
173        # Error messages are multiline so not testing on full message
174        # assertTupleEqual and assertListEqual delegate to this method
175        self.assertMessages('assertSequenceEqual', ([], [None]),
176                            ["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
177                             r"\+ \[None\] : oops$"])
178
179    def testAssertSetEqual(self):
180        self.assertMessages('assertSetEqual', (set(), set([None])),
181                            ["None$", "^oops$", "None$",
182                             "None : oops$"])
183
184    def testAssertIn(self):
185        self.assertMessages('assertIn', (None, []),
186                            ['^None not found in \[\]$', "^oops$",
187                             '^None not found in \[\]$',
188                             '^None not found in \[\] : oops$'])
189
190    def testAssertNotIn(self):
191        self.assertMessages('assertNotIn', (None, [None]),
192                            ['^None unexpectedly found in \[None\]$', "^oops$",
193                             '^None unexpectedly found in \[None\]$',
194                             '^None unexpectedly found in \[None\] : oops$'])
195
196    def testAssertDictEqual(self):
197        self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
198                            [r"\+ \{'key': 'value'\}$", "^oops$",
199                             "\+ \{'key': 'value'\}$",
200                             "\+ \{'key': 'value'\} : oops$"])
201
202    def testAssertDictContainsSubset(self):
203        self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
204                            ["^Missing: 'key'$", "^oops$",
205                             "^Missing: 'key'$",
206                             "^Missing: 'key' : oops$"])
207
208    def testAssertItemsEqual(self):
209        self.assertMessages('assertItemsEqual', ([], [None]),
210                            [r"\[None\]$", "^oops$",
211                             r"\[None\]$",
212                             r"\[None\] : oops$"])
213
214    def testAssertMultiLineEqual(self):
215        self.assertMessages('assertMultiLineEqual', ("", "foo"),
216                            [r"\+ foo$", "^oops$",
217                             r"\+ foo$",
218                             r"\+ foo : oops$"])
219
220    def testAssertLess(self):
221        self.assertMessages('assertLess', (2, 1),
222                            ["^2 not less than 1$", "^oops$",
223                             "^2 not less than 1$", "^2 not less than 1 : oops$"])
224
225    def testAssertLessEqual(self):
226        self.assertMessages('assertLessEqual', (2, 1),
227                            ["^2 not less than or equal to 1$", "^oops$",
228                             "^2 not less than or equal to 1$",
229                             "^2 not less than or equal to 1 : oops$"])
230
231    def testAssertGreater(self):
232        self.assertMessages('assertGreater', (1, 2),
233                            ["^1 not greater than 2$", "^oops$",
234                             "^1 not greater than 2$",
235                             "^1 not greater than 2 : oops$"])
236
237    def testAssertGreaterEqual(self):
238        self.assertMessages('assertGreaterEqual', (1, 2),
239                            ["^1 not greater than or equal to 2$", "^oops$",
240                             "^1 not greater than or equal to 2$",
241                             "^1 not greater than or equal to 2 : oops$"])
242
243    def testAssertIsNone(self):
244        self.assertMessages('assertIsNone', ('not None',),
245                            ["^'not None' is not None$", "^oops$",
246                             "^'not None' is not None$",
247                             "^'not None' is not None : oops$"])
248
249    def testAssertIsNotNone(self):
250        self.assertMessages('assertIsNotNone', (None,),
251                            ["^unexpectedly None$", "^oops$",
252                             "^unexpectedly None$",
253                             "^unexpectedly None : oops$"])
254
255    def testAssertIs(self):
256        self.assertMessages('assertIs', (None, 'foo'),
257                            ["^None is not 'foo'$", "^oops$",
258                             "^None is not 'foo'$",
259                             "^None is not 'foo' : oops$"])
260
261    def testAssertIsNot(self):
262        self.assertMessages('assertIsNot', (None, None),
263                            ["^unexpectedly identical: None$", "^oops$",
264                             "^unexpectedly identical: None$",
265                             "^unexpectedly identical: None : oops$"])
266
267
268if __name__ == '__main__':
269    unittest2.main()
270