1import datetime
2
3import unittest2
4
5
6class Test_Assertions(unittest2.TestCase):
7    def test_AlmostEqual(self):
8        self.assertAlmostEqual(1.00000001, 1.0)
9        self.assertNotAlmostEqual(1.0000001, 1.0)
10        self.assertRaises(self.failureException,
11                          self.assertAlmostEqual, 1.0000001, 1.0)
12        self.assertRaises(self.failureException,
13                          self.assertNotAlmostEqual, 1.00000001, 1.0)
14
15        self.assertAlmostEqual(1.1, 1.0, places=0)
16        self.assertRaises(self.failureException,
17                          self.assertAlmostEqual, 1.1, 1.0, places=1)
18
19        self.assertAlmostEqual(0, .1+.1j, places=0)
20        self.assertNotAlmostEqual(0, .1+.1j, places=1)
21        self.assertRaises(self.failureException,
22                          self.assertAlmostEqual, 0, .1+.1j, places=1)
23        self.assertRaises(self.failureException,
24                          self.assertNotAlmostEqual, 0, .1+.1j, places=0)
25
26        try:
27            self.assertAlmostEqual(float('inf'), float('inf'))
28            self.assertRaises(self.failureException, self.assertNotAlmostEqual,
29                              float('inf'), float('inf'))
30        except ValueError:
31            # float('inf') is invalid on Windows in Python 2.4 / 2.5
32            x = object()
33            self.assertAlmostEqual(x, x)
34            self.assertRaises(self.failureException, self.assertNotAlmostEqual,
35                              x, x)
36
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, 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(self.testableFalse._formatMessage(None, "foo"), "foo")
100        self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo")
101
102        self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
103        self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
104
105        # This blows up if _formatMessage uses string concatenation
106        self.testableTrue._formatMessage(object(), 'foo')
107
108    def assertMessages(self, methodName, args, errors):
109        def getMethod(i):
110            useTestableFalse  = i < 2
111            if useTestableFalse:
112                test = self.testableFalse
113            else:
114                test = self.testableTrue
115            return getattr(test, methodName)
116
117        for i, expected_regexp in enumerate(errors):
118            testMethod = getMethod(i)
119            kwargs = {}
120            withMsg = i % 2
121            if withMsg:
122                kwargs = {"msg": "oops"}
123
124            self.assertRaisesRegexp(self.failureException,
125                                    expected_regexp,
126                                    lambda: testMethod(*args, **kwargs))
127
128    def testAssertTrue(self):
129        self.assertMessages('assertTrue', (False,),
130                            ["^False is not True$", "^oops$", "^False is not True$",
131                             "^False is not True : oops$"])
132
133    def testAssertFalse(self):
134        self.assertMessages('assertFalse', (True,),
135                            ["^True is not False$", "^oops$", "^True is not False$",
136                             "^True is not False : oops$"])
137
138    def testNotEqual(self):
139        self.assertMessages('assertNotEqual', (1, 1),
140                            ["^1 == 1$", "^oops$", "^1 == 1$",
141                             "^1 == 1 : oops$"])
142
143    def testAlmostEqual(self):
144        self.assertMessages('assertAlmostEqual', (1, 2),
145                            ["^1 != 2 within 7 places$", "^oops$",
146                             "^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"])
147
148    def testNotAlmostEqual(self):
149        self.assertMessages('assertNotAlmostEqual', (1, 1),
150                            ["^1 == 1 within 7 places$", "^oops$",
151                             "^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"])
152
153    def test_baseAssertEqual(self):
154        self.assertMessages('_baseAssertEqual', (1, 2),
155                            ["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
156
157    def testAssertSequenceEqual(self):
158        # Error messages are multiline so not testing on full message
159        # assertTupleEqual and assertListEqual delegate to this method
160        self.assertMessages('assertSequenceEqual', ([], [None]),
161                            ["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
162                             r"\+ \[None\] : oops$"])
163
164    def testAssertSetEqual(self):
165        self.assertMessages('assertSetEqual', (set(), set([None])),
166                            ["None$", "^oops$", "None$",
167                             "None : oops$"])
168
169    def testAssertIn(self):
170        self.assertMessages('assertIn', (None, []),
171                            ['^None not found in \[\]$', "^oops$",
172                             '^None not found in \[\]$',
173                             '^None not found in \[\] : oops$'])
174
175    def testAssertNotIn(self):
176        self.assertMessages('assertNotIn', (None, [None]),
177                            ['^None unexpectedly found in \[None\]$', "^oops$",
178                             '^None unexpectedly found in \[None\]$',
179                             '^None unexpectedly found in \[None\] : oops$'])
180
181    def testAssertDictEqual(self):
182        self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
183                            [r"\+ \{'key': 'value'\}$", "^oops$",
184                             "\+ \{'key': 'value'\}$",
185                             "\+ \{'key': 'value'\} : oops$"])
186
187    def testAssertDictContainsSubset(self):
188        self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
189                            ["^Missing: 'key'$", "^oops$",
190                             "^Missing: 'key'$",
191                             "^Missing: 'key' : oops$"])
192
193    def testAssertItemsEqual(self):
194        self.assertMessages('assertItemsEqual', ([], [None]),
195                            [r"\[None\]$", "^oops$",
196                             r"\[None\]$",
197                             r"\[None\] : oops$"])
198
199    def testAssertMultiLineEqual(self):
200        self.assertMessages('assertMultiLineEqual', ("", "foo"),
201                            [r"\+ foo$", "^oops$",
202                             r"\+ foo$",
203                             r"\+ foo : oops$"])
204
205    def testAssertLess(self):
206        self.assertMessages('assertLess', (2, 1),
207                            ["^2 not less than 1$", "^oops$",
208                             "^2 not less than 1$", "^2 not less than 1 : oops$"])
209
210    def testAssertLessEqual(self):
211        self.assertMessages('assertLessEqual', (2, 1),
212                            ["^2 not less than or equal to 1$", "^oops$",
213                             "^2 not less than or equal to 1$",
214                             "^2 not less than or equal to 1 : oops$"])
215
216    def testAssertGreater(self):
217        self.assertMessages('assertGreater', (1, 2),
218                            ["^1 not greater than 2$", "^oops$",
219                             "^1 not greater than 2$",
220                             "^1 not greater than 2 : oops$"])
221
222    def testAssertGreaterEqual(self):
223        self.assertMessages('assertGreaterEqual', (1, 2),
224                            ["^1 not greater than or equal to 2$", "^oops$",
225                             "^1 not greater than or equal to 2$",
226                             "^1 not greater than or equal to 2 : oops$"])
227
228    def testAssertIsNone(self):
229        self.assertMessages('assertIsNone', ('not None',),
230                            ["^'not None' is not None$", "^oops$",
231                             "^'not None' is not None$",
232                             "^'not None' is not None : oops$"])
233
234    def testAssertIsNotNone(self):
235        self.assertMessages('assertIsNotNone', (None,),
236                            ["^unexpectedly None$", "^oops$",
237                             "^unexpectedly None$",
238                             "^unexpectedly None : oops$"])
239
240    def testAssertIs(self):
241        self.assertMessages('assertIs', (None, 'foo'),
242                            ["^None is not 'foo'$", "^oops$",
243                             "^None is not 'foo'$",
244                             "^None is not 'foo' : oops$"])
245
246    def testAssertIsNot(self):
247        self.assertMessages('assertIsNot', (None, None),
248                            ["^unexpectedly identical: None$", "^oops$",
249                             "^unexpectedly identical: None$",
250                             "^unexpectedly identical: None : oops$"])
251
252
253if __name__ == '__main__':
254    unittest2.main()
255