def test_0_call_int3(self):
c = rpc.Client(self._client_sock)
obj = -sys.maxint - 1
assert isinstance(obj, int)
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, type(obj))
def test_0_call_long(self):
c = rpc.Client(self._client_sock)
obj = 0xffffffffffffffff # max value for msgpack
assert isinstance(obj, numbers.Integral)
result = c.call('resp', [obj])
assert result == obj
assert isinstance(result, numbers.Integral)
def test_0_call_int3(self):
c = rpc.Client(self._client_sock)
obj = - six.MAXSIZE - 1
assert isinstance(obj, int)
result = c.call(b'resp', [obj])
assert result == obj
assert isinstance(result, type(obj))
def test_0_call_int2(self):
c = rpc.Client(self._client_sock)
obj = six.MAXSIZE
assert isinstance(obj, int)
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, type(obj))
def test_2_call_small_binary(self):
import struct
c = rpc.Client(self._client_sock)
obj = struct.pack("100x")
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, bytes)
def test_0_call_int(self):
c = rpc.Client(self._client_sock)
obj = 12345
assert isinstance(obj, int)
result = c.call('resp', [obj])
assert result == obj
assert isinstance(result, numbers.Integral)
def test_0_call_long(self):
c = rpc.Client(self._client_sock)
obj = 0xffffffffffffffff # max value for msgpack
assert isinstance(obj, long)
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, type(obj))
def test_0_call_long2(self):
c = rpc.Client(self._client_sock)
# NOTE: the python type of this value is int for 64-bit arch
obj = -0x8000000000000000 # min value for msgpack
assert isinstance(obj, (int, long))
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, type(obj))
def test_0_call_error(self):
c = rpc.Client(self._client_sock)
obj = b'hoge'
try:
c.call(b'err', [obj])
raise Exception("unexpected")
except rpc.RPCError as e:
assert e.get_value() == obj
def test_4_call_large_binary(self):
import struct
c = rpc.Client(self._client_sock)
obj = struct.pack("10000000x")
result = c.call(b'resp', [obj])
assert result == obj
assert isinstance(result, bytes)
def test_0_call_long(self):
c = rpc.Client(self._client_sock)
obj = 0xffffffffffffffff # max value for msgpack
_long = int if six.PY3 else long
assert isinstance(obj, _long)
result = c.call(b'resp', [obj])
assert result == obj
assert isinstance(result, type(obj))
def test_0_call_error(self):
c = rpc.Client(self._client_sock)
obj = "hoge"
try:
c.call("err", [obj])
raise Exception("unexpected")
except rpc.RPCError, e:
assert e.get_value() == obj
def test_0_call_long2(self):
c = rpc.Client(self._client_sock)
# Note: the python type of this value is int for 64-bit arch
obj = -0x8000000000000000 # min value for msgpack
assert isinstance(obj, numbers.Integral)
result = c.call('resp', [obj])
assert result == obj
assert isinstance(result, numbers.Integral)
def test_2_call_unicode(self):
c = rpc.Client(self._client_sock)
# Note: We use encoding='utf-8' option in msgpack.Packer/Unpacker
# in order to support Python 3.
# With this option, utf-8 encoded bytes will be decoded into unicode
# type in Python 2 and str type in Python 3.
obj = u"hoge"
result = c.call('resp', [obj])
assert result == obj
assert isinstance(result, six.text_type)
def test_0_call_bytearray(self):
c = rpc.Client(self._client_sock)
obj = bytearray(b'foo')
# Note: msgpack-python version 0.50 or later supports bytearray
# objects, here ignores TypeError for the backward compatibility.
try:
result = c.call('resp', [obj])
except TypeError:
# Case with msgpack-python version 0.4.x or earlier.
return
self.assertEqual(obj, result)
self.assertIsInstance(result, six.binary_type)
def test_2_call_unicode(self):
c = rpc.Client(self._client_sock)
# note: on-wire msgpack has no notion of encoding.
# the msgpack library implicitly converts unicode to
# utf-8 encoded bytes by default.
# we don't want to rely on the behaviour though because
# it seems to be going to change.
# https://gist.github.com/methane/5022403
obj = u"hoge"
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, bytes)
def test_0_call_int2(self):
c = rpc.Client(self._client_sock)
obj = six.MAXSIZE
assert isinstance(obj, int)
result = c.call(b'resp', [obj])
assert result == obj
import sys
# note: on PyPy, result will be a long type value.
sv = getattr(sys, 'subversion', None)
if sv is not None and sv[0] == 'PyPy':
assert isinstance(result, long)
else:
assert isinstance(result, type(obj))
def test_4_call_large_binary(self):
import struct
import sys
# note: on PyPy, this test case may hang up.
sv = getattr(sys, 'subversion', None)
if sv is not None and sv[0] == 'PyPy':
return
c = rpc.Client(self._client_sock)
obj = struct.pack("10000000x")
result = c.call(b'resp', [obj])
assert result == obj
assert isinstance(result, bytes)
def test_0_call_error_notification(self):
l = []
def callback(n):
l.append(n)
c = rpc.Client(self._client_sock, notification_callback=callback)
c.send_notification("notify2", ["notify_foo", []])
hub.sleep(0.5) # give the peer a chance to run
obj = "hoge"
try:
c.call("err", [obj])
raise Exception("unexpected")
except rpc.RPCError, e:
assert e.get_value() == obj
def test_0_notification2(self):
l = []
def callback(n):
l.append(n)
c = rpc.Client(self._client_sock, notification_callback=callback)
obj = "hogehogehoge"
c.send_notification("notify2", ["notify_hoge", [obj]])
c.receive_notification()
assert len(l) == 1
n = l.pop(0)
assert n is not None
method, params = n
assert method == "notify_hoge"
assert params[0] == obj
def test_0_notification1(self):
l = []
def callback(n):
l.append(n)
c = rpc.Client(self._client_sock, notification_callback=callback)
obj = "hogehoge"
robj = "fugafuga"
assert c.call("notify1", [robj, "notify_hoge", [obj]]) == robj
c.receive_notification()
assert len(l) == 1
n = l.pop(0)
assert n is not None
method, params = n
assert method == "notify_hoge"
assert params[0] == obj
def test_0_call_error_notification(self):
l = []
def callback(n):
l.append(n)
c = rpc.Client(self._client_sock, notification_callback=callback)
c.send_notification(b'notify2', [b'notify_foo', []])
hub.sleep(0.5) # give the peer a chance to run
obj = b'hoge'
try:
c.call(b'err', [obj])
raise Exception("unexpected")
except rpc.RPCError as e:
assert e.get_value() == obj
assert len(l) == 1
n = l.pop(0)
method, params = n
assert method == b'notify_foo'
assert params == []
def connect(self):
self.client = None
s = socket.create_connection(self._addr)
self.client = rpc.Client(s, notification_callback=self.notification)
def test_0_call_str(self):
c = rpc.Client(self._client_sock)
obj = "hoge"
result = c.call("resp", [obj])
assert result == obj
assert isinstance(result, bytes)
def test_3_call_complex(self):
c = rpc.Client(self._client_sock)
obj = [1, "hoge", {"foo": 1, 3: "bar"}]
assert c.call("resp", [obj]) == list(obj)
def test_2_call_tuple(self):
c = rpc.Client(self._client_sock)
# note: msgpack library implicitly convert a tuple into a list
obj = (1, 2, 3)
assert c.call("resp", [obj]) == list(obj)
def test_2_call_empty_array(self):
c = rpc.Client(self._client_sock)
obj = []
assert c.call("resp", [obj]) == obj
def test_2_call_empty_dict(self):
c = rpc.Client(self._client_sock)
obj = {}
assert c.call("resp", [obj]) == obj
def test_2_call_dict(self):
c = rpc.Client(self._client_sock)
obj = {"hoge": 1, "fuga": 2}
assert c.call("resp", [obj]) == obj
def test_2_call_False(self):
c = rpc.Client(self._client_sock)
obj = False
assert c.call("resp", [obj]) == obj
