def TestFunc(self, req=req, files=files, resp=resp):
if self.http_method == "POST":
log.write("URL[%s]\n\tPOST data: %s\n\tresp: %s\n\n" % (self.url, json.dumps(req), json.dumps(resp)))
# send the request
if files:
r = self.http_session.post(self.url, data=req, files=files)
else:
r = self.http_session.post(self.url, data=req)
self.assertEqual(r.status_code, 200)
real_resp = r.json()
#print real_resp
# check the resp
self.assertTrue(CheckDictContain_v2(resp, real_resp))
res = True
try:
dict_to_protobuf(self.resp_type, real_resp)
except Exception, e:
res = False
self.assertTrue(res)
def test_dict_to_protobuf(self):
pb = bess_msg.CreatePortResponse()
pb.error.code = 1
pb.error.errmsg = 'bar'
pb.name = 'foo'
msg_dict = {
'error': {
'code': 1,
'errmsg': 'bar',
},
'name': 'foo'
}
msg = pb_conv.dict_to_protobuf(bess_msg.CreatePortResponse, msg_dict)
self.assertEqual(msg, pb)
pb = bess_msg.CreateModuleRequest()
pb.name = 'm1'
pb.mclass = 'bpf'
kv = {
'name': 'm1',
'mclass': 'bpf',
}
msg = pb_conv.dict_to_protobuf(bess_msg.CreateModuleRequest, kv)
self.assertEqual(msg, pb)
def test_message_with_proto3_bool_dict_to_protobuf(self):
d = {'bool_field': False}
m = dict_to_protobuf(d, SomeMessage)
self.assertEqual(m.bool_field, False)
d = {'bool_field': True}
m = dict_to_protobuf(d, SomeMessage)
self.assertEqual(m.bool_field, True)
def test_message_with_proto3_enum_dict_to_protobuf(self):
d = {'enum_field': 0}
m = dict_to_protobuf(d, SomeMessage)
self.assertEqual(m.enum_field, 0)
d = {'enum_field': 1}
m = dict_to_protobuf(d, SomeMessage)
self.assertEqual(m.enum_field, 1)
def test_strict(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
d['meow'] = 1
with nose.tools.assert_raises(KeyError):
m2 = dict_to_protobuf(d, MessageOfTypes)
m2 = dict_to_protobuf(d, MessageOfTypes, strict=False)
assert m == m2
def test_strict(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
d['meow'] = 1
with pytest.raises(KeyError):
m2 = dict_to_protobuf(MessageOfTypes, d)
m2 = dict_to_protobuf(MessageOfTypes, d, strict=False)
assert m == m2
def test_strict(self, add_class_metadata, overwrite_package_with_name):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(
m,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
d['meow'] = 1
with nose.tools.assert_raises(KeyError):
m2 = dict_to_protobuf(MessageOfTypes, d)
m2 = dict_to_protobuf(MessageOfTypes, d, strict=False)
assert m == m2
def test_repeated_enum(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m, use_enum_labels=True)
self.compare(m, d, ['enm', 'enmRepeated', 'nestedRepeated'])
assert d['enmRepeated'] == ['A', 'C']
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
d['enmRepeated'] = ['MEOW']
with nose.tools.assert_raises(KeyError):
dict_to_protobuf(MessageOfTypes, d)
def test_repeated_enum(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m, use_enum_labels=True)
self.compare(m, d, ['enm', 'enmRepeated', 'nestedRepeated'])
assert d['enmRepeated'] == ['A', 'C']
m2 = dict_to_protobuf(d, MessageOfTypes)
assert m == m2
d['enmRepeated'] = ['MEOW']
with nose.tools.assert_raises(KeyError):
dict_to_protobuf(d, MessageOfTypes)
def run_module_command(self, name, cmd, arg_type, arg):
request = bess_msg.CommandRequest()
request.name = name
request.cmd = cmd
try:
message_type = getattr(module_msg, arg_type)
except AttributeError as e:
raise self.APIError('Unknown arg "%s"' % arg_type)
try:
arg_msg = pb_conv.dict_to_protobuf(message_type, arg)
except (KeyError, ValueError) as e:
raise self.APIError(e)
request.arg.Pack(arg_msg)
try:
response = self._request('ModuleCommand', request)
except self.Error as e:
e.info.update(module=name, command=cmd, command_arg=arg)
raise
if response.HasField('data'):
response_type_str = response.data.type_url.split('.')[-1]
response_type = getattr(module_msg, response_type_str,
bess_msg.EmptyArg)
result = response_type()
response.data.Unpack(result)
return result
else:
return response
def test_extensions(self, add_class_metadata, overwrite_package_with_name):
m = MessageOfTypes()
primitives = {
extDouble: 123.4,
extString: "string",
NestedExtension.extInt: 4
}
for key, value in primitives.items():
m.Extensions[key] = value
m.Extensions[NestedExtension.extNested].req = "nested"
# Confirm compatibility with JSON serialization
res = json.loads(
json.dumps(
protobuf_to_dict(
m,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)))
assert '___X' in res
exts = res['___X']
assert set(exts.keys()) == set(
[str(f.number) for f, _ in m.ListFields() if f.is_extension])
for key, value in primitives.items():
assert exts[str(key.number)] == value
assert exts[str(NestedExtension.extNested.number)]['req'] == 'nested'
deser = dict_to_protobuf(MessageOfTypes, res)
assert deser
for key, value in primitives.items():
assert deser.Extensions[key] == m.Extensions[key]
assert deser.Extensions[NestedExtension.extNested].req == m.Extensions[
NestedExtension.extNested].req
def dumps(obj):
"""
Serializes a dictionary into Manifest data.
:param obj: A dictionary to serialize.
:return: A file object.
"""
if not isinstance(obj, dict):
raise TypeError('can only dump a dictionary as a Manifest but got ' + type(obj).__name__)
data = []
int32 = struct.Struct('<I')
for message_name in ('payload', 'metadata', 'signature'):
message_data = obj[message_name]
message_id = MSG_IDS[message_name]
message_class = MessageClass[message_id]
message = dict_to_protobuf(message_class, message_data)
message_bytes = message.SerializeToString()
message_size = len(message_bytes)
data.append(int32.pack(message_id))
data.append(int32.pack(message_size))
data.append(message_bytes)
# MSG_EOF marks the end of messages.
data.append(int32.pack(MSG_EOF))
return b''.join(data)
def test_pass_instance(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
d['dubl'] = 1
m2 = dict_to_protobuf(d, m)
assert m is m2
assert m.dubl == 1
def test_basics(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
self.compare(m, d, ['nestedRepeated', 'nestedMap'])
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
def test_basics(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
self.compare(m, d, ['nestedRepeated'])
m2 = dict_to_protobuf(d, MessageOfTypes)
assert m == m2
def decode_part(self, part):
headers, content = part[0], part[1]
content_type, params = self._parse_content_type(headers['Content-Type']) #@UnusedVariable
if params['serial'] != self.SERIAL_FORMAT:
raise TypeError("Unable to decode %s, of content_type='%s'" % (params['serial'], part['Content-Type']))
klass = self.get_class(params['proto'])
return dict_to_protobuf(klass, content, strict=False)
def dumps(obj):
"""
Serializes a dictionary into Manifest data.
:param obj: A dictionary to serialize.
:return: A file object.
"""
if not isinstance(obj, dict):
raise TypeError('can only dump a dictionary as a Manifest but got ' +
type(obj).__name__)
data = []
int32 = struct.Struct('<I')
for message_name in ('payload', 'metadata', 'signature'):
message_data = obj[message_name]
message_id = MSG_IDS[message_name]
message_class = MessageClass[message_id]
message = dict_to_protobuf(message_class, message_data)
message_bytes = message.SerializeToString()
message_size = len(message_bytes)
data.append(int32.pack(message_id))
data.append(int32.pack(message_size))
data.append(message_bytes)
# MSG_EOF marks the end of messages.
data.append(int32.pack(MSG_EOF))
return b''.join(data)
def test_incomplete(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
d.pop('dubl')
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m2.dubl == 0
assert m != m2
def test_incomplete(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
d.pop('dubl')
m2 = dict_to_protobuf(d, MessageOfTypes)
assert m2.dubl == 0
assert m != m2
def test_pass_instance(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m)
d['dubl'] = 1
m2 = dict_to_protobuf(m, d)
assert m is m2
assert m.dubl == 1
def test_value_in_dict_is_none(self):
m = self.populate_MessageOfTypes()
res = protobuf_to_dict(m)
res['optional_string'] = None
res['nested'] = None
d = dict_to_protobuf(res, MessageOfTypes)
self.assertEqual(d.optional_string, '')
def test_use_enum_labels(self, add_class_metadata,
overwrite_package_with_name):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(
m,
use_enum_labels=True,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
self.compare(m,
d, ['enm', 'enmRepeated', 'nestedRepeated'],
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
assert d['enm'] == 'C'
assert d['enmRepeated'] == ['A', 'C']
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
d['enm'] = 'MEOW'
with nose.tools.assert_raises(KeyError):
dict_to_protobuf(MessageOfTypes, d)
d['enm'] = 'A'
d['enmRepeated'] = ['B']
dict_to_protobuf(MessageOfTypes, d)
d['enmRepeated'] = ['CAT']
with nose.tools.assert_raises(KeyError):
dict_to_protobuf(MessageOfTypes, d)
def list_all_available_users(self, action):
reply = cpb.server_action()
for users in self.userList:
reply.contacts.user.add()
user = dict_to_protobuf(cpb.User, values=users)
reply.contacts.user.append(user)
reply.action = 'ACK'
reply.result = 'Server listing all possible user'
return reply
def test_lowercase_enum_lables_work(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m,
use_enum_labels=True,
lowercase_enum_lables=True)
self.compare(m, d,
['enm', 'enmRepeated', 'nestedRepeated', 'nestedMap'])
assert d['enm'] == 'c'
assert d['enmRepeated'] == ['a', 'c']
d['enm'] = 'meow'
d['enm'] = 'a'
d['enmRepeated'] = ['a', 'c']
with pytest.raises(KeyError):
dict_to_protobuf(MessageOfTypes, d)
dict_to_protobuf(MessageOfTypes, d, strict=False)
def decode_part(self, part):
headers, content = part[0], part[1]
content_type, params = self._parse_content_type(
headers['Content-Type']) #@UnusedVariable
if params['serial'] != self.SERIAL_FORMAT:
raise TypeError("Unable to decode %s, of content_type='%s'" %
(params['serial'], part['Content-Type']))
klass = self.get_class(params['proto'])
return dict_to_protobuf(klass, content, strict=False)
def test_nested_ignore_none(self):
m = MessageOfTypes()
m.nestedMap['123'].req = '42'
d = protobuf_to_dict(m)
d['nestedMap']['123']['req'] = None
m2 = dict_to_protobuf(MessageOfTypes, d, ignore_none=True)
assert m2.nestedMap['123'].req == ''
def test_nested_ignore_none(self):
m = MessageOfTypes()
m.nestedMap['123'].req = '42'
d = protobuf_to_dict(m)
d['nestedMap']['123']['req'] = None
m2 = dict_to_protobuf(MessageOfTypes, d, ignore_none=True)
assert m2.nestedMap['123'].req == ''
def test_ignore_none(self):
m = MessageOfTypes()
d = protobuf_to_dict(m)
assert d == {}
for field in m.DESCRIPTOR.fields:
d[field.name] = None
m2 = dict_to_protobuf(MessageOfTypes, d, ignore_none=True)
assert m == m2
def test_incomplete(self, add_class_metadata, overwrite_package_with_name):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(
m,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
d.pop('dubl')
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m2.dubl == 0
assert m != m2
def test_type_callable_map_used_for_maps(self):
# we give a string key and value and ensure they get run through int()
d = {}
d['intMap'] = {}
d['intMap']['123'] = '456'
type_callable_map = {FieldDescriptor.TYPE_INT32: int}
m = dict_to_protobuf(MessageOfTypes, d, type_callable_map)
assert m.intMap[123] == 456
def test_pb_convert_to_dict_with_datetime_and_back(self):
now = datetime.datetime.utcnow()
timestamp = datetime_to_timestamp(now)
obj1 = sample_pb2.Obj(item_id="item id", transacted_at=timestamp)
pb_dict = protobuf_to_dict(obj1)
assert pb_dict['transacted_at'] == now
obj1_again = dict_to_protobuf(sample_pb2.Obj, values=pb_dict)
assert obj1 == obj1_again
def test_nested_repeated(self):
m = self.populate_MessageOfTypes()
m.nestedRepeated.extend([MessageOfTypes.NestedType(req=str(i)) for i in range(10)])
d = protobuf_to_dict(m)
self.compare(m, d, exclude=['nestedRepeated'])
assert d['nestedRepeated'] == [{'req': str(i)} for i in range(10)]
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
def test_nested_repeated(self):
m = self.populate_MessageOfTypes()
m.nestedRepeated.extend([MessageOfTypes.NestedType(req=str(i)) for i in range(10)])
d = protobuf_to_dict(m)
self.compare(m, d, exclude=['nestedRepeated'])
assert d['nestedRepeated'] == [{'req': str(i)} for i in range(10)]
m2 = dict_to_protobuf(d, MessageOfTypes)
assert m == m2
def test_ignore_none(self):
m = MessageOfTypes()
d = protobuf_to_dict(m)
assert d == {}
for field in m.DESCRIPTOR.fields:
d[field.name] = None
m2 = dict_to_protobuf(MessageOfTypes, d, ignore_none=True)
assert m == m2
def test_reverse(self, add_class_metadata, overwrite_package_with_name):
m = self.populate_MessageOfTypes()
m2 = dict_to_protobuf(
MessageOfTypes,
protobuf_to_dict(
m,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name))
assert m == m2
m2.dubl = 0
assert m2 != m
def test_pass_instance(self, add_class_metadata,
overwrite_package_with_name):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(
m,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
d['dubl'] = 1
m2 = dict_to_protobuf(m, d)
assert m is m2
assert m.dubl == 1
def create_module(self, mclass, name=None, arg=None):
arg = arg or {}
request = bess_msg.CreateModuleRequest()
request.name = name or ''
request.mclass = mclass
message_type = getattr(module_msg, mclass + 'Arg', bess_msg.EmptyArg)
arg_msg = pb_conv.dict_to_protobuf(message_type, arg)
request.arg.Pack(arg_msg)
return self._request('CreateModule', request)
def test_including_default_value_fields(self):
m = MessageOfTypes()
d = protobuf_to_dict(m)
assert d == {}
d = protobuf_to_dict(m, including_default_value_fields=True)
for field in m.DESCRIPTOR.fields:
if field.name != 'nested':
assert field.name in d, field.name
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
def test_including_default_value_fields(self):
m = MessageOfTypes()
d = protobuf_to_dict(m)
assert d == {}
d = protobuf_to_dict(m, including_default_value_fields=True)
for field in m.DESCRIPTOR.fields:
if field.name != 'nested':
assert field.name in d, field.name
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
async def send(self, path, callback, msg=None):
try:
while self._ws is None:
await asyncio.sleep(1)
self._msgIndex %= 60007
method = self._addrBook.DESCRIPTOR.services_by_name[
self._serviceRoot].methods_by_name[path]
except KeyError:
print('API not exist')
return
obj = reflection.MakeClass(method.input_type)()
self._msgPool[self._msgIndex] = (reflection.MakeClass(
method.output_type), callback)
if msg is not None:
dict_to_protobuf(obj, msg)
self._wrapper.name = bytes('.' + method.full_name, 'utf-8')
self._wrapper.data = obj.SerializeToString()
req = self.__class__._msgType['req'] + bytes([
self._msgIndex % 256, self._msgIndex // 256
]) + self._wrapper.SerializeToString()
self._msgIndex += 1
await self._ws.send(req)
def test_nested_map(self):
m = self.populate_MessageOfTypes()
for i in range(10):
m.nestedMap[str(i)].req = str(i**2)
d = protobuf_to_dict(m)
self.compare(m, d, exclude=['nestedRepeated', 'nestedMap'])
assert d['nestedMap'] == {
str(i): {'req': str(i**2)} for i in range(10)
}
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
def test_basics(self, add_class_metadata, overwrite_package_with_name):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(
m,
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
print("overwrite_package_with_name: %s" % overwrite_package_with_name)
self.compare(m,
d, ['nestedRepeated'],
add_class_metadata=add_class_metadata,
overwrite_package_with_name=overwrite_package_with_name)
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
def create_port(self, driver, name=None, arg=None):
arg = arg or {}
request = bess_msg.CreatePortRequest()
request.name = name or ''
request.driver = driver
request.num_inc_q = arg.pop('num_inc_q', 0)
request.num_out_q = arg.pop('num_out_q', 0)
request.size_inc_q = arg.pop('size_inc_q', 0)
request.size_out_q = arg.pop('size_out_q', 0)
request.mac_addr = arg.pop('mac_addr', '')
message_type = getattr(port_msg, driver + 'Arg', bess_msg.EmptyArg)
arg_msg = pb_conv.dict_to_protobuf(message_type, arg)
request.arg.Pack(arg_msg)
return self._request('CreatePort', request)
def test_nested_map(self):
m = self.populate_MessageOfTypes()
for i in range(10):
m.nestedMap[str(i)].req = str(i**2)
d = protobuf_to_dict(m)
self.compare(m, d, exclude=['nestedRepeated', 'nestedMap'])
assert d['nestedMap'] == {
str(i): {
'req': str(i**2)
}
for i in range(10)
}
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
def _to_pb(self, req, url_params):
"""Return a protobuf given the request and the URL params."""
body = req.stream.read() or '{}'
try:
body_dict = json.loads(body)
except ValueError:
raise falcon.HTTPBadRequest('Invalid request',
'Cannot parse JSON in request body.')
# Copy URL params and URL query params.
for params in (url_params, req.params):
for key in params:
body_dict[key] = params[key]
pb_class = getattr(self.pb_class, req.method)
return protobuf_to_dict.dict_to_protobuf(pb_class, body_dict)
def __init__(self, load_all=False, init_file=DB_INIT_FNAME):
init_data = None
if exists(init_file) and access(init_file, R_OK):
try:
with open(init_file) as f:
tmp = json.load(f)
if tmp is not None and 'data' in tmp:
init_data = dict_to_protobuf(db, tmp['data'])
except EnvironmentError:
self.logger.debug("DB file does not exist, creating new ...")
except (ValueError, KeyError):
self.logger.warning("Wrong format of DB file, ignoring ...")
if init_data:
self.data = init_data
if not load_all:
self.data.oper.Clear()
else:
self.data = db()
self.dump()
def test_use_enum_labels(self):
m = self.populate_MessageOfTypes()
d = protobuf_to_dict(m, use_enum_labels=True)
self.compare(m, d, ['enm', 'enmRepeated', 'nestedRepeated', 'nestedMap'])
assert d['enm'] == 'C'
assert d['enmRepeated'] == ['A', 'C']
m2 = dict_to_protobuf(MessageOfTypes, d)
assert m == m2
d['enm'] = 'MEOW'
with nose.tools.assert_raises(KeyError):
dict_to_protobuf(MessageOfTypes, d)
d['enm'] = 'A'
d['enmRepeated'] = ['B']
dict_to_protobuf(MessageOfTypes, d)
d['enmRepeated'] = ['CAT']
with nose.tools.assert_raises(KeyError):
dict_to_protobuf(MessageOfTypes, d)
def test_extensions(self):
m = MessageOfTypes()
primitives = {extDouble: 123.4, extString: "string", NestedExtension.extInt: 4}
for key, value in primitives.items():
m.Extensions[key] = value
m.Extensions[NestedExtension.extNested].req = "nested"
# Confirm compatibility with JSON serialization
res = json.loads(json.dumps(protobuf_to_dict(m)))
assert '___X' in res
exts = res['___X']
assert set(exts.keys()) == set([str(f.number) for f, _ in m.ListFields() if f.is_extension])
for key, value in primitives.items():
assert exts[str(key.number)] == value
assert exts[str(NestedExtension.extNested.number)]['req'] == 'nested'
deser = dict_to_protobuf(res, MessageOfTypes)
assert deser
for key, value in primitives.items():
assert deser.Extensions[key] == m.Extensions[key]
assert deser.Extensions[NestedExtension.extNested].req == m.Extensions[NestedExtension.extNested].req
def login_proxy_body_serialize2(datadic):
#εΊεεη
datapb = (dict_to_protobuf(getattr(testim_pb_pb2, 'login_proxy'), datadic)).SerializeToString()
return datapb
def to_bin(self):
return dict_to_protobuf(MortgagePB, self.to_dict()).SerializeToString()
def test_message_with_proto3_map_dict_to_protobuf(self):
d = {'some_map': {'key1': 'value1', 'key2': 'value2'}}
m = dict_to_protobuf(d, SomeMessage)
self.assertEqual(m.some_map['key1'], d['some_map']['key1'])
self.assertEqual(m.some_map['key2'], d['some_map']['key2'])
def to_bin(self):
return dict_to_protobuf(InvestmentPB, self.to_dict()).SerializeToString()
def test_reverse(self):
m = self.populate_MessageOfTypes()
m2 = dict_to_protobuf(protobuf_to_dict(m), MessageOfTypes)
assert m == m2
m2.dubl = 0
assert m2 != m
def to_bin(self):
return dict_to_protobuf(ConfirmationPB, self.to_dict()).SerializeToString()
def _encode_protobuf(self, message_cls, message):
return dict_to_protobuf(message_cls, message.payload.dictionary).SerializeToString(),
