def test_times_auto(self):
meta = MetaData()
before = time.time()
meta.set_create_time(None)
meta.set_send_time(None)
meta.set_receive_time(None)
meta.set_deliver_time(None)
after = time.time()
assert meta.create_time is not None
assert meta.send_time is not None
assert meta.receive_time is not None
assert meta.deliver_time is not None
assert before <= meta.create_time
assert before <= meta.send_time
assert before <= meta.receive_time
assert before <= meta.deliver_time
assert after >= meta.create_time
assert after >= meta.send_time
assert after >= meta.receive_time
assert after >= meta.deliver_time
def testUserTimes(self):
meta = MetaData()
before = time.time()
meta.setUserTime("foo")
after = time.time()
self.assertNotEquals(None, meta.userTimes["foo"])
self.assertTrue(meta.userTimes["foo"] >= before)
self.assertTrue(meta.userTimes["foo"] <= after)
def test_user_times(self):
meta = MetaData()
before = time.time()
meta.set_user_time("foo")
after = time.time()
assert meta.user_times["foo"] is not None
assert meta.user_times["foo"] >= before
assert meta.user_times["foo"] <= after
def test_construction(self):
before = time.time()
meta = MetaData()
after = time.time()
assert meta.create_time is not None
assert meta.send_time is None
assert meta.receive_time is None
assert meta.deliver_time is None
assert meta.create_time >= before
assert meta.create_time <= after
def testConstruction(self):
before = time.time()
meta = MetaData()
after = time.time()
self.assertTrue(meta.getCreateTime() != None)
self.assertTrue(meta.getSendTime() == None)
self.assertTrue(meta.getReceiveTime() == None)
self.assertTrue(meta.getDeliverTime() == None)
self.assertTrue(meta.getCreateTime() >= before)
self.assertTrue(meta.getCreateTime() <= after)
def testComparison(self):
meta1 = MetaData()
meta2 = MetaData()
meta2.setCreateTime(meta1.getCreateTime())
self.assertEquals(meta1, meta2)
meta1.setCreateTime(213123)
self.assertNotEquals(meta1, meta2)
meta2.setCreateTime(meta1.getCreateTime())
self.assertEquals(meta1, meta2)
meta1.setSendTime()
self.assertNotEquals(meta1, meta2)
meta2.setSendTime(meta1.getSendTime())
self.assertEquals(meta1, meta2)
meta1.setReceiveTime()
self.assertNotEquals(meta1, meta2)
meta2.setReceiveTime(meta1.getReceiveTime())
self.assertEquals(meta1, meta2)
meta1.setDeliverTime()
self.assertNotEquals(meta1, meta2)
meta2.setDeliverTime(meta1.getDeliverTime())
self.assertEquals(meta1, meta2)
meta1.setUserTime("foo")
self.assertNotEquals(meta1, meta2)
meta2.setUserTime("foo", meta1.getUserTimes()["foo"])
self.assertEquals(meta1, meta2)
meta1.setUserInfo("foox", "bla")
self.assertNotEquals(meta1, meta2)
meta2.setUserInfo("foox", meta1.getUserInfos()["foox"])
self.assertEquals(meta1, meta2)
def testTimesAuto(self):
meta = MetaData()
before = time.time()
meta.setCreateTime(None)
meta.setSendTime(None)
meta.setReceiveTime(None)
meta.setDeliverTime(None)
after = time.time()
self.assertNotEquals(None, meta.getCreateTime())
self.assertNotEquals(None, meta.getSendTime())
self.assertNotEquals(None, meta.getReceiveTime())
self.assertNotEquals(None, meta.getDeliverTime())
self.assertTrue(before <= meta.getCreateTime())
self.assertTrue(before <= meta.getSendTime())
self.assertTrue(before <= meta.getReceiveTime())
self.assertTrue(before <= meta.getDeliverTime())
self.assertTrue(after >= meta.getCreateTime())
self.assertTrue(after >= meta.getSendTime())
self.assertTrue(after >= meta.getReceiveTime())
self.assertTrue(after >= meta.getDeliverTime())
def test_comparison(self):
meta1 = MetaData()
meta2 = MetaData()
meta2.set_create_time(meta1.create_time)
assert meta1 == meta2
meta1.set_create_time(213123)
assert meta1 != meta2
meta2.set_create_time(meta1.create_time)
assert meta1 == meta2
meta1.set_send_time()
assert meta1 != meta2
meta2.set_send_time(meta1.send_time)
assert meta1 == meta2
meta1.set_receive_time()
assert meta1 != meta2
meta2.set_receive_time(meta1.receive_time)
assert meta1 == meta2
meta1.set_deliver_time()
assert meta1 != meta2
meta2.set_deliver_time(meta1.deliver_time)
assert meta1 == meta2
meta1.set_user_time("foo")
assert meta1 != meta2
meta2.set_user_time("foo", meta1.user_times["foo"])
assert meta1 == meta2
meta1.set_user_info("foox", "bla")
assert meta1 != meta2
meta2.set_user_info("foox", meta1.user_infos["foox"])
assert meta1 == meta2
def send_transform(self, transform, transform_type):
'''
Add transform information to the rct data structure.
:param transform:
:param transform_type:
:return: True unless an error occured
'''
if not self.__rsb_informer_transform:
self.__logger.error(
"[{}] RSB communicator was not initialized!".format(
self.__authority))
# some small type checks for usability
assert isinstance(
transform, Transform
), "Input transformation has to be of type rct.Transform! (Input was: {})".format(
type(transform))
assert hasattr(
TransformType, transform_type
), "Input transformation type has to be of type rct.TransformType! (Input was: {})".format(
type(transform_type))
cache_key = transform.get_frame_parent() + transform.get_frame_child()
meta_data = MetaData()
if transform.get_authority() is "":
meta_data.setUserInfo(self.__user_key_authority, self.__authority)
else:
meta_data.setUserInfo(self.__user_key_authority,
transform.get_authority())
self.__logger.info("[{}] Publishing transform from {}".format(
self.__authority, self.__rsb_informer_transform.getId()))
# TODO: threaded?
event = Event()
event.setData(transform)
event.setType(type(transform))
event.setMetaData(meta_data)
if transform_type is TransformType.STATIC:
self.__send_cache_static[cache_key] = (transform, meta_data)
event.setScope(self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_static)))
elif transform_type is TransformType.DYNAMIC:
self.__send_cache_dynamic[cache_key] = (transform, meta_data)
event.setScope(self.__rsb_informer_transform.getScope().concat(
Scope(self.__scope_suffix_dynamic)))
else:
self.__logger.error(
"[{}] Cannot send transform. Reason: Unknown TransformType: {}"
.format(self.__authority, str(transform_type)))
return False
self.__logger.info("[{}] Sending {} to scope {}".format(
self.__authority, transform.__str__(), event.getScope()))
self.__rsb_informer_transform.publishEvent(event)
self.__logger.debug("[{}] Sending successful!".format(
self.__authority))
return True