def test_maintain_notifier_for_added(self): # Test adding downstream notifier by observing a nested dict # inside another dict instance = ClassWithDict() graph = create_graph( create_observer(notify=False, optional=False), create_observer(notify=True, optional=False), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.dict_of_dict, graph=graph, handler=handler, ) # when instance.dict_of_dict.update({"1": {"2": 2}}) # then # ``notify`` is set to False for mutations on the outer dict self.assertEqual(handler.call_count, 0) # when del instance.dict_of_dict["1"]["2"] # then # ``notify`` is set to True for mutations on the inner dict self.assertEqual(handler.call_count, 1) ((event, ), _), = handler.call_args_list self.assertEqual(event.added, {}) self.assertEqual(event.removed, {"2": 2})
def test_maintain_notifier_for_removed(self): # Test removing downstream notifier by observing a nested dict # inside another dict instance = ClassWithDict(dict_of_dict={"1": {"2": 2}}) graph = create_graph( create_observer(notify=False, optional=False), create_observer(notify=True, optional=False), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.dict_of_dict, graph=graph, handler=handler, ) # sanity check test setup inner_dict = instance.dict_of_dict["1"] inner_dict["3"] = 3 self.assertEqual(handler.call_count, 1) ((event, ), _), = handler.call_args_list self.assertEqual(event.added, {"3": 3}) self.assertEqual(event.removed, {}) handler.reset_mock() # when # Change the content to something else instance.dict_of_dict["1"] = {} # the inner dict is not inside the instance.dict_of_dict any more inner_dict["4"] = 4 # then self.assertEqual(handler.call_count, 0)
def test_add_maintainers(self): # Test adding maintainers for children graphs observable = DummyObservable() maintainer = DummyNotifier() root_observer = DummyObserver( notify=False, observables=[observable], maintainer=maintainer, ) # two children, each will have a maintainer graph = ObserverGraph( node=root_observer, children=[ ObserverGraph(node=DummyObserver()), ObserverGraph(node=DummyObserver()), ], ) # when call_add_or_remove_notifiers( graph=graph, remove=False, ) # then # the dummy observer always return the same maintainer object. self.assertEqual(observable.notifiers, [maintainer, maintainer])
def test_observe_remove_notifiers_remove_trait_added(self): graph = create_graph( create_observer(name="value", notify=True, optional=True), ) handler = mock.Mock() foo = ClassWithInstance() # when # The following should cancel each other call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, remove=False) call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, remove=True) # when foo.add_trait("value", Int()) # then self.assertEqual(handler.call_count, 0) # when foo.value += 1 # then self.assertEqual(handler.call_count, 0)
def test_add_notifier_atomic(self): class BadNotifier(DummyNotifier): def add_to(self, observable): raise ZeroDivisionError() observable = DummyObservable() good_observer = DummyObserver( notify=True, observables=[observable], next_objects=[mock.Mock()], notifier=DummyNotifier(), maintainer=DummyNotifier(), ) bad_observer = DummyObserver( notify=True, observables=[observable], notifier=BadNotifier(), maintainer=DummyNotifier(), ) graph = create_graph( good_observer, bad_observer, ) # when with self.assertRaises(ZeroDivisionError): call_add_or_remove_notifiers( object=mock.Mock(), graph=graph, ) # then self.assertEqual(observable.notifiers, [])
def test_notify_filter_values_changed(self): instance = DummyParent() # Observes number and number2 observer = create_observer( filter=lambda name, trait: type(trait.trait_type) is Int, ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance, graph=create_graph(observer), handler=handler, ) # when instance.number += 1 # then self.assertEqual(handler.call_count, 1) handler.reset_mock() # when instance.number2 += 1 # then self.assertEqual(handler.call_count, 1)
def test_maintainer_keep_notify_flag(self): # Test the maintainer will maintain the notify flag for the root # observer in the subgraph. instance = DummyHasTraitsClass() notifier = DummyNotifier() graph = create_graph( self.observer, DummyObserver( notify=False, notifier=notifier, ), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance, handler=handler, target=instance, graph=graph, remove=False, ) # when instance.add_trait("good_name", Str()) # then # notify flag is set to false, so there are no notifiers added. notifiers = instance._trait("good_name", 2)._notifiers(True) self.assertNotIn(notifier, notifiers)
def test_notifier_can_be_removed(self): def filter_func(name, trait): return name.startswith("num") instance = DummyParent() handler = mock.Mock() call_add_or_remove_notifiers( object=instance, graph=create_graph(create_observer(filter=filter_func)), handler=handler, ) # sanity check instance.number += 1 self.assertEqual(handler.call_count, 1) handler.reset_mock() # when call_add_or_remove_notifiers( object=instance, graph=create_graph(create_observer(filter=filter_func)), handler=handler, remove=True, ) # then instance.number += 1 self.assertEqual(handler.call_count, 0)
def test_filter_metadata(self): class Person(HasTraits): n_jobs = Int(status="public") n_children = Int() # no metadata observer = FilteredTraitObserver( filter=MetadataFilter(metadata_name="status", ), notify=True, ) person = Person() handler = mock.Mock() call_add_or_remove_notifiers( object=person, graph=create_graph(observer), handler=handler, ) # when person.n_jobs += 1 # then self.assertEqual(handler.call_count, 1) handler.reset_mock() # when person.n_children += 1 # then self.assertEqual(handler.call_count, 0)
def test_add_trait_remove_trait_then_add_trait_again(self): # Test a scenario when a trait is added, then removed, then added back. # given # trait is optional. It will be added later. graph = create_graph( create_observer(name="new_value", notify=True, optional=True), ) handler = mock.Mock() foo = ClassWithInstance() call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, remove=False) foo.add_trait("new_value", Int()) foo.new_value += 1 handler.assert_called_once() handler.reset_mock() # when # remove the trait and then add it back foo.remove_trait("new_value") foo.add_trait("new_value", Int()) # then # the handler is now back! The trait was not defined on the class, # so the last 'add_trait' fires a trait_added event. foo.new_value += 1 handler.assert_called_once()
def test_notifier_extended_trait_change(self): foo = ClassWithInstance() graph = create_graph( create_observer(name="instance", notify=True), create_observer(name="value1", notify=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, ) self.assertIsNone(foo.instance) # when foo.instance = ClassWithTwoValue() # then ((event, ), _), = handler.call_args_list self.assertEqual(event.object, foo) self.assertEqual(event.name, "instance") self.assertEqual(event.old, None) self.assertEqual(event.new, foo.instance) # when handler.reset_mock() foo.instance.value1 += 1 # then ((event, ), _), = handler.call_args_list self.assertEqual(event.object, foo.instance) self.assertEqual(event.name, "value1") self.assertEqual(event.old, 0) self.assertEqual(event.new, 1)
def test_get_maintainer_excuse_old_value_with_no_notifiers(self): # The "instance" trait has a default that has not been # materialized prior to the user setting a new value to the trait. # There isn't an old: Uninitialized -> new: Default value change event. # Instead, there is a old: Default -> new value event. # The old default value in this event won't have any notifiers # to be removed, therefore we need to excuse the NotifierNotFound # in the maintainer when it tries to remove notifiers from the old # value. foo = ClassWithDefault() graph = create_graph( create_observer(name="instance", notify=True), create_observer(name="value1", notify=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, ) try: foo.instance = ClassWithTwoValue() except Exception: self.fail( "Reassigning the instance value should not fail." )
def test_remove_maintainers(self): observable = DummyObservable() maintainer = DummyNotifier() observable.notifiers = [maintainer, maintainer] root_observer = DummyObserver( notify=False, observables=[observable], maintainer=maintainer, ) # for there are two children graphs # two maintainers will be removed. graph = ObserverGraph( node=root_observer, children=[ ObserverGraph(node=DummyObserver()), ObserverGraph(node=DummyObserver()), ], ) # when call_add_or_remove_notifiers( graph=graph, remove=True, ) # then self.assertEqual(observable.notifiers, [])
def test_maintain_notifier_for_default(self): # Dynamic defaults are not computed when hooking up the notifiers. # By when the default is defined, the maintainer will then hook up # the child observer. foo = ClassWithDefault() graph = create_graph( create_observer(name="instance", notify=True), create_observer(name="value1", notify=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, ) # sanity check test setup. self.assertNotIn("instance", foo.__dict__) # when foo.instance # this triggers the default to be computed and set # then # setting the default does not trigger notifications self.assertEqual(handler.call_count, 0) # when foo.instance.value1 += 1 # then # the notifier for value1 has been hooked up by the maintainer self.assertEqual(handler.call_count, 1)
def test_maintain_notifier_change_to_none(self): # Instance may accept None, maintainer should accomodate that # and skip it for the next observer. class UnassumingObserver(DummyObserver): def iter_observables(self, object): if object is None: raise ValueError("This observer cannot handle None.") yield from () foo = ClassWithInstance() graph = create_graph( create_observer(name="instance", notify=True), UnassumingObserver(), ) handler = mock.Mock() call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, ) foo.instance = ClassWithTwoValue() try: foo.instance = None except Exception: self.fail("Setting instance back to None should not fail.")
def test_maintain_notifier_change_to_new_value(self): # Test when the container object is changed, the notifiers are # maintained downstream. foo = ClassWithInstance() graph = create_graph( create_observer(name="instance", notify=True), create_observer(name="value1", notify=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=foo, graph=graph, handler=handler, ) # sanity check foo.instance = ClassWithTwoValue() foo.instance.value1 += 1 self.assertEqual(handler.call_count, 2) # when old_instance = foo.instance foo.instance = ClassWithTwoValue() handler.reset_mock() old_instance.value1 += 1 # then self.assertEqual(handler.call_count, 0) # when foo.instance.value1 += 1 # then self.assertEqual(handler.call_count, 1)
def test_add_notifiers_for_children_graphs(self): # Test adding notifiers using children graphs observable1 = DummyObservable() child_observer1 = DummyObserver(observables=[observable1], ) observable2 = DummyObservable() child_observer2 = DummyObserver(observables=[observable2], ) parent_observer = DummyObserver(next_objects=[mock.Mock()], ) graph = ObserverGraph( node=parent_observer, children=[ ObserverGraph(node=child_observer1, ), ObserverGraph(node=child_observer2, ) ], ) # when call_add_or_remove_notifiers( graph=graph, remove=False, ) # then self.assertCountEqual( observable1.notifiers, [ # For child1 observer child_observer1.notifier, ]) self.assertCountEqual( observable2.notifiers, [ # For child2 observer child_observer2.notifier, ])
def test_remove_atomic(self): # Test atomicity notifier = DummyNotifier() maintainer = DummyNotifier() observable1 = DummyObservable() observable1.notifiers = [ notifier, maintainer, ] old_observable1_notifiers = observable1.notifiers.copy() observable2 = DummyObservable() observable2.notifiers = [maintainer] old_observable2_notifiers = observable2.notifiers.copy() observable3 = DummyObservable() observable3.notifiers = [ notifier, maintainer, ] old_observable3_notifiers = observable3.notifiers.copy() observer = DummyObserver( notify=True, observables=[ observable1, observable2, observable3, ], notifier=notifier, maintainer=maintainer, ) graph = create_graph( observer, DummyObserver(), # Need a child graph to get maintainer in ) # when with self.assertRaises(NotifierNotFound): call_add_or_remove_notifiers( object=mock.Mock(), graph=graph, remove=True, ) # then # as if nothing has happened, the order might not be maintained though! self.assertCountEqual( observable1.notifiers, old_observable1_notifiers, ) self.assertCountEqual( observable2.notifiers, old_observable2_notifiers, ) self.assertCountEqual( observable3.notifiers, old_observable3_notifiers, )
def test_remove_notifier_raises_let_error_propagate(self): # Test if the notifier remove_from raises, the error will # be propagated. # DummyNotifier.remove_from raises if the notifier is not found. observer = DummyObserver( observables=[DummyObservable()], notifier=DummyNotifier(), ) with self.assertRaises(NotifierNotFound): call_add_or_remove_notifiers( graph=ObserverGraph(node=observer), remove=True, )
def test_optional_observers(self): # ListItemObserver.optional is true, meaning it will ignore # incompatible incoming object. instance = ClassWithList() graph = create_graph(ListItemObserver(notify=True, optional=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.not_a_trait_list, graph=graph, handler=handler, ) instance.not_a_trait_list = CustomList() instance.not_a_trait_list.append(1) self.assertEqual(handler.call_count, 0)
def test_optional_trait_added(self): graph = create_graph( create_observer(name="value", notify=True, optional=True), ) handler = mock.Mock() not_an_has_traits_instance = mock.Mock() # does not complain because optional is set to true try: call_add_or_remove_notifiers( object=not_an_has_traits_instance, graph=graph, handler=handler, ) except Exception: self.fail("Optional flag should have been propagated.")
def test_notify_set_change(self): instance = ClassWithSet(values=set()) graph = create_graph(create_observer(notify=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.values, graph=graph, handler=handler, ) # when instance.values.add(1) # then ((event, ), _), = handler.call_args_list self.assertEqual(event.added, set([1])) self.assertEqual(event.removed, set())
def test_maintain_notifier(self): # Test maintaining downstream notifier by # observing list of list instance = ClassWithListOfList() graph = create_graph( ListItemObserver(notify=False, optional=False), ListItemObserver(notify=True, optional=False), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.list_of_list, graph=graph, handler=handler, ) # when instance.list_of_list.append([]) # then # the first ListItemObserver has notify=False self.assertEqual(handler.call_count, 0) # but the second ListItemObserver is given to the nested list nested_list = instance.list_of_list[0] # when nested_list.append(1) # then ((event, ), _), = handler.call_args_list self.assertIs(event.object, nested_list) self.assertEqual(event.added, [1]) self.assertEqual(event.removed, []) self.assertEqual(event.index, 0) handler.reset_mock() # when # the list is removed, it is not observed instance.list_of_list.pop() nested_list.append(1) # then self.assertEqual(handler.call_count, 0)
def test_add_trait_notifiers(self): observable = DummyObservable() notifier = DummyNotifier() observer = DummyObserver( notify=True, observables=[observable], notifier=notifier, ) graph = ObserverGraph(node=observer) # when call_add_or_remove_notifiers( graph=graph, remove=False, ) # then self.assertEqual(observable.notifiers, [notifier])
def test_notify_custom_trait_dict_change(self): # Test using DictItemObserver for changes on a subclass of TraitDict # that isn't TraitDictObject instance = ClassWithDict(custom_trait_dict=CustomTraitDict()) graph = create_graph(create_observer(notify=True), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.custom_trait_dict, graph=graph, handler=handler, ) # when instance.custom_trait_dict.update({"1": 1}) # then ((event, ), _), = handler.call_args_list self.assertEqual(event.added, {"1": 1}) self.assertEqual(event.removed, {})
def test_add_notifiers_for_extra_graph(self): observable = DummyObservable() extra_notifier = DummyNotifier() extra_observer = DummyObserver( observables=[observable], notifier=extra_notifier, ) extra_graph = ObserverGraph(node=extra_observer, ) observer = DummyObserver(extra_graphs=[extra_graph], ) graph = ObserverGraph(node=observer) # when call_add_or_remove_notifiers( graph=graph, remove=False, ) # then self.assertEqual(observable.notifiers, [extra_notifier])
def test_notifier_list_change(self): instance = ClassWithList(values=[]) graph = create_graph(ListItemObserver(notify=True, optional=False), ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance.values, graph=graph, handler=handler, ) # when instance.values.append(1) # then ((event, ), _), = handler.call_args_list self.assertIs(event.object, instance.values) self.assertEqual(event.added, [1]) self.assertEqual(event.removed, []) self.assertEqual(event.index, 0)
def test_add_trait_notifiers_notify_flag_is_false(self): # Test when the notify flag is false, the notifier is not # added. observable = DummyObservable() notifier = DummyNotifier() observer = DummyObserver( notify=False, observables=[observable], notifier=notifier, ) graph = ObserverGraph(node=observer) # when call_add_or_remove_notifiers( graph=graph, remove=False, ) # then self.assertEqual(observable.notifiers, [])
def test_trait_added_filtered_matched(self): instance = DummyParent() integer_observer = create_observer( filter=lambda name, trait: type(trait.trait_type) is Int, notify=True, ) handler = mock.Mock() call_add_or_remove_notifiers( object=instance, graph=create_graph(integer_observer), handler=handler, ) # when instance.add_trait("another_number", Int()) instance.another_number += 1 # then self.assertEqual(handler.call_count, 1)
def test_remove_notifiers_skip_if_notify_flag_is_false(self): observable = DummyObservable() notifier = DummyNotifier() observable.notifiers = [notifier] observer = DummyObserver( notify=False, observables=[observable], notifier=notifier, ) graph = ObserverGraph(node=observer, ) # when call_add_or_remove_notifiers( graph=graph, remove=True, ) # then # notify is false, remove does nothing. self.assertEqual(observable.notifiers, [notifier])