def round_trip_poto_spec_via_string(self, match): """ Convert a MsgSpec object model to canonical string form, parse that to make a clone, and verify that the two are equal. """ canonical_spec = str(match.__repr__()) # DEBUG print("\n### roundTrip: SPEC IN CANONICAL FORM:\n" + canonical_spec) print("### END SPEC IN CANONICAL FORM #######") # END ppp = StringProtoSpecParser(StringIO(canonical_spec)) cloned_spec = ppp.parse() self.assertIsNone(cloned_spec.parent) # created by default self.assertIsNotNone(cloned_spec.reg) # DEBUG clone_repr = cloned_spec.__repr__() print("### CLONED SPEC IN CANONICAL FORM:\n" + clone_repr) print("### END CLONED SPEC ##############") # END # crude tests of __eq__ AKA == self.assertFalse(match is None) self.assertTrue(match == match) # one way of saying it ------------------ self.assertTrue(match.__eq__(cloned_spec)) self.assertTrue(cloned_spec.__eq__(match)) # this is the same test ----------------- self.assertTrue(match == cloned_spec) self.assertTrue(cloned_spec == match)
def test_caching(self): # SETUP data = StringIO(ZOGGERY_PROTO_SPEC) ppp = StringProtoSpecParser(data) # data should be file-like self.str_obj_model = ppp.parse() # object model from string serialization self.proto_name = self.str_obj_model.name # the dotted name of the protocol # END SETUp self.assertTrue(isinstance(self.str_obj_model, M.ProtoSpec)) msg_spec = self.str_obj_model.msgs[0] name = msg_spec.name cls0 = make_msg_class(self.str_obj_model, name) cls1 = make_msg_class(self.str_obj_model, name) # we cache classe, so the two should be the same self.assertEqual(id(cls0), id(cls1)) # chan = Channel(BUFSIZE) values = self.le_msg_values() le_msg0 = cls0(values) le_msg1 = cls0(values) # we don't cache instances, so these will differ self.assertNotEqual(id(le_msg0), id(le_msg1)) field_spec = msg_spec[0] dotted_name = "%s.%s" % (self.proto_name, msg_spec.name) f0cls = make_field_class(dotted_name, field_spec) f1cls = make_field_class(dotted_name, field_spec) self.assertEqual(id(f0cls), id(f1cls))
def test_parse_and_write_proto_spec(self): data = StringIO(ZOGGERY_PROTO_SPEC) ppp = StringProtoSpecParser(data) # data should be file-like str_obj_model = ppp.parse() # object model from string serialization self.assertIsNotNone(str_obj_model) self.assertTrue(isinstance(str_obj_model, M.ProtoSpec)) self.assertEqual('org.xlattice.zoggery', str_obj_model.name) self.assertEqual(0, len(str_obj_model.enums)) self.assertEqual(1, len(str_obj_model.msgs)) self.assertEqual(0, len(str_obj_model.seqs)) msg_spec = str_obj_model.msgs[0] # XXX THIS SHOULD BE A LOOP, with no magic numbers self.assertEqual(msg_spec.f_name(0), 'timestamp') self.assertEqual(msg_spec.field_type_name(0), 'fuint32') self.assertEqual(msg_spec.f_name(1), 'nodeID') self.assertEqual(msg_spec.field_type_name(1), 'fbytes20') self.assertEqual(msg_spec.f_name(2), 'key') self.assertEqual(msg_spec.field_type_name(2), 'fbytes20') self.assertEqual(msg_spec.f_name(3), 'length') self.assertEqual(msg_spec.field_type_name(3), 'vuint32') self.assertEqual(msg_spec.f_name(4), 'by') self.assertEqual(msg_spec.field_type_name(4), 'lstring') self.assertEqual(msg_spec.f_name(5), 'path') self.assertEqual(msg_spec.field_type_name(5), 'lstring') # GEEP
def round_trip_proto_spec_via_string(self, match): """ Convert a MsgSpec object model to canonical string form, parse that to make a clone, and verify that the two are """ canonical_spec = str(match.__repr__()) # DEBUG print("### roundTrip: SPEC IN CANONICAL FORM:\n" + canonical_spec) print("### END SPEC IN CANONICAL FORM #######") # END str_ps_parser = StringProtoSpecParser(StringIO(canonical_spec)) cloned_spec = str_ps_parser.parse() self.assertIsNone(cloned_spec.parent) self.assertIsNotNone(cloned_spec.reg) # DEBUG clone_repr = cloned_spec.__repr__() print("### CLONED SPEC IN CANONICAL FORM:\n" + clone_repr) print("### END CLONED SPEC ##############") # END # crude tests of __eq__ AKA == self.assertFalse(match is None) self.assertTrue(match == match) # one way of saying it ------------------ # XXX NEXT LINE FAILS self.assertTrue(match.__eq__(cloned_spec)) self.assertTrue(cloned_spec.__eq__(match)) # this is the same test ----------------- self.assertTrue(match == cloned_spec) self.assertTrue(cloned_spec == match)
def test_parse_and_write_proto_spec(self): data = StringIO(ALERTZ_PROTO_SPEC) str_ps_parser = StringProtoSpecParser( data) # data should be file-like # object model from string serialization str_obj_model = str_ps_parser.parse() self.assertIsNotNone(str_obj_model) self.assertTrue(isinstance(str_obj_model, M.ProtoSpec)) self.assertEqual('org.xlattice.alertz', str_obj_model.name) self.assertEqual(0, len(str_obj_model.enums)) self.assertEqual(16, len(str_obj_model.msgs)) self.assertEqual(0, len(str_obj_model.seqs)) msg_spec = str_obj_model.msgs[0] self.assertEqual(msg_spec.field_name(0), 'timestamp') self.assertEqual(msg_spec.field_type_name(0), 'fuint32') self.assertEqual(msg_spec.field_name(1), 'seq_nbr') self.assertEqual(msg_spec.field_type_name(1), 'vuint32') self.assertEqual(msg_spec.field_name(2), 'zone_name') self.assertEqual(msg_spec.field_type_name(2), 'lstring') self.assertEqual(msg_spec.field_name(3), 'expected_serial') self.assertEqual(msg_spec.field_type_name(3), 'vuint32') self.assertEqual(msg_spec.field_name(4), 'actual_serial') self.assertEqual(msg_spec.field_type_name(4), 'vuint32')
def setUp(self): data = StringIO(ZOGGERY_PROTO_SPEC) ppp = StringProtoSpecParser(data) # data should be file-like self.assertTrue(ppp is not None) self.str_obj_model = ppp.parse() # object model from string serialization self.assertTrue(self.str_obj_model is not None) self.proto_name = self.str_obj_model.name # the dotted name of the protocol # DEBUG print("setUp: proto name is %s" % self.proto_name)
def test_round_trip_ring_data_instances_to_wire_format(self): str_spec = StringIO(RING_DATA_PROTO_SPEC) ppp = StringProtoSpecParser(str_spec) ring_data_spec = ppp.parse() count = 3 + RNG.next_int16(6) # so 3..8 inclusive # make that many semi-random nodes, taking care to avoid duplicates, # and round-trip each for _ in range(count): ring_host = HostInfo.create_random_host() self.round_trip_ring_data_instance_to_wire_format( ring_data_spec, ring_host)
def test_nested_msgs(self): """ XXX so far this is just testNestedEnum XXX """ data = StringIO(NESTED_MSGS_PROTO_SPEC) ppp = StringProtoSpecParser(data) # data should be file-like str_obj_model = ppp.parse() # object model from string serialization self.assertIsNotNone(str_obj_model) self.assertTrue(isinstance(str_obj_model, M.ProtoSpec)) self.assertEqual('org.xlattice.zoggery.nm', str_obj_model.name) self.assertEqual(1, len(str_obj_model.msgs)) msg = str_obj_model.msgs[0] self.assertEqual('nestedMsgs', msg.name) enums = msg.enums self.assertIsNotNone(enums) self.assertEqual(2, len(enums)) foo_enum = enums[0] bar_enum = enums[1] self.assertEqual('Foo', foo_enum.name) self.assertEqual('Bar', bar_enum.name) self.assertEqual(2, len(foo_enum)) self.assertEqual(3, len(bar_enum)) a_pair = foo_enum[0] self.assertEqual('aVal', a_pair.symbol) self.assertEqual(1, a_pair.value) b_pair = foo_enum[1] self.assertEqual('b_val', b_pair.symbol) self.assertEqual(2, b_pair.value) c_pair = bar_enum[0] self.assertEqual('cVal', c_pair.symbol) self.assertEqual(3, c_pair.value) d_pair = bar_enum[1] self.assertEqual('dVal', d_pair.symbol) self.assertEqual(4, d_pair.value) e_pair = bar_enum[2] self.assertEqual('exc', e_pair.symbol) self.assertEqual(5, e_pair.value) self.round_trip_poto_spec_via_string(str_obj_model)
def setUp(self): # data = StringIO(ALERTZ_PROTO_SPEC) # str_ps_parser = StringProtoSpecParser(data) # data must be file-like # # object model from string serialization # self.str_obj_model = str_ps_parser.parse() # self.proto_name = self.str_obj_model.name # dotted name of protocol data = StringIO(ALERTZ_PROTO_SPEC) print("AAA") str_ps_parser = StringProtoSpecParser(data) # data must be file-like print("BBB") # object model from string serialization self.str_obj_model = str_ps_parser.parse() print("CCC") self.proto_name = self.str_obj_model.name # dotted name of protocol print("NNN")
def test_parse_and_write_proto_spec(self): data = StringIO(ALERTZ_PROTO_SPEC) str_ps_parser = StringProtoSpecParser(data) # data should be file-like # object model from string serialization str_obj_model = str_ps_parser.parse() self.assertIsNotNone(str_obj_model) self.assertTrue(isinstance(str_obj_model, M.ProtoSpec)) self.assertEqual('org.xlattice.alertz', str_obj_model.name) self.assertEqual(0, len(str_obj_model.enums)) self.assertEqual(16, len(str_obj_model.msgs)) self.assertEqual(0, len(str_obj_model.seqs)) msg_spec = str_obj_model.msgs[0] self.assertEqual(msg_spec.field_name(0), 'timestamp') self.assertEqual(msg_spec.field_type_name(0), 'fuint32') self.assertEqual(msg_spec.field_name(1), 'seq_nbr') self.assertEqual(msg_spec.field_type_name(1), 'vuint32') self.assertEqual(msg_spec.field_name(2), 'zone_name') self.assertEqual(msg_spec.field_type_name(2), 'lstring') self.assertEqual(msg_spec.field_name(3), 'expected_serial') self.assertEqual(msg_spec.field_type_name(3), 'vuint32') self.assertEqual(msg_spec.field_name(4), 'actual_serial') self.assertEqual(msg_spec.field_type_name(4), 'vuint32')
from alertz_proto_spec import ALERTZ_PROTO_SPEC __all__ = ['__version__', '__version_date__', 'ALERTZ_MAX_MSG', 'ALERTZ_PORT', 'BUFSIZE', 'Namespace', 'STR_OBJ_MODEL', 'PROTO_NAME', 'ZONE_MISMATCH_MSG', 'CORRUPT_LIST_MSG', 'SHUTDOWN_MSG', ] __version__ = '0.2.20' __version_date__ = '2018-03-11' BUFSIZE = 16 * 1024 # must allow for all using protocols # SYNTACTIC MACHINERY ----------------------------------------------- PROTO_TEXT = StringIO(ALERTZ_PROTO_SPEC) # file-like STR_PS_PARSER = StringProtoSpecParser(PROTO_TEXT) # object model from string serialization STR_OBJ_MODEL = STR_PS_PARSER.parse() # the dotted name of the protocol PROTO_NAME = STR_OBJ_MODEL.name ZONE_MISMATCH_MSG = make_msg_class(STR_OBJ_MODEL, 'zoneMismatch') CORRUPT_LIST_MSG = make_msg_class(STR_OBJ_MODEL, 'corruptList') SHUTDOWN_MSG = make_msg_class(STR_OBJ_MODEL, 'shutdown') # the maximum number of bytes in a message ALERTZ_MAX_MSG = 512 ALERTZ_PORT = 55555 # -- NAME SPACE ----------------------------------------------------- # code.activestate.com/recipes/577887-a-simple-namespace-class offers
__all__ = ['__version__', '__version_date__', 'ALERTZ_MAX_MSG', 'ALERTZ_PORT', 'BUFSIZE', 'Namespace', 'STR_OBJ_MODEL', 'PROTO_NAME', 'ZONE_MISMATCH_MSG', 'CORRUPT_LIST_MSG', 'SHUTDOWN_MSG', ] __version__ = '0.2.12' __version_date__ = '2016-11-08' BUFSIZE = 16 * 1024 # must allow for all using protocols # SYNTACTIC MACHINERY ----------------------------------------------- PROTO_TEXT = StringIO(ALERTZ_PROTO_SPEC) # file-like STR_PS_PARSER = StringProtoSpecParser(PROTO_TEXT) # object model from string serialization STR_OBJ_MODEL = STR_PS_PARSER.parse() # the dotted name of the protocol PROTO_NAME = STR_OBJ_MODEL.name ZONE_MISMATCH_MSG = make_msg_class(STR_OBJ_MODEL, 'zoneMismatch') CORRUPT_LIST_MSG = make_msg_class(STR_OBJ_MODEL, 'corruptList') SHUTDOWN_MSG = make_msg_class(STR_OBJ_MODEL, 'shutdown') # the maximum number of bytes in a message ALERTZ_MAX_MSG = 512 ALERTZ_PORT = 55555 # -- NAME SPACE ----------------------------------------------------- # code.activestate.com/recipes/577887-a-simple-namespace-class offers
def setUp(self): data = StringIO(ZOGGERY_PROTO_SPEC) ppp = StringProtoSpecParser(data) # data should be file-like self.str_obj_model = ppp.parse() # object model from string serialization
def make_str_obj_model(self): # MODEL: testProtoSpec XXX data = StringIO(RING_DATA_PROTO_SPEC) ppp = StringProtoSpecParser(data) str_obj_model = ppp.parse() # object model from string serialization return str_obj_model
def setUp(self): self.rng = SimpleRNG(time.time()) data = StringIO(LITTLE_BIG_PROTO_SPEC) ppp = StringProtoSpecParser(data) # data should be file-like self.str_obj_model = ppp.parse() # object model from string serialization self.proto_name = self.str_obj_model.name # the dotted name of the protocol