def testRoundtrip(self): goodScope = Scope("/good") inconnector = self._getInPushConnector(goodScope) outconnector = self._getOutConnector(goodScope) receiver = SettingReceiver(goodScope) inconnector.setObserverAction(receiver) # first an event that we do not want event = Event(EventId(uuid.uuid4(), 0)) event.scope = Scope("/notGood") event.data = "dummy data" event.type = str event.metaData.senderId = uuid.uuid4() outconnector.handle(event) # and then a desired event event.scope = goodScope outconnector.handle(event) with receiver.resultCondition: while receiver.resultEvent is None: receiver.resultCondition.wait(10) self.assertTrue(receiver.resultEvent) # ignore meta data here event.setMetaData(None) receiver.resultEvent.setMetaData(None) self.assertEqual(receiver.resultEvent, event) inconnector.deactivate() outconnector.deactivate()
def testParsing(self): root = rsb.Scope("/") self.assertEqual(0, len(root.getComponents())) onePart = rsb.Scope("/test/") self.assertEqual(1, len(onePart.getComponents())) self.assertEqual("test", onePart.getComponents()[0]) manyParts = rsb.Scope("/this/is/a/dumb3/test/") self.assertEqual(5, len(manyParts.getComponents())) self.assertEqual("this", manyParts.getComponents()[0]) self.assertEqual("is", manyParts.getComponents()[1]) self.assertEqual("a", manyParts.getComponents()[2]) self.assertEqual("dumb3", manyParts.getComponents()[3]) self.assertEqual("test", manyParts.getComponents()[4]) # also ensure that the shortcut syntax works shortcut = rsb.Scope("/this/is") self.assertEqual(2, len(shortcut.getComponents())) self.assertEqual("this", shortcut.getComponents()[0]) self.assertEqual("is", shortcut.getComponents()[1]) # Non-ASCII characters are not allowed. However, unicode # object consisting of acceptable characters are OK. Scope(u'/') Scope(u'/test') self.assertRaises(ValueError, Scope, u'/br\xc3\xb6tchen')
def testSequencing(self): goodScope = Scope("/good") inConnector = getConnector(goodScope, clazz=rsbspread.InPushConnector) outConnector = getConnector(goodScope, clazz=rsbspread.OutConnector) try: receiver = SettingReceiver(goodScope) inConnector.setObserverAction(receiver) # first an event that we do not want event = Event(EventId(uuid.uuid4(), 0)) event.scope = Scope("/notGood") event.data = "".join( random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(300502)) event.type = str event.metaData.senderId = uuid.uuid4() outConnector.handle(event) # and then a desired event event.scope = goodScope outConnector.handle(event) with receiver.resultCondition: receiver.resultCondition.wait(10) if receiver.resultEvent is None: self.fail("Did not receive an event") # self.assertEqual(receiver.resultEvent, event) finally: inConnector.deactivate() outConnector.deactivate()
def test_roundtrip(self): good_scope = Scope("/good") inconnector = self._get_in_connector(good_scope) outconnector = self._get_out_connector(good_scope) receiver = SettingReceiver(good_scope) inconnector.set_observer_action(receiver) # first an event that we do not want event = Event(EventId(uuid.uuid4(), 0)) event.scope = Scope("/notGood") event.data = "x" * 600000 event.data_type = str event.meta_data.sender_id = uuid.uuid4() outconnector.handle(event) # and then a desired event event.scope = good_scope outconnector.handle(event) with receiver.result_condition: while receiver.result_event is None: receiver.result_condition.wait(10) assert receiver.result_event # ignore meta data here event.meta_data = None receiver.result_event.meta_data = None assert receiver.result_event == event outconnector.deactivate() inconnector.deactivate()
def test_sequencing(self): good_scope = Scope("/good") in_connector = get_connector(good_scope, clazz=spread_transport.InConnector) out_connector = get_connector(good_scope, clazz=spread_transport.OutConnector) try: receiver = SettingReceiver(good_scope) in_connector.set_observer_action(receiver) # first an event that we do not want event = Event(EventId(uuid.uuid4(), 0)) event.scope = Scope("/notGood") event.data = ''.join( random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(300502)) event.data_type = str event.meta_data.sender_id = uuid.uuid4() out_connector.handle(event) # and then a desired event event.scope = good_scope out_connector.handle(event) with receiver.result_condition: receiver.result_condition.wait(10) assert receiver.result_event is not None # self.assertEqual(receiver.result_event, event) finally: in_connector.deactivate() out_connector.deactivate()
def testPullRoundtrip(self): goodScope = Scope("/good") try: inconnector = self._getInPullConnector(goodScope) except NotImplementedError: return outconnector = self._getOutConnector(goodScope) # first an event that we do not want event = Event(EventId(uuid.uuid4(), 0)) event.scope = Scope("/notGood") event.data = "dummy data" event.type = str event.metaData.senderId = uuid.uuid4() outconnector.handle(event) # and then a desired event event.scope = goodScope outconnector.handle(event) received = inconnector.raiseEvent(True) # ignore meta data here event.setMetaData(None) received.setMetaData(None) self.assertEqual(received, event) inconnector.deactivate() outconnector.deactivate()
def test_round_trip(self): converter = ScopeConverter() root = Scope('/foo/bar') assert converter.deserialize(*converter.serialize(root)) == root some_scope = Scope('/foo/bar') assert converter.deserialize( *converter.serialize(some_scope)) == some_scope
def testRoundTrip(self): converter = ScopeConverter() root = Scope('/foo/bar') self.assertEqual(root, converter.deserialize(*converter.serialize(root))) someScope = Scope('/foo/bar') self.assertEqual( someScope, converter.deserialize(*converter.serialize(someScope)))
def testSendEventWrongScope(self): # Error: unrelated scope e = Event(scope=Scope("/blubb"), data='foo', type=self.informer.type) self.assertRaises(ValueError, self.informer.publishEvent, e) # OK: identical scope e = Event(scope=self.defaultScope, data='foo', type=self.informer.type) self.informer.publishEvent(e) # OK: sub-scope e = Event(scope=self.defaultScope.concat(Scope('/sub')), data='foo', type=self.informer.type) self.informer.publishEvent(e)
def testMatch(self): scope = Scope("/bla") f = rsb.filter.ScopeFilter(scope) self.assertEqual(scope, f.getScope()) e = rsb.Event() e.scope = scope self.assertTrue(f.match(e)) e.scope = scope.concat(Scope("/sub/scope")) self.assertTrue(f.match(e)) e.scope = Scope("/blubbbbbb") self.assertFalse(f.match(e))
def test_match(self): scope = Scope("/bla") f = rsb.filter.ScopeFilter(scope) assert scope == f.scope e = rsb.Event() e.scope = scope assert f.match(e) e.scope = scope.concat(Scope("/sub/scope")) assert f.match(e) e.scope = Scope("/blubbbbbb") assert not f.match(e)
def test_parsing(self, str_repr, components): scope = rsb.Scope(str_repr) assert scope.components == components # Non-ASCII characters are not allowed. However, unicode # object consisting of acceptable characters are OK. with pytest.raises(ValueError): Scope('/br\xc3\xb6tchen')
def testDeactivate(self): dummySpread = SpreadConnectorTest.DummySpread() connector = getConnector(Scope("/foo"), module=dummySpread) self.assertEqual(1, len(dummySpread.returnedConnections)) connection = dummySpread.returnedConnections[0] connector.deactivate() self.assertEqual(1, connection.disconnectCalls)
def test_deactivate(self): dummy_spread = self.DummySpread() connector = get_connector(Scope("/foo"), module=dummy_spread) assert len(dummy_spread.returned_connections) == 1 connection = dummy_spread.returned_connections[0] connector.deactivate() assert connection.disconnect_calls == 1
def set_up(self): self.default_scope = Scope("/a/test") self.informer = Informer(self.default_scope, rsb.get_default_participant_config(), data_type=str) yield self.informer.deactivate()
def test_user_roundtrip(self): scope = Scope("/test/it") in_connector = self._get_in_connector(scope, activate=False) out_connector = self._get_out_connector(scope, activate=False) in_configurator = rsb.eventprocessing.InRouteConfigurator( connectors=[in_connector]) out_configurator = rsb.eventprocessing.OutRouteConfigurator( connectors=[out_connector]) listener = create_listener(scope, configurator=in_configurator) publisher = create_informer(scope, data_type=str, configurator=out_configurator) receiver = SettingReceiver(scope) listener.add_handler(receiver) data1 = "a string to test" sent_event = Event(EventId(uuid.uuid4(), 0)) sent_event.data = data1 sent_event.data_type = str sent_event.scope = scope sent_event.meta_data.set_user_info("test", "it") sent_event.meta_data.set_user_info("test again", "it works?") sent_event.meta_data.set_user_time("blubb", 234234.0) sent_event.meta_data.set_user_time("bla", 3434343.45) sent_event.add_cause(EventId(uuid.uuid4(), 1323)) sent_event.add_cause(EventId(uuid.uuid4(), 42)) publisher.publish_event(sent_event) with receiver.result_condition: while receiver.result_event is None: receiver.result_condition.wait(10) if receiver.result_event is None: self.fail("Listener did not receive an event") assert receiver.result_event.meta_data.create_time <= \ receiver.result_event.meta_data.send_time assert receiver.result_event.meta_data.send_time <= \ receiver.result_event.meta_data.receive_time assert receiver.result_event.meta_data.receive_time <= \ receiver.result_event.meta_data.deliver_time sent_event.meta_data.receive_time = \ receiver.result_event.meta_data.receive_time sent_event.meta_data.deliver_time = \ receiver.result_event.meta_data.deliver_time # HACK: floating point precision leads to an imprecision here, # avoid this. sent_event.meta_data.send_time = \ receiver.result_event.meta_data.send_time sent_event.meta_data.create_time = \ receiver.result_event.meta_data.create_time assert sent_event == receiver.result_event publisher.deactivate() listener.deactivate()
def test_send_event_wrong_scope(self): # Error: unrelated scope e = Event(scope=Scope("/blubb"), data='foo', data_type=self.informer.data_type) with pytest.raises(ValueError): self.informer.publish_event(e) # OK: identical scope e = Event(scope=self.default_scope, data='foo', data_type=self.informer.data_type) self.informer.publish_event(e) # OK: sub-scope e = Event(scope=self.default_scope.concat(Scope('/sub')), data='foo', data_type=self.informer.data_type) self.informer.publish_event(e)
def testPullNonBlocking(self): try: inconnector = self._getInPullConnector(Scope("/somewhere")) except NotImplementedError: return received = inconnector.raiseEvent(False) self.assertIsNone(received) inconnector.deactivate()
def testNotifyHierarchy(self): bus = Bus() targetScope = Scope("/this/is/a/test") scopes = targetScope.superScopes(True) sinksByScope = {} for scope in scopes: sinksByScope[scope] = StubSink(scope) bus.addSink(sinksByScope[scope]) notNotifiedSiblingSink = StubSink(Scope("/not/notified")) bus.addSink(notNotifiedSiblingSink) notNotifiedChildSink = StubSink(targetScope.concat(Scope("/child"))) bus.addSink(notNotifiedChildSink) event = Event(scope=targetScope) bus.handle(event) for scope, sink in sinksByScope.items(): self.assertTrue(event in sink.events) self.assertEqual(1, len(sink.events))
def test_notify_hierarchy(self): bus = Bus() target_scope = Scope("/this/is/a/test") scopes = target_scope.super_scopes(True) sinks_by_scope = {} for scope in scopes: sinks_by_scope[scope] = StubSink(scope) bus.add_sink(sinks_by_scope[scope]) not_notified_sibling_sink = StubSink(Scope("/not/notified")) bus.add_sink(not_notified_sibling_sink) not_notified_child_sink = StubSink(target_scope.concat( Scope("/child"))) bus.add_sink(not_notified_child_sink) event = Event(scope=target_scope) bus.handle(event) for scope, sink in list(sinks_by_scope.items()): assert event in sink.events assert len(sink.events) == 1
def publish_cache(self): self.__logger.debug("[{}] Publishing cache... ({} total)".format( self.__authority, len(self.__send_cache_dynamic.keys()) + len(self.__send_cache_static.keys()))) for _, v in self.__send_cache_dynamic.iteritems(): event = Event() event.setData(v[0]) event.setType(type(v[0])) event.setScope(self.__rsb_informer_transform.getScope().concat( Scope(self.__scope_suffix_dynamic))) event.setMetaData(v[1]) self.__rsb_informer_transform.publishEvent(event) for _, v in self.__send_cache_static.iteritems(): event = Event() event.setData(v[0]) event.setType(type(v[0])) event.setScope(self.__rsb_informer_transform.getScope().concat( Scope(self.__scope_suffix_static))) event.setMetaData(v[1]) self.__rsb_informer_transform.publishEvent(event)
def testUserRoundtrip(self): scope = Scope("/test/it") inConnector = self._getInPushConnector(scope, activate=False) outConnector = self._getOutConnector(scope, activate=False) outConfigurator = rsb.eventprocessing.OutRouteConfigurator( connectors=[outConnector]) inConfigurator = rsb.eventprocessing.InPushRouteConfigurator( connectors=[inConnector]) publisher = createInformer(scope, dataType=str, configurator=outConfigurator) listener = createListener(scope, configurator=inConfigurator) receiver = SettingReceiver(scope) listener.addHandler(receiver) data1 = "a string to test" sentEvent = Event(EventId(uuid.uuid4(), 0)) sentEvent.setData(data1) sentEvent.setType(str) sentEvent.setScope(scope) sentEvent.getMetaData().setUserInfo("test", "it") sentEvent.getMetaData().setUserInfo("test again", "it works?") sentEvent.getMetaData().setUserTime("blubb", 234234) sentEvent.getMetaData().setUserTime("bla", 3434343.45) sentEvent.addCause(EventId(uuid.uuid4(), 1323)) sentEvent.addCause(EventId(uuid.uuid4(), 42)) publisher.publishEvent(sentEvent) with receiver.resultCondition: while receiver.resultEvent is None: receiver.resultCondition.wait(10) if receiver.resultEvent is None: self.fail("Listener did not receive an event") self.assertTrue( receiver.resultEvent.metaData.createTime <= receiver. resultEvent.metaData.sendTime <= receiver.resultEvent.metaData. receiveTime <= receiver.resultEvent.metaData.deliverTime) sentEvent.metaData.receiveTime = \ receiver.resultEvent.metaData.receiveTime sentEvent.metaData.deliverTime = \ receiver.resultEvent.metaData.deliverTime self.assertEqual(sentEvent, receiver.resultEvent) listener.deactivate() publisher.deactivate()
def test_spread_subscription(self): s1 = Scope("/xxx") dummy_spread = self.DummySpread() connector = get_connector(s1, clazz=spread_transport.InConnector, module=dummy_spread) assert len(dummy_spread.returned_connections) == 1 connection = dummy_spread.returned_connections[0] hasher = hashlib.md5() hasher.update(s1.to_string().encode('ascii')) hashed = hasher.hexdigest()[:-1].encode('ascii') assert hashed in connection.join_calls connector.deactivate()
def testSpreadSubscription(self): s1 = Scope("/xxx") dummySpread = SpreadConnectorTest.DummySpread() connector = getConnector(s1, clazz=rsbspread.InPushConnector, module=dummySpread) self.assertEqual(1, len(dummySpread.returnedConnections)) connection = dummySpread.returnedConnections[0] hasher = hashlib.md5() hasher.update(s1.toString()) hashed = hasher.hexdigest()[:-1] self.assertTrue(hashed in connection.joinCalls) connector.deactivate()
def transform_handler(self, event): ''' Handles incoming transformation updates. The C++ counterpart is "transformCallback" :param event:Incoming event ''' if event.getSenderId() == self.__rsb_informer_transform.getId(): self.__logger.debug( "[{}] Received transform update from myself. Ignore. (id: {})". format(self.__authority, str(event.getSenderId()))) return # data is of type rct.core.Transform data = event.getData() if not isinstance(data, Transform): self.__logger.warning( "[{}] Incoming data is of type {} (expected {}). Ignore.". format(self.__authority, type(data), Transform)) return try: received_authority = event.getMetaData().userInfos[ self.__user_key_authority] static_scope = self.__rsb_informer_transform.getScope().concat( Scope(self.__scope_suffix_static)) is_static = event.scope == static_scope data.__authority = received_authority self.__logger.debug("[%s] Received transform from '%s: %s", self.__authority, received_authority, data) # TODO: threaded? for a_listener in self.__listeners: a_listener.new_transform_available(data, is_static) except KeyError as ke: self.__logger.warning( "[{}] ERROR during data handling: Cannot find neccessary key '{}' in meta data user info field of event! Actual content: {}" .format(self.__authority, ke, event.metaData)) except Exception as e: self.__logger.exception( "[{}] ERROR during data handling: {}".format( self.__authority, str(e)))
def testPassToAction(self): scope = Scope("/lets/go") bus = Bus() connector = InPushConnector(bus=bus) connector.setScope(scope) connector.activate() action = StubSink(scope) connector.setObserverAction(action) e = Event() e.scope = scope bus.handle(e) self.assertEqual(1, len(action.events)) self.assertTrue(e in action.events)
def test_pass_to_action(self): scope = Scope("/lets/go") bus = Bus() connector = InConnector(bus=bus) connector.scope = scope connector.activate() action = StubSink(scope) connector.set_observer_action(action) e = Event() e.scope = scope bus.handle(e) assert len(action.events) == 1 assert e in action.events
def test_hierarchy_sending(self): send_scope = Scope("/this/is/a/test") super_scopes = send_scope.super_scopes(True) out_connector = self._get_out_connector(send_scope, activate=False) out_configurator = rsb.eventprocessing.OutRouteConfigurator( connectors=[out_connector]) informer = create_informer(send_scope, data_type=str, configurator=out_configurator) # set up listeners on the complete hierarchy listeners = [] receivers = [] for scope in super_scopes: in_connector = self._get_in_connector(scope, activate=False) in_configurator = rsb.eventprocessing.InRouteConfigurator( connectors=[in_connector]) listener = create_listener(scope, configurator=in_configurator) listeners.append(listener) receiver = SettingReceiver(scope) listener.add_handler(receiver) receivers.append(receiver) data = "a string to test" informer.publish_data(data) for receiver in receivers: with receiver.result_condition: while receiver.result_event is None: receiver.result_condition.wait(10) if receiver.result_event is None: pytest.fail( "Listener on scope {} did not receive an event".format( receiver.scope)) assert receiver.result_event.data == data for listener in listeners: listener.deactivate() informer.deactivate()
def testHierarchySending(self): sendScope = Scope("/this/is/a/test") superScopes = sendScope.superScopes(True) outConnector = self._getOutConnector(sendScope, activate=False) outConfigurator = rsb.eventprocessing.OutRouteConfigurator( connectors=[outConnector]) informer = createInformer(sendScope, dataType=str, configurator=outConfigurator) # set up listeners on the complete hierarchy listeners = [] receivers = [] for scope in superScopes: inConnector = self._getInPushConnector(scope, activate=False) inConfigurator = rsb.eventprocessing.InPushRouteConfigurator( connectors=[inConnector]) listener = createListener(scope, configurator=inConfigurator) listeners.append(listener) receiver = SettingReceiver(scope) listener.addHandler(receiver) receivers.append(receiver) data = "a string to test" informer.publishData(data) for receiver in receivers: with receiver.resultCondition: while receiver.resultEvent is None: receiver.resultCondition.wait(10) if receiver.resultEvent is None: self.fail("Listener on scope %s did not receive an event" % receiver.scope) self.assertEqual(receiver.resultEvent.data, data) for listener in listeners: listener.deactivate() informer.deactivate()
def test_handle(self): bus = Bus() connector = OutConnector(bus=bus) scope = Scope("/a/test") sink = StubSink(scope) bus.add_sink(sink) e = Event() e.scope = scope before = time.time() connector.handle(e) after = time.time() assert len(sink.events) == 1 assert e in sink.events assert e.meta_data.send_time >= before assert e.meta_data.send_time <= after