def test_append_save(self):
     i1 = MockInfo()
     
     kb.append('a', 'b', i1)
     kb.raw_write('a', 'b', 3)
     
     self.assertEqual(kb.raw_read('a', 'b'), 3)

    def test_observer_multiple_observers(self):
        observer1 = Mock()
        observer2 = Mock()
        
        kb.add_observer(None, None, observer1)
        kb.add_observer(None, None, observer2)
        kb.raw_write('a', 'b', 1)

        observer1.assert_called_once_with('a', 'b', 1)
        observer2.assert_called_once_with('a', 'b', 1)

    def test_observer_multiple_observers(self):
        observer1 = Mock()
        observer2 = Mock()
        
        kb.add_observer(observer1)
        kb.add_observer(observer2)
        kb.raw_write('a', 'b', 1)

        observer1.append.assert_called_once_with('a', 'b', 1, ignore_type=True)
        observer2.append.assert_called_once_with('a', 'b', 1, ignore_type=True)

 def test_observer_all(self):
     observer = Mock()
     
     kb.add_observer(None, None, observer)
     kb.raw_write('a', 'b', 1)
     
     observer.assert_called_once_with('a', 'b', 1)
     observer.reset_mock()
     
     i = MockInfo()
     kb.append('a', 'c', i)
     observer.assert_called_with('a', 'c', i)

 def test_observer_location_b(self):
     observer = Mock()
     
     kb.add_observer('a', 'b', observer)
     kb.raw_write('a', 'b', 1)
     
     observer.assert_called_once_with('a', 'b', 1)
     observer.reset_mock()
     
     # Shouldn't call the observer
     kb.raw_write('a', 'xyz', 1)
     self.assertFalse(observer.called)
     
     i = MockInfo()
     kb.append('a', 'b', i)
     observer.assert_called_with('a', 'b', i)

    def test_types_observer(self):
        observer = Mock()
        info_inst = MockInfo()
        
        kb.add_types_observer(Info, observer)
        kb.append('a', 'b', info_inst)
        observer.assert_called_once_with('a', 'b', info_inst)
        observer.reset_mock()
        
        info_inst = MockInfo()
        kb.append('a', 'c', info_inst)
        observer.assert_called_with('a', 'c', info_inst)
        observer.reset_mock()

        # Should NOT call it because it is NOT an Info instance        
        some_int = 3
        kb.raw_write('a', 'd', some_int)
        self.assertEqual(observer.call_count, 0)

 def test_default_first_saved(self):
     kb.raw_write('a', 'b', 'c')
     self.assertEqual(kb.get('a', 'not-exist'), [])
     self.assertEqual(kb.raw_read('a', 'not-exist'), [])

 def test_basic(self):
     kb.raw_write('a', 'b', 'c')
     data = kb.raw_read('a', 'b')
     self.assertEqual(data, 'c')

 def test_raw_write_list(self):
     """
     Test for _get_uniq_id which needs to be able to hash any object type.
     """
     kb.raw_write('a', 'b', [1,2,3])
     self.assertEqual(kb.raw_read('a','b'), [1,2,3])

 def test_overwrite(self):
     kb.raw_write('a', 'b', 'abc')
     kb.raw_write('a', 'b', 'def')
     self.assertEqual(kb.raw_read('a', 'b'), 'def')

 def test_clear(self):
     kb.raw_write('a', 'b', 'abc')
     kb.raw_write('a', 'c', 'abc')
     kb.clear('a', 'b')
     self.assertEqual(kb.raw_read('a', 'b'), [])
     self.assertEqual(kb.raw_read('a', 'c'), 'abc')

 def test_dump(self):
     kb.raw_write('a', 'b', 1)
     self.assertEqual(kb.dump(), {'a': {'b': [1]}})

 def test_all_of_klass_str(self):
     kb.raw_write('a', 'b', 'abc')
     self.assertEqual(kb.get_all_entries_of_class(str), ['abc'])

 def test_all_of_klass(self):
     kb.raw_write('a', 'b', 1)
     self.assertEqual(kb.get_all_entries_of_class(int), [1])

 def test_raw_write_dict(self):
     kb.raw_write('a', 'b', {})
     self.assertEqual(kb.raw_read('a', 'b'), {})