← Back to branch summary

~ubuntuone-hackers/u1db/for-demo

« back to all changes in this revision

Viewing changes to u1db/tests/test_remote_client.py

Incorporate remote sync

Show diffs side-by-side

added added

removed removed

Lines of Context:
u1db/tests/test_remote_client.py
23
23
from u1db.remote import (
24
24
    client,
25
25
    protocol,
 
26
    requests,
26
27
    sync_server,
27
28
    )
28
29
from u1db.tests import test_remote_sync_server
33
34
    def test_received_header(self):
34
35
        response_handler = client.StructureToResponse()
35
36
        response_handler.received_header(
36
 
            {'server_version': '1', 'request': 'hello', 'status': 'success'})
 
37
            {'server_version': '1', 'request': 'hello'})
37
38
        self.assertEqual('hello', response_handler.request_name)
38
39
        self.assertEqual('1', response_handler.server_version)
39
 
        self.assertEqual('success', response_handler.status)
40
40
        self.assertEqual(None, response_handler.kwargs)
41
41
        self.assertFalse(response_handler.finished)
42
42
 
43
43
    def test_received_args(self):
44
44
        response_handler = client.StructureToResponse()
45
45
        response_handler.received_header(
46
 
            {'server_version': '1', 'request': 'hello', 'status': 'success'})
 
46
            {'server_version': '1', 'request': 'hello'})
47
47
        response_handler.received_args({'arg': 2, 'arg2': 'value'})
 
48
        self.assertEqual('success', response_handler.status)
48
49
        self.assertEqual({'arg': 2, 'arg2': 'value'}, response_handler.kwargs)
49
50
        self.assertFalse(response_handler.finished)
50
51
 
 
52
    def test_received_stream_entry(self):
 
53
        entries = []
 
54
        def take_entry(entry):
 
55
            entries.append(entry)
 
56
        response_handler = client.StructureToResponse(take_entry)
 
57
        response_handler.received_header(
 
58
            {'server_version': '1', 'request': 'hello'})
 
59
        response_handler.received_stream_entry({'entry': True})
 
60
        self.assertEqual([{'entry': True}], entries)
 
61
        self.assertFalse(response_handler.finished)
 
62
 
51
63
    def test_received_end(self):
52
64
        response_handler = client.StructureToResponse()
53
65
        response_handler.received_header(
54
 
            {'server_version': '1', 'request': 'hello', 'status': 'success'})
 
66
            {'server_version': '1', 'request': 'hello'})
55
67
        response_handler.received_args({'arg': 2, 'arg2': 'value'})
56
68
        response_handler.received_end()
57
69
        self.assertTrue(response_handler.finished)
58
70
 
59
71
 
 
72
class WithStreamRequest(requests.RPCRequest):
 
73
 
 
74
    name = 'withstream'
 
75
 
 
76
    def __init__(self, state, responder):
 
77
        super(WithStreamRequest, self).__init__(state, responder)
 
78
 
 
79
    def handle_args(self, **kwargs):
 
80
        self.responder.send_response(**kwargs)
 
81
 
 
82
    def handle_stream_entry(self, entry):
 
83
        v = entry['outgoing'] * 5
 
84
        self.responder.stream_entry({'incoming': v})
 
85
 
 
86
    def handle_end(self):
 
87
        pass
 
88
 
 
89
 
 
90
 
60
91
class TestClient(tests.TestCase):
61
92
 
62
93
    def test__encode_request(self):
82
113
            + 'e\x00\x00\x00\x00',
83
114
            server_sock.recv(4096))
84
115
 
 
116
    def test__encode_request_with_stream(self):
 
117
        server_sock, client_sock = tests.socket_pair()
 
118
        cli = client.Client(client_sock)
 
119
        def stream():
 
120
            yield {'stream_entry': 1}
 
121
            yield {'stream_entry': 2}
 
122
        cli._encode_request('name', dict(a=1), stream=stream())
 
123
        self.assertEqual(
 
124
            'u1db-1\n'
 
125
            'h%s{"client_version": "%s", "request": "name"}'
 
126
            % (struct.pack('!L', 41 + len(_u1db_version)), _u1db_version)
 
127
            + 'a\x00\x00\x00\x08{"a": 1}'
 
128
            + 'x\x00\x00\x00\x13{"stream_entry": 1}'
 
129
            + 'x\x00\x00\x00\x13{"stream_entry": 2}'
 
130
            + 'e\x00\x00\x00\x00',
 
131
            server_sock.recv(4096))
 
132
 
85
133
    def test_client_to_server_and_back(self):
86
134
        server_sock, client_sock = tests.socket_pair()
87
135
        cli = client.Client(client_sock)
105
153
        content = client_sock.recv(4096)
106
154
        self.assertEqual(
107
155
            'u1db-1\n'
108
 
            'h%s{"server_version": "%s", "request": "arg", "status": "success"}'
109
 
            % (struct.pack('!L', 61 + len(_u1db_version)), _u1db_version)
 
156
            'h%s{"server_version": "%s", "request": "arg"}'
 
157
            % (struct.pack('!L', 40 + len(_u1db_version)), _u1db_version)
110
158
            + 'a\x00\x00\x00\x0a{"one": 1}'
111
159
            + 'e\x00\x00\x00\x00',
112
160
            content)
118
166
        self.assertEqual(_u1db_version, response_handler.server_version)
119
167
        self.assertEqual('success', response_handler.status)
120
168
        self.assertTrue(response_handler.finished)
 
169
 
 
170
    def test_client_to_server_and_back_with_streaming(self):
 
171
        server_sock, client_sock = tests.socket_pair()
 
172
        cli = client.Client(client_sock)
 
173
        def stream():
 
174
            yield {'outgoing': 10}
 
175
            yield {'outgoing': 20}
 
176
        cli._encode_request('withstream', {'one': 1}, stream())
 
177
        reqs = {'withstream': WithStreamRequest}
 
178
        responder = sync_server.Responder(server_sock)
 
179
        handler = sync_server.StructureToRequest(reqs, responder,
 
180
            tests.ServerStateForTests())
 
181
        decoder = protocol.ProtocolDecoder(handler)
 
182
        # This should be the message from the client to the server
 
183
        content = server_sock.recv(4096)
 
184
        self.assertEqual(
 
185
            'u1db-1\n'
 
186
            'h%s{"client_version": "%s", "request": "withstream"}'
 
187
            % (struct.pack('!L', 47 + len(_u1db_version)), _u1db_version)
 
188
            + 'a\x00\x00\x00\x0a{"one": 1}'
 
189
            + 'x\x00\x00\x00\x10{"outgoing": 10}'
 
190
            + 'x\x00\x00\x00\x10{"outgoing": 20}'
 
191
            + 'e\x00\x00\x00\x00',
 
192
            content)
 
193
        decoder.accept_bytes(content)
 
194
        # The response from the server
 
195
        content = client_sock.recv(4096)
 
196
        self.assertEqual(
 
197
            'u1db-1\n'
 
198
            'h%s{"server_version": "%s", "request": "withstream"}'
 
199
            % (struct.pack('!L', 47 + len(_u1db_version)), _u1db_version)
 
200
            + 'a\x00\x00\x00\x0a{"one": 1}'
 
201
            + 'x\x00\x00\x00\x10{"incoming": 50}'
 
202
            + 'x\x00\x00\x00\x11{"incoming": 100}'
 
203
            + 'e\x00\x00\x00\x00',
 
204
            content)
 
205
        entries = []
 
206
        def take_entry(entry):
 
207
            entries.append(entry)
 
208
        response_handler = client.StructureToResponse(take_entry)
 
209
        decoder = protocol.ProtocolDecoder(response_handler)
 
210
        decoder.accept_bytes(content)
 
211
        self.assertEqual([{'incoming': 50}, {'incoming': 100}], entries)
 
212
        self.assertEqual({'one': 1}, response_handler.kwargs)
 
213
        self.assertEqual('withstream', response_handler.request_name)
 
214
        self.assertEqual(_u1db_version, response_handler.server_version)
 
215
        self.assertEqual('success', response_handler.status)
 
216
        self.assertTrue(response_handler.finished)