| # Copyright 2012 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unittests for the partial_mock test helper code.""" |
| |
| from chromite.lib import cros_test_lib |
| from chromite.lib import partial_mock |
| |
| |
| # pylint: disable=protected-access |
| |
| |
| class ComparatorTest(cros_test_lib.TestCase): |
| """Test Comparitor functionality.""" |
| |
| TEST_KEY1 = "monkey" |
| TEST_KEY2 = "foon" |
| |
| def testEquals(self) -> None: |
| """__eq__, __ne__ functionality of Comparator classes.""" |
| for cls_name in ["In", "Regex", "ListRegex"]: |
| cls = getattr(partial_mock, cls_name) |
| obj1 = cls(self.TEST_KEY1) |
| obj2 = cls(self.TEST_KEY1) |
| obj3 = cls(self.TEST_KEY2) |
| self.assertEqual(obj1, obj2) |
| self.assertFalse(obj1 == obj3) |
| self.assertNotEqual(obj1, obj3) |
| |
| def testIgnoreEquals(self) -> None: |
| """Verify __eq__ functionality for Ignore.""" |
| obj1 = partial_mock.Ignore() |
| obj2 = partial_mock.Ignore() |
| self.assertEqual(obj1, obj2) |
| self.assertFalse(obj1 != obj2) |
| |
| def testListRegex(self) -> None: |
| """Verify ListRegex match functionality.""" |
| obj = partial_mock.ListRegex(".*monkey.*") |
| self.assertTrue(obj.Match(["the", "small monkeys", "jumped"])) |
| self.assertFalse(obj.Match(["the", "jumped"])) |
| self.assertFalse(obj.Match(None)) |
| self.assertFalse(obj.Match(1)) |
| |
| |
| class RecursiveCompareTest(cros_test_lib.TestCase): |
| """Test recursive compare functionality.""" |
| |
| LHS_DICT = {3: 1, 1: 2} |
| RHS_DICT = {1: 2, 3: 1} |
| LIST = [1, 2, 3, 4] |
| TUPLE = (1, 2, 3, 4) |
| |
| def TrueHelper(self, lhs, rhs) -> None: |
| self.assertTrue(partial_mock._RecursiveCompare(lhs, rhs)) |
| |
| def FalseHelper(self, lhs, rhs) -> None: |
| self.assertFalse(partial_mock._RecursiveCompare(lhs, rhs)) |
| |
| def testIt(self) -> None: |
| """Test basic equality cases.""" |
| self.TrueHelper(self.LHS_DICT, self.RHS_DICT) |
| self.TrueHelper( |
| {3: self.LIST, 1: self.LHS_DICT}, {1: self.LHS_DICT, 3: self.LIST} |
| ) |
| self.FalseHelper( |
| {1: self.LHS_DICT, 3: self.LIST}, |
| {1: self.LHS_DICT, 3: self.LIST + [5]}, |
| ) |
| self.FalseHelper(self.LIST, self.TUPLE) |
| |
| def testUnicode(self) -> None: |
| """Test recursively comparing unicode and non-unicode strings.""" |
| self.assertTrue(partial_mock._RecursiveCompare(["foo"], ["foo"])) |
| |
| |
| class ListContainsTest(cros_test_lib.TestCase): |
| """Unittests for ListContains method.""" |
| |
| L = list(range(10)) + list(range(10)) + [9] |
| STRICTLY_TRUE_LISTS = [ |
| list(range(10)), |
| list(range(9, 10)), |
| list(range(3, 6)), |
| list(range(1)), |
| [], |
| [9, 9], |
| ] |
| LOOSELY_TRUE_LISTS = [list(range(0, 10, 2)), list(range(3, 6, 2)), [1, 1]] |
| FALSE_LISTS = [ |
| [1.5], |
| [-1], |
| [1, 1, 1], |
| [10], |
| [22], |
| list(range(6, 11)), |
| list(range(-1, 5)), |
| ] |
| |
| def testStrictContains(self) -> None: |
| """Test ListContains with strict=True.""" |
| for x in self.STRICTLY_TRUE_LISTS: |
| self.assertTrue(partial_mock.ListContains(x, self.L, strict=True)) |
| for x in self.LOOSELY_TRUE_LISTS + self.FALSE_LISTS: |
| self.assertFalse(partial_mock.ListContains(x, self.L, strict=True)) |
| |
| def testLooseContains(self) -> None: |
| """Test ListContains with strict=False.""" |
| for x in self.STRICTLY_TRUE_LISTS + self.LOOSELY_TRUE_LISTS: |
| self.assertTrue(partial_mock.ListContains(x, self.L)) |
| for x in self.FALSE_LISTS: |
| self.assertFalse(partial_mock.ListContains(x, self.L)) |
| |
| def testUnicode(self) -> None: |
| """Test ListContains with unicode and non-unicode strings.""" |
| self.assertTrue(partial_mock.ListContains(["foo"], ["foo"])) |
| |
| |
| class HasStringTest(cros_test_lib.TestCase): |
| """Unittests for HasString.""" |
| |
| def testEqual(self) -> None: |
| self.assertTrue( |
| partial_mock.HasString("substring") == "sentence with substring..." |
| ) |
| self.assertTrue(partial_mock.HasString("tr") == "it should be true") |
| self.assertTrue(partial_mock.HasString("") == "match any string") |
| |
| def testUneuqal(self) -> None: |
| self.assertFalse(partial_mock.HasString("not there") == "typo no there") |
| self.assertFalse( |
| partial_mock.HasString("Uppercase matters") == "uppercase matters" |
| ) |
| |
| |
| class MockedCallResultsTest(cros_test_lib.TestCase): |
| """Test MockedCallResults functionality.""" |
| |
| ARGS = ("abc",) |
| LIST_ARGS = ([1, 2, 3, 4],) |
| KWARGS = {"test": "ing"} |
| NEW_ENTRY = {"new": "entry"} |
| |
| def KwargsHelper(self, result, kwargs, strict=True) -> None: |
| self.mr.AddResultForParams( |
| self.ARGS, result, kwargs=kwargs, strict=strict |
| ) |
| |
| def setUp(self) -> None: |
| self.mr = partial_mock.MockedCallResults("SomeFunction") |
| |
| def testNoMock(self) -> None: |
| """The call is not mocked.""" |
| self.assertRaises(AssertionError, self.mr.LookupResult, self.ARGS) |
| |
| def testArgReplacement(self) -> None: |
| """Replacing mocks for args-only calls.""" |
| self.mr.AddResultForParams(self.ARGS, 1) |
| self.mr.AddResultForParams(self.ARGS, 2) |
| self.assertEqual(2, self.mr.LookupResult(self.ARGS)) |
| |
| def testKwargsStrictReplacement(self) -> None: |
| """Replacing strict kwargs mock with another strict mock.""" |
| self.KwargsHelper(1, self.KWARGS) |
| self.KwargsHelper(2, self.KWARGS) |
| self.assertEqual(2, self.mr.LookupResult(self.ARGS, kwargs=self.KWARGS)) |
| |
| def testKwargsNonStrictReplacement(self) -> None: |
| """Replacing strict kwargs mock with nonstrict mock.""" |
| self.KwargsHelper(1, self.KWARGS) |
| self.KwargsHelper(2, self.KWARGS, strict=False) |
| self.assertEqual(2, self.mr.LookupResult(self.ARGS, kwargs=self.KWARGS)) |
| |
| def testListArgLookup(self) -> None: |
| """Matching of arguments containing lists.""" |
| self.mr.AddResultForParams(self.LIST_ARGS, 1) |
| self.mr.AddResultForParams(self.ARGS, 1) |
| self.assertEqual(1, self.mr.LookupResult(self.LIST_ARGS)) |
| |
| def testKwargsStrictLookup(self) -> None: |
| """Strict lookup fails due to extra kwarg.""" |
| self.KwargsHelper(1, self.KWARGS) |
| kwargs = self.NEW_ENTRY |
| kwargs.update(self.KWARGS) |
| self.assertRaises( |
| AssertionError, self.mr.LookupResult, self.ARGS, kwargs=kwargs |
| ) |
| |
| def testKwargsNonStrictLookup(self) -> None: |
| """Nonstrict lookup passes with extra kwarg.""" |
| self.KwargsHelper(1, self.KWARGS, strict=False) |
| kwargs = self.NEW_ENTRY |
| kwargs.update(self.KWARGS) |
| self.assertEqual(1, self.mr.LookupResult(self.ARGS, kwargs=kwargs)) |
| |
| def testIgnoreMatching(self) -> None: |
| """Deep matching of Ignore objects.""" |
| ignore = partial_mock.Ignore() |
| self.mr.AddResultForParams((ignore, ignore), 1, kwargs={"test": ignore}) |
| self.assertEqual( |
| 1, self.mr.LookupResult(("some", "values"), {"test": "bla"}) |
| ) |
| |
| def testRegexMatching(self) -> None: |
| """Regex matching.""" |
| self.mr.AddResultForParams((partial_mock.Regex("pre.ix"),), 1) |
| self.mr.AddResultForParams((partial_mock.Regex("suffi."),), 2) |
| self.assertEqual(1, self.mr.LookupResult(("prefix",))) |
| self.assertEqual(2, self.mr.LookupResult(("suffix",))) |
| |
| def testMultipleMatches(self) -> None: |
| """Lookup matches mutilple results.""" |
| self.mr.AddResultForParams((partial_mock.Ignore(),), 1) |
| self.mr.AddResultForParams((partial_mock.In("test"),), 2) |
| self.assertRaises(AssertionError, self.mr.LookupResult, ("test",)) |
| |
| def testDefaultResult(self) -> None: |
| """Test default result matching.""" |
| self.mr.SetDefaultResult(1) |
| self.mr.AddResultForParams((partial_mock.In("test"),), 2) |
| self.assertEqual(1, self.mr.LookupResult(self.ARGS)) |
| self.assertEqual(2, self.mr.LookupResult(("test",))) |
| |
| def _ExampleHook(self, *args, **kwargs): |
| """Example hook for testing.""" |
| self.assertEqual(args, self.LIST_ARGS) |
| self.assertEqual(kwargs, self.KWARGS) |
| return 2 |
| |
| def testHook(self) -> None: |
| """Return value of hook is used as the final result.""" |
| self.mr.AddResultForParams(self.ARGS, 1, side_effect=self._ExampleHook) |
| self.assertEqual( |
| 2, |
| self.mr.LookupResult( |
| self.ARGS, hook_args=self.LIST_ARGS, hook_kwargs=self.KWARGS |
| ), |
| ) |
| |
| def testDefaultHook(self) -> None: |
| """Verify default hooks are used.""" |
| self.mr.SetDefaultResult(1, self._ExampleHook) |
| self.mr.AddResultForParams((partial_mock.In("test"),), 3) |
| self.assertEqual( |
| 2, |
| self.mr.LookupResult( |
| self.ARGS, hook_args=self.LIST_ARGS, hook_kwargs=self.KWARGS |
| ), |
| ) |
| self.assertEqual(3, self.mr.LookupResult(("test",))) |
| |
| class _StubException(Exception): |
| """A do-nothing exception class for test.""" |
| |
| def testExceptionInstanceRaise(self) -> None: |
| """Verify that exception is raised.""" |
| expected_msg = "expected exception" |
| self.mr.AddResultForParams( |
| (partial_mock.In("test"),), |
| 3, |
| side_effect=self._StubException(expected_msg), |
| ) |
| with self.assertRaisesRegex(self._StubException, expected_msg): |
| self.mr.LookupResult(("test",)) |
| |
| def testExceptionClassRaise(self) -> None: |
| """Verify that exception is raised.""" |
| self.mr.AddResultForParams( |
| (partial_mock.In("test"),), 3, side_effect=self._StubException |
| ) |
| with self.assertRaises(self._StubException): |
| self.mr.LookupResult(("test",)) |
