From 89102b5652e32821a2836788100d907488cdfa84 Mon Sep 17 00:00:00 2001 From: Paulus Schoutsen Date: Fri, 28 Nov 2014 19:42:16 -0800 Subject: [PATCH] Increase homeassistant.util test coverage --- homeassistant/util.py | 6 +-- test/test_util.py | 103 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 106 insertions(+), 3 deletions(-) diff --git a/homeassistant/util.py b/homeassistant/util.py index 42b6e668096..a4b812803d4 100644 --- a/homeassistant/util.py +++ b/homeassistant/util.py @@ -223,8 +223,8 @@ class OrderedSet(collections.MutableSet): curr = curr[1] def pop(self, last=True): # pylint: disable=arguments-differ - """ Pops element of the beginning of the set. - Set last=True to pop from the back. """ + """ Pops element of the end of the set. + Set last=False to pop from the beginning. """ if not self: raise KeyError('set is empty') key = self.end[1][0] if last else self.end[2][0] @@ -318,7 +318,7 @@ class ThreadPool(object): """ Add a job to be sent to the workers. """ with self._lock: if not self.running: - raise Exception("We are shutting down the ") + raise RuntimeError("ThreadPool not running") self.work_queue.put(PriorityQueueItem(priority, job)) diff --git a/test/test_util.py b/test/test_util.py index 727034ac409..1edb4b92a8c 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -43,6 +43,7 @@ class TestUtil(unittest.TestCase): """ Test str_to_datetime. """ self.assertEqual(datetime(1986, 7, 9, 12, 0, 0), util.str_to_datetime("12:00:00 09-07-1986")) + self.assertIsNone(util.str_to_datetime("not a datetime string")) def test_split_entity_id(self): """ Test split_entity_id. """ @@ -87,3 +88,105 @@ class TestUtil(unittest.TestCase): self.assertEqual( "Beer_3", util.ensure_unique_string("Beer", ["Beer", "Beer_2"])) + self.assertEqual( + "Beer", + util.ensure_unique_string("Beer", ["Wine", "Soda"])) + + def test_ordered_enum(self): + """ Test the ordered enum class. """ + + class TestEnum(util.OrderedEnum): + """ Test enum that can be ordered. """ + FIRST = 1 + SECOND = 2 + THIRD = 3 + + self.assertTrue(TestEnum.SECOND >= TestEnum.FIRST) + self.assertTrue(TestEnum.SECOND >= TestEnum.SECOND) + self.assertFalse(TestEnum.SECOND >= TestEnum.THIRD) + + self.assertTrue(TestEnum.SECOND > TestEnum.FIRST) + self.assertFalse(TestEnum.SECOND > TestEnum.SECOND) + self.assertFalse(TestEnum.SECOND > TestEnum.THIRD) + + self.assertFalse(TestEnum.SECOND <= TestEnum.FIRST) + self.assertTrue(TestEnum.SECOND <= TestEnum.SECOND) + self.assertTrue(TestEnum.SECOND <= TestEnum.THIRD) + + self.assertFalse(TestEnum.SECOND < TestEnum.FIRST) + self.assertFalse(TestEnum.SECOND < TestEnum.SECOND) + self.assertTrue(TestEnum.SECOND < TestEnum.THIRD) + + # Python will raise a TypeError if the <, <=, >, >= methods + # raise a NotImplemented error. + self.assertRaises(TypeError, + lambda x, y: x < y, TestEnum.FIRST, 1) + + self.assertRaises(TypeError, + lambda x, y: x <= y, TestEnum.FIRST, 1) + + self.assertRaises(TypeError, + lambda x, y: x > y, TestEnum.FIRST, 1) + + self.assertRaises(TypeError, + lambda x, y: x >= y, TestEnum.FIRST, 1) + + def test_ordered_set(self): + set1 = util.OrderedSet([1, 2, 3, 4]) + set2 = util.OrderedSet([3, 4, 5]) + + self.assertEqual(4, len(set1)) + self.assertEqual(3, len(set2)) + + self.assertIn(1, set1) + self.assertIn(2, set1) + self.assertIn(3, set1) + self.assertIn(4, set1) + self.assertNotIn(5, set1) + + self.assertNotIn(1, set2) + self.assertNotIn(2, set2) + self.assertIn(3, set2) + self.assertIn(4, set2) + self.assertIn(5, set2) + + set1.add(5) + self.assertIn(5, set1) + + set1.discard(5) + self.assertNotIn(5, set1) + + # Try again while key is not in + set1.discard(5) + self.assertNotIn(5, set1) + + self.assertEqual([1, 2, 3, 4], list(set1)) + self.assertEqual([4, 3, 2, 1], list(reversed(set1))) + + self.assertEqual(1, set1.pop(False)) + self.assertEqual([2, 3, 4], list(set1)) + + self.assertEqual(4, set1.pop()) + self.assertEqual([2, 3], list(set1)) + + self.assertEqual('OrderedSet()', str(util.OrderedSet())) + self.assertEqual('OrderedSet([2, 3])', str(set1)) + + self.assertEqual(set1, util.OrderedSet([2, 3])) + self.assertNotEqual(set1, util.OrderedSet([3, 2])) + self.assertEqual(set1, set([2, 3])) + self.assertEqual(set1, set([3, 2])) + self.assertEqual(set1, [2, 3]) + self.assertEqual(set1, [3, 2]) + self.assertNotEqual(set1, set([2])) + + set3 = util.OrderedSet(set1) + set3.update(set2) + + self.assertEqual([3, 4, 5, 2], set3) + self.assertEqual([3, 4, 5, 2], set1 | set2) + self.assertEqual([3], set1 & set2) + self.assertEqual([2], set1 - set2) + + set1.update([1, 2], [5, 6]) + self.assertEqual([2, 3, 1, 5, 6], set1)