async def test_shipmentupdate_notification(communicator): # Disable Shipment post-save signal await sync_to_async(models.signals.post_save.disconnect)(sender=Shipment, dispatch_uid='shipment_post_save') shipment, _ = await sync_to_async(Shipment.objects.get_or_create)( id=random_id(), owner_id=USER_ID, storage_credentials_id=random_id(), shipper_wallet_id=random_id(), carrier_wallet_id=random_id(), contract_version='1.0.0' ) # Update shipment (should get a message) shipment.carriers_scac = 'TESTING123' await sync_to_async(shipment.save)() # Have to manually send message to channel channel_layer = get_channel_layer() await channel_layer.group_send(shipment.owner_id, { "type": "shipments.update", "shipment_id": shipment.id }) # Re-enable Shipment post-save signal await sync_to_async(models.signals.post_save.connect)(shipment_post_save, sender=Shipment, dispatch_uid='shipment_post_save') response = await communicator.receive_json_from() assert response['event'] == EventTypes.shipment_update.name assert response['data']['data']['type'] == 'Shipment' assert response['data']['data']['attributes']['carriers_scac'] == shipment.carriers_scac await communicator.disconnect()
def set_up(self, shipment_alice, shipment_alice_two, mocked_engine_rpc): self.shipment_alice_url = reverse('shipment-documents-list', kwargs={'version': 'v1', 'shipment_pk': shipment_alice.id}) self.shipment_alice_two_url = reverse('shipment-documents-list', kwargs={'version': 'v1', 'shipment_pk': shipment_alice_two.id}) self.shipment_random_url = reverse('shipment-documents-list', kwargs={'version': 'v1', 'shipment_pk': random_id()})
async def test_telemetrydata_notification(communicator): # Disable Shipment post-save signal await sync_to_async(models.signals.post_save.disconnect)(sender=Shipment, dispatch_uid='shipment_post_save') shipment, _ = await sync_to_async(Shipment.objects.get_or_create)( id='FAKE_SHIPMENT_ID', owner_id=USER_ID, storage_credentials_id='FAKE_STORAGE_CREDENTIALS_ID', shipper_wallet_id='FAKE_SHIPPER_WALLET_ID', carrier_wallet_id='FAKE_CARRIER_WALLET_ID', contract_version='1.0.0' ) # Re-enable Shipment post-save signal await sync_to_async(models.signals.post_save.connect)(shipment_post_save, sender=Shipment, dispatch_uid='shipment_post_save') device = await sync_to_async(Device.objects.create)(id=random_id()) telemetry_id = random_id() telemetry_data = await sync_to_async(TelemetryData.objects.create)( id=telemetry_id, device=device, shipment=shipment, hardware_id='hardware_id', sensor_id='sensor_id', value=867.5309, version='1.1.0', timestamp=datetime.datetime.now(datetime.timezone.utc) ) response = await communicator.receive_json_from() assert response['event'] == EventTypes.telemetrydata_update.name assert response['data'] == { 'sensor_id': telemetry_data.sensor_id, 'timestamp': telemetry_data.timestamp.isoformat().replace('+00:00', 'Z'), 'hardware_id': telemetry_data.hardware_id, 'value': telemetry_data.value } t_data = await sync_to_async(TelemetryData.objects.get)(id=telemetry_id) await sync_to_async(t_data.delete)() await communicator.disconnect()
def setup_url(self, new_route, new_route_with_device, new_route_bob, shipment, shipment_bob): leg = new_route.routeleg_set.create(shipment=shipment) leg_bob = new_route_bob.routeleg_set.create(shipment=shipment_bob) self.url_random_route = reverse('route-legs-detail', kwargs={'version': 'v1', 'route_pk': random_id(), 'pk': leg.pk}) self.url_route = reverse('route-legs-detail', kwargs={'version': 'v1', 'route_pk': new_route.id, 'pk': leg.pk}) self.url_random_leg = reverse('route-legs-detail', kwargs={'version': 'v1', 'route_pk': new_route_with_device.id, 'pk': random_id()}) self.url_route_bob = reverse('route-legs-detail', kwargs={'version': 'v1', 'route_pk': new_route_bob.id, 'pk': leg_bob.pk})
def set_up(self, document_shipment_alice, document_shipment_two_alice): self.document_alice_url = reverse('shipment-documents-detail', kwargs={'version': 'v1', 'shipment_pk': document_shipment_alice.shipment.id, 'pk': document_shipment_alice.id}) self.random_url = reverse('shipment-documents-detail', kwargs={'version': 'v1', 'shipment_pk': document_shipment_alice.shipment.id, 'pk': random_id()})
def setup_url(self, new_route, new_route_bob, shipment, second_shipment, third_shipment): leg1 = new_route.routeleg_set.create(shipment=shipment) leg2 = new_route.routeleg_set.create(shipment=second_shipment) leg3 = new_route.routeleg_set.create(shipment=third_shipment) self.url_random = reverse('route-reorder', kwargs={'version': 'v1', 'pk': random_id()}) self.url_route = reverse('route-reorder', kwargs={'version': 'v1', 'pk': new_route.id}) self.url_route_bob = reverse('route-reorder', kwargs={'version': 'v1', 'pk': new_route_bob.id}) self.insert_order = [leg1.pk, leg2.pk, leg3.pk] self.reverse_order = [leg3.pk, leg2.pk, leg1.pk] self.short_order = [leg1.pk, leg3.pk] self.long_order = [leg1.pk, leg3.pk] self.bad_order = [leg1.pk, random_id(), leg3.pk] self.leg1_entity = AssertionHelper.EntityRef(resource='RouteLeg', pk=leg1.pk, attributes={'shipment_id': shipment.pk}) self.leg2_entity = AssertionHelper.EntityRef(resource='RouteLeg', pk=leg2.pk, attributes={'shipment_id': second_shipment.pk}) self.leg3_entity = AssertionHelper.EntityRef(resource='RouteLeg', pk=leg3.pk, attributes={'shipment_id': third_shipment.pk})
def shipments_with_device(user_alice, user_bob, devices, mocked_engine_rpc, mocked_iot_api, profiles_ids, modified_http_pretty): list_shipment = [] owner_id = user_alice.token.payload['organization_id'] third_owner_id = user_bob.token.payload['organization_id'] for device in devices: list_shipment.append( Shipment.objects.create( vault_id=random_id(), carrier_wallet_id=profiles_ids['carrier_wallet_id'], shipper_wallet_id=profiles_ids['shipper_wallet_id'], storage_credentials_id=random_id(), device=device, owner_id=owner_id)) # Shipment without device list_shipment[NUM_DEVICES - 2].device_id = None # Shipment not owned list_shipment[NUM_DEVICES - 3].owner_id = third_owner_id # Shipment with location field populated location = Location.objects.create(name='Test Location', city='Greenville') list_shipment[NUM_DEVICES - 4].ship_to_location = location # Shipment with shipper's reference field populated list_shipment[NUM_DEVICES - 5].shippers_reference = 'For search purposes' for shipment in list_shipment: shipment.save() modified_http_pretty.reset( ) # Clear any calls made from shipment creation, i.e. location geocoding return list_shipment
def test_random_device_id(self, api_client, tracking_data, shipment_alice_with_device): signed_tracking_data = self.sign_tracking(tracking_data, self.device) response = api_client.post(self.url_random, {'payload': signed_tracking_data}) AssertionHelper.HTTP_403( response, error='No shipment/route found associated to device.') # Does not matter which device id is in the data just the id in the endpoint signed_tracking_data = self.sign_tracking(tracking_data, self.device, device_id=random_id()) response = api_client.post(self.url_device, {'payload': signed_tracking_data}) AssertionHelper.HTTP_204(response)
def test_create_shipment_note(api_client, shipment): url = reverse('shipment-notes-list', kwargs={ 'version': 'v1', 'shipment_pk': shipment.id }) bad_shipment_url = reverse('shipment-notes-list', kwargs={ 'version': 'v1', 'shipment_pk': random_id() }) create_note_data, content_type = create_form_content({ 'message': MESSAGE, 'user_id': USER_ID }) # An unauthenticated user cannot create a shipment note without specifying the user response = api_client.post(url, {'message': MESSAGE}) AssertionHelper.HTTP_400(response, error='This field is required.', pointer='user_id') # A shipment note cannot be created for a non existing shipment response = api_client.post(bad_shipment_url, create_note_data, content_type=content_type) AssertionHelper.HTTP_403( response, error='You do not have permission to perform this action.') # An authenticated user with a specified user can create a shipment note response = api_client.post(url, create_note_data, content_type=content_type) AssertionHelper.HTTP_201(response, entity_refs=AssertionHelper.EntityRef( resource='ShipmentNote', attributes={ 'message': MESSAGE, 'user_id': USER_ID, 'username': None }, relationships={ 'shipment': AssertionHelper.EntityRef( resource='Shipment', pk=shipment.id) }))
def device_two(mocked_iot): device_id = random_id() # Create device 'thing' mocked_iot.create_thing( thingName=device_id ) # Load device cert into AWS with open('tests/data/cert.pem', 'r') as cert_file: cert_pem = cert_file.read() cert_response = mocked_iot.register_certificate( certificatePem=cert_pem, status='ACTIVE' ) certificate_id = cert_response['certificateId'] return Device.objects.create(id=device_id, certificate_id=certificate_id)
def set_up(self, mocked_engine_rpc, mocked_iot_api, mock_requests_session, device, mocked_iot): self.mocked_iot = mocked_iot self.url_device = reverse('device-tracking', kwargs={ 'version': 'v1', 'pk': device.id }) self.url_random = reverse('device-tracking', kwargs={ 'version': 'v1', 'pk': random_id() }) self.device = device with open('tests/data/eckey.pem', 'r') as key_file: self.key_pem = key_file.read() with open('tests/data/eckey2.pem', 'r') as key_file: self.key_pem2 = key_file.read()
async def test_trackingdata_notification(communicator): # Disable Shipment post-save signal await sync_to_async(models.signals.post_save.disconnect)(sender=Shipment, dispatch_uid='shipment_post_save') shipment, _ = await sync_to_async(Shipment.objects.get_or_create)( id='FAKE_SHIPMENT_ID', owner_id=USER_ID, storage_credentials_id='FAKE_STORAGE_CREDENTIALS_ID', shipper_wallet_id='FAKE_SHIPPER_WALLET_ID', carrier_wallet_id='FAKE_CARRIER_WALLET_ID', contract_version='1.0.0' ) # Re-enable Shipment post-save signal await sync_to_async(models.signals.post_save.connect)(shipment_post_save, sender=Shipment, dispatch_uid='shipment_post_save') device = await sync_to_async(Device.objects.create)(id=random_id()) tracking_data = await sync_to_async(TrackingData.objects.create)( id='FAKE_TRACKING_DATA_ID', device=device, shipment=shipment, latitude=75.65, longitude=84.36, altitude=36.65, source='gps', uncertainty=66, speed=36, version='1.1.0', timestamp=datetime.datetime.now(tz=None) ) response = await communicator.receive_json_from() assert response['event'] == EventTypes.trackingdata_update.name assert response['data']['shipment_id'] == shipment.id assert response['data']['feature']['type'] == 'Feature' assert response['data']['feature']['geometry']['coordinates'][0] == tracking_data.longitude t_data = await sync_to_async(TrackingData.objects.get)(id='FAKE_TRACKING_DATA_ID') await sync_to_async(t_data.delete)() await communicator.disconnect()
def set_up(self, mocked_engine_rpc, mocked_iot_api, successful_wallet_owner_calls_assertions, shipment_alice, nonsuccessful_wallet_owner_calls_assertions): self.assert_success = successful_wallet_owner_calls_assertions self.assert_fail = nonsuccessful_wallet_owner_calls_assertions self.mocked_iot_api = mocked_iot_api self.shipment = shipment_alice self.history_url = reverse('shipment-history-list', kwargs={ 'version': 'v1', 'shipment_pk': shipment_alice.id }) self.random_url = reverse('shipment-history-list', kwargs={ 'version': 'v1', 'shipment_pk': random_id() }) self.update_url = reverse('shipment-detail', kwargs={ 'version': 'v1', 'pk': shipment_alice.id })
import pytest import json from rest_framework import status from rest_framework.reverse import reverse from shipchain_common.utils import random_id from shipchain_common.test_utils import create_form_content, AssertionHelper GEOFENCE_1 = random_id() GEOFENCE_2 = random_id() GEOFENCE_3 = random_id() @pytest.mark.django_db def test_shadow_geofence_updates(mocked_iot_api, shipment_with_device): call_count = mocked_iot_api.call_count shipment_with_device.geofences = [GEOFENCE_1, GEOFENCE_2] shipment_with_device.save() call_count += 1 # Geofence should have been updated in the shadow assert mocked_iot_api.call_count == call_count mocked_iot_api.assert_called_with( shipment_with_device.device_id, {'geofences': shipment_with_device.geofences}) shipment_with_device.geofences = None shipment_with_device.save() call_count += 1 # Geofence should have been updated in the shadow assert mocked_iot_api.call_count == call_count mocked_iot_api.assert_called_with(shipment_with_device.device_id, {'geofences': ''})
def profiles_ids(): return { "shipper_wallet_id": random_id(), "carrier_wallet_id": random_id(), "storage_credentials_id": random_id() }
def set_up(self, shipment_alice_with_device, create_signed_telemetry_post): self.telemetry_url = reverse('device-telemetry', kwargs={'version': 'v1', 'pk': shipment_alice_with_device.device.id}) self.random_telemetry_url = reverse('device-telemetry', kwargs={'version': 'v1', 'pk': random_id()})
def set_up(self, shipment_alice_with_device, create_signed_telemetry_post, shipment_alice, unsigned_telemetry, successful_wallet_owner_calls_assertions, nonsuccessful_wallet_owner_calls_assertions): self.telemetry_url = reverse('shipment-telemetry-list', kwargs={'version': 'v1', 'shipment_pk': shipment_alice_with_device.id}) self.empty_telemetry_url = reverse('shipment-telemetry-list', kwargs={'version': 'v1', 'shipment_pk': shipment_alice.id}) self.random_telemetry_url = reverse('shipment-telemetry-list', kwargs={'version': 'v1', 'shipment_pk': random_id()}) self.shipment_alice_with_device = shipment_alice_with_device add_telemetry_data_to_model([unsigned_telemetry], self.shipment_alice_with_device) self.unsigned_telemetry = unsigned_telemetry self.assert_success = successful_wallet_owner_calls_assertions self.assert_fail = nonsuccessful_wallet_owner_calls_assertions
def shipment_bob(mocked_engine_rpc, mocked_iot_api): return Shipment.objects.create(vault_id=VAULT_ID, carrier_wallet_id=random_id(), shipper_wallet_id=ORGANIZATION_BOB_SHIPPER_ID, storage_credentials_id=random_id(), owner_id=ORGANIZATION_BOB_ID)
def user_lionel_id(): return random_id()
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from datetime import datetime, timezone import freezegun import pytest import requests from moto import mock_iot from rest_framework.test import APIClient from shipchain_common.test_utils import mocked_rpc_response, modified_http_pretty, AssertionHelper from shipchain_common.utils import random_id from apps.shipments.models import Shipment, Device USER_ID = random_id() SHIPPER_ID = random_id() VAULT_ID = random_id() DEVICE_ID = random_id() TRANSACTION_HASH = 'txHash' FROM_ADDRESS = "0x13b1eebb31a1aa2ecaa2ad9e7455df2f717f2143" TO_ADDRESS = "0x25ff5dc79a7c4e34254ff0f4a19d69e491201dd3" BLOCK_HASH = "0x38823cb26b528867c8dbea4146292908f55e1ee7f293685db1df0851d1b93b24" BLOCK_NUMBER = 14 CUMULATIVE_GAS_USED = 270710 GAS_USED = 270710 LOGS = [{"address": "0x25Ff5dc79A7c4e34254ff0f4a19d69E491201DD3"}] LOGS_BLOOM = "0x0000000000000000000000000000000...00000000000000000000" STATUS = True TRANSACTION_INDEX = 0
def user_alice_id(): return random_id()
def setup_url(self, new_route, new_route_with_device, new_route_bob): self.url_random = reverse('route-legs-list', kwargs={'version': 'v1', 'route_pk': random_id()}) self.url_route = reverse('route-legs-list', kwargs={'version': 'v1', 'route_pk': new_route.id}) self.url_route_device = reverse('route-legs-list', kwargs={'version': 'v1', 'route_pk': new_route_with_device.id}) self.url_route_bob = reverse('route-legs-list', kwargs={'version': 'v1', 'route_pk': new_route_bob.id})
def leg_attributes(self): return { 'shipment_id': random_id(), }
def third_shipment(mocked_engine_rpc, mocked_iot_api, profiles_ids): return Shipment.objects.create(vault_id=random_id(), owner_id=USER_ID, **profiles_ids)
# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pytest from rest_framework.reverse import reverse from shipchain_common.test_utils import AssertionHelper from shipchain_common.utils import random_id USER_ID = random_id() @pytest.fixture def shipment_tag_creation_data(): return { 'tag_type': '*Export-Shipment*', 'tag_value': '-->Europe', 'owner_id': USER_ID, } @pytest.fixture def shipment_tag_creation_missing_owner_id(): return {'tag_type': 'Destination', 'tag_value': 'Toronto'}
def create_organization_shipments(user, profiles_ids): return [ Shipment.objects.create(vault_id=random_id(), owner_id=user.token.payload['organization_id'], **profiles_ids) for i in range(0, 3) ]
def devices(): list_device = [] for i in range(0, NUM_DEVICES): list_device.append(Device.objects.create(id=random_id())) return list_device
def route_attributes(): return { 'name': 'Route #1', 'driver_id': random_id(), }
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import uuid import pytest from rest_framework.reverse import reverse from shipchain_common.test_utils import AssertionHelper from shipchain_common.utils import random_id VALID_UUID4 = random_id() @pytest.mark.django_db def test_shipment_creation_with_assignee(client_alice, mocked_is_shipper, mocked_storage_credential, shipment): url = reverse('shipment-list', kwargs={'version': 'v1'}) valid_uuid4_data = { 'storage_credentials_id': shipment.storage_credentials_id, 'shipper_wallet_id': shipment.shipper_wallet_id, 'carrier_wallet_id': shipment.carrier_wallet_id, 'assignee_id': VALID_UUID4, }
def setup_url(self, new_route): self.url_random = reverse('route-detail', kwargs={'version': 'v1', 'pk': random_id()}) self.url_route = reverse('route-detail', kwargs={'version': 'v1', 'pk': new_route.id})