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 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
