def test_ambulance_create_serializer(self):
serializer = AmbulanceSerializer(
data={
'identifier': 'NEW-1897',
'capability': AmbulanceCapability.R.name,
'comment': 'no comments'
})
serializer.is_valid()
serializer.save(updated_by=self.u1)
# test AmbulanceSerializer
a = Ambulance.objects.get(identifier='NEW-1897')
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': 'NEW-1897',
'comment': 'no comments',
'capability': AmbulanceCapability.R.name,
'status': AmbulanceStatus.UK.name,
'orientation': a.orientation,
'location': point2str(a.location),
'timestamp': date2iso(a.timestamp),
'client_id': None,
'updated_by': self.u1.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
def test_hospital_serializer(self):
# test HospitalSerializer
for h in (self.h1, self.h2, self.h3):
serializer = HospitalSerializer(h)
result = {
'id': h.id,
'name': h.name,
'number': h.number,
'street': h.street,
'unit': h.unit,
'neighborhood': h.neighborhood,
'city': h.city,
'state': h.state,
'zipcode': h.zipcode,
'country': h.country,
'location': point2str(h.location),
'comment': h.comment,
'updated_by': h.updated_by.id,
'updated_on': date2iso(h.updated_on),
'equipmentholder_id': h.equipmentholder.id
# 'hospitalequipment_set':
# EquipmentItemSerializer(EquipmentItem.objects.filter(equipmentholder_id=h.equipmentholder.id),
# many=True).data
}
logger.debug('answer= {}'.format(serializer.data))
logger.debug('result = {}'.format(result))
self.assertDictEqual(serializer.data, result)
def test_ambulance_serializer(self):
# test AmbulanceSerializer
for a in (self.a1, self.a2, self.a3):
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.UK.name,
'orientation': a.orientation,
'location': point2str(a.location),
'timestamp': date2iso(a.timestamp),
'client_id': None,
'updated_by': a.updated_by.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
def test_equipment_item_serializer(self):
# test HospitalSerializer
for he in (self.he1, self.he2, self.he3, self.he4):
serializer = EquipmentItemSerializer(he)
result = {
'equipmentholder_id': he.equipmentholder.id,
'equipment_id': he.equipment.id,
'equipment_name': he.equipment.name,
'equipment_type': he.equipment.type,
'value': he.value,
'comment': he.comment,
'updated_by': he.updated_by.id,
'updated_on': date2iso(he.updated_on)
}
self.assertDictEqual(serializer.data, result)
def test_hospital_equipment_serializer(self):
# test HospitalSerializer
for he in (self.he1, self.he2, self.he3, self.he4):
serializer = HospitalEquipmentSerializer(he)
result = {
'hospital_id': he.hospital.id,
'hospital_name': he.hospital.name,
'equipment_id': he.equipment.id,
'equipment_name': he.equipment.name,
'equipment_etype': he.equipment.etype,
'value': he.value,
'comment': he.comment,
'updated_by': he.updated_by.id,
'updated_on': date2iso(he.updated_on)
}
self.assertDictEqual(serializer.data, result)
def test_location_serializer(self):
# test LocationSerializer
for h in (self.l1, self.l2, self.l3):
serializer = LocationSerializer(h)
result = {
'id': h.id,
'name': h.name,
'type': h.type,
'number': h.number,
'street': h.street,
'unit': h.unit,
'neighborhood': h.neighborhood,
'city': h.city,
'state': h.state,
'zipcode': h.zipcode,
'country': h.country,
'location': point2str(h.location),
'comment': h.comment,
'updated_by': h.updated_by.id,
'updated_on': date2iso(h.updated_on)
}
self.assertDictEqual(serializer.data, result)
def test_call_create_viewset(self):
# instantiate client
client = Client()
client.login(username=settings.MQTT['USERNAME'],
password=settings.MQTT['PASSWORD'])
data = {
'status':
CallStatus.P.name,
'priority':
CallPriority.B.name,
'sms_notifications': [],
'ambulancecall_set': [{
'ambulance_id':
self.a1.id,
'waypoint_set': [{
'order': 0,
'location': {
'type': LocationType.i.name,
'number': '123',
'street': 'some street'
}
}, {
'order': 1,
'status': WaypointStatus.D.name,
'location': {
'type': LocationType.w.name,
'location': {
'longitude': -110.54,
'latitude': 35.75
}
}
}]
}, {
'ambulance_id':
self.a2.id,
'waypoint_set': [{
'order': 0,
'location': {
'type': LocationType.i.name,
'number': '321',
'street': 'another street'
}
}]
}],
'patient_set': [{
'name': 'Jose',
'age': 3
}, {
'name': 'Maria',
'age': 10
}]
}
response = client.post('/en/api/call/',
data,
content_type='application/json')
self.assertEqual(response.status_code, 201)
c1 = Call.objects.get(status=CallStatus.P.name)
# add notes
data = {'comment': 'some comment'}
response = client.post('/en/api/call/{}/note/'.format(c1.id),
data,
content_type='application/json')
self.assertEqual(response.status_code, 201)
data = {'comment': 'another comment'}
response = client.post('/en/api/call/{}/note/'.format(c1.id),
data,
content_type='application/json')
self.assertEqual(response.status_code, 201)
# serialize
serializer = CallSerializer(c1)
expected_patient_set = PatientSerializer(
Patient.objects.filter(call_id=c1.id), many=True).data
expected_ambulancecall_set = AmbulanceCallSerializer(
AmbulanceCall.objects.filter(call_id=c1.id), many=True).data
expected_callnote_set = CallNoteSerializer(
CallNote.objects.filter(call_id=c1.id), many=True).data
self.assertEqual(len(expected_patient_set), 2)
self.assertEqual(len(expected_callnote_set), 2)
self.assertEqual(
len(expected_ambulancecall_set[0]['waypoint_set']) +
len(expected_ambulancecall_set[1]['waypoint_set']), 3)
expected = {
'id': c1.id,
'status': c1.status,
'details': c1.details,
'priority': c1.priority,
'priority_code': c1.priority_code,
'radio_code': c1.radio_code,
'created_at': date2iso(c1.created_at),
'pending_at': date2iso(c1.pending_at),
'started_at': date2iso(c1.started_at),
'ended_at': date2iso(c1.ended_at),
'comment': c1.comment,
'updated_by': c1.updated_by.id,
'updated_on': date2iso(c1.updated_on),
'sms_notifications': [],
'ambulancecall_set': expected_ambulancecall_set,
'patient_set': expected_patient_set,
'callnote_set': expected_callnote_set
}
result = serializer.data
self.assertCountEqual(result['ambulancecall_set'],
expected['ambulancecall_set'])
self.assertCountEqual(result['patient_set'], expected['patient_set'])
self.assertCountEqual(result['callnote_set'], expected['callnote_set'])
expected['ambulancecall_set'] = []
result['ambulancecall_set'] = []
expected['patient_set'] = []
result['patient_set'] = []
expected['callnote_set'] = []
result['callnote_set'] = []
self.assertDictEqual(result, expected)
# get notes
response = client.get('/en/api/call/{}/note/'.format(c1.id))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, expected_callnote_set)
# logout
client.logout()
# login as testuser2
client.login(username='******', password='******')
# Will fail for anyone not superuser or staff or dispatcher
data = {
'status':
CallStatus.P.name,
'priority':
CallPriority.B.name,
'sms_notifications': [],
'ambulancecall_set': [{
'ambulance_id': self.a1.id
}, {
'ambulance_id': self.a2.id
}],
'patient_set': [{
'name': 'Jose',
'age': 3
}, {
'name': 'Maria',
'age': 10
}]
}
response = client.post('/en/api/call/',
data,
content_type='application/json')
self.assertEqual(response.status_code, 403)
# should fail because user can not read or write to ambulances
response = client.get('/en/api/call/{}/note/'.format(c1.id))
self.assertEqual(response.status_code, 403)
data = {'comment': 'some comment'}
response = client.post('/en/api/call/{}/note/'.format(c1.id),
data,
content_type='application/json')
self.assertEqual(response.status_code, 403)
# logout
client.logout()
# login as staff
client.login(username='******', password='******')
# Should not fail, is staff
data = {
'status':
CallStatus.P.name,
'priority':
CallPriority.A.name,
'sms_notifications': [],
'ambulancecall_set': [{
'ambulance_id': self.a1.id
}, {
'ambulance_id': self.a2.id
}],
'patient_set': [{
'name': 'Jose',
'age': 3
}, {
'name': 'Maria',
'age': 10
}]
}
response = client.post('/en/api/call/',
data,
content_type='application/json')
logger.debug(response.content)
self.assertEqual(response.status_code, 201)
c2 = Call.objects.get(priority=CallPriority.A.name)
# should not fail, user is staff
response = client.get('/en/api/call/{}/note/'.format(c2.id))
self.assertEqual(response.status_code, 200)
data = {'comment': 'yet another comment'}
response = client.post('/en/api/call/{}/note/'.format(c2.id),
data,
content_type='application/json')
self.assertEqual(response.status_code, 201)
# logout
client.logout()
# login as dispatcher
client.login(username='******', password='******')
# Should not fail, is dispatcher
data = {
'status':
CallStatus.P.name,
'priority':
CallPriority.C.name,
'sms_notifications': [],
'ambulancecall_set': [{
'ambulance_id': self.a3.id
}],
'patient_set': [{
'name': 'Jose',
'age': 3
}, {
'name': 'Maria',
'age': 10
}]
}
response = client.post('/en/api/call/',
data,
content_type='application/json')
logger.debug(response.content)
self.assertEqual(response.status_code, 201)
c3 = Call.objects.get(priority=CallPriority.C.name)
# should not fail, user is dispatcher
response = client.get('/en/api/call/{}/note/'.format(c3.id))
self.assertEqual(response.status_code, 200)
data = {'comment': 'yet another comment'}
response = client.post('/en/api/call/{}/note/'.format(c3.id),
data,
content_type='application/json')
self.assertEqual(response.status_code, 201)
# Should fail, dispatcher but not in authorized list of ambulances
data = {
'status':
CallStatus.P.name,
'priority':
CallPriority.B.name,
'sms_notifications': [],
'ambulancecall_set': [{
'ambulance_id': self.a1.id
}],
'patient_set': [{
'name': 'Jose',
'age': 3
}, {
'name': 'Maria',
'age': 10
}]
}
response = client.post('/en/api/call/',
data,
content_type='application/json')
logger.debug(response.content)
self.assertEqual(response.status_code, 403)
# should fail, user is staff
response = client.get('/en/api/call/{}/note/'.format(c2.id))
self.assertEqual(response.status_code, 403)
data = {'comment': 'yet another comment'}
response = client.post('/en/api/call/{}/note/'.format(c2.id),
data,
content_type='application/json')
self.assertEqual(response.status_code, 403)
# Should fail, dispatcher but not in authorized list of ambulances
data = {
'status':
CallStatus.P.name,
'priority':
CallPriority.B.name,
'sms_notifications': [],
'ambulancecall_set': [{
'ambulance_id': self.a3.id
}, {
'ambulance_id': self.a1.id
}],
'patient_set': [{
'name': 'Jose',
'age': 3
}, {
'name': 'Maria',
'age': 10
}]
}
response = client.post('/en/api/call/',
data,
content_type='application/json')
logger.debug(response.content)
self.assertEqual(response.status_code, 403)
# logout
client.logout()
def test_location_serializer_create(self):
# test LocationSerializer create
json = {
'type': LocationType.i.name,
'number': '123',
'street': 'some street'
}
serializer = LocationSerializer(data=json)
serializer.is_valid()
loc = serializer.save(updated_by=self.u1)
# test CallSerializer
l1 = Location.objects.get(id=loc.id)
serializer = LocationSerializer(l1)
expected = {
'id': l1.id,
'name': l1.name,
'type': l1.type,
'number': '123',
'street': 'some street',
'unit': l1.unit,
'neighborhood': l1.neighborhood,
'city': l1.city,
'state': l1.state,
'zipcode': l1.zipcode,
'country': l1.country,
'location': point2str(l1.location),
'comment': l1.comment,
'updated_by': l1.updated_by.id,
'updated_on': date2iso(l1.updated_on)
}
result = serializer.data
self.assertEqual(result, expected)
json = {
'type': LocationType.w.name,
'location': {
'longitude': -110.54,
'latitude': 35.75
}
}
serializer = LocationSerializer(data=json)
serializer.is_valid()
loc = serializer.save(updated_by=self.u1)
# test CallSerializer
l2 = Location.objects.get(id=loc.id)
serializer = LocationSerializer(l2)
expected = {
'id': l2.id,
'name': l2.name,
'type': l2.type,
'number': l2.number,
'street': l2.street,
'unit': l2.unit,
'neighborhood': l2.neighborhood,
'city': l2.city,
'state': l2.state,
'zipcode': l2.zipcode,
'country': l2.country,
'location': {
'longitude': -110.54,
'latitude': 35.75
},
'comment': l2.comment,
'updated_by': l2.updated_by.id,
'updated_on': date2iso(l2.updated_on)
}
result = serializer.data
self.assertEqual(result, expected)
def test(self):
# Bulk update ambulance a1
a = self.a1
user = self.u1
location0 = {'latitude': -3., 'longitude': 6.}
location = {'latitude': -2., 'longitude': 7.}
orientation = calculate_orientation(dict2point(location0),
dict2point(location))
data = [{
'status': AmbulanceStatus.AH.name,
'location': location0,
}, {
'location': location,
'timestamp': timezone.now()
}, {
'status': AmbulanceStatus.OS.name
}]
serializer = AmbulanceUpdateSerializer(data=data,
many=True,
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save(ambulance=Ambulance.objects.get(id=a.id),
updated_by=user)
# test AmbulanceUpdateSerializer
queryset = AmbulanceUpdate.objects.filter(ambulance=a)
answer1 = []
for u in queryset:
serializer = AmbulanceUpdateSerializer(u)
result = {
'id': u.id,
'ambulance_id': u.ambulance.id,
'ambulance_identifier': u.ambulance.identifier,
'comment': u.comment,
'capability': u.capability,
'status': u.status,
'orientation': u.orientation,
'location': point2str(u.location),
'timestamp': date2iso(u.timestamp),
'updated_by_username': u.updated_by.username,
'updated_on': date2iso(u.updated_on)
}
answer1.append(serializer.data)
self.assertDictEqual(serializer.data, result)
# make sure last update is reflected in ambulance
a = Ambulance.objects.get(id=a.id)
serializer = AmbulanceSerializer(a)
self.assertEqual(math.fabs(orientation - a.orientation) < 1e-4, True)
orientation = a.orientation
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.OS.name,
'orientation': orientation,
'location': point2str(location),
'timestamp': date2iso(a.timestamp),
'client_id': None,
'updated_by': a.updated_by.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Bulk update ambulance a2
a = self.a3
user = self.u3
data = [{
'status': AmbulanceStatus.AH.name,
'location': location0
}, {
'status': AmbulanceStatus.OS.name
}, {
'location': location,
'timestamp': timezone.now()
}]
serializer = AmbulanceUpdateSerializer(data=data,
many=True,
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save(ambulance=Ambulance.objects.get(id=a.id),
updated_by=user)
# test AmbulanceUpdateSerializer
queryset = AmbulanceUpdate.objects.filter(ambulance=a)
answer3 = []
for u in queryset:
serializer = AmbulanceUpdateSerializer(u)
result = {
'id': u.id,
'ambulance_id': a.id,
'ambulance_identifier': a.identifier,
'comment': u.comment,
'capability': u.capability,
'status': u.status,
'orientation': u.orientation,
'location': point2str(u.location),
'timestamp': date2iso(u.timestamp),
'updated_by_username': u.updated_by.username,
'updated_on': date2iso(u.updated_on)
}
answer3.append(serializer.data)
self.assertDictEqual(serializer.data, result)
# make sure last update is reflected in ambulance
a = Ambulance.objects.get(id=a.id)
serializer = AmbulanceSerializer(a)
self.assertEqual(math.fabs(orientation - a.orientation) < 1e-4, True)
orientation = a.orientation
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.OS.name,
'orientation': orientation,
'location': point2str(location),
'timestamp': date2iso(a.timestamp),
'client_id': None,
'updated_by': a.updated_by.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Test api
# instantiate client
client = Client()
# login as admin
client.login(username=settings.MQTT['USERNAME'],
password=settings.MQTT['PASSWORD'])
# retrieve ambulances updates
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a1.id),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, answer1)
self.assertEqual(len(result), 4)
# retrieve ambulances updates
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a3.id),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, answer3)
self.assertEqual(len(result), 4)
# logout
client.logout()
# login as testuser1
client.login(username='******', password='******')
# retrieve ambulances
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a1.id),
follow=True)
self.assertEqual(response.status_code, 404)
# retrieve ambulances
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a3.id),
follow=True)
self.assertEqual(response.status_code, 404)
# logout
client.logout()
# login as testuser2
client.login(username='******', password='******')
# retrieve ambulances
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a1.id),
follow=True)
self.assertEqual(response.status_code, 404)
# retrieve ambulances updates
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a3.id),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, answer3)
self.assertEqual(len(result), 4)
# logout
client.logout()
def test(self):
# Update ambulance a1
a = self.a1
user = self.u1
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
data={
'location': location,
'timestamp': timestamp
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
status = AmbulanceStatus.OS.name
serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# This update does not go to AmbulanceUpdate!
serializer = AmbulanceSerializer(Ambulance.objects.get(id=a.id),
data={
'identifier': 'someid',
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test AmbulanceUpdateSerializer
queryset = AmbulanceUpdate.objects.filter(ambulance=a)
answer1 = []
for u in queryset:
serializer = AmbulanceUpdateSerializer(u)
result = {
'id': u.id,
'ambulance_id': u.ambulance.id,
'ambulance_identifier': u.ambulance.identifier,
'comment': u.comment,
'capability': u.capability,
'status': u.status,
'orientation': u.orientation,
'location': point2str(u.location),
'timestamp': date2iso(u.timestamp),
'updated_by_username': u.updated_by.username,
'updated_on': date2iso(u.updated_on)
}
answer1.append(serializer.data)
self.assertDictEqual(serializer.data, result)
# Update ambulance a2
a = self.a3
user = self.u3
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location': location,
'timestamp': timestamp
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
status = AmbulanceStatus.OS.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test AmbulanceUpdateSerializer
queryset = AmbulanceUpdate.objects.filter(ambulance=a)
answer3 = []
for u in queryset:
serializer = AmbulanceUpdateSerializer(u)
result = {
'id': u.id,
'ambulance_id': u.ambulance.id,
'ambulance_identifier': a.identifier,
'comment': u.comment,
'capability': u.capability,
'status': u.status,
'orientation': u.orientation,
'location': point2str(u.location),
'timestamp': date2iso(u.timestamp),
'updated_by_username': u.updated_by.username,
'updated_on': date2iso(u.updated_on)
}
answer3.append(serializer.data)
self.assertDictEqual(serializer.data, result)
# Test api
# instantiate client
client = Client()
# login as admin
client.login(username=settings.MQTT['USERNAME'],
password=settings.MQTT['PASSWORD'])
# retrieve ambulances updates
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a1.id),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, answer1)
self.assertEqual(len(result), 4)
# retrieve ambulances updates
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a3.id),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, answer3)
self.assertEqual(len(result), 4)
# logout
client.logout()
# login as testuser1
client.login(username='******', password='******')
# retrieve ambulances
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a1.id),
follow=True)
self.assertEqual(response.status_code, 404)
# retrieve ambulances
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a3.id),
follow=True)
self.assertEqual(response.status_code, 404)
# logout
client.logout()
# login as testuser2
client.login(username='******', password='******')
# retrieve ambulances
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a1.id),
follow=True)
self.assertEqual(response.status_code, 404)
# retrieve ambulances updates
response = client.get('/en/api/ambulance/{}/updates/'.format(
self.a3.id),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertCountEqual(result, answer3)
self.assertEqual(len(result), 4)
# logout
client.logout()
def test_ambulance_patch_viewset(self):
# instantiate client
client = Client()
# login as admin
client.login(username=settings.MQTT['USERNAME'],
password=settings.MQTT['PASSWORD'])
# retrieve ambulance
response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = AmbulanceSerializer(self.a1).data
self.assertDictEqual(result, answer)
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a1.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data
self.assertDictEqual(result, answer)
# retrieve new ambulance status
response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['status'], status)
# set status location
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a1.id)),
content_type='application/json',
data=json.dumps({
'location':
point2str(location),
'timestamp':
date2iso(timestamp),
}),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a1.id)).data
if math.fabs(answer['orientation'] - result['orientation']) < 1e-4:
answer['orientation'] = result['orientation']
self.assertDictEqual(result, answer)
# retrieve new ambulance location
response = client.get('/en/api/ambulance/{}/'.format(str(self.a1.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['status'], status)
self.assertEqual(result['location'], point2str(location))
self.assertEqual(result['timestamp'], date2iso(timestamp))
# set wrong attribute
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a1.id)),
content_type='application/json',
data=json.dumps({'status': 'will fail'}),
follow=True)
self.assertEqual(response.status_code, 400)
# set wrong ambulance id
response = client.patch('/en/api/ambulance/100/',
data=json.dumps({'status': status}),
follow=True)
self.assertEqual(response.status_code, 404)
# logout
client.logout()
# login as testuser2
client.login(username='******', password='******')
# retrieve ambulance
response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = AmbulanceSerializer(self.a3).data
self.assertDictEqual(result, answer)
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a3.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data
self.assertDictEqual(result, answer)
# retrieve new ambulance status
response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['status'], status)
# set location
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a3.id)),
content_type='application/json',
data=json.dumps({
'location':
point2str(location),
'timestamp':
date2iso(timestamp),
}),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = AmbulanceSerializer(Ambulance.objects.get(id=self.a3.id)).data
if math.fabs(answer['orientation'] - result['orientation']) < 1e-4:
answer['orientation'] = result['orientation']
self.assertDictEqual(result, answer)
# retrieve new ambulance location
response = client.get('/en/api/ambulance/{}/'.format(str(self.a3.id)),
follow=True)
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['status'], status)
self.assertEqual(result['location'], point2str(location))
self.assertEqual(result['timestamp'], date2iso(timestamp))
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a1.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 404)
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a2.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 404)
# logout
client.logout()
# login as testuser1
client.login(username='******', password='******')
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a1.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 404)
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a2.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 404)
# set status ambulance
status = AmbulanceStatus.OS.name
response = client.patch('/en/api/ambulance/{}/'.format(str(
self.a3.id)),
content_type='application/json',
data=json.dumps({
'status': status,
}),
follow=True)
self.assertEqual(response.status_code, 404)
# logout
client.logout()
def test_ambulance_update_serializer(self):
# superuser first
# Update ambulance status
a = self.a1
user = self.u1
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': status,
'orientation': a.orientation,
'location': point2str(a.location),
'client_id': None,
'timestamp': date2iso(a.timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update ambulance location
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location': location,
'timestamp': timestamp,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'client_id': None,
'timestamp': date2iso(timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# error update timestamp without location or status
serializer = AmbulanceSerializer(a,
data={
'timestamp': timestamp,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# regular authorized user
# Update ambulance status
a = self.a3
user = self.u3
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': status,
'orientation': a.orientation,
'location': point2str(a.location),
'client_id': None,
'timestamp': date2iso(a.timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update ambulance location
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location': location,
'timestamp': timestamp
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'client_id': None,
'timestamp': date2iso(timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# error update timestamp without location or status
serializer = AmbulanceSerializer(a,
data={
'timestamp': timestamp,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# update client
client1 = loginClient(client_id='client_id_1',
user_id=self.u1.id,
ambulance=a)
client1.save()
client2 = loginClient(client_id='client_id_2', user_id=self.u3.id)
client2.save()
self.assertEqual(client1.ambulance, a)
self.assertEqual(client2.ambulance, None)
self.assertEqual(a.client, client1)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'client_id': client1.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will not change
client2.ambulance = self.a2
with self.assertRaises(Exception) as raised:
with transaction.atomic():
client2.save()
self.assertEqual(PermissionDenied, type(raised.exception))
# will not change
client2.ambulance = a
with self.assertRaises(Exception) as raised:
with transaction.atomic():
client2.save()
self.assertEqual(IntegrityError, type(raised.exception))
client2 = loginClient.objects.get(client_id='client_id_2')
a = Ambulance.objects.get(id=a.id)
self.assertEqual(client1.ambulance, a)
self.assertEqual(client2.ambulance, None)
self.assertEqual(a.client, client1)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'client_id': client1.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will reset
client1.ambulance = None
client1.save()
a = Ambulance.objects.get(id=a.id)
self.assertEqual(client1.ambulance, None)
self.assertEqual(client2.ambulance, None)
self.assertEqual(hasattr(a, 'client'), False)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'client_id': None,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will change
client2.ambulance = a
client2.save()
self.assertEqual(client1.ambulance, None)
self.assertEqual(client2.ambulance, a)
self.assertEqual(a.client, client2)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'client_id': client2.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will not change in partial update
serializer = AmbulanceSerializer(
a, data={'status': AmbulanceStatus.OS.name}, partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.OS.name,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'client_id': client2.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will not change in partial update
serializer = AmbulanceSerializer(a,
data={
'status': AmbulanceStatus.PB.name,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.PB.name,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'client_id': client2.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
def testClientSerializer(self):
# test ClientSerializer
# client online
client1 = Client.objects.create(client_id='client_id_1',
user=self.u1,
status=ClientStatus.O.name,
ambulance=self.a1)
serializer = ClientSerializer(client1)
result = {
'client_id': client1.client_id,
'username': client1.user.username,
'status': client1.status,
'ambulance': client1.ambulance.id,
'hospital': None,
'updated_on': date2iso(client1.updated_on)
}
self.assertDictEqual(serializer.data, result)
# create client
serializer = ClientSerializer(
data={
'client_id': 'client_id_3',
'status': ClientStatus.O.name,
'ambulance': None,
'hospital': None
})
if not serializer.is_valid():
logger.debug('errors = {}'.format(serializer.errors))
self.assertTrue(False)
serializer.save(user=self.u2)
client2 = Client.objects.get(client_id='client_id_3')
self.assertEqual(client2.status, ClientStatus.O.name)
self.assertEqual(client2.user, self.u2)
self.assertEqual(client2.ambulance, None)
self.assertEqual(client2.hospital, None)
# create client
serializer = ClientSerializer(
data={
'client_id': 'client_id_4',
'status': ClientStatus.O.name,
'ambulance': self.a2.id,
'hospital': None
})
if not serializer.is_valid():
logger.debug('errors = {}'.format(serializer.errors))
self.assertTrue(False)
serializer.save(user=self.u1)
client2 = Client.objects.get(client_id='client_id_4')
self.assertEqual(client2.status, ClientStatus.O.name)
self.assertEqual(client2.user, self.u1)
self.assertEqual(client2.ambulance, self.a2)
self.assertEqual(client2.hospital, None)
# update client
serializer = ClientSerializer(data={
'client_id': 'client_id_4',
'hospital': self.h1.id
},
partial=True)
if not serializer.is_valid():
logger.debug('errors = {}'.format(serializer.errors))
self.assertTrue(False)
serializer.save(user=self.u1)
client2 = Client.objects.get(client_id='client_id_4')
self.assertEqual(client2.status, ClientStatus.O.name)
self.assertEqual(client2.user, self.u1)
self.assertEqual(client2.ambulance, self.a2)
self.assertEqual(client2.hospital, self.h1)
def test_hospital_update_serializer(self):
# superuser first
# Update hospital street
h = self.h1
user = self.u1
street = 'new street'
serializer = HospitalSerializer(h,
data={
'street': street,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = HospitalSerializer(h)
result = {
'id': h.id,
'name': h.name,
'number': h.number,
'street': street,
'unit': h.unit,
'neighborhood': h.neighborhood,
'city': h.city,
'state': h.state,
'zipcode': h.zipcode,
'country': h.country,
'comment': h.comment,
'location': point2str(h.location),
'updated_by': user.id,
'updated_on': date2iso(h.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update hospital location
location = {'latitude': -2., 'longitude': 7.}
serializer = HospitalSerializer(h,
data={
'location': location,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = HospitalSerializer(h)
result = {
'id': h.id,
'name': h.name,
'number': h.number,
'street': h.street,
'unit': h.unit,
'neighborhood': h.neighborhood,
'city': h.city,
'state': h.state,
'zipcode': h.zipcode,
'country': h.country,
'comment': h.comment,
'location': point2str(location),
'updated_by': user.id,
'updated_on': date2iso(h.updated_on)
}
self.assertDictEqual(serializer.data, result)
# regular authorized user
# Update hospital street
h = self.h2
user = self.u2
street = 'new street'
serializer = HospitalSerializer(h,
data={
'street': street,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = HospitalSerializer(h)
result = {
'id': h.id,
'name': h.name,
'number': h.number,
'street': street,
'unit': h.unit,
'neighborhood': h.neighborhood,
'city': h.city,
'state': h.state,
'zipcode': h.zipcode,
'country': h.country,
'comment': h.comment,
'location': point2str(h.location),
'updated_by': user.id,
'updated_on': date2iso(h.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update hospital location
location = {'latitude': -2., 'longitude': 7.}
serializer = HospitalSerializer(h,
data={
'location': location,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = HospitalSerializer(h)
result = {
'id': h.id,
'name': h.name,
'number': h.number,
'street': h.street,
'unit': h.unit,
'neighborhood': h.neighborhood,
'city': h.city,
'state': h.state,
'zipcode': h.zipcode,
'country': h.country,
'comment': h.comment,
'location': point2str(location),
'updated_by': user.id,
'updated_on': date2iso(h.updated_on)
}
self.assertDictEqual(serializer.data, result)
def test_ambulance_update_serializer(self):
# superuser first
# Update ambulance status
a = self.a1
user = self.u1
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': status,
'orientation': a.orientation,
'location': point2str(a.location),
'location_timestamp': date2iso(a.location_timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update ambulance location
location_timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location':
location,
'location_timestamp':
location_timestamp,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'location_timestamp': date2iso(location_timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# error update location with timestamp
serializer = AmbulanceSerializer(a,
data={
'location': location,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# error update timestamp without location
serializer = AmbulanceSerializer(a,
data={
'location_timestamp':
location_timestamp,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# regular authorized user
# Update ambulance status
a = self.a3
user = self.u3
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': status,
'orientation': a.orientation,
'location': point2str(a.location),
'location_timestamp': date2iso(a.location_timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update ambulance location
location_timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location':
location,
'location_timestamp':
location_timestamp
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'location_timestamp': date2iso(location_timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# error update location with timestamp
serializer = AmbulanceSerializer(a,
data={'location': location},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# error update timestamp without location
serializer = AmbulanceSerializer(a,
data={
'location_timestamp':
location_timestamp,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
def test_ambulance_update_serializer(self):
# superuser first
# Update ambulance status
a = self.a1
user = self.u1
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': status,
'orientation': a.orientation,
'location': point2str(a.location),
'location_client_id': None,
'timestamp': date2iso(a.timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update ambulance location
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location': location,
'timestamp': timestamp,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'location_client_id': None,
'timestamp': date2iso(timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# error update timestamp without location or status
serializer = AmbulanceSerializer(a,
data={
'timestamp': timestamp,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# regular authorized user
# Update ambulance status
a = self.a3
user = self.u3
status = AmbulanceStatus.AH.name
serializer = AmbulanceSerializer(a,
data={
'status': status,
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': status,
'orientation': a.orientation,
'location': point2str(a.location),
'location_client_id': None,
'timestamp': date2iso(a.timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# Update ambulance location
timestamp = timezone.now()
location = {'latitude': -2., 'longitude': 7.}
serializer = AmbulanceSerializer(a,
data={
'location': location,
'timestamp': timestamp
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'location_client_id': None,
'timestamp': date2iso(timestamp),
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# error update timestamp without location or status
serializer = AmbulanceSerializer(a,
data={
'timestamp': timestamp,
},
partial=True)
self.assertEqual(serializer.is_valid(), False)
# update location_client
client1 = loginClient(client_id='client_id_1', user_id=self.u1.id)
client1.save()
client2 = loginClient(client_id='client_id_2', user_id=self.u2.id)
client2.save()
serializer = AmbulanceSerializer(
a, data={'location_client_id': client1.client_id}, partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'location_client_id': client1.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will not change
serializer = AmbulanceSerializer(
a, data={'location_client_id': client2.client_id}, partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'location_client_id': client1.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will reset
serializer = AmbulanceSerializer(a,
data={'location_client_id': None},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'location_client_id': None,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will change
serializer = AmbulanceSerializer(
a, data={'location_client_id': client2.client_id}, partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': a.status,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'location_client_id': client2.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will not change in partial update
serializer = AmbulanceSerializer(
a, data={'status': AmbulanceStatus.OS.name}, partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.OS.name,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'location_client_id': client2.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# will not change in partial update
serializer = AmbulanceSerializer(a,
data={
'status':
AmbulanceStatus.PB.name,
'location_client_id':
client1.client_id
},
partial=True)
serializer.is_valid()
serializer.save(updated_by=user)
# test
serializer = AmbulanceSerializer(a)
result = {
'id': a.id,
'identifier': a.identifier,
'comment': a.comment,
'capability': a.capability,
'status': AmbulanceStatus.PB.name,
'orientation': a.orientation,
'location': point2str(location),
'timestamp': date2iso(timestamp),
'location_client_id': client2.client_id,
'updated_by': user.id,
'updated_on': date2iso(a.updated_on)
}
self.assertDictEqual(serializer.data, result)
# invalid client id
serializer = AmbulanceSerializer(a,
data={
'status': AmbulanceStatus.PB.name,
'location_client_id':
'__invalid__'
},
partial=True)
self.assertFalse(serializer.is_valid())
