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_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_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_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(self):
# Start client as admin
broker = {
'HOST': 'localhost',
'PORT': 1883,
'KEEPALIVE': 60,
'CLEAN_SESSION': True
}
# Start subscribe client
broker.update(settings.MQTT)
broker['CLIENT_ID'] = 'test_mqttclient'
subscribe_client = SubscribeClient(broker, debug=True)
self.is_connected(subscribe_client)
self.is_subscribed(subscribe_client)
# Start test client
broker.update(settings.MQTT)
client_id = 'test_mqtt_subscribe_admin'
username = broker['USERNAME']
broker['CLIENT_ID'] = client_id
test_client = MQTTTestClient(broker, check_payload=False, debug=True)
self.is_connected(test_client)
# start django client
django_client = DjangoClient()
# login as admin
django_client.login(username=settings.MQTT['USERNAME'],
password=settings.MQTT['PASSWORD'])
# handshake ambulance and hospital
response = django_client.post('/en/api/client/',
content_type='application/json',
data=json.dumps({
'client_id':
client_id,
'status':
ClientStatus.O.name,
'ambulance':
self.a1.id,
'hospital':
self.h1.id
}),
follow=True)
self.assertEqual(response.status_code, 201)
# check record
clnt = Client.objects.get(client_id=client_id)
self.assertEqual(clnt.status, ClientStatus.O.name)
self.assertEqual(clnt.ambulance, self.a1)
self.assertEqual(clnt.hospital, self.h1)
# Modify ambulance
# retrieve current ambulance status
obj = Ambulance.objects.get(id=self.a1.id)
self.assertEqual(obj.status, AmbulanceStatus.UK.name)
# expect update once
test_client.expect('ambulance/{}/data'.format(self.a1.id))
self.is_subscribed(test_client)
# publish change
test_client.publish('user/{}/client/{}/ambulance/{}/data'.format(
self.u1.username, client_id, self.a1.id),
json.dumps({
'status': AmbulanceStatus.OS.name,
}),
qos=0)
# process messages
self.loop(test_client, subscribe_client)
# verify change
obj = Ambulance.objects.get(id=self.a1.id)
self.assertEqual(obj.status, AmbulanceStatus.OS.name)
# Modify hospital
# retrieve current hospital status
obj = Hospital.objects.get(id=self.h1.id)
self.assertEqual(obj.comment, 'no comments')
# expect update once
test_client.expect('hospital/{}/data'.format(self.h1.id))
self.is_subscribed(test_client)
test_client.publish('user/{}/client/{}/hospital/{}/data'.format(
self.u1.username, client_id, self.h1.id),
json.dumps({
'comment': 'no more comments',
}),
qos=0)
# process messages
self.loop(test_client, subscribe_client)
# verify change
obj = Hospital.objects.get(id=self.h1.id)
self.assertEqual(obj.comment, 'no more comments')
# Modify hospital equipment
# retrieve current equipment value
obj = EquipmentItem.objects.get(
equipmentholder=self.h1.equipmentholder, equipment=self.e1)
self.assertEqual(obj.value, 'True')
# expect update once
test_client.expect('equipment/{}/item/{}/data'.format(
self.h1.equipmentholder.id, self.e1.id))
self.is_subscribed(test_client)
test_client.publish(
'user/{}/client/{}/equipment/{}/item/{}/data'.format(
self.u1.username, client_id, self.h1.equipmentholder.id,
self.e1.id),
json.dumps({
'value': 'False',
}),
qos=0)
# process messages
self.loop(test_client, subscribe_client)
# verify change
obj = EquipmentItem.objects.get(
equipmentholder=self.h1.equipmentholder, equipment=self.e1)
self.assertEqual(obj.value, 'False')
# test bulk ambulance update
# expect null client after logout
test_client.expect('ambulance/{}/data'.format(self.a1.id))
self.is_subscribed(test_client)
# handshake ambulance
response = django_client.post('/en/api/client/',
content_type='application/json',
data=json.dumps({
'client_id':
client_id,
'status':
ClientStatus.O.name,
'ambulance':
self.a2.id,
}),
follow=True)
# result = JSONParser().parse(BytesIO(response.content))
# logger.debug(result)
self.assertEqual(response.status_code, 201)
# check record
clnt = Client.objects.get(client_id=client_id)
self.assertEqual(clnt.status, ClientStatus.O.name)
self.assertEqual(clnt.ambulance, self.a2)
self.assertEqual(clnt.hospital, self.h1)
# retrieve last ambulance
obj = Ambulance.objects.get(id=self.a1.id)
self.assertEqual(hasattr(obj, 'client'), False)
# retrieve current ambulance status
obj = Ambulance.objects.get(id=self.a2.id)
self.assertEqual(obj.status, AmbulanceStatus.UK.name)
location = {'latitude': -2., 'longitude': 7.}
timestamp = timezone.now()
data = [{
'status': AmbulanceStatus.OS.name,
}, {
'status': AmbulanceStatus.AV.name,
'location': location,
}, {
'status': AmbulanceStatus.PB.name,
'timestamp': str(timestamp)
}]
# expect update once
test_client.expect('ambulance/{}/data'.format(self.a2.id))
self.is_subscribed(test_client)
test_client.publish('user/{}/client/{}/ambulance/{}/data'.format(
self.u1.username, client_id, self.a2.id),
json.dumps(data),
qos=0)
# process messages
self.loop(test_client, subscribe_client)
# verify change
obj = Ambulance.objects.get(id=self.a2.id)
self.assertEqual(obj.status, AmbulanceStatus.PB.name)
self.assertEqual(obj.timestamp, timestamp)
self.assertEqual(point2str(obj.location), point2str(location))
# Client handshake
test_client.publish(
'user/{}/client/{}/status'.format(username, client_id),
ClientStatus.F.name)
# process messages
self.loop(test_client, subscribe_client)
# check record
clnt = Client.objects.get(client_id=client_id)
self.assertEqual(clnt.status, ClientStatus.F.name)
self.assertEqual(clnt.ambulance, None)
self.assertEqual(clnt.hospital, None)
# wait for disconnect
test_client.wait()
subscribe_client.wait()
django_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 test_hospital_patch_viewset(self):
# instantiate client
client = Client()
# login as admin
client.login(username=settings.MQTT['USERNAME'],
password=settings.MQTT['PASSWORD'])
# retrieve hospital
response = client.get('/api/hospital/{}/'.format(str(self.h1.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = HospitalSerializer(self.h1).data
self.assertDictEqual(result, answer)
# set street hospital
street = 'new street'
response = client.patch('/api/hospital/{}/'.format(str(self.h1.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = HospitalSerializer(Hospital.objects.get(id=self.h1.id)).data
self.assertDictEqual(result, answer)
# retrieve new hospital street
response = client.get('/api/hospital/{}/'.format(str(self.h1.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['street'], street)
# set hospital location
location = {'latitude': -2., 'longitude': 7.}
response = client.patch('/api/hospital/{}/'.format(str(self.h1.id)),
content_type='application/json',
data=json.dumps({'location': str(location)}))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = HospitalSerializer(Hospital.objects.get(id=self.h1.id)).data
self.assertDictEqual(result, answer)
# retrieve new hospital location
response = client.get('/api/hospital/{}/'.format(str(self.h1.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['street'], street)
self.assertEqual(result['location'], point2str(location))
# set wrong hospital id
response = client.patch('/api/hospital/100/',
data=json.dumps({'street': street}))
self.assertEqual(response.status_code, 404)
# logout
client.logout()
# login as testuser1
client.login(username='******', password='******')
# retrieve hospital
response = client.get('/api/hospital/{}/'.format(str(self.h2.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = HospitalSerializer(self.h2).data
self.assertDictEqual(result, answer)
# set street hospital
street = 'another street'
response = client.patch('/api/hospital/{}/'.format(str(self.h2.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = HospitalSerializer(Hospital.objects.get(id=self.h2.id)).data
self.assertDictEqual(result, answer)
# retrieve new hospital street
response = client.get('/api/hospital/{}/'.format(str(self.h2.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['street'], street)
# set hospital location
location = {'latitude': -2., 'longitude': 7.}
response = client.patch('/api/hospital/{}/'.format(str(self.h2.id)),
content_type='application/json',
data=json.dumps(
{'location': point2str(location)}))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
answer = HospitalSerializer(Hospital.objects.get(id=self.h2.id)).data
self.assertDictEqual(result, answer)
# retrieve new hospital location
response = client.get('/api/hospital/{}/'.format(str(self.h2.id)))
self.assertEqual(response.status_code, 200)
result = JSONParser().parse(BytesIO(response.content))
self.assertEqual(result['street'], street)
self.assertEqual(result['location'], point2str(location))
# set status hospital (no permission)
street = 'yet another hospital'
response = client.patch('/api/hospital/{}/'.format(str(self.h1.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 404)
# set street hospital (no permission)
street = 'another one street'
response = client.patch('/api/hospital/{}/'.format(str(self.h3.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 404)
# logout
client.logout()
# login as testuser2
client.login(username='******', password='******')
# set street hospital
street = 'some street'
response = client.patch('/api/hospital/{}/'.format(str(self.h1.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 404)
# set street hospital
response = client.patch('/api/hospital/{}/'.format(str(self.h2.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 404)
# set street hospital
response = client.patch('/api/hospital/{}/'.format(str(self.h2.id)),
content_type='application/json',
data=json.dumps({
'street': street,
}))
self.assertEqual(response.status_code, 404)
# logout
client.logout()
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())
