diff options
Diffstat (limited to 'tests/test_testing.py')
-rw-r--r-- | tests/test_testing.py | 192 |
1 files changed, 192 insertions, 0 deletions
diff --git a/tests/test_testing.py b/tests/test_testing.py new file mode 100644 index 00000000..c2d1453d --- /dev/null +++ b/tests/test_testing.py @@ -0,0 +1,192 @@ +# -*- coding: utf-8 -*- +"""Tests that our test infrastructure is really working!""" + +import os, sys +from coverage.backward import to_bytes, rpartition +from test.backunittest import TestCase +from test.coveragetest import CoverageTest + +from coverage.backward import set # pylint: disable=W0622 + +class TestingTest(TestCase): + """Tests of helper methods on `backunittest.TestCase`.""" + + run_in_temp_dir = False + + def please_raise(self, exc, msg): + """Raise an exception for testing assertRaisesRegexp.""" + raise exc(msg) + + def please_succeed(self): + """A simple successful method for testing assertRaisesRegexp.""" + return "All is well" + + def test_assert_same_elements(self): + self.assertSameElements(set(), set()) + self.assertSameElements(set([1,2,3]), set([3,1,2])) + self.assertRaises(AssertionError, self.assertSameElements, + set([1,2,3]), set() + ) + self.assertRaises(AssertionError, self.assertSameElements, + set([1,2,3]), set([4,5,6]) + ) + + def test_assert_regexp_matches(self): + self.assertRegexpMatches("hello", "hel*o") + self.assertRegexpMatches("Oh, hello there!", "hel*o") + self.assertRaises(AssertionError, self.assertRegexpMatches, + "hello there", "^hello$" + ) + + def test_assert_multiline_equal(self): + self.assertMultiLineEqual("hello", "hello") + self.assertRaises(AssertionError, self.assertMultiLineEqual, + "hello there", "Hello there" + ) + self.assertRaises(AssertionError, self.assertMultiLineEqual, + "hello\nthere", "hello\nThere" + ) + # With messages also. + self.assertMultiLineEqual("hi", "hi", "it's ok") + self.assertRaisesRegexp( + AssertionError, "my message", + self.assertMultiLineEqual, "xyz", "abc", "my message" + ) + + def test_assert_raises_regexp(self): + # Raising the right error with the right message passes. + self.assertRaisesRegexp( + ZeroDivisionError, "Wow! Zero!", + self.please_raise, ZeroDivisionError, "Wow! Zero!" + ) + # Raising the right error with a match passes. + self.assertRaisesRegexp( + ZeroDivisionError, "Zero", + self.please_raise, ZeroDivisionError, "Wow! Zero!" + ) + # Raising the right error with a mismatch fails. + self.assertRaises(AssertionError, + self.assertRaisesRegexp, ZeroDivisionError, "XYZ", + self.please_raise, ZeroDivisionError, "Wow! Zero!" + ) + # Raising the right error with a mismatch fails. + self.assertRaises(AssertionError, + self.assertRaisesRegexp, ZeroDivisionError, "XYZ", + self.please_raise, ZeroDivisionError, "Wow! Zero!" + ) + # Raising the wrong error raises the error itself. + self.assertRaises(ZeroDivisionError, + self.assertRaisesRegexp, IOError, "Wow! Zero!", + self.please_raise, ZeroDivisionError, "Wow! Zero!" + ) + # Raising no error fails. + self.assertRaises(AssertionError, + self.assertRaisesRegexp, ZeroDivisionError, "XYZ", + self.please_succeed + ) + + def test_assert_true(self): + self.assertTrue(True) + self.assertRaises(AssertionError, self.assertTrue, False) + + def test_assert_false(self): + self.assertFalse(False) + self.assertRaises(AssertionError, self.assertFalse, True) + + def test_assert_in(self): + self.assertIn("abc", "hello abc") + self.assertIn("abc", ["xyz", "abc", "foo"]) + self.assertIn("abc", {'abc': 1, 'xyz': 2}) + self.assertRaises(AssertionError, self.assertIn, "abc", "xyz") + self.assertRaises(AssertionError, self.assertIn, "abc", ["x", "xabc"]) + self.assertRaises(AssertionError, self.assertIn, "abc", {'x':'abc'}) + + def test_assert_not_in(self): + self.assertRaises(AssertionError, self.assertNotIn, "abc", "hello abc") + self.assertRaises(AssertionError, + self.assertNotIn, "abc", ["xyz", "abc", "foo"] + ) + self.assertRaises(AssertionError, + self.assertNotIn, "abc", {'abc': 1, 'xyz': 2} + ) + self.assertNotIn("abc", "xyz") + self.assertNotIn("abc", ["x", "xabc"]) + self.assertNotIn("abc", {'x':'abc'}) + + def test_assert_greater(self): + self.assertGreater(10, 9) + self.assertGreater("xyz", "abc") + self.assertRaises(AssertionError, self.assertGreater, 9, 10) + self.assertRaises(AssertionError, self.assertGreater, 10, 10) + self.assertRaises(AssertionError, self.assertGreater, "abc", "xyz") + self.assertRaises(AssertionError, self.assertGreater, "xyz", "xyz") + + +class CoverageTestTest(CoverageTest): + """Test the methods in `CoverageTest`.""" + + def file_text(self, fname): + """Return the text read from a file.""" + return open(fname, "rb").read().decode('ascii') + + def test_make_file(self): + # A simple file. + self.make_file("fooey.boo", "Hello there") + self.assertEqual(open("fooey.boo").read(), "Hello there") + # A file in a sub-directory + self.make_file("sub/another.txt", "Another") + self.assertEqual(open("sub/another.txt").read(), "Another") + # A second file in that sub-directory + self.make_file("sub/second.txt", "Second") + self.assertEqual(open("sub/second.txt").read(), "Second") + # A deeper directory + self.make_file("sub/deeper/evenmore/third.txt") + self.assertEqual(open("sub/deeper/evenmore/third.txt").read(), "") + + def test_make_file_newline(self): + self.make_file("unix.txt", "Hello\n") + self.assertEqual(self.file_text("unix.txt"), "Hello\n") + self.make_file("dos.txt", "Hello\n", newline="\r\n") + self.assertEqual(self.file_text("dos.txt"), "Hello\r\n") + self.make_file("mac.txt", "Hello\n", newline="\r") + self.assertEqual(self.file_text("mac.txt"), "Hello\r") + + def test_make_file_non_ascii(self): + self.make_file("unicode.txt", "tabblo: «ταБЬℓσ»") + self.assertEqual( + open("unicode.txt", "rb").read(), + to_bytes("tabblo: «ταБЬℓσ»") + ) + + def test_file_exists(self): + self.make_file("whoville.txt", "We are here!") + self.assert_exists("whoville.txt") + self.assert_doesnt_exist("shadow.txt") + self.assertRaises( + AssertionError, self.assert_doesnt_exist, "whoville.txt" + ) + self.assertRaises(AssertionError, self.assert_exists, "shadow.txt") + + def test_sub_python_is_this_python(self): + # Try it with a python command. + os.environ['COV_FOOBAR'] = 'XYZZY' + self.make_file("showme.py", """\ + import os, sys + print(sys.executable) + print(os.__file__) + print(os.environ['COV_FOOBAR']) + """) + out = self.run_command("python showme.py").splitlines() + self.assertEqual(out[0], sys.executable) + self.assertEqual(out[1], os.__file__) + self.assertEqual(out[2], 'XYZZY') + + # Try it with a "coverage debug sys" command. + out = self.run_command("coverage debug sys").splitlines() + # "environment: COV_FOOBAR = XYZZY" or "COV_FOOBAR = XYZZY" + executable = [l for l in out if "executable:" in l][0] + executable = executable.split(":", 1)[1].strip() + self.assertEqual(executable, sys.executable) + environ = [l for l in out if "COV_FOOBAR" in l][0] + _, _, environ = rpartition(environ, ":") + self.assertEqual(environ.strip(), "COV_FOOBAR = XYZZY") |