def test_set_vault_hash_tx(self):
rpc_client = Load110RPCClient()
# Error response from RPC Server should return server detail in exception
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"error": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.set_vault_hash_tx(SHIPPER_WALLET_ID, SHIPMENT_ID,
VAULT_HASH)
self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail, 'Error from RPC Server')
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"transaction": VAULT_HASH
},
"id": 0
})
transaction = rpc_client.set_vault_hash_tx(STORAGE_CRED_ID,
SHIPPER_WALLET_ID,
CARRIER_WALLET_ID)
self.assertEqual(transaction, VAULT_HASH)
def create_shipment(self):
with mock.patch.object(requests.Session, 'post') as mock_method, \
mock.patch('apps.shipments.rpc.ShipmentRPCClient.create_vault') as create_vault, \
mock.patch('apps.shipments.rpc.Load110RPCClient.add_shipment_data') as add_shipment_data:
add_shipment_data.return_value = {'hash': 'txHash'}
create_vault.return_value = (VAULT_ID, 's3://bucket/' + VAULT_ID)
mock_method.return_value = mocked_rpc_response(
{"vault_id": VAULT_ID})
mock_method.return_value = mocked_rpc_response({
"success": True,
"vault_signed": {
'hash': "TEST_VAULT_SIGNATURE"
}
})
self.shipments = []
self.load_shipments = []
self.shipments.append(
Shipment.objects.create(
vault_id=VAULT_ID,
owner_id=self.user_1.id,
carrier_wallet_id=CARRIER_WALLET_ID,
shipper_wallet_id=SHIPPER_WALLET_ID,
storage_credentials_id=STORAGE_CRED_ID))
self.load_shipments.append(self.shipments[0].loadshipment)
self.shipments.append(
Shipment.objects.create(
vault_id=VAULT_ID,
owner_id=self.user_1.id,
carrier_wallet_id=CARRIER_WALLET_ID,
shipper_wallet_id=SHIPPER_WALLET_ID,
storage_credentials_id=STORAGE_CRED_ID))
def test_get_telemetry_data(self):
rpc_client = ShipmentRPCClient()
# Error response from RPC Server should return server detail in exception
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"error": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.get_telemetry_data(STORAGE_CRED_ID,
SHIPPER_WALLET_ID, VAULT_ID)
self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail, 'Error from RPC Server')
mock_method.return_value = mocked_rpc_response({
"result": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.get_telemetry_data(STORAGE_CRED_ID,
SHIPPER_WALLET_ID, VAULT_ID)
self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail,
'Invalid response from Engine')
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"contents": {
"ayy": "lmao"
}
},
"id": 0
})
contents = rpc_client.get_telemetry_data(STORAGE_CRED_ID,
SHIPPER_WALLET_ID,
VAULT_ID)
self.assertEqual(contents, {"ayy": "lmao"})
def test_add_shipment_data(self):
rpc_client = ShipmentRPCClient()
# Error response from RPC Server should return server detail in exception
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"error": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.add_shipment_data(STORAGE_CRED_ID,
SHIPPER_WALLET_ID,
CARRIER_WALLET_ID, '{}')
self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail, 'Error from RPC Server')
mock_method.return_value = mocked_rpc_response({
"result": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.add_shipment_data(STORAGE_CRED_ID,
SHIPPER_WALLET_ID,
CARRIER_WALLET_ID, '{}')
self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail,
'Invalid response from Engine')
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"vault_signed": SHIPPER_WALLET_ID
},
"id": 0
})
vault_signed = rpc_client.add_shipment_data(
STORAGE_CRED_ID, SHIPPER_WALLET_ID, CARRIER_WALLET_ID, '{}')
self.assertEqual(vault_signed, SHIPPER_WALLET_ID)
def test_create_shipment_transaction(self):
rpc_client = Load110RPCClient()
# Error response from RPC Server should return server detail in exception
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"error": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.create_shipment_transaction(STORAGE_CRED_ID,
SHIPPER_WALLET_ID)
# self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail, 'Error from RPC Server')
mock_method.return_value = mocked_rpc_response({
"result": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.create_shipment_transaction(STORAGE_CRED_ID,
SHIPPER_WALLET_ID)
# self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail,
'Invalid response from Engine')
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"transaction": SHIPPER_WALLET_ID,
"contractVersion": "v1"
},
"id": 0
})
contractVersion, transaction = rpc_client.create_shipment_transaction(
STORAGE_CRED_ID, SHIPPER_WALLET_ID)
self.assertEqual(contractVersion, "v1")
self.assertEqual(transaction, SHIPPER_WALLET_ID)
def test_create_document(self):
url = reverse('shipment-documents-list',
kwargs={
'version': 'v1',
'shipment_pk': self.shipment.id
})
file_data = {
'name': 'Test BOL',
'owner_id': OWNER_ID,
'description': 'Auto generated file for test purposes',
'document_type': 'Bol',
'file_type': 'Pdf'
}
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({"success": True})
response = self.client.post(url, file_data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
data = response.json()['data']
self.assertTrue(
isinstance(data['meta']['presigned_s3']['fields'], dict))
document = Document.objects.all()
self.assertEqual(document.count(), 1)
self.assertEqual(self.shipment.id, document[0].shipment_id)
# A request with an invalid shipment_id should fail
bad_shipment_id = 'non-existing-shipment-in-db'
bad_shipment_in_url = reverse('shipment-documents-list',
kwargs={
'version': 'v1',
'shipment_pk': bad_shipment_id
})
response = self.client.post(bad_shipment_in_url, file_data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_engine_subscribe_generic(self):
mock_shipment_rpc = EventRPCClient()
params = {
"url": "URL",
"project": "LOAD",
"interval": 5000,
"eventNames": ["allEvents"],
"version": "1.1.0"
}
full_params = {
'jsonrpc': '2.0',
'id': 0,
'params': params,
'method': 'event.subscribe'
}
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response(
{'result': {
'success': True,
'subscription': params
}})
mock_shipment_rpc.subscribe(project="LOAD",
version=test_settings.LOAD_VERSION,
url="URL")
# The timeout parameter derives from shipchain_common.rpc.RPCClient
mock_method.assert_called_with(test_settings.ENGINE_RPC_URL,
data=json.dumps(full_params),
timeout=270)
def mocked_iot_api(mocker):
return mocker.patch(
'apps.shipments.iot_client.DeviceAWSIoTClient.update_shadow',
return_value=mocked_rpc_response({
'data': {
'shipmentId': 'dunno yet',
'shipmentState': 'dunno yet'
}
}))
def test_add_document_from_s3(self):
rpc_client = DocumentRPCClient()
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"error": {
"code": 1337,
"message": "Error from RPC Server",
},
})
try:
rpc_client.add_document_from_s3('bucket', 's3_key',
SHIPPER_WALLET_ID,
STORAGE_CRED_ID, VAULT_ID,
'Document Name')
self.fail("Should have thrown RPC Error")
except RPCError as rpc_error:
self.assertEqual(rpc_error.status_code, 500)
self.assertEqual(rpc_error.detail, 'Error from RPC Server')
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"vault_signed": VAULT_HASH
},
"id": 0
})
vault_hash = rpc_client.add_document_from_s3(
bucket='bucket',
key='s3_key',
vault_wallet=SHIPPER_WALLET_ID,
storage_credentials=STORAGE_CRED_ID,
vault=VAULT_ID,
document_name='Document Name')
self.assertEqual(vault_hash, VAULT_HASH)
def test_requires_document(self, api_client, document_shipment_alice, mock_s3_buckets):
self.s3_event["Records"][0]["s3"]["object"]["key"] = f"{random_id()}/{random_id()}/{random_id()}/{random_id()}.png"
response = api_client.post(self.url, json.dumps(self.s3_event), content_type="application/json",
X_NGINX_SOURCE='internal', X_SSL_CLIENT_VERIFY='SUCCESS',
X_SSL_CLIENT_DN='/CN=document-management-s3-hook.test-internal')
AssertionHelper.HTTP_400(response, error='Document not found with ID')
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": False
},
"id": 0
})
self.s3_event["Records"][0]["s3"]["object"]["key"] = f"{random_id()}/{random_id()}/{random_id()}/{document_shipment_alice.id}.png"
response = api_client.post(self.url, json.dumps(self.s3_event), content_type="application/json",
X_NGINX_SOURCE='internal', X_SSL_CLIENT_VERIFY='SUCCESS',
X_SSL_CLIENT_DN='/CN=document-management-s3-hook.test-internal')
AssertionHelper.HTTP_500(response, error='Invalid response from Engine')
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"vault_signed": {
'hash': 'VAULT_HASH'
}
},
"id": 0
})
self.s3_event["Records"][0]["s3"]["object"]["key"] = f"{random_id()}/{random_id()}/{random_id()}/{document_shipment_alice.id}.png"
response = api_client.post(self.url, json.dumps(self.s3_event), content_type="application/json",
X_NGINX_SOURCE='internal', X_SSL_CLIENT_VERIFY='SUCCESS',
X_SSL_CLIENT_DN='/CN=document-management-s3-hook.test-internal')
AssertionHelper.HTTP_204(response)
document_shipment_alice.refresh_from_db()
assert document_shipment_alice.upload_status == UploadStatus.COMPLETE
def mock_requests_session(mocker):
mocker.patch.object(requests.Session,
'post',
return_value=mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"vault_id": "TEST_VAULT_ID",
"vault_uri": "engine://test_url",
"vault_signed": {
'hash': "TEST_VAULT_SIGNATURE"
}
}
}))
def test_put_document_in_s3(self):
rpc_client = DocumentRPCClient()
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"error": {
"code": 1337,
"message": "Error from RPC Server",
},
})
rpc_response = rpc_client.put_document_in_s3(
bucket='bucket',
key='s3_key',
vault_wallet=SHIPPER_WALLET_ID,
storage_credentials=STORAGE_CRED_ID,
vault=VAULT_ID,
document_name='Document Name')
self.assertFalse(rpc_response)
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
},
"id": 0
})
rpc_response = rpc_client.put_document_in_s3(
bucket='bucket',
key='s3_key',
vault_wallet=SHIPPER_WALLET_ID,
storage_credentials=STORAGE_CRED_ID,
vault=VAULT_ID,
document_name='Document Name')
self.assertTrue(rpc_response)
def setUp(self):
self.client = APIClient()
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": True,
"vault_id": "TEST_VAULT_ID"
}
})
self.shipments = []
self.shipments.append(Shipment.objects.create(vault_id=VAULT_ID,
carrier_wallet_id=CARRIER_WALLET_ID,
shipper_wallet_id=SHIPPER_WALLET_ID,
storage_credentials_id=STORAGE_CRED_ID,
pickup_est="2018-11-10T17:57:05.070419Z",
owner_id=OWNER_ID))
def test_presigned_s3(self, client_alice, entity_ref_document_shipment_alice, mock_s3_buckets,
document_shipment_alice):
document_shipment_alice.upload_status = UploadStatus.COMPLETE.name
document_shipment_alice.save()
assert len(list(mock_s3_buckets.Bucket(settings.DOCUMENT_MANAGEMENT_BUCKET)
.objects.filter(Prefix=document_shipment_alice.s3_key))) == 0
with mock.patch.object(requests.Session, 'post') as mock_method:
mock_method.return_value = mocked_rpc_response({
"jsonrpc": "2.0",
"result": {
"success": False,
},
"id": 0
})
response = client_alice.get(self.document_alice_url)
entity_ref_document_shipment_alice.attributes['upload_status'] = UploadStatus.COMPLETE.name
AssertionHelper.HTTP_200(response, entity_ref_document_shipment_alice)
assert response.json()['data']['meta']['presigned_s3'] == None
assert mock_method.call_count == 1
