def test_receipt_processing(self):
"""it should be able to process an incoming XML receipt via HTTP"""
publisher = TestPublisher()
resource = transport.OperaReceiptResource(publisher)
request = DummyRequest('/api/v1/sms/opera/receipt.xml')
request.content = StringIO("""
<?xml version="1.0"?>
<!DOCTYPE receipts>
<receipts>
<receipt>
<msgid>26567958</msgid>
<reference>001efc31</reference>
<msisdn>+27123456789</msisdn>
<status>D</status>
<timestamp>20080831T15:59:24</timestamp>
<billed>NO</billed>
</receipt>
</receipts>
""".strip())
resource.render_POST(request)
self.assertEquals(publisher.queue.pop(), (Message(**{
'transport_name': 'Opera',
'transport_msg_id': '001efc31',
'transport_status': 'D', # OK / delivered, opera specific
'transport_delivered_at': datetime(2008, 8, 31, 15, 59, 24),
}), {
'routing_key': 'sms.receipt.opera'
})
)
def request_generator(url, method='GET', content=True, headers=True):
request = DummyRequest(url)
request.method = method
if content:
request.content = StringIO()
if headers:
request.requestHeaders = Headers()
return request
def request_generator(url, method='GET', content=True, headers=True):
request = DummyRequest(url)
request.method = method
if content:
request.content = StringIO()
if headers:
request.requestHeaders = Headers()
return request
def test_contentType(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "id": 1, "params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
self.assert_has_header(request.responseHeaders, name='content-type', expected='application/json')
d.addCallback(rendered)
return d
def test_notificationV2(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_noSuchMethodNoId(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "aaaa"}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_notificationV1(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "sql"}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_sqlOkV2(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"jsonrpc": "2.0", "method": "sql", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
self.assert_json_values(request.written[0], jsonrpc="2.0", id=1, result=list)
d.addCallback(rendered)
return d
def test_noSuchMethodNoId(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "aaaa"}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_invalidIdCaseSensitive(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "ID": "ABCD", "params": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_notificationV2(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_keywordsOkV2(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "id": 1, "params": {"data": "arg"}, "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": 1, "result": "arg"}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_caseSensitiveParamsV2(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "id": "ABCD", "params": ["AB"], "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": "ABCD", "result": "AB"}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_contentLength(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "id": 1, "params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
self.assert_has_header(request.responseHeaders, name='content-length',
expected=str(len(request.written[0])))
d.addCallback(rendered)
return d
def test_invalidIdCaseSensitive(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "ID": "ABCD", ' +
'"params": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_idStrV1(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "id": "abcd", "params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": "abcd", "result": "ab"}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_sqlOkV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": 1, "result": ['
self.assertTrue(request.written[0].startswith(expected))
d.addCallback(rendered)
return d
def test_sqlOkV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": 1, "result": ['
self.assertTrue(request.written[0].startswith(expected))
d.addCallback(rendered)
return d
def test_contentLength(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, ' +
'"params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(str(len(request.written[0])),
request.outgoingHeaders['content-length'])
d.addCallback(rendered)
return d
def test_caseSensitiveMethodV1(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "ECHO", "id": "ABCD", "params": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": "ABCD", "error": {' + \
'"message": "Method ECHO not found", "code": -32601}}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_malformed(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "id')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": null, "error": ' + \
'{"message": "Parse error", "code": -32700}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_batchSingle(self):
json = '[{"method": "echo", "id": 1, "params": ["arg"]}]'
request = DummyRequest([''])
request.content = StringIO(json)
d = _render(self.srv, request)
def rendered(_):
expected = '[{"error": null, "id": 1, "result": "arg"}]'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_batchNotificationOnly(self):
json = '[{"method": "echo", "params": {"data": "arg"}}, ' + \
'{"method": "echo", "params": {"data": "arg"}}]'
request = DummyRequest([''])
request.content = StringIO(json)
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_keywordsOkV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, "params": ' +
'{"data": "arg"}}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": 1, "result": "arg"}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_invalidMethodCaseSensitive(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"METHOD": "echo", "id": "ABCD", "params": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": "ABCD", "error": ' + \
'{"message": "Invalid method type", "code": -32600}}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_invalidParamsCaseSensitive(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "echo", "id": "ABCD", "PARAMS": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"id": "ABCD", "error": {"message": "jsonrpc_echo() missing 1 required positional argument:' + \
' \'data\'", "code": -32602}, "result": null}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_wrongParams(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "sql", "id": 1, "params": ["aa", "bb"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"id": 1, "error": {"message": "jsonrpc_sql() takes 1 positional argument ' + \
'but 3 were given", "code": -32602}, "result": null}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_emptyRequest(self):
request = DummyRequest([''])
request.content = BytesIO(b'')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": null, "error": ' + \
'{"message": "Parse error", "code": -32700}}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_echoOkV2(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, ' +
'"params": ["ab"], "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": 1, "result": "ab"}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_returnNone(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "returnNone", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": 1, "result": null}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_returnNone(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "returnNone", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": 1, "result": null}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_contentType(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, ' +
'"params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.outgoingHeaders['content-type'],
'application/json')
d.addCallback(rendered)
return d
def test_caseSensitiveParamsV2(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": "ABCD", ' +
'"params": ["AB"], "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": "ABCD", "result": "AB"}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_batchSingle(self):
json = '[{"method": "echo", "id": 1, "params": ["arg"]}]'
request = DummyRequest([''])
request.content = StringIO(json)
d = _render(self.srv, request)
def rendered(_):
expected = '[{"error": null, "id": 1, "result": "arg"}]'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_contentType(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, ' +
'"params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.outgoingHeaders['content-type'],
'application/json')
d.addCallback(rendered)
return d
def test_malformed(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "id')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": null, "error": ' + \
'{"message": "Parse error", "code": -32700}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_contentLength(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, ' +
'"params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(str(len(request.written[0])),
request.outgoingHeaders['content-length'])
d.addCallback(rendered)
return d
def test_idStrV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": "abcd", ' +
'"params": ["ab"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"error": null, "id": "abcd", "result": "ab"}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_batchNotificationOnly(self):
json = '[{"method": "echo", "params": {"data": "arg"}}, ' + \
'{"method": "echo", "params": {"data": "arg"}}]'
request = DummyRequest([''])
request.content = StringIO(json)
d = _render(self.srv, request)
def rendered(_):
self.assertEquals(request.written, [])
d.addCallback(rendered)
return d
def test_keywordsOkV2(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, "params": ' +
'{"data": "arg"}, "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": 1, "result": "arg"}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_incoming_sms_processing(self):
"""
it should be able to process in incoming sms as XML delivered via HTTP
"""
publisher = TestPublisher()
resource = transport.OperaReceiveResource(publisher)
request = DummyRequest('/api/v1/sms/opera/receive.xml')
request.content = StringIO("""
<?xml version="1.0"?>
<!DOCTYPE bspostevent>
<bspostevent>
<field name="MOReference" type = "string">282341913</field>
<field name="IsReceipt" type = "string">NO</field>
<field name="RemoteNetwork" type = "string">mtn-za</field>
<field name="BSDate-tomorrow" type = "string">20100605</field>
<field name="BSDate-today" type = "string">20100604</field>
<field name="ReceiveDate" type = "date">2010-06-04 15:51:25 +0000</field>
<field name="Local" type = "string">*32323</field>
<field name="ClientID" type = "string">4</field>
<field name="ChannelID" type = "string">111</field>
<field name="MessageID" type = "string">373736741</field>
<field name="ReceiptStatus" type = "string"></field>
<field name="Prefix" type = "string"></field>
<field name="ClientName" type = "string">Praekelt</field>
<field name="MobileDevice" type = "string"></field>
<field name="BSDate-yesterday" type = "string">20100603</field>
<field name="Remote" type = "string">+27831234567</field>
<field name="State" type = "string">5</field>
<field name="MobileNetwork" type = "string">mtn-za</field>
<field name="MobileNumber" type = "string">+27831234567</field>
<field name="Text" type = "string">Hello World</field>
<field name="ServiceID" type = "string">20222</field>
<field name="RegType" type = "string">1</field>
<field name="NewSubscriber" type = "string">NO</field>
<field name="Subscriber" type = "string">+27831234567</field>
<field name="Parsed" type = "string"></field>
<field name="ServiceName" type = "string">Prktl Vumi</field>
<field name="BSDate-thisweek" type = "string">20100531</field>
<field name="ServiceEndDate" type = "string">2010-06-30 07:47:00 +0200</field>
<field name="Now" type = "date">2010-06-04 15:51:27 +0000</field>
</bspostevent>
""".strip())
resource.render_POST(request)
self.assertEquals(publisher.queue.pop(), (Message(**{
'to_msisdn': '*32323',
'from_msisdn': '+27831234567',
'message': 'Hello World',
'transport_name': 'Opera',
'received_at': iso8601.parse_date('2010-06-04 15:51:25 +0000'),
}), {
'routing_key': 'sms.inbound.opera.s32323' # * -> s
}))
def test_noSuchMethodV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "aaaa", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": 1, "error": ' + \
'{"message": "Method aaaa not found", ' + \
'"code": -32601}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_noSuchMethodV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "aaaa", "id": 1}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": 1, "error": ' + \
'{"message": "Method aaaa not found", ' + \
'"code": -32601}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_invalidMethodCaseSensitive(self):
request = DummyRequest([''])
request.content = StringIO('{"METHOD": "echo", "id": "ABCD", ' +
'"params": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": "ABCD", "error": ' + \
'{"message": "Invalid method type", "code": -32600}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_noSuchMethodV2(self):
request = DummyRequest([''])
request.content = BytesIO(b'{"method": "aaaa", "id": 1, "jsonrpc": "2.0"}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"jsonrpc": "2.0", "id": 1, "error": ' + \
'{"message": "Method aaaa not found", ' + \
'"code": -32601}}'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_batchNotificationAndSingle(self):
json = '[{"method": "echo", "id": 1, "params": ["arg"]}, ' + \
'{"method": "echo", "params": ["arg"]}]'
request = DummyRequest([''])
request.content = BytesIO(json.encode())
d = _render(self.srv, request)
def rendered(_):
expected = '[{"error": null, "id": 1, "result": "arg"}]'
self.assert_json(request.written[0], expected)
d.addCallback(rendered)
return d
def test_caseSensitiveMethodV1(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "ECHO", "id": "ABCD", ' +
'"params": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": "ABCD", "error": {' + \
'"message": "Method ECHO not found", "code": -32601}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def testPOST(self):
handler = webserver.JobsHandler(self.service)
request = DummyRequest([''])
request.content = StringIO(json.dumps(
{'sprite_idx': 0,
'block_idx': 0,
'project': open(program_path('wh_words.xml')).read()}))
# Start a job
json_res = handler.render_POST(request)
res = json.loads(json_res)
self.assertTrue(res['id'], res)
# Check job handler has the correct job_id
job_handler = handler.children[res['id']]
self.assertEqual(res['id'], job_handler.id)
self.assertEqual(job_handler.state, 'running')
# Check job process handler has the correct job_id
job_process = job_handler.job_process
self.assertEqual(res['id'], job_process.id)
# Check state dict
state = job_handler.state_dict()
self.assertEqual(state['finished'], None)
self.assertTrue(isinstance(parse_date(state['started']), datetime),
state['started'])
self.assertEqual(state['id'], res['id'])
self.assertEqual(state['state'], 'running')
request = DummyRequest([''])
d = Deferred()
def _check_response(data):
data = job_handler.render_GET(request)
state = json.loads(data)
self.assertTrue(isinstance(parse_date(state['finished']),
datetime),
state['finished'])
self.assertTrue(isinstance(parse_date(state['started']),
datetime),
state['started'])
self.assertEqual(state['id'], res['id'])
self.assertEqual(state['state'], 'finished')
self.assertEqual(state['result'],
["whoever", "Who", "What.", "What"])
d1 = job_process.wait_for()
d1.addCallback(_check_response)
d1.chainDeferred(d)
return d
def test_save_document(self):
formatter = IncomingFormatter()
doc_id, scheme = uuid4().hex, EncryptionSchemes.PUBKEY
content = 'Incoming content'
request = DummyRequest([self.user_uuid, doc_id])
request.content = BytesIO(content)
self.resource.render_PUT(request)
open_database = self.backend_factory.open_database
open_database.assert_called_once_with(self.user_uuid)
self.couchdb.put_doc.assert_called_once()
doc = self.couchdb.put_doc.call_args[0][0]
self.assertEquals(doc_id, doc.doc_id)
self.assertEquals(formatter.format(content, scheme), doc.content)
def test_invalidParamsCaseSensitive(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": "ABCD", ' +
'"PARAMS": ["AB"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": "ABCD", "error": ' + \
'{"message": "jsonrpc_echo() takes exactly 2 ' + \
'arguments (1 given)", "code": -32602}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_wrongParams(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "id": 1, ' +
'"params": ["aa", "bb"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": 1, "error": {"message": ' + \
'"jsonrpc_sql() takes exactly 1 argument (3 given)"' + \
', "code": -32602}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_wrongParams(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "sql", "id": 1, ' +
'"params": ["aa", "bb"]}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": 1, "error": {"message": ' + \
'"jsonrpc_sql() takes exactly 1 argument (3 given)"' + \
', "code": -32602}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_save_document(self):
formatter = IncomingFormatter()
doc_id, scheme = uuid4().hex, EncryptionSchemes.PUBKEY
content = 'Incoming content'
request = DummyRequest([self.user_uuid, doc_id])
request.content = BytesIO(content)
self.resource.render_PUT(request)
open_database = self.backend_factory.open_database
open_database.assert_called_once_with(self.user_uuid)
self.couchdb.put_doc.assert_called_once()
doc = self.couchdb.put_doc.call_args[0][0]
self.assertEquals(doc_id, doc.doc_id)
self.assertEquals(formatter.format(content, scheme), doc.content)
def test_keywordsUnexpected(self):
request = DummyRequest([''])
request.content = StringIO('{"method": "echo", "id": 1, "params": ' +
'{"wrongname": "arg"}}')
d = _render(self.srv, request)
def rendered(_):
expected = '{"result": null, "id": 1, "error": {"message": ' + \
'"jsonrpc_echo() got an unexpected keyword argument' + \
' \'wrongname\'", "code": -32602}}'
self.assertEquals(request.written[0], expected)
d.addCallback(rendered)
return d
def test_withRequest(self):
"""
When an XML-RPC method is called and the implementation is
decorated with L{withRequest}, the request object is passed as
the first argument.
"""
request = DummyRequest('/RPC2')
request.method = "POST"
request.content = StringIO(xmlrpclib.dumps(("foo",), 'withRequest'))
def valid(n, request):
data = xmlrpclib.loads(request.written[0])
self.assertEqual(data, (('POST foo',), None))
d = request.notifyFinish().addCallback(valid, request)
self.resource.render_POST(request)
return d
