1 files changed, 164 insertions, 0 deletions
diff --git a/.emacs.d.back/.python-environments/default/lib/python3.7/site-packages/epc/tests/test_client.py b/.emacs.d.back/.python-environments/default/lib/python3.7/site-packages/epc/tests/test_client.py
new file mode 100644
index 00000000..278111df
--- /dev/null
+++ b/.emacs.d.back/.python-environments/default/lib/python3.7/site-packages/epc/tests/test_client.py
@@ -0,0 +1,164 @@
+# Copyright (C) 2012-  Takafumi Arakaki
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import io
+
+from sexpdata import Symbol
+
+from ..client import EPCClient
+from ..handler import encode_message, unpack_message, BlockingCallback, \
+    ReturnError, EPCError
+from ..py3compat import Queue
+from .utils import BaseTestCase
+
+
+class FakeFile(object):
+    pass
+
+
+class FakeSocket(object):
+
+    def __init__(self):
+        self._queue = Queue.Queue()
+        self._buffer = io.BytesIO()
+        self.sent_message = Queue.Queue()
+        self._alive = True
+
+    def makefile(self, mode, *_):
+        ff = FakeFile()
+        ff.closed = False
+        ff.close = lambda: None
+        ff.flush = lambda: None
+        if 'r' in mode:
+            ff.read = self.recv
+            return ff
+        elif 'w' in mode:
+            ff.write = self.sendall
+            return ff
+
+    def append(self, byte):
+        self._queue.put(byte)
+
+    def _pull(self):
+        byte = self._queue.get()
+        pos = self._buffer.tell()
+        self._buffer.write(byte)
+        self._buffer.seek(pos)
+
+    def recv(self, bufsize):
+        while True:
+            if not self._alive:
+                return ''
+            got = self._buffer.read(bufsize)
+            if got:
+                return got
+            # Do not go to the next loop until some byte is appended
+            # to the queue:
+            self._pull()
+
+    def sendall(self, string):
+        self.sent_message.put(string)
+
+    def close(self):
+        self._alive = False
+        self.append(''.encode('ascii'))
+
+
+class TestClient(BaseTestCase):
+
+    def setUp(self):
+        self.fsock = FakeSocket()
+        self.next_reply = []
+        self.client = EPCClient(self.fsock)
+
+        @self.client.register_function
+        def echo(*a):
+            """Return argument unchanged."""
+            return a
+
+    def tearDown(self):
+        self.client.socket.close()  # connection is closed by server
+
+    def set_next_reply(self, *args):
+        self.next_reply.append(encode_message(*args))
+
+    def request(self, name, *args):
+        bc = BlockingCallback()
+        getattr(self.client, name)(*args, **bc.cbs)
+        self.fsock.append(self.next_reply.pop(0))  # reply comes after call!
+        return bc.result(timeout=self.timeout)
+
+    def sent_message(self):
+        raw = self.fsock.sent_message.get(timeout=self.timeout)
+        (name, uid, rest) = unpack_message(raw[6:])
+        if name == 'call':
+            rest[0] = rest[0].value()
+        return [name, uid] + rest
+
+    def check_sent_message(self, name, uid, args):
+        sent = self.sent_message()
+        self.assertEqual(sent, [name, uid] + list(args))
+
+    def check_return(self, desired_return, name, *args):
+        uid = 1
+        self.set_next_reply('return', uid, desired_return)
+        got = self.request(name, *args)
+        self.assertEqual(got, desired_return)
+        self.check_sent_message(name, uid, args)
+
+    def test_call_return(self):
+        self.check_return('some value', 'call', 'dummy', [1, 2, 3])
+
+    def test_methods_return(self):
+        self.check_return([[Symbol('dummy'), [], "document"]], 'methods')
+
+    def check_return_error(self, reply_name, name, *args):
+        uid = 1
+        reply = 'error value'
+        eclass = ReturnError if reply_name == 'return-error' else EPCError
+        error = eclass(reply)
+        self.set_next_reply(reply_name, uid, reply)
+        try:
+            self.request(name, *args)
+            assert False, 'self.client.{0}({1}) should raise an error' \
+                .format(name, args)
+        except Exception as got:
+            self.assertIsInstance(got, type(error))
+            self.assertEqual(got.args, error.args)
+        self.check_sent_message(name, uid, args)
+
+    def test_call_return_error(self):
+        self.check_return_error('return-error', 'call', 'dummy', [1, 2, 3])
+
+    def test_call_epc_error(self):
+        self.check_return_error('epc-error', 'call', 'dummy', [1, 2, 3])
+
+    def test_methods_return_error(self):
+        self.check_return_error('return-error', 'methods')
+
+    def test_methods_epc_error(self):
+        self.check_return_error('epc-error', 'methods')
+
+    def test_echo(self):
+        uid = 1
+        self.fsock.append(encode_message('call', uid, Symbol('echo'), [55]))
+        self.check_sent_message('return', uid, [[55]])
+
+
+class TestClientClosedByClient(TestClient):
+
+    def tearDown(self):
+        self.client.close()