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})
