def __init__(self, rpc_connection, stream_connection):
self._types = Types()
self._rpc_connection = rpc_connection
self._rpc_connection_lock = threading.Lock()
self._stream_connection = stream_connection
self._stream_cache = {}
self._stream_cache_lock = threading.Lock()
self._request_type = self._types.as_type('KRPC.Request')
self._response_type = self._types.as_type('KRPC.Response')
# Get the services
services = self._invoke('KRPC', 'GetServices', [], [], [],
self._types.as_type('KRPC.Services')).services
# Set up services
for service in services:
setattr(self, snake_case(service.name),
create_service(self, service))
# Set up stream update thread
if stream_connection is not None:
self._stream_thread_stop = threading.Event()
self._stream_thread = threading.Thread(
target=krpc.stream.update_thread,
args=(stream_connection, self._stream_thread_stop,
self._stream_cache, self._stream_cache_lock))
self._stream_thread.daemon = True
self._stream_thread.start()
else:
self._stream_thread = None
def __init__(self, rpc_connection, stream_connection):
self._types = Types()
self._rpc_connection = rpc_connection
self._rpc_connection_lock = threading.Lock()
self._stream_connection = stream_connection
self._stream_manager = StreamManager(self)
# Get the services
services = self._invoke('KRPC', 'GetServices', [], [], [],
self._types.services_type).services
# Set up services
for service in services:
setattr(self, snake_case(service.name),
create_service(self, service))
# Set up stream update thread
if stream_connection is not None:
self._stream_thread_stop = threading.Event()
self._stream_thread = threading.Thread(
target=krpc.streammanager.update_thread,
args=(self._stream_manager, stream_connection,
self._stream_thread_stop))
self._stream_thread.daemon = True
self._stream_thread.start()
else:
self._stream_thread = None
def test_tuple_3_types(self):
types = Types()
typ = types.tuple_type(types.float_type, types.uint64_type,
types.string_type)
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.check_protobuf_type(Type.TUPLE, '', '', 3, typ.protobuf_type)
self.check_protobuf_type(Type.FLOAT, '', '', 0,
typ.protobuf_type.types[0])
self.check_protobuf_type(Type.UINT64, '', '', 0,
typ.protobuf_type.types[1])
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.protobuf_type.types[2])
self.assertEqual(3, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertTrue(isinstance(typ.value_types[2], ValueType))
self.assertEqual(float, typ.value_types[0].python_type)
self.assertEqual(int, typ.value_types[1].python_type)
self.assertEqual(str, typ.value_types[2].python_type)
self.check_protobuf_type(Type.FLOAT, '', '', 0,
typ.value_types[0].protobuf_type)
self.check_protobuf_type(Type.UINT64, '', '', 0,
typ.value_types[1].protobuf_type)
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.value_types[2].protobuf_type)
def test_enumeration_types(self):
types = Types()
typ = types.enumeration_type('ServiceName', 'EnumName',
'enum documentation')
self.assertTrue(isinstance(typ, EnumerationType))
self.assertIsNone(typ.python_type)
self.check_protobuf_type(Type.ENUMERATION, 'ServiceName', 'EnumName',
0, typ.protobuf_type)
typ.set_values({
'a': {
'value': 0,
'doc': 'doca'
},
'b': {
'value': 42,
'doc': 'docb'
},
'c': {
'value': 100,
'doc': 'docc'
}
})
self.assertTrue(issubclass(typ.python_type, Enum))
self.assertEqual('enum documentation', typ.python_type.__doc__)
self.assertEqual(0, typ.python_type.a.value)
self.assertEqual(42, typ.python_type.b.value)
self.assertEqual(100, typ.python_type.c.value)
self.assertEqual('doca', typ.python_type.a.__doc__)
self.assertEqual('docb', typ.python_type.b.__doc__)
self.assertEqual('docc', typ.python_type.c.__doc__)
typ2 = types.as_type(typ.protobuf_type)
self.assertEqual(typ, typ2)
def decode_default_value(value, typ):
value = base64.b64decode(value)
value = array.array('B', value).tostring()
# Note: following is a workaround for decoding EnumerationType,
# as set_values has not been called
if not isinstance(typ, EnumerationType):
return Decoder.decode(value, typ)
return Decoder.decode(value, Types().sint32_type)
def test_value_types(self):
types = Types()
for protobuf_typ in PROTOBUF_VALUE_TYPES:
python_typ = PROTOBUF_TO_PYTHON_VALUE_TYPE[protobuf_typ]
typ = types.as_type(protobuf_typ)
self.assertTrue(isinstance(typ, ValueType))
self.assertEqual(protobuf_typ, typ.protobuf_type)
self.assertEqual(python_typ, typ.python_type)
self.assertRaises(ValueError, ValueType, 'invalid')
class TestDecoder(unittest.TestCase):
types = Types()
def test_decode_message(self):
typ = krpc.schema.KRPC.Request
message = '0a0b536572766963654e616d65120d50726f6365647572654e616d65'
request = Decoder.decode(unhexlify(message),
self.types.as_type('KRPC.Request'))
self.assertEqual('ServiceName', request.service)
self.assertEqual('ProcedureName', request.procedure)
def test_decode_value(self):
value = Decoder.decode(unhexlify('ac02'), self.types.as_type('int32'))
self.assertEqual(int(300), value)
def test_decode_unicode_string(self):
value = Decoder.decode(unhexlify('03e284a2'),
self.types.as_type('string'))
self.assertEqual(b'\xe2\x84\xa2'.decode('utf-8'), value)
def test_decode_size_and_position(self):
message = '1c'
size, position = Decoder.decode_size_and_position(unhexlify(message))
self.assertEqual(28, size)
self.assertEqual(1, position)
def test_decode_message_delimited(self):
typ = krpc.schema.KRPC.Request
message = '1c' + '0a0b536572766963654e616d65120d50726f6365647572654e616d65'
request = Decoder.decode_delimited(unhexlify(message),
self.types.as_type('KRPC.Request'))
self.assertEqual('ServiceName', request.service)
self.assertEqual('ProcedureName', request.procedure)
def test_decode_value_delimited(self):
value = Decoder.decode_delimited(unhexlify('02' + 'ac02'),
self.types.as_type('int32'))
self.assertEqual(300, value)
def test_decode_class(self):
typ = self.types.as_type('Class(ServiceName.ClassName)')
value = Decoder.decode(unhexlify('ac02'), typ)
self.assertTrue(isinstance(value, typ.python_type))
self.assertEqual(300, value._object_id)
def test_decode_class_none(self):
typ = self.types.as_type('Class(ServiceName.ClassName)')
value = Decoder.decode(unhexlify('00'), typ)
self.assertIsNone(value)
def test_guid(self):
self.assertEqual(
'6f271b39-00dd-4de4-9732-f0d3a68838df',
Decoder.guid(unhexlify('391b276fdd00e44d9732f0d3a68838df')))
def update_thread(connection, stop):
stream_message_type = Types().as_type('KRPC.StreamMessage')
response_type = Types().as_type('KRPC.Response')
while True:
# Read the size and position of the response message
data = b''
while True:
try:
data += connection.partial_receive(1)
size,position = Decoder.decode_size_and_position(data)
break
except IndexError:
pass
except:
#TODO: is there a better way to catch exceptions when the thread is forcibly stopped (e.g. by CTRL+c)?
return
if stop.is_set():
connection.close()
return
# Read and decode the response message
data = connection.receive(size)
response = Decoder.decode(data, stream_message_type)
# Add the data to the cache
with _stream_cache_lock:
for response in response.responses:
id = response.id
if id not in _stream_cache:
continue
# Check for an error response
if response.response.has_error:
_stream_cache[id].value = RPCError(response.response.error)
continue
# Decode the return value and store it in the cache
typ = _stream_cache[id].return_type
value = Decoder.decode(response.response.return_value, typ)
_stream_cache[id].update(value)
def test_enum_types(self):
types = Types()
typ = types.as_type('Enum(ServiceName.EnumName)')
self.assertTrue(isinstance(typ, EnumType))
self.assertEqual(None, typ.python_type)
self.assertTrue('Enum(ServiceName.EnumName)', typ.protobuf_type)
typ.set_values({'a': 0, 'b': 42, 'c': 100})
self.assertTrue(issubclass(typ.python_type, Enum))
self.assertEquals(0, typ.python_type.a.value)
self.assertEquals(42, typ.python_type.b.value)
self.assertEquals(100, typ.python_type.c.value)
def test_message_types(self):
types = Types()
cases = [(types.procedure_call_type, Type.PROCEDURE_CALL,
ProcedureCall), (types.stream_type, Type.STREAM, Stream),
(types.status_type, Type.STATUS, Status),
(types.services_type, Type.SERVICES, Services)]
for typ, protobuf_code, python_type in cases:
self.assertTrue(isinstance(typ, MessageType))
self.assertEqual(python_type, typ.python_type)
self.check_protobuf_type(protobuf_code, '', '', 0,
typ.protobuf_type)
def test_message_types(self):
types = Types()
typ = types.as_type('KRPC.Request')
self.assertTrue(isinstance(typ, MessageType))
self.assertEqual(krpc.schema.KRPC.Request, typ.python_type)
self.assertEqual('KRPC.Request', typ.protobuf_type)
self.assertRaises(ValueError, types.as_type, 'KRPC.DoesntExist')
self.assertRaises(ValueError, MessageType, '')
self.assertRaises(ValueError, MessageType, 'invalid')
self.assertRaises(ValueError, MessageType, '.')
self.assertRaises(ValueError, MessageType, 'foo.bar')
class Appendable(object):
def __init__(self):
self._appended = []
types = Types()
def append(self, value):
self._appended.append(value)
@property
def appended(self):
return '\n\n'.join(self._appended)
def test_list_types(self):
types = Types()
typ = types.list_type(types.uint32_type)
self.assertTrue(isinstance(typ, ListType))
self.assertEqual(typ.python_type, list)
self.check_protobuf_type(Type.LIST, '', '', 1, typ.protobuf_type)
self.check_protobuf_type(Type.UINT32, '', '', 0,
typ.protobuf_type.types[0])
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual(int, typ.value_type.python_type)
self.check_protobuf_type(Type.UINT32, '', '', 0,
typ.value_type.protobuf_type)
def test_set_types(self):
types = Types()
typ = types.set_type(types.string_type)
self.assertTrue(isinstance(typ, SetType))
self.assertEqual(typ.python_type, set)
self.check_protobuf_type(Type.SET, '', '', 1, typ.protobuf_type)
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.protobuf_type.types[0])
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual(str, typ.value_type.python_type)
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.value_type.protobuf_type)
def test_class_types(self):
types = Types()
typ = types.as_type('Class(ServiceName.ClassName)')
self.assertTrue(isinstance(typ, ClassType))
self.assertTrue(issubclass(typ.python_type, ClassBase))
self.assertTrue('Class(ServiceName.ClassName)', typ.protobuf_type)
instance = typ.python_type(42)
self.assertEqual(42, instance._object_id)
self.assertEqual('ServiceName', instance._service_name)
self.assertEqual('ClassName', instance._class_name)
typ2 = types.as_type('Class(ServiceName.ClassName)')
self.assertEqual(typ, typ2)
def test_tuple_1_types(self):
types = Types()
typ = types.tuple_type(types.bool_type)
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.check_protobuf_type(Type.TUPLE, '', '', 1, typ.protobuf_type)
self.check_protobuf_type(Type.BOOL, '', '', 0,
typ.protobuf_type.types[0])
self.assertEqual(1, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertEqual(bool, typ.value_types[0].python_type)
self.check_protobuf_type(Type.BOOL, '', '', 0,
typ.value_types[0].protobuf_type)
class TestEncoder(unittest.TestCase):
types = Types()
def test_encode_message(self):
call = self.types.procedure_call_type.python_type()
call.service = 'ServiceName'
call.procedure = 'ProcedureName'
data = Encoder.encode(call, self.types.procedure_call_type)
expected = '0a0b536572766963654e616d65120d50726f6365647572654e616d65'
self.assertEqual(expected, hexlify(data))
def test_encode_value(self):
data = Encoder.encode(300, self.types.uint32_type)
self.assertEqual('ac02', hexlify(data))
def test_encode_unicode_string(self):
data = Encoder.encode(b'\xe2\x84\xa2'.decode('utf-8'),
self.types.string_type)
self.assertEqual('03e284a2', hexlify(data))
def test_encode_message_with_size(self):
call = self.types.procedure_call_type.python_type()
call.service = 'ServiceName'
call.procedure = 'ProcedureName'
data = Encoder.encode_message_with_size(call)
expected = '1c' + \
'0a0b536572766963654e616d6512' + \
'0d50726f6365647572654e616d65'
self.assertEqual(expected, hexlify(data))
def test_encode_class(self):
typ = self.types.class_type('ServiceName', 'ClassName')
class_type = typ.python_type
self.assertTrue(issubclass(class_type, ClassBase))
value = class_type(300)
self.assertEqual(300, value._object_id)
data = Encoder.encode(value, typ)
self.assertEqual('ac02', hexlify(data))
def test_encode_class_none(self):
typ = self.types.class_type('ServiceName', 'ClassName')
value = None
data = Encoder.encode(value, typ)
self.assertEqual('00', hexlify(data))
def test_encode_tuple_wrong_arity(self):
typ = self.types.tuple_type(self.types.uint32_type,
self.types.uint32_type,
self.types.uint32_type)
value = (0, 1)
self.assertRaises(EncodingError, Encoder.encode, value, typ)
def test_get_return_type(self):
types = Types()
self.assertEqual('float',
types.get_return_type('float', []).protobuf_type)
self.assertEqual('int32',
types.get_return_type('int32', []).protobuf_type)
self.assertEqual(
'KRPC.Response',
types.get_return_type('KRPC.Response', []).protobuf_type)
self.assertEqual(
'Class(ServiceName.ClassName)',
types.get_return_type(
'uint64',
['ReturnType.Class(ServiceName.ClassName)']).protobuf_type)
def test_list_types(self):
types = Types()
typ = types.as_type('List(int32)')
self.assertTrue(isinstance(typ, ListType))
self.assertEqual(typ.python_type, list)
self.assertEqual('List(int32)', typ.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('int32', typ.value_type.protobuf_type)
self.assertEqual(int, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'List')
self.assertRaises(ValueError, types.as_type, 'List(')
self.assertRaises(ValueError, types.as_type, 'List()')
self.assertRaises(ValueError, types.as_type, 'List(foo')
self.assertRaises(ValueError, types.as_type, 'List(int32,string)')
def test_class_types(self):
types = Types()
typ = types.class_type('ServiceName', 'ClassName',
'class documentation')
self.assertTrue(isinstance(typ, ClassType))
self.assertTrue(issubclass(typ.python_type, ClassBase))
self.assertEqual('class documentation', typ.python_type.__doc__)
self.check_protobuf_type(Type.CLASS, 'ServiceName', 'ClassName', 0,
typ.protobuf_type)
instance = typ.python_type(42)
self.assertEqual(42, instance._object_id)
self.assertEqual('ServiceName', instance._service_name)
self.assertEqual('ClassName', instance._class_name)
typ2 = types.as_type(typ.protobuf_type)
self.assertEqual(typ, typ2)
def test_set_types(self):
types = Types()
typ = types.as_type('Set(string)')
self.assertTrue(isinstance(typ, SetType))
self.assertEqual(typ.python_type, set)
self.assertEqual('Set(string)', typ.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('string', typ.value_type.protobuf_type)
self.assertEqual(str, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'Set')
self.assertRaises(ValueError, types.as_type, 'Set(')
self.assertRaises(ValueError, types.as_type, 'Set()')
self.assertRaises(ValueError, types.as_type, 'Set(string,)')
self.assertRaises(ValueError, types.as_type, 'Set(,)')
self.assertRaises(ValueError, types.as_type, 'Set(,string)')
self.assertRaises(ValueError, types.as_type, 'Set(int,string))')
def test_value_types(self):
types = Types()
cases = [(types.double_type, Type.DOUBLE, float),
(types.float_type, Type.FLOAT, float),
(types.sint32_type, Type.SINT32, int),
(types.sint64_type, Type.SINT64, int),
(types.uint32_type, Type.UINT32, int),
(types.uint64_type, Type.UINT64, int),
(types.bool_type, Type.BOOL, bool),
(types.string_type, Type.STRING, str),
(types.bytes_type, Type.BYTES, bytes)]
for typ, protobuf_code, python_type in cases:
self.assertTrue(isinstance(typ, ValueType))
self.check_protobuf_type(protobuf_code, '', '', 0,
typ.protobuf_type)
self.assertEqual(python_type, typ.python_type)
def test_coerce_to(self):
types = Types()
cases = [
(42.0, 42, 'double'),
(42.0, 42, 'float'),
(42, 42.0, 'int32'),
(42, 42L, 'int32'),
(42L, 42.0, 'int64'),
(42L, 42, 'int64'),
(42, 42.0, 'uint32'),
(42, 42L, 'uint32'),
(42L, 42.0, 'uint64'),
(42L, 42, 'uint64'),
(list(), tuple(), 'List(string)'),
((0, 1, 2), [0, 1, 2], 'Tuple(int32,int32,int32)'),
([0, 1, 2], (0, 1, 2), 'List(int32)'),
]
for expected, value, typ in cases:
coerced_value = types.coerce_to(value, types.as_type(typ))
self.assertEqual(expected, coerced_value)
self.assertEqual(type(expected), type(coerced_value))
strings = [
u'foo', u'\xe2\x84\xa2',
u'Mystery Goo\xe2\x84\xa2 Containment Unit'
]
for string in strings:
self.assertEqual(string,
types.coerce_to(string, types.as_type('string')))
self.assertEqual(['foo', 'bar'],
types.coerce_to(['foo', 'bar'],
types.as_type('List(string)')))
self.assertRaises(ValueError, types.coerce_to, None,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, '',
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, True,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, list(),
types.as_type('Tuple(int32)'))
self.assertRaises(ValueError, types.coerce_to, ['foo', 2],
types.as_type('Tuple(string)'))
self.assertRaises(ValueError, types.coerce_to, [1],
types.as_type('Tuple(string)'))
def test_dictionary_types(self):
types = Types()
typ = types.dictionary_type(types.string_type, types.uint32_type)
self.assertTrue(isinstance(typ, DictionaryType))
self.assertEqual(typ.python_type, dict)
self.check_protobuf_type(Type.DICTIONARY, '', '', 2, typ.protobuf_type)
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.protobuf_type.types[0])
self.check_protobuf_type(Type.UINT32, '', '', 0,
typ.protobuf_type.types[1])
self.assertTrue(isinstance(typ.key_type, ValueType))
self.assertEqual(str, typ.key_type.python_type)
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.key_type.protobuf_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual(int, typ.value_type.python_type)
self.check_protobuf_type(Type.UINT32, '', '', 0,
typ.value_type.protobuf_type)
def test_tuple_types(self):
types = Types()
typ = types.as_type('Tuple(bool)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(bool)', typ.protobuf_type)
self.assertEqual(1, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertEqual('bool', typ.value_types[0].protobuf_type)
self.assertEqual(bool, typ.value_types[0].python_type)
typ = types.as_type('Tuple(int32,string)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(int32,string)', typ.protobuf_type)
self.assertEqual(2, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertEqual('int32', typ.value_types[0].protobuf_type)
self.assertEqual('string', typ.value_types[1].protobuf_type)
self.assertEqual(int, typ.value_types[0].python_type)
self.assertEqual(str, typ.value_types[1].python_type)
typ = types.as_type('Tuple(float,int64,string)')
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.assertEqual('Tuple(float,int64,string)', typ.protobuf_type)
self.assertEqual(3, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertTrue(isinstance(typ.value_types[2], ValueType))
self.assertEqual('float', typ.value_types[0].protobuf_type)
self.assertEqual('int64', typ.value_types[1].protobuf_type)
self.assertEqual('string', typ.value_types[2].protobuf_type)
self.assertEqual(float, typ.value_types[0].python_type)
self.assertEqual(long, typ.value_types[1].python_type)
self.assertEqual(str, typ.value_types[2].python_type)
self.assertRaises(ValueError, types.as_type, 'Tuple')
self.assertRaises(ValueError, types.as_type, 'Tuple(')
self.assertRaises(ValueError, types.as_type, 'Tuple()')
self.assertRaises(ValueError, types.as_type, 'Tuple(foo')
self.assertRaises(ValueError, types.as_type, 'Tuple(string,)')
self.assertRaises(ValueError, types.as_type, 'Tuple(,)')
self.assertRaises(ValueError, types.as_type, 'Tuple(,string)')
self.assertRaises(ValueError, types.as_type, 'Tuple(int,string))')
def test_tuple_2_types(self):
types = Types()
typ = types.tuple_type(types.uint32_type, types.string_type)
self.assertTrue(isinstance(typ, TupleType))
self.assertEqual(typ.python_type, tuple)
self.check_protobuf_type(Type.TUPLE, '', '', 2, typ.protobuf_type)
self.check_protobuf_type(Type.UINT32, '', '', 0,
typ.protobuf_type.types[0])
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.protobuf_type.types[1])
self.assertEqual(2, len(typ.value_types))
self.assertTrue(isinstance(typ.value_types[0], ValueType))
self.assertTrue(isinstance(typ.value_types[1], ValueType))
self.assertEqual(int, typ.value_types[0].python_type)
self.assertEqual(str, typ.value_types[1].python_type)
self.check_protobuf_type(Type.UINT32, '', '', 0,
typ.value_types[0].protobuf_type)
self.check_protobuf_type(Type.STRING, '', '', 0,
typ.value_types[1].protobuf_type)
def test_dictionary_types(self):
types = Types()
typ = types.as_type('Dictionary(string,int32)')
self.assertTrue(isinstance(typ, DictionaryType))
self.assertEqual(typ.python_type, dict)
self.assertEqual('Dictionary(string,int32)', typ.protobuf_type)
self.assertTrue(isinstance(typ.key_type, ValueType))
self.assertEqual('string', typ.key_type.protobuf_type)
self.assertEqual(str, typ.key_type.python_type)
self.assertTrue(isinstance(typ.value_type, ValueType))
self.assertEqual('int32', typ.value_type.protobuf_type)
self.assertEqual(int, typ.value_type.python_type)
self.assertRaises(ValueError, types.as_type, 'Dictionary')
self.assertRaises(ValueError, types.as_type, 'Dictionary(')
self.assertRaises(ValueError, types.as_type, 'Dictionary()')
self.assertRaises(ValueError, types.as_type, 'Dictionary(foo')
self.assertRaises(ValueError, types.as_type, 'Dictionary(string)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(string,)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(,)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(,string)')
self.assertRaises(ValueError, types.as_type, 'Dictionary(int,string))')
def __init__(self, rpc_connection, stream_connection):
self._types = Types()
self._rpc_connection = rpc_connection
self._rpc_connection_lock = threading.Lock()
self._stream_connection = stream_connection
self._request_type = self._types.as_type('KRPC.Request')
self._response_type = self._types.as_type('KRPC.Response')
# Set up the main KRPC service
self.krpc = KRPC(self)
services = self.krpc.get_services().services
# Create class types
#TODO: is this needed?!?
#for service in services:
# for procedure in service.procedures:
# try:
# name = Attributes.get_class_name(procedure.attributes)
# self._types.as_type('Class(' + service.name + '.' + name + ')')
# except ValueError:
# pass
# Set up services
for service in services:
if service.name != 'KRPC':
setattr(self, _to_snake_case(service.name),
create_service(self, service))
# Set up stream update thread
if stream_connection is not None:
self._stream_thread_stop = threading.Event()
self._stream_thread = threading.Thread(
target=krpc.stream.update_thread,
args=(stream_connection, self._stream_thread_stop))
self._stream_thread.daemon = True
self._stream_thread.start()
else:
self._stream_thread = None
def test_coerce_to(self):
types = Types()
cases = [
(42.0, 42, 'double'),
(42.0, 42, 'float'),
(42, 42.0, 'int32'),
(42, 42L, 'int32'),
(42L, 42.0, 'int64'),
(42L, 42, 'int64'),
(42, 42.0, 'uint32'),
(42, 42L, 'uint32'),
(42L, 42.0, 'uint64'),
(42L, 42, 'uint64'),
(list(), tuple(), 'List(string)'),
((0, 1, 2), [0, 1, 2], 'Tuple(int32,int32,int32)'),
([0, 1, 2], (0, 1, 2), 'List(int32)'),
]
for expected, value, typ in cases:
coerced_value = types.coerce_to(value, types.as_type(typ))
self.assertEqual(expected, coerced_value)
self.assertEqual(type(expected), type(coerced_value))
self.assertEqual(['foo', 'bar'],
types.coerce_to(['foo', 'bar'],
types.as_type('List(string)')))
self.assertRaises(ValueError, types.coerce_to, None,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, '',
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, True,
types.as_type('float'))
self.assertRaises(ValueError, types.coerce_to, list(),
types.as_type('Tuple(int32)'))
self.assertRaises(ValueError, types.coerce_to, ["foo", 2],
types.as_type('Tuple(string)'))
self.assertRaises(ValueError, types.coerce_to, [1],
types.as_type('Tuple(string)'))
class TestDecoder(unittest.TestCase):
types = Types()
def test_guid(self):
self.assertEqual(
'6f271b39-00dd-4de4-9732-f0d3a68838df',
Decoder.guid(unhexlify('391b276fdd00e44d9732f0d3a68838df')))
def test_decode_value(self):
value = Decoder.decode(unhexlify('ac02'), self.types.uint32_type)
self.assertEqual(int(300), value)
def test_decode_unicode_string(self):
value = Decoder.decode(unhexlify('03e284a2'), self.types.string_type)
self.assertEqual(b'\xe2\x84\xa2'.decode('utf-8'), value)
def test_message_size(self):
message = '1c'
size = Decoder.decode_message_size(unhexlify(message))
self.assertEqual(28, size)
def test_decode_message(self):
message = '0a0b536572766963654e616d65120d50726f6365647572654e616d65'
call = Decoder.decode(unhexlify(message),
self.types.procedure_call_type)
self.assertEqual('ServiceName', call.service)
self.assertEqual('ProcedureName', call.procedure)
def test_decode_class(self):
typ = self.types.class_type('ServiceName', 'ClassName')
value = Decoder.decode(unhexlify('ac02'), typ)
self.assertTrue(isinstance(value, typ.python_type))
self.assertEqual(300, value._object_id)
def test_decode_class_none(self):
typ = self.types.class_type('ServiceName', 'ClassName')
value = Decoder.decode(unhexlify('00'), typ)
self.assertIsNone(value)
