Test cases for supply delivery apis (#3304) · satanvysakh.tngl.sh/care@bd7400b

+1881

1 changed file

expand all

care

emr

tests

test_supply_delivery.py

+1881

care/emr/tests/test_supply_delivery.py

··· 1 + from decimal import Decimal 2 + 3 + from django.urls import reverse 4 + from model_bakery import baker 5 + 6 + from care.emr.models.charge_item_definition import ChargeItemDefinition 7 + from care.emr.models.product_knowledge import ProductKnowledge 8 + from care.emr.resources.inventory.inventory_item.sync_inventory_item import ( 9 + sync_inventory_item, 10 + ) 11 + from care.emr.resources.inventory.supply_delivery.delivery_order import ( 12 + SupplyDeliveryOrderStatusOptions, 13 + ) 14 + from care.emr.resources.inventory.supply_delivery.spec import ( 15 + SupplyDeliveryConditionOptions, 16 + SupplyDeliveryStatusOptions, 17 + SupplyDeliveryTypeOptions, 18 + ) 19 + from care.security.permissions.supply_delivery import SupplyDeliveryPermissions 20 + from care.utils.tests.base import CareAPITestBase 21 + 22 + 23 + class TestSupplyDeliveryViewSet(CareAPITestBase): 24 + def setUp(self): 25 + super().setUp() 26 + self.user = self.create_user(username="testuser") 27 + self.superuser = self.create_super_user(username="superuser") 28 + self.patient = self.create_patient(name="Test Patient") 29 + self.facility = self.create_facility(user=self.superuser) 30 + self.facility_organization = self.create_facility_organization( 31 + facility=self.facility, 32 + ) 33 + 34 + self.product_knowledge = baker.make( 35 + ProductKnowledge, 36 + facility=self.facility, 37 + slug=f"f-{self.facility.external_id}-product-knowledge", 38 + ) 39 + self.charge_item_definition = baker.make( 40 + ChargeItemDefinition, 41 + facility=self.facility, 42 + slug=f"f-{self.facility.external_id}-charge-item-definition", 43 + ) 44 + self.product = self.create_product(facility=self.facility) 45 + 46 + self.supplier = self.create_organization(name="Test Supplier") 47 + self.destination = self.create_facility_location(facility=self.facility) 48 + self.origin = self.create_facility_location(facility=self.facility) 49 + self.inventory_item_origin = self.create_inventory_item( 50 + product=self.product, location=self.origin, status="active" 51 + ) 52 + self.inventory_item_destination = self.create_inventory_item( 53 + product=self.product, location=self.destination, status="active" 54 + ) 55 + self.request_order_destination_external = self.create_request_order( 56 + supplier=self.supplier, 57 + destination=self.destination, 58 + ) 59 + self.request_order_internal = self.create_request_order( 60 + origin=self.origin, 61 + destination=self.destination, 62 + ) 63 + self.supply_request_destination_external = self.create_supply_request( 64 + item=self.product_knowledge, 65 + status="active", 66 + quantity=Decimal(1500), 67 + supplied_item_condition=SupplyDeliveryConditionOptions.normal.value, 68 + order=self.request_order_destination_external, 69 + ) 70 + self.supply_request_internal = self.create_supply_request( 71 + item=self.product_knowledge, 72 + status="active", 73 + quantity=Decimal(200), 74 + supplied_item_condition=SupplyDeliveryConditionOptions.normal.value, 75 + order=self.request_order_internal, 76 + ) 77 + self.role = self.create_role_with_permissions( 78 + permissions=[ 79 + SupplyDeliveryPermissions.can_read_supply_delivery.name, 80 + SupplyDeliveryPermissions.can_write_supply_delivery.name, 81 + ] 82 + ) 83 + self.base_url = reverse("supply_delivery-list") 84 + self.delivery_orders_url = reverse("supply_delivery-delivery-orders") 85 + 86 + """ Setup for Delivery Orders and Locations for initial purchase orders""" 87 + 88 + self.delivery_order_destination_external = self.create_delivery_order( 89 + destination=self.destination, 90 + supplier=self.supplier, 91 + ) 92 + self.delivery_order_origin_external = self.create_delivery_order( 93 + destination=self.origin, 94 + supplier=self.supplier, 95 + ) 96 + self.delivery_order_internal = self.create_delivery_order( 97 + origin=self.origin, 98 + destination=self.destination, 99 + ) 100 + # Purchase Order of 1500 units to destination location 101 + self.purchase_order_destination = self.create_supply_delivery( 102 + order=self.delivery_order_destination_external, 103 + supplied_item_quantity=Decimal(1500), 104 + supplied_item=self.product, 105 + status=SupplyDeliveryStatusOptions.completed.value, 106 + supplied_inventory_item=self.inventory_item_destination, 107 + supply_request=self.supply_request_destination_external, 108 + ) 109 + 110 + # Purchase Order of 500 units from origin location 111 + self.purchase_order_origin = self.create_supply_delivery( 112 + order=self.delivery_order_origin_external, 113 + supplied_item_quantity=Decimal(500), 114 + supplied_item=self.product, 115 + status=SupplyDeliveryStatusOptions.completed.value, 116 + supplied_inventory_item=self.inventory_item_origin, 117 + ) 118 + self.inventory_item_origin.refresh_from_db() 119 + self.inventory_item_destination.refresh_from_db() 120 + self.assertEqual(self.inventory_item_origin.net_content, Decimal(500)) 121 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1500)) 122 + 123 + def get_detail_url(self, external_id): 124 + return reverse( 125 + "supply_delivery-detail", 126 + kwargs={ 127 + "external_id": external_id, 128 + }, 129 + ) 130 + 131 + def create_product(self, **kwargs): 132 + from care.emr.models import Product 133 + 134 + return baker.make( 135 + Product, 136 + product_knowledge=self.product_knowledge, 137 + charge_item_definition=self.charge_item_definition, 138 + **kwargs, 139 + ) 140 + 141 + def create_facility_location(self, facility, **kwargs): 142 + from care.emr.models import FacilityLocation, FacilityLocationOrganization 143 + 144 + location = baker.make(FacilityLocation, facility=facility, **kwargs) 145 + baker.make( 146 + FacilityLocationOrganization, 147 + location=location, 148 + organization=self.facility_organization, 149 + ) 150 + return location 151 + 152 + def create_inventory_item(self, **kwargs): 153 + from care.emr.models import InventoryItem 154 + 155 + return baker.make(InventoryItem, **kwargs) 156 + 157 + def create_delivery_order(self, **kwargs): 158 + from care.emr.models import DeliveryOrder 159 + 160 + return baker.make(DeliveryOrder, **kwargs) 161 + 162 + def create_supply_request(self, **kwargs): 163 + from care.emr.models import SupplyRequest 164 + 165 + return baker.make(SupplyRequest, **kwargs) 166 + 167 + def create_request_order(self, **kwargs): 168 + from care.emr.models import RequestOrder 169 + 170 + return baker.make(RequestOrder, **kwargs) 171 + 172 + def create_supply_delivery_data( 173 + self, 174 + quantity=None, 175 + condition=None, 176 + delivery_type=None, 177 + status=None, 178 + **kwargs, 179 + ): 180 + return { 181 + "supplied_item_quantity": quantity or Decimal(50), 182 + "status": status or SupplyDeliveryStatusOptions.in_progress.value, 183 + "supplied_item_condition": condition 184 + or SupplyDeliveryConditionOptions.normal.value, 185 + "delivery_type": delivery_type or SupplyDeliveryTypeOptions.product.value, 186 + **kwargs, 187 + } 188 + 189 + def create_supply_delivery(self, **kwargs): 190 + from care.emr.models import SupplyDelivery 191 + 192 + supply_delivery = baker.make(SupplyDelivery, **kwargs) 193 + if supply_delivery.order.origin: 194 + sync_inventory_item(inventory_item=supply_delivery.supplied_inventory_item) 195 + else: 196 + sync_inventory_item( 197 + location=supply_delivery.order.destination, 198 + product=supply_delivery.supplied_inventory_item.product, 199 + ) 200 + return supply_delivery 201 + 202 + # Testcases for create supply delivery 203 + 204 + def test_create_supply_delivery_internally_as_superuser(self): 205 + """ 206 + Test creating a supply delivery internally as a superuser from origin to destination 207 + and check if the inventory items are updated correctly. 208 + """ 209 + self.client.force_authenticate(user=self.superuser) 210 + data = self.create_supply_delivery_data( 211 + supplied_inventory_item=self.inventory_item_origin.external_id, 212 + order=self.delivery_order_internal.external_id, 213 + ) 214 + response = self.client.post(self.base_url, data, format="json") 215 + self.assertEqual(response.status_code, 200) 216 + get_response = self.client.get(self.get_detail_url(response.data["id"])) 217 + self.assertEqual(get_response.status_code, 200) 218 + self.assertEqual(get_response.data["supplied_item_quantity"], "50.000000") 219 + self.assertEqual( 220 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 221 + ) 222 + self.assertEqual( 223 + get_response.data["supplied_inventory_item"]["id"], 224 + str(self.inventory_item_origin.external_id), 225 + ) 226 + self.inventory_item_origin.refresh_from_db() 227 + self.inventory_item_destination.refresh_from_db() 228 + self.assertEqual(self.inventory_item_origin.net_content, Decimal(450)) 229 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1500)) 230 + update_response = self.client.put( 231 + self.get_detail_url(response.data["id"]), 232 + {"status": SupplyDeliveryStatusOptions.completed.value}, 233 + format="json", 234 + ) 235 + self.assertEqual(update_response.status_code, 200) 236 + self.inventory_item_destination.refresh_from_db() 237 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1550)) 238 + 239 + def test_create_supply_delivery_externally_as_superuser(self): 240 + """ 241 + Test creating a supply delivery externally as a superuser to destination location 242 + and check if the inventory items are updated correctly. 243 + """ 244 + self.client.force_authenticate(user=self.superuser) 245 + data = self.create_supply_delivery_data( 246 + supplied_item=self.product.external_id, 247 + order=self.delivery_order_destination_external.external_id, 248 + quantity=Decimal(500), 249 + ) 250 + response = self.client.post(self.base_url, data, format="json") 251 + self.assertEqual(response.status_code, 200) 252 + get_response = self.client.get( 253 + self.get_detail_url(response.data["id"]), format="json" 254 + ) 255 + self.assertEqual(get_response.status_code, 200) 256 + self.assertEqual(get_response.data["supplied_item_quantity"], "500.000000") 257 + self.assertEqual( 258 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 259 + ) 260 + self.assertEqual( 261 + get_response.data["supplied_inventory_item"]["id"], 262 + str(self.inventory_item_destination.external_id), 263 + ) 264 + self.inventory_item_destination.refresh_from_db() 265 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1500)) 266 + update_response = self.client.put( 267 + self.get_detail_url(response.data["id"]), 268 + {"status": SupplyDeliveryStatusOptions.completed.value}, 269 + format="json", 270 + ) 271 + self.assertEqual(update_response.status_code, 200) 272 + self.inventory_item_destination.refresh_from_db() 273 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(2000)) 274 + 275 + def test_create_supply_delivery_internally_as_user_with_permissions(self): 276 + """ 277 + Test creating a internal supply delivery as a user with permissions 278 + """ 279 + self.client.force_authenticate(user=self.user) 280 + self.attach_role_facility_organization_user( 281 + facility_organization=self.facility_organization, 282 + user=self.user, 283 + role=self.role, 284 + ) 285 + data = self.create_supply_delivery_data( 286 + supplied_inventory_item=self.inventory_item_origin.external_id, 287 + order=self.delivery_order_internal.external_id, 288 + ) 289 + response = self.client.post(self.base_url, data, format="json") 290 + self.assertEqual(response.status_code, 200) 291 + get_response = self.client.get(self.get_detail_url(response.data["id"])) 292 + self.assertEqual(get_response.status_code, 200) 293 + self.assertEqual(get_response.data["supplied_item_quantity"], "50.000000") 294 + self.assertEqual( 295 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 296 + ) 297 + self.assertEqual( 298 + get_response.data["supplied_inventory_item"]["id"], 299 + str(self.inventory_item_origin.external_id), 300 + ) 301 + self.inventory_item_origin.refresh_from_db() 302 + self.inventory_item_destination.refresh_from_db() 303 + self.assertEqual(self.inventory_item_origin.net_content, Decimal(450)) 304 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1500)) 305 + update_response = self.client.put( 306 + self.get_detail_url(response.data["id"]), 307 + {"status": SupplyDeliveryStatusOptions.completed.value}, 308 + format="json", 309 + ) 310 + self.assertEqual(update_response.status_code, 200) 311 + self.inventory_item_destination.refresh_from_db() 312 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1550)) 313 + 314 + def test_create_supply_delivery_externally_as_user_with_permissions(self): 315 + """ 316 + Test creating a external supply delivery as a user with permissions 317 + """ 318 + self.client.force_authenticate(user=self.user) 319 + self.attach_role_facility_organization_user( 320 + facility_organization=self.facility_organization, 321 + user=self.user, 322 + role=self.role, 323 + ) 324 + data = self.create_supply_delivery_data( 325 + supplied_item=self.product.external_id, 326 + order=self.delivery_order_destination_external.external_id, 327 + quantity=Decimal(500), 328 + ) 329 + response = self.client.post(self.base_url, data, format="json") 330 + self.assertEqual(response.status_code, 200) 331 + get_response = self.client.get( 332 + self.get_detail_url(response.data["id"]), format="json" 333 + ) 334 + self.assertEqual(get_response.status_code, 200) 335 + self.assertEqual(get_response.data["supplied_item_quantity"], "500.000000") 336 + self.assertEqual( 337 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 338 + ) 339 + self.assertEqual( 340 + get_response.data["supplied_inventory_item"]["id"], 341 + str(self.inventory_item_destination.external_id), 342 + ) 343 + self.inventory_item_destination.refresh_from_db() 344 + self.assertEqual(self.inventory_item_destination.net_content, (Decimal(1500))) 345 + update_response = self.client.put( 346 + self.get_detail_url(response.data["id"]), 347 + {"status": SupplyDeliveryStatusOptions.completed.value}, 348 + format="json", 349 + ) 350 + self.assertEqual(update_response.status_code, 200) 351 + self.inventory_item_destination.refresh_from_db() 352 + self.assertEqual(self.inventory_item_destination.net_content, (Decimal(2000))) 353 + 354 + def test_create_external_supply_delivery_as_user_without_permissions(self): 355 + """ 356 + Test creating a external supply delivery as a user without permissions 357 + """ 358 + self.client.force_authenticate(user=self.user) 359 + data = self.create_supply_delivery_data( 360 + supplied_item=self.product.external_id, 361 + order=self.delivery_order_destination_external.external_id, 362 + quantity=Decimal(500), 363 + ) 364 + response = self.client.post(self.base_url, data, format="json") 365 + self.assertEqual(response.status_code, 403) 366 + self.assertContains(response, "Cannot write supply requests", status_code=403) 367 + 368 + def test_create_internal_supply_delivery_as_user_without_permissions(self): 369 + """ 370 + Test creating a internal supply delivery as a user without permissions 371 + """ 372 + self.client.force_authenticate(user=self.user) 373 + data = self.create_supply_delivery_data( 374 + supplied_inventory_item=self.inventory_item_origin.external_id, 375 + order=self.delivery_order_internal.external_id, 376 + ) 377 + response = self.client.post(self.base_url, data, format="json") 378 + self.assertEqual(response.status_code, 403) 379 + self.assertContains(response, "Cannot write supply requests", status_code=403) 380 + 381 + def test_create_supply_delivery_as_superuser_with_insufficient_stock(self): 382 + """ 383 + Test creating a supply delivery as a superuser with insufficient stock in internal delivery 384 + The origin location has only 500 units, trying to deliver 501 should fail 385 + """ 386 + self.client.force_authenticate(user=self.superuser) 387 + data = self.create_supply_delivery_data( 388 + supplied_inventory_item=self.inventory_item_origin.external_id, 389 + order=self.delivery_order_internal.external_id, 390 + quantity=Decimal(501), 391 + ) 392 + response = self.client.post(self.base_url, data, format="json") 393 + self.assertEqual(response.status_code, 400) 394 + self.assertContains(response, "Insufficient stock", status_code=400) 395 + 396 + def test_create_supply_delivery_with_different_origin_and_inventory_item_location( 397 + self, 398 + ): 399 + """ 400 + Test creating a supply delivery as a superuser with different origin location in order 401 + and inventory item location 402 + """ 403 + self.client.force_authenticate(user=self.superuser) 404 + data = self.create_supply_delivery_data( 405 + supplied_inventory_item=self.inventory_item_destination.external_id, 406 + order=self.delivery_order_internal.external_id, 407 + ) 408 + response = self.client.post(self.base_url, data, format="json") 409 + self.assertEqual(response.status_code, 400) 410 + self.assertContains( 411 + response, 412 + "Supplied inventory item is not part of the origin or its children", 413 + status_code=400, 414 + ) 415 + 416 + def test_create_supply_delivery_internally_with_order_but_no_supplied_inventory_item( 417 + self, 418 + ): 419 + """ 420 + Test creating a supply delivery as a superuser with order having order origin 421 + but no supplied_inventory_item provided 422 + """ 423 + self.client.force_authenticate(user=self.superuser) 424 + data = self.create_supply_delivery_data( 425 + order=self.delivery_order_internal.external_id, 426 + supplied_item=self.product.external_id, 427 + ) 428 + response = self.client.post(self.base_url, data, format="json") 429 + self.assertEqual(response.status_code, 400) 430 + self.assertContains( 431 + response, 432 + "supplied_inventory_item is required when origin is provided", 433 + status_code=400, 434 + ) 435 + 436 + def test_create_supply_delivery_externally_with_order_but_no_supplied_item(self): 437 + """ 438 + Test creating a supply delivery as a superuser with order having order origin 439 + but no supplied_item provided 440 + """ 441 + self.client.force_authenticate(user=self.superuser) 442 + data = self.create_supply_delivery_data( 443 + order=self.delivery_order_destination_external.external_id 444 + ) 445 + response = self.client.post(self.base_url, data, format="json") 446 + self.assertEqual(response.status_code, 400) 447 + self.assertContains( 448 + response, 449 + "supplied_item is required when origin is not provided", 450 + status_code=400, 451 + ) 452 + 453 + def test_create_supply_delivery_with_both_supplied_item_and_inventory_item(self): 454 + """ 455 + Test creating a supply delivery as a superuser with both supplied_item and supplied_inventory_item 456 + """ 457 + self.client.force_authenticate(user=self.superuser) 458 + data = self.create_supply_delivery_data( 459 + supplied_item=self.product.external_id, 460 + supplied_inventory_item=self.inventory_item_destination.external_id, 461 + order=self.delivery_order_destination_external.external_id, 462 + ) 463 + response = self.client.post(self.base_url, data, format="json") 464 + self.assertEqual(response.status_code, 400) 465 + self.assertContains( 466 + response, 467 + "supplied_item and supplied_inventory_item cannot both be provided", 468 + status_code=400, 469 + ) 470 + 471 + def test_create_supply_delivery_with_completed_order(self): 472 + """ 473 + Test creating a supply delivery as a superuser with order which is already completed 474 + """ 475 + self.client.force_authenticate(user=self.superuser) 476 + self.delivery_order_internal.status = ( 477 + SupplyDeliveryOrderStatusOptions.completed.value 478 + ) 479 + self.delivery_order_internal.save() 480 + data = self.create_supply_delivery_data( 481 + supplied_inventory_item=self.inventory_item_origin.external_id, 482 + order=self.delivery_order_internal.external_id, 483 + ) 484 + response = self.client.post(self.base_url, data, format="json") 485 + self.assertEqual(response.status_code, 400) 486 + self.assertContains( 487 + response, 488 + "Delivery order is completed", 489 + status_code=400, 490 + ) 491 + 492 + def test_create_supply_delivery_with_abandoned_order(self): 493 + """ 494 + Test creating a supply delivery as a superuser with order which is already abandoned 495 + """ 496 + self.client.force_authenticate(user=self.superuser) 497 + self.delivery_order_internal.status = ( 498 + SupplyDeliveryOrderStatusOptions.abandoned.value 499 + ) 500 + self.delivery_order_internal.save() 501 + data = self.create_supply_delivery_data( 502 + supplied_inventory_item=self.inventory_item_origin.external_id, 503 + order=self.delivery_order_internal.external_id, 504 + ) 505 + response = self.client.post(self.base_url, data, format="json") 506 + self.assertEqual(response.status_code, 400) 507 + self.assertContains( 508 + response, 509 + "Delivery order is abandoned or entered in error", 510 + status_code=400, 511 + ) 512 + 513 + def test_create_supply_delivery_with_entered_in_error_order(self): 514 + """ 515 + Test creating a supply delivery as a superuser with order which is already entered in error 516 + """ 517 + self.client.force_authenticate(user=self.superuser) 518 + self.delivery_order_internal.status = ( 519 + SupplyDeliveryOrderStatusOptions.entered_in_error.value 520 + ) 521 + self.delivery_order_internal.save() 522 + data = self.create_supply_delivery_data( 523 + supplied_inventory_item=self.inventory_item_origin.external_id, 524 + order=self.delivery_order_internal.external_id, 525 + ) 526 + response = self.client.post(self.base_url, data, format="json") 527 + self.assertEqual(response.status_code, 400) 528 + self.assertContains( 529 + response, 530 + "Delivery order is abandoned or entered in error", 531 + status_code=400, 532 + ) 533 + 534 + # Testcases for update supply delivery 535 + 536 + def test_update_supply_delivery_as_superuser(self): 537 + """ 538 + Test updating an external supply delivery as a superuser 539 + """ 540 + self.client.force_authenticate(user=self.superuser) 541 + supply_delivery = self.create_supply_delivery( 542 + order=self.delivery_order_destination_external, 543 + supplied_item_quantity=Decimal(500), 544 + supplied_item=self.product, 545 + status=SupplyDeliveryStatusOptions.in_progress.value, 546 + supplied_inventory_item=self.inventory_item_destination, 547 + ) 548 + update_response = self.client.put( 549 + self.get_detail_url(supply_delivery.external_id), 550 + {"status": SupplyDeliveryStatusOptions.completed.value}, 551 + format="json", 552 + ) 553 + self.assertEqual(update_response.status_code, 200) 554 + self.inventory_item_destination.refresh_from_db() 555 + self.assertEqual(self.inventory_item_destination.net_content, (Decimal(2000))) 556 + get_response = self.client.get( 557 + self.get_detail_url(supply_delivery.external_id), format="json" 558 + ) 559 + self.assertEqual(get_response.status_code, 200) 560 + self.assertEqual(get_response.data["status"], "completed") 561 + 562 + def test_update_external_supply_delivery_as_user_with_permissions(self): 563 + """ 564 + Test updating an external supply delivery as a user with permissions 565 + """ 566 + self.client.force_authenticate(user=self.user) 567 + self.attach_role_facility_organization_user( 568 + facility_organization=self.facility_organization, 569 + user=self.user, 570 + role=self.role, 571 + ) 572 + supply_delivery = self.create_supply_delivery( 573 + order=self.delivery_order_destination_external, 574 + supplied_item_quantity=Decimal(500), 575 + supplied_item=self.product, 576 + status=SupplyDeliveryStatusOptions.in_progress.value, 577 + supplied_inventory_item=self.inventory_item_destination, 578 + ) 579 + update_response = self.client.put( 580 + self.get_detail_url(supply_delivery.external_id), 581 + {"status": SupplyDeliveryStatusOptions.completed.value}, 582 + format="json", 583 + ) 584 + self.assertEqual(update_response.status_code, 200) 585 + self.inventory_item_destination.refresh_from_db() 586 + self.assertEqual(self.inventory_item_destination.net_content, (Decimal(2000))) 587 + get_response = self.client.get( 588 + self.get_detail_url(supply_delivery.external_id), format="json" 589 + ) 590 + self.assertEqual(get_response.status_code, 200) 591 + self.assertEqual(get_response.data["status"], "completed") 592 + 593 + def test_update_internal_supply_delivery_as_user_with_permissions(self): 594 + """ 595 + Test updating an internal supply delivery as a user with permissions 596 + """ 597 + self.client.force_authenticate(user=self.user) 598 + self.attach_role_facility_organization_user( 599 + facility_organization=self.facility_organization, 600 + user=self.user, 601 + role=self.role, 602 + ) 603 + supply_delivery = self.create_supply_delivery( 604 + order=self.delivery_order_internal, 605 + supplied_item_quantity=Decimal(200), 606 + supplied_item=self.product, 607 + status=SupplyDeliveryStatusOptions.in_progress.value, 608 + supplied_inventory_item=self.inventory_item_origin, 609 + ) 610 + update_response = self.client.put( 611 + self.get_detail_url(supply_delivery.external_id), 612 + {"status": SupplyDeliveryStatusOptions.completed.value}, 613 + format="json", 614 + ) 615 + self.assertEqual(update_response.status_code, 200) 616 + self.inventory_item_destination.refresh_from_db() 617 + self.assertEqual(self.inventory_item_destination.net_content, Decimal(1700)) 618 + get_response = self.client.get( 619 + self.get_detail_url(supply_delivery.external_id), format="json" 620 + ) 621 + self.assertEqual(get_response.status_code, 200) 622 + self.assertEqual(get_response.data["status"], "completed") 623 + 624 + def test_update_external_supply_delivery_as_user_without_permissions(self): 625 + """ 626 + Test updating an external supply delivery as a user without permissions 627 + """ 628 + self.client.force_authenticate(user=self.user) 629 + supply_delivery = self.create_supply_delivery( 630 + order=self.delivery_order_destination_external, 631 + supplied_item_quantity=Decimal(500), 632 + supplied_item=self.product, 633 + status=SupplyDeliveryStatusOptions.in_progress.value, 634 + supplied_inventory_item=self.inventory_item_destination, 635 + ) 636 + update_response = self.client.put( 637 + self.get_detail_url(supply_delivery.external_id), 638 + {"status": SupplyDeliveryStatusOptions.completed.value}, 639 + format="json", 640 + ) 641 + self.assertEqual(update_response.status_code, 403) 642 + self.assertContains( 643 + update_response, "Cannot write supply requests", status_code=403 644 + ) 645 + 646 + def test_update_internal_supply_delivery_as_user_without_permissions(self): 647 + """ 648 + Test updating an internal supply delivery as a user without permissions 649 + """ 650 + self.client.force_authenticate(user=self.user) 651 + supply_delivery = self.create_supply_delivery( 652 + order=self.delivery_order_internal, 653 + supplied_item_quantity=Decimal(500), 654 + supplied_item=self.product, 655 + status=SupplyDeliveryStatusOptions.in_progress.value, 656 + supplied_inventory_item=self.inventory_item_origin, 657 + ) 658 + update_response = self.client.put( 659 + self.get_detail_url(supply_delivery.external_id), 660 + {"status": SupplyDeliveryStatusOptions.completed.value}, 661 + format="json", 662 + ) 663 + self.assertEqual(update_response.status_code, 403) 664 + self.assertContains( 665 + update_response, "Cannot write supply requests", status_code=403 666 + ) 667 + 668 + def test_update_status_of_completed_internal_supply_delivery(self): 669 + """ 670 + Test updating an internal supply delivery which is already completed as a superuser 671 + """ 672 + self.client.force_authenticate(user=self.superuser) 673 + supply_delivery = self.create_supply_delivery( 674 + order=self.delivery_order_internal, 675 + supplied_item_quantity=Decimal(200), 676 + supplied_item=self.product, 677 + status=SupplyDeliveryStatusOptions.completed.value, 678 + supplied_inventory_item=self.inventory_item_destination, 679 + ) 680 + update_response = self.client.put( 681 + self.get_detail_url(supply_delivery.external_id), 682 + {"status": SupplyDeliveryStatusOptions.abandoned.value}, 683 + format="json", 684 + ) 685 + self.assertEqual(update_response.status_code, 400) 686 + self.assertContains( 687 + update_response, 688 + "Supply delivery already completed", 689 + status_code=400, 690 + ) 691 + 692 + def test_update_supply_delivery_with_no_status_change(self): 693 + """ 694 + Test updating an external supply delivery without changing the status 695 + """ 696 + self.client.force_authenticate(user=self.superuser) 697 + supply_delivery = self.create_supply_delivery( 698 + order=self.delivery_order_destination_external, 699 + supplied_item_quantity=Decimal(500), 700 + supplied_item=self.product, 701 + status=SupplyDeliveryStatusOptions.in_progress.value, 702 + supplied_inventory_item=self.inventory_item_destination, 703 + ) 704 + update_response = self.client.put( 705 + self.get_detail_url(supply_delivery.external_id), 706 + { 707 + "status": SupplyDeliveryStatusOptions.in_progress.value, 708 + "supplied_item_condition": SupplyDeliveryConditionOptions.damaged.value, 709 + }, 710 + format="json", 711 + ) 712 + self.assertEqual(update_response.status_code, 200) 713 + get_response = self.client.get( 714 + self.get_detail_url(supply_delivery.external_id), format="json" 715 + ) 716 + self.assertEqual(get_response.status_code, 200) 717 + self.assertEqual( 718 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 719 + ) 720 + self.assertEqual( 721 + get_response.data["supplied_item_condition"], 722 + SupplyDeliveryConditionOptions.damaged.value, 723 + ) 724 + 725 + def test_update_supply_delivery_with_status_entered_in_error(self): 726 + """ 727 + Test updating a supply delivery with status as entered in error 728 + """ 729 + self.client.force_authenticate(user=self.superuser) 730 + supply_delivery = self.create_supply_delivery( 731 + order=self.delivery_order_destination_external, 732 + supplied_item_quantity=Decimal(500), 733 + supplied_item=self.product, 734 + status=SupplyDeliveryStatusOptions.entered_in_error.value, 735 + supplied_inventory_item=self.inventory_item_destination, 736 + ) 737 + response = self.client.put( 738 + self.get_detail_url(supply_delivery.external_id), 739 + {"status": SupplyDeliveryStatusOptions.in_progress.value}, 740 + format="json", 741 + ) 742 + self.assertEqual(response.status_code, 400) 743 + self.assertContains( 744 + response, 745 + "Supply delivery is abandoned or entered in error", 746 + status_code=400, 747 + ) 748 + 749 + def test_update_supply_delivery_with_status_abandoned(self): 750 + """ 751 + Test updating a supply delivery with status as abandoned 752 + """ 753 + self.client.force_authenticate(user=self.superuser) 754 + supply_delivery = self.create_supply_delivery( 755 + order=self.delivery_order_destination_external, 756 + supplied_item_quantity=Decimal(500), 757 + supplied_item=self.product, 758 + status=SupplyDeliveryStatusOptions.abandoned.value, 759 + supplied_inventory_item=self.inventory_item_destination, 760 + ) 761 + response = self.client.put( 762 + self.get_detail_url(supply_delivery.external_id), 763 + {"status": SupplyDeliveryStatusOptions.in_progress.value}, 764 + format="json", 765 + ) 766 + self.assertEqual(response.status_code, 400) 767 + self.assertContains( 768 + response, 769 + "Supply delivery is abandoned or entered in error", 770 + status_code=400, 771 + ) 772 + 773 + # Testcases for retrieve supply delivery 774 + 775 + def test_retrieve_supply_delivery_as_superuser(self): 776 + """ 777 + Test retrieving a supply delivery as a superuser 778 + """ 779 + self.client.force_authenticate(user=self.superuser) 780 + supply_delivery = self.create_supply_delivery( 781 + order=self.delivery_order_destination_external, 782 + supplied_item_quantity=Decimal(500), 783 + supplied_item=self.product, 784 + status=SupplyDeliveryStatusOptions.in_progress.value, 785 + supplied_inventory_item=self.inventory_item_destination, 786 + ) 787 + get_response = self.client.get( 788 + self.get_detail_url(supply_delivery.external_id), format="json" 789 + ) 790 + self.assertEqual(get_response.status_code, 200) 791 + self.assertEqual(get_response.data["supplied_item_quantity"], "500.000000") 792 + self.assertEqual( 793 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 794 + ) 795 + self.assertEqual( 796 + get_response.data["supplied_inventory_item"]["id"], 797 + str(self.inventory_item_destination.external_id), 798 + ) 799 + 800 + def test_retrieve_supply_delivery_as_user_with_permissions(self): 801 + """ 802 + Test retrieving a supply delivery as a user with permissions 803 + """ 804 + self.client.force_authenticate(user=self.user) 805 + self.attach_role_facility_organization_user( 806 + facility_organization=self.facility_organization, 807 + user=self.user, 808 + role=self.role, 809 + ) 810 + supply_delivery = self.create_supply_delivery( 811 + order=self.delivery_order_destination_external, 812 + supplied_item_quantity=Decimal(500), 813 + supplied_item=self.product, 814 + status=SupplyDeliveryStatusOptions.in_progress.value, 815 + supplied_inventory_item=self.inventory_item_destination, 816 + ) 817 + get_response = self.client.get( 818 + self.get_detail_url(supply_delivery.external_id), format="json" 819 + ) 820 + self.assertEqual(get_response.status_code, 200) 821 + self.assertEqual(get_response.data["supplied_item_quantity"], "500.000000") 822 + self.assertEqual( 823 + get_response.data["status"], SupplyDeliveryStatusOptions.in_progress.value 824 + ) 825 + self.assertEqual( 826 + get_response.data["supplied_inventory_item"]["id"], 827 + str(self.inventory_item_destination.external_id), 828 + ) 829 + 830 + def test_retrieve_supply_delivery_as_user_without_permissions(self): 831 + """Test retrieving a supply delivery as a user without permissions""" 832 + self.client.force_authenticate(user=self.user) 833 + supply_delivery = self.create_supply_delivery( 834 + order=self.delivery_order_destination_external, 835 + supplied_item_quantity=Decimal(500), 836 + supplied_item=self.product, 837 + status=SupplyDeliveryStatusOptions.in_progress.value, 838 + supplied_inventory_item=self.inventory_item_destination, 839 + ) 840 + get_response = self.client.get( 841 + self.get_detail_url(supply_delivery.external_id), format="json" 842 + ) 843 + self.assertEqual(get_response.status_code, 403) 844 + self.assertContains( 845 + get_response, "Cannot read supply requests", status_code=403 846 + ) 847 + 848 + # Testcases for list supply delivery 849 + 850 + def test_list_supply_delivery_as_superuser_with_order_filter(self): 851 + """Test listing supply deliveries as a superuser with order queryset filter""" 852 + self.client.force_authenticate(user=self.superuser) 853 + list_response = self.client.get( 854 + self.base_url, 855 + {"order": self.delivery_order_destination_external.external_id}, 856 + format="json", 857 + ) 858 + self.assertEqual(list_response.status_code, 200) 859 + self.assertEqual(list_response.data["count"], 1) 860 + self.assertEqual( 861 + list_response.data["results"][0]["status"], 862 + SupplyDeliveryStatusOptions.completed.value, 863 + ) 864 + self.assertEqual( 865 + list_response.data["results"][0]["supplied_item_quantity"], "1500.000000" 866 + ) 867 + self.assertEqual( 868 + list_response.data["results"][0]["id"], 869 + str(self.purchase_order_destination.external_id), 870 + ) 871 + 872 + def test_list_supply_delivery_as_user_with_permissions_with_order_filter(self): 873 + """Test listing supply deliveries as a user with permissions""" 874 + self.client.force_authenticate(user=self.user) 875 + self.attach_role_facility_organization_user( 876 + facility_organization=self.facility_organization, 877 + user=self.user, 878 + role=self.role, 879 + ) 880 + list_response = self.client.get( 881 + self.base_url, 882 + {"order": self.delivery_order_origin_external.external_id}, 883 + format="json", 884 + ) 885 + self.assertEqual(list_response.status_code, 200) 886 + self.assertEqual(list_response.data["count"], 1) 887 + self.assertEqual( 888 + list_response.data["results"][0]["id"], 889 + str(self.purchase_order_origin.external_id), 890 + ) 891 + self.assertEqual( 892 + list_response.data["results"][0]["status"], 893 + SupplyDeliveryStatusOptions.completed.value, 894 + ) 895 + self.assertEqual( 896 + list_response.data["results"][0]["supplied_item_quantity"], "500.000000" 897 + ) 898 + 899 + def test_list_supply_delivery_as_user_without_permissions(self): 900 + """Test listing supply deliveries as a user without 'can_list_facility_supply_delivery' permissions""" 901 + self.client.force_authenticate(user=self.user) 902 + list_response = self.client.get( 903 + self.base_url, 904 + {"order": self.delivery_order_origin_external.external_id}, 905 + format="json", 906 + ) 907 + self.assertEqual(list_response.status_code, 403) 908 + self.assertContains( 909 + list_response, "Cannot read supply requests", status_code=403 910 + ) 911 + 912 + def test_list_supply_delivery_as_superuser_without_filters(self): 913 + """Test listing supply deliveries as a superuser without any filters""" 914 + self.client.force_authenticate(user=self.superuser) 915 + list_response = self.client.get(self.base_url, format="json") 916 + self.assertEqual(list_response.status_code, 400) 917 + self.assertContains( 918 + list_response, 919 + "No filters provided", 920 + status_code=400, 921 + ) 922 + 923 + def test_list_supply_delivery_as_superuser_with_destination_filter(self): 924 + """Test listing supply deliveries as a superuser with destination location filter""" 925 + self.client.force_authenticate(user=self.superuser) 926 + list_response = self.client.get( 927 + self.base_url, {"destination": self.destination.external_id}, format="json" 928 + ) 929 + self.assertEqual(list_response.status_code, 200) 930 + self.assertEqual(list_response.data["count"], 1) 931 + self.assertEqual( 932 + list_response.data["results"][0]["id"], 933 + str(self.purchase_order_destination.external_id), 934 + ) 935 + self.assertEqual( 936 + list_response.data["results"][0]["status"], 937 + SupplyDeliveryStatusOptions.completed.value, 938 + ) 939 + self.assertEqual( 940 + list_response.data["results"][0]["supplied_item_quantity"], "1500.000000" 941 + ) 942 + 943 + def test_list_supply_delivery_as_superuser_with_origin_filter(self): 944 + """Test listing supply deliveries as a superuser with origin location filter""" 945 + self.client.force_authenticate(user=self.superuser) 946 + internal_delivery = self.create_supply_delivery( 947 + order=self.delivery_order_internal, 948 + supplied_item_quantity=Decimal(200), 949 + supplied_item=self.product, 950 + status=SupplyDeliveryStatusOptions.completed.value, 951 + supplied_inventory_item=self.inventory_item_origin, 952 + ) 953 + list_response = self.client.get( 954 + self.base_url, {"origin": self.origin.external_id}, format="json" 955 + ) 956 + self.assertEqual(list_response.status_code, 200) 957 + self.assertEqual(list_response.data["count"], 1) 958 + self.assertEqual( 959 + list_response.data["results"][0]["id"], str(internal_delivery.external_id) 960 + ) 961 + self.assertEqual( 962 + list_response.data["results"][0]["status"], 963 + SupplyDeliveryStatusOptions.completed.value, 964 + ) 965 + self.assertEqual( 966 + list_response.data["results"][0]["supplied_item_quantity"], "200.000000" 967 + ) 968 + self.assertEqual( 969 + list_response.data["results"][0]["supplied_inventory_item"]["id"], 970 + str(self.inventory_item_origin.external_id), 971 + ) 972 + self.assertEqual( 973 + list_response.data["results"][0]["supplied_inventory_item"]["net_content"], 974 + "300.000000", 975 + ) 976 + 977 + def test_list_supply_delivery_as_user_with_permissions_with_destination_filter( 978 + self, 979 + ): 980 + """Test listing supply deliveries as a user with permissions with destination location filter""" 981 + self.client.force_authenticate(user=self.user) 982 + self.attach_role_facility_organization_user( 983 + facility_organization=self.facility_organization, 984 + user=self.user, 985 + role=self.role, 986 + ) 987 + list_response = self.client.get( 988 + self.base_url, {"destination": self.destination.external_id}, format="json" 989 + ) 990 + self.assertEqual(list_response.status_code, 200) 991 + self.assertEqual(list_response.data["count"], 1) 992 + self.assertEqual( 993 + list_response.data["results"][0]["id"], 994 + str(self.purchase_order_destination.external_id), 995 + ) 996 + self.assertEqual( 997 + list_response.data["results"][0]["status"], 998 + SupplyDeliveryStatusOptions.completed.value, 999 + ) 1000 + self.assertEqual( 1001 + list_response.data["results"][0]["supplied_item_quantity"], "1500.000000" 1002 + ) 1003 + 1004 + def test_list_supply_delivery_as_user_with_permissions_with_origin_filter(self): 1005 + """Test listing supply deliveries as a user with permissions with origin location filter""" 1006 + self.client.force_authenticate(user=self.user) 1007 + self.attach_role_facility_organization_user( 1008 + facility_organization=self.facility_organization, 1009 + user=self.user, 1010 + role=self.role, 1011 + ) 1012 + internal_delivery = self.create_supply_delivery( 1013 + order=self.delivery_order_internal, 1014 + supplied_item_quantity=200, 1015 + supplied_item=self.product, 1016 + status=SupplyDeliveryStatusOptions.completed.value, 1017 + supplied_inventory_item=self.inventory_item_origin, 1018 + ) 1019 + list_response = self.client.get( 1020 + self.base_url, {"origin": self.origin.external_id}, format="json" 1021 + ) 1022 + self.assertEqual(list_response.status_code, 200) 1023 + self.assertEqual(list_response.data["count"], 1) 1024 + self.assertEqual( 1025 + list_response.data["results"][0]["id"], str(internal_delivery.external_id) 1026 + ) 1027 + self.assertEqual( 1028 + list_response.data["results"][0]["status"], 1029 + SupplyDeliveryStatusOptions.completed.value, 1030 + ) 1031 + self.assertEqual( 1032 + list_response.data["results"][0]["supplied_item_quantity"], "200.000000" 1033 + ) 1034 + self.assertEqual( 1035 + list_response.data["results"][0]["supplied_inventory_item"]["id"], 1036 + str(self.inventory_item_origin.external_id), 1037 + ) 1038 + self.assertEqual( 1039 + list_response.data["results"][0]["supplied_inventory_item"]["net_content"], 1040 + "300.000000", 1041 + ) 1042 + 1043 + def test_list_supply_delivery_as_user_without_permissions_with_destination_filter( 1044 + self, 1045 + ): 1046 + """Test listing supply deliveries as a user without permissions with destination location filter""" 1047 + self.client.force_authenticate(user=self.user) 1048 + list_response = self.client.get( 1049 + self.base_url, {"destination": self.destination.external_id}, format="json" 1050 + ) 1051 + self.assertEqual(list_response.status_code, 403) 1052 + self.assertContains( 1053 + list_response, "Cannot list supply requests", status_code=403 1054 + ) 1055 + 1056 + def test_list_supply_delivery_as_user_without_permissions_with_origin_filter(self): 1057 + """Test listing supply deliveries as a user without permissions with origin location filter""" 1058 + self.client.force_authenticate(user=self.user) 1059 + list_response = self.client.get( 1060 + self.base_url, {"origin": self.origin.external_id}, format="json" 1061 + ) 1062 + self.assertEqual(list_response.status_code, 403) 1063 + self.assertContains( 1064 + list_response, "Cannot list supply requests", status_code=403 1065 + ) 1066 + 1067 + def test_list_supply_delivery_with_include_children_as_true(self): 1068 + """Test listing supply deliveries with include_children filter as true , should return deliveries to origin and its child locations""" 1069 + 1070 + self.client.force_authenticate(user=self.superuser) 1071 + child_location = self.create_facility_location( 1072 + name="Child Location", parent=self.origin, facility=self.facility 1073 + ) 1074 + inventory_item_child = self.create_inventory_item( 1075 + product=self.product, 1076 + location=child_location, 1077 + status="active", 1078 + ) 1079 + child_delivery_order_external = self.create_delivery_order( 1080 + destination=child_location, 1081 + supplier=self.supplier, 1082 + ) 1083 + self.create_supply_delivery( 1084 + order=child_delivery_order_external, 1085 + supplied_item_quantity=Decimal(200), 1086 + supplied_item=self.product, 1087 + status=SupplyDeliveryStatusOptions.completed.value, 1088 + supplied_inventory_item=inventory_item_child, 1089 + ) 1090 + 1091 + child_delivery_order_internal = self.create_delivery_order( 1092 + origin=child_location, 1093 + destination=self.destination, 1094 + ) 1095 + supply_delivery_parent = self.create_supply_delivery( 1096 + order=self.delivery_order_internal, 1097 + supplied_item_quantity=Decimal(200), 1098 + supplied_item=self.product, 1099 + status=SupplyDeliveryStatusOptions.completed.value, 1100 + supplied_inventory_item=self.inventory_item_origin, 1101 + ) 1102 + supply_delivery_child = self.create_supply_delivery( 1103 + supplied_item_quantity=Decimal(100), 1104 + order=child_delivery_order_internal, 1105 + supplied_item=self.product, 1106 + status=SupplyDeliveryStatusOptions.completed.value, 1107 + supplied_inventory_item=inventory_item_child, 1108 + ) 1109 + list_response = self.client.get( 1110 + self.base_url, 1111 + {"origin": self.origin.external_id, "include_children": "true"}, 1112 + format="json", 1113 + ) 1114 + self.assertEqual(list_response.status_code, 200) 1115 + self.assertEqual(list_response.data["count"], 2) 1116 + self.assertEqual( 1117 + list_response.data["results"][0]["id"], 1118 + str(supply_delivery_child.external_id), 1119 + ) 1120 + self.assertEqual( 1121 + list_response.data["results"][1]["id"], 1122 + str(supply_delivery_parent.external_id), 1123 + ) 1124 + 1125 + self.assertEqual( 1126 + list_response.data["results"][0]["supplied_item_quantity"], "100.000000" 1127 + ) 1128 + self.assertEqual( 1129 + list_response.data["results"][1]["supplied_item_quantity"], "200.000000" 1130 + ) 1131 + self.assertEqual( 1132 + list_response.data["results"][0]["supplied_inventory_item"]["id"], 1133 + str(inventory_item_child.external_id), 1134 + ) 1135 + self.assertEqual( 1136 + list_response.data["results"][0]["supplied_inventory_item"]["net_content"], 1137 + "100.000000", 1138 + ) 1139 + self.assertEqual( 1140 + list_response.data["results"][1]["supplied_inventory_item"]["id"], 1141 + str(self.inventory_item_origin.external_id), 1142 + ) 1143 + self.assertEqual( 1144 + list_response.data["results"][1]["supplied_inventory_item"]["net_content"], 1145 + "300.000000", 1146 + ) 1147 + 1148 + def test_list_supply_delivery_with_include_children_as_false(self): 1149 + """Test listing supply deliveries with include_children filter as false should return deliveries to origin location only""" 1150 + self.client.force_authenticate(user=self.superuser) 1151 + child_location = self.create_facility_location( 1152 + name="Child Location", parent=self.origin, facility=self.facility 1153 + ) 1154 + inventory_item_child = self.create_inventory_item( 1155 + product=self.product, 1156 + location=child_location, 1157 + status="active", 1158 + ) 1159 + child_delivery_order_external = self.create_delivery_order( 1160 + destination=child_location, 1161 + supplier=self.supplier, 1162 + ) 1163 + self.create_supply_delivery( 1164 + order=child_delivery_order_external, 1165 + supplied_item_quantity=200, 1166 + supplied_item=self.product, 1167 + status=SupplyDeliveryStatusOptions.completed.value, 1168 + supplied_inventory_item=inventory_item_child, 1169 + ) 1170 + 1171 + child_delivery_order_internal = self.create_delivery_order( 1172 + origin=child_location, 1173 + destination=self.destination, 1174 + ) 1175 + supply_delivery_parent = self.create_supply_delivery( 1176 + order=self.delivery_order_internal, 1177 + supplied_item_quantity=200, 1178 + supplied_item=self.product, 1179 + status=SupplyDeliveryStatusOptions.completed.value, 1180 + supplied_inventory_item=self.inventory_item_origin, 1181 + ) 1182 + self.create_supply_delivery( 1183 + supplied_item_quantity=100, 1184 + order=child_delivery_order_internal, 1185 + supplied_item=self.product, 1186 + status=SupplyDeliveryStatusOptions.completed.value, 1187 + supplied_inventory_item=inventory_item_child, 1188 + ) 1189 + list_response = self.client.get( 1190 + self.base_url, 1191 + {"origin": self.origin.external_id, "include_children": "false"}, 1192 + format="json", 1193 + ) 1194 + self.assertEqual(list_response.status_code, 200) 1195 + self.assertEqual(list_response.data["count"], 1) 1196 + self.assertEqual( 1197 + list_response.data["results"][0]["id"], 1198 + str(supply_delivery_parent.external_id), 1199 + ) 1200 + self.assertEqual( 1201 + list_response.data["results"][0]["supplied_item_quantity"], "200.000000" 1202 + ) 1203 + self.assertEqual( 1204 + list_response.data["results"][0]["supplied_inventory_item"]["id"], 1205 + str(self.inventory_item_origin.external_id), 1206 + ) 1207 + self.assertEqual( 1208 + list_response.data["results"][0]["supplied_inventory_item"]["net_content"], 1209 + "300.000000", 1210 + ) 1211 + 1212 + def test_list_supply_delivery_as_superuser_with_request_order_filter(self): 1213 + """Test listing supply deliveries as a superuser with request_order queryset filter""" 1214 + self.client.force_authenticate(user=self.superuser) 1215 + 1216 + list_response = self.client.get( 1217 + self.base_url, 1218 + {"request_order": self.request_order_destination_external.external_id}, 1219 + format="json", 1220 + ) 1221 + self.assertEqual(list_response.status_code, 200) 1222 + self.assertEqual(list_response.data["count"], 1) 1223 + self.assertEqual( 1224 + list_response.data["results"][0]["id"], 1225 + str(self.purchase_order_destination.external_id), 1226 + ) 1227 + self.assertEqual( 1228 + list_response.data["results"][0]["status"], 1229 + SupplyDeliveryStatusOptions.completed.value, 1230 + ) 1231 + self.assertEqual( 1232 + list_response.data["results"][0]["supplied_item_quantity"], "1500.000000" 1233 + ) 1234 + 1235 + def test_list_supply_delivery_as_user_with_permissions_with_request_order_filter( 1236 + self, 1237 + ): 1238 + """Test listing supply deliveries as a user with permissions and request_order queryset filter""" 1239 + self.client.force_authenticate(user=self.user) 1240 + self.attach_role_facility_organization_user( 1241 + facility_organization=self.facility_organization, 1242 + user=self.user, 1243 + role=self.role, 1244 + ) 1245 + list_response = self.client.get( 1246 + self.base_url, 1247 + {"request_order": self.request_order_destination_external.external_id}, 1248 + format="json", 1249 + ) 1250 + self.assertEqual(list_response.status_code, 200) 1251 + self.assertEqual(list_response.data["count"], 1) 1252 + self.assertEqual( 1253 + list_response.data["results"][0]["id"], 1254 + str(self.purchase_order_destination.external_id), 1255 + ) 1256 + self.assertEqual( 1257 + list_response.data["results"][0]["status"], 1258 + SupplyDeliveryStatusOptions.completed.value, 1259 + ) 1260 + self.assertEqual( 1261 + list_response.data["results"][0]["supplied_item_quantity"], "1500.000000" 1262 + ) 1263 + 1264 + def test_list_supply_delivery_as_user_without_permissions_with_request_order_filter( 1265 + self, 1266 + ): 1267 + """Test listing supply deliveries as a user without permissions and request_order queryset filter""" 1268 + self.client.force_authenticate(user=self.user) 1269 + 1270 + list_response = self.client.get( 1271 + self.base_url, 1272 + {"request_order": self.request_order_destination_external.external_id}, 1273 + format="json", 1274 + ) 1275 + self.assertEqual(list_response.status_code, 403) 1276 + self.assertContains( 1277 + list_response, "Cannot read supply requests", status_code=403 1278 + ) 1279 + 1280 + # Testcases for retrieve delivery orders 1281 + 1282 + def test_retrieve_delivery_order_as_superuser_with_request_order_filter(self): 1283 + """ 1284 + Test retrieving a delivery order as a superuser with request_order filter 1285 + """ 1286 + self.client.force_authenticate(user=self.superuser) 1287 + get_response = self.client.get( 1288 + self.delivery_orders_url, 1289 + { 1290 + "request_order": self.request_order_destination_external.external_id, 1291 + }, 1292 + format="json", 1293 + ) 1294 + self.assertEqual(get_response.status_code, 200) 1295 + self.assertEqual( 1296 + get_response.data["results"][0]["id"], 1297 + str(self.delivery_order_destination_external.external_id), 1298 + ) 1299 + 1300 + def test_retrieve_delivery_order_as_user_with_permissions_with_request_order_filter( 1301 + self, 1302 + ): 1303 + """ 1304 + Test retrieving a delivery order as a user with permissions and request_order filter 1305 + """ 1306 + self.client.force_authenticate(user=self.user) 1307 + self.attach_role_facility_organization_user( 1308 + facility_organization=self.facility_organization, 1309 + user=self.user, 1310 + role=self.role, 1311 + ) 1312 + get_response = self.client.get( 1313 + self.delivery_orders_url, 1314 + { 1315 + "request_order": self.request_order_destination_external.external_id, 1316 + }, 1317 + format="json", 1318 + ) 1319 + self.assertEqual(get_response.status_code, 200) 1320 + self.assertEqual( 1321 + get_response.data["results"][0]["id"], 1322 + str(self.delivery_order_destination_external.external_id), 1323 + ) 1324 + 1325 + def test_retrieve_delivery_order_as_user_without_permissions_with_request_order_filter( 1326 + self, 1327 + ): 1328 + """ 1329 + Test retrieving a delivery order as a user without permissions and request_order filter 1330 + """ 1331 + self.client.force_authenticate(user=self.user) 1332 + get_response = self.client.get( 1333 + self.delivery_orders_url, 1334 + { 1335 + "request_order": self.request_order_destination_external.external_id, 1336 + }, 1337 + format="json", 1338 + ) 1339 + self.assertEqual(get_response.status_code, 403) 1340 + self.assertContains( 1341 + get_response, "Cannot read supply requests", status_code=403 1342 + ) 1343 + 1344 + def test_retrieve_delivery_order_as_superuser_without_filter(self): 1345 + """ 1346 + Test retrieving a delivery order as a superuser without filter 1347 + """ 1348 + self.client.force_authenticate(user=self.superuser) 1349 + get_response = self.client.get(self.delivery_orders_url, format="json") 1350 + self.assertEqual(get_response.status_code, 400) 1351 + self.assertContains(get_response, "No filters provided", status_code=400) 1352 + 1353 + def test_retrieve_delivery_order_as_superuser_without_request_order_filter(self): 1354 + """ 1355 + Test retrieving a delivery order as a superuser without request_order filter 1356 + """ 1357 + self.client.force_authenticate(user=self.superuser) 1358 + get_response = self.client.get( 1359 + self.delivery_orders_url, 1360 + { 1361 + "order": self.delivery_order_destination_external.external_id, 1362 + }, 1363 + format="json", 1364 + ) 1365 + self.assertEqual(get_response.status_code, 400) 1366 + self.assertContains(get_response, "request_order is required", status_code=400) 1367 + 1368 + def test_retrieve_delivery_order_as_user_with_permissions_with_order_filter(self): 1369 + """ 1370 + Test retrieving a delivery order as a user with permissions and order filter 1371 + """ 1372 + self.client.force_authenticate(user=self.user) 1373 + self.attach_role_facility_organization_user( 1374 + facility_organization=self.facility_organization, 1375 + user=self.user, 1376 + role=self.role, 1377 + ) 1378 + get_response = self.client.get( 1379 + self.delivery_orders_url, 1380 + { 1381 + "request_order": self.request_order_destination_external.external_id, 1382 + "order": self.delivery_order_destination_external.external_id, 1383 + }, 1384 + format="json", 1385 + ) 1386 + self.assertEqual(get_response.status_code, 200) 1387 + self.assertEqual( 1388 + get_response.data["results"][0]["id"], 1389 + str(self.delivery_order_destination_external.external_id), 1390 + ) 1391 + 1392 + def test_retrieve_delivery_order_as_user_without_permissions_with_order_filter( 1393 + self, 1394 + ): 1395 + """ 1396 + Test retrieving a delivery order as a user without permissions and order filter 1397 + """ 1398 + self.client.force_authenticate(user=self.user) 1399 + get_response = self.client.get( 1400 + self.delivery_orders_url, 1401 + { 1402 + "request_order": self.request_order_destination_external.external_id, 1403 + "order": self.delivery_order_destination_external.external_id, 1404 + }, 1405 + format="json", 1406 + ) 1407 + self.assertEqual(get_response.status_code, 403) 1408 + self.assertContains( 1409 + get_response, "Cannot read supply requests", status_code=403 1410 + ) 1411 + 1412 + def test_retrieve_delivery_order_as_user_with_permissions_with_origin_filter(self): 1413 + """ 1414 + Test retrieving a delivery order as a user with permissions with origin filter 1415 + """ 1416 + self.client.force_authenticate(user=self.user) 1417 + self.attach_role_facility_organization_user( 1418 + facility_organization=self.facility_organization, 1419 + user=self.user, 1420 + role=self.role, 1421 + ) 1422 + data = self.create_supply_delivery_data( 1423 + supplied_inventory_item=self.inventory_item_origin.external_id, 1424 + order=self.delivery_order_internal.external_id, 1425 + supplied_item_quantity=Decimal(200), 1426 + supply_request=self.supply_request_internal.external_id, 1427 + ) 1428 + response = self.client.post(self.base_url, data, format="json") 1429 + self.assertEqual(response.status_code, 200) 1430 + 1431 + get_response = self.client.get( 1432 + self.delivery_orders_url, 1433 + { 1434 + "request_order": self.request_order_internal.external_id, 1435 + "origin": self.origin.external_id, 1436 + }, 1437 + format="json", 1438 + ) 1439 + self.assertEqual(get_response.status_code, 200) 1440 + self.assertEqual( 1441 + get_response.data["results"][0]["id"], 1442 + str(self.delivery_order_internal.external_id), 1443 + ) 1444 + 1445 + def test_retrieve_delivery_order_as_user_without_permissions_with_origin_filter( 1446 + self, 1447 + ): 1448 + """ 1449 + Test retrieving a delivery order as a user without permissions with origin filter 1450 + """ 1451 + self.client.force_authenticate(user=self.user) 1452 + get_response = self.client.get( 1453 + self.delivery_orders_url, 1454 + { 1455 + "request_order": self.request_order_internal.external_id, 1456 + "origin": self.origin.external_id, 1457 + }, 1458 + format="json", 1459 + ) 1460 + self.assertEqual(get_response.status_code, 403) 1461 + self.assertContains( 1462 + get_response, "Cannot read supply requests", status_code=403 1463 + ) 1464 + 1465 + def test_retrieve_delivery_order_as_superuser_with_destination_filter(self): 1466 + """ 1467 + Test retrieving a delivery order as a superuser with destination filter 1468 + """ 1469 + self.client.force_authenticate(user=self.superuser) 1470 + get_response = self.client.get( 1471 + self.delivery_orders_url, 1472 + { 1473 + "request_order": self.request_order_destination_external.external_id, 1474 + "destination": self.destination.external_id, 1475 + }, 1476 + format="json", 1477 + ) 1478 + self.assertEqual(get_response.status_code, 200) 1479 + self.assertEqual( 1480 + get_response.data["results"][0]["id"], 1481 + str(self.delivery_order_destination_external.external_id), 1482 + ) 1483 + 1484 + def test_retrieve_delivery_order_as_user_with_permissions_with_destination_filter( 1485 + self, 1486 + ): 1487 + """ 1488 + Test retrieving a delivery order as a user with permissions with destination filter 1489 + """ 1490 + self.client.force_authenticate(user=self.user) 1491 + self.attach_role_facility_organization_user( 1492 + facility_organization=self.facility_organization, 1493 + user=self.user, 1494 + role=self.role, 1495 + ) 1496 + get_response = self.client.get( 1497 + self.delivery_orders_url, 1498 + { 1499 + "request_order": self.request_order_destination_external.external_id, 1500 + "destination": self.destination.external_id, 1501 + }, 1502 + format="json", 1503 + ) 1504 + self.assertEqual(get_response.status_code, 200) 1505 + self.assertEqual( 1506 + get_response.data["results"][0]["id"], 1507 + str(self.delivery_order_destination_external.external_id), 1508 + ) 1509 + 1510 + def test_retrieve_delivery_order_as_user_without_permissions_with_destination_filter( 1511 + self, 1512 + ): 1513 + """ 1514 + Test retrieving a delivery order as a user without permissions with destination filter 1515 + """ 1516 + self.client.force_authenticate(user=self.user) 1517 + get_response = self.client.get( 1518 + self.delivery_orders_url, 1519 + { 1520 + "request_order": self.request_order_destination_external.external_id, 1521 + "destination": self.destination.external_id, 1522 + }, 1523 + format="json", 1524 + ) 1525 + self.assertEqual(get_response.status_code, 403) 1526 + self.assertContains( 1527 + get_response, "Cannot read supply requests", status_code=403 1528 + ) 1529 + 1530 + # Testcases for filtering supply deliveries 1531 + 1532 + def test_filter_supply_delivery_by_status_as_superuser(self): 1533 + """ 1534 + Test filtering supply deliveries by status as a superuser 1535 + """ 1536 + self.client.force_authenticate(user=self.superuser) 1537 + supply_delivery = self.create_supply_delivery( 1538 + order=self.delivery_order_destination_external, 1539 + supplied_item_quantity=500, 1540 + supplied_item=self.product, 1541 + status=SupplyDeliveryStatusOptions.in_progress.value, 1542 + supplied_inventory_item=self.inventory_item_destination, 1543 + ) 1544 + response = self.client.get( 1545 + self.base_url, 1546 + { 1547 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1548 + "order": self.delivery_order_destination_external.external_id, 1549 + }, 1550 + format="json", 1551 + ) 1552 + self.assertEqual(response.status_code, 200) 1553 + self.assertEqual(response.data["count"], 1) 1554 + self.assertEqual( 1555 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1556 + ) 1557 + self.assertEqual( 1558 + response.data["results"][0]["status"], 1559 + SupplyDeliveryStatusOptions.in_progress.value, 1560 + ) 1561 + 1562 + def test_filter_supply_delivery_by_status_as_user_with_permissions(self): 1563 + """ 1564 + Test filtering supply deliveries by status as a user with permissions 1565 + """ 1566 + self.client.force_authenticate(user=self.user) 1567 + self.attach_role_facility_organization_user( 1568 + facility_organization=self.facility_organization, 1569 + user=self.user, 1570 + role=self.role, 1571 + ) 1572 + supply_delivery = self.create_supply_delivery( 1573 + order=self.delivery_order_destination_external, 1574 + supplied_item_quantity=Decimal(500), 1575 + supplied_item=self.product, 1576 + status=SupplyDeliveryStatusOptions.in_progress.value, 1577 + supplied_inventory_item=self.inventory_item_destination, 1578 + ) 1579 + response = self.client.get( 1580 + self.base_url, 1581 + { 1582 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1583 + "order": self.delivery_order_destination_external.external_id, 1584 + }, 1585 + format="json", 1586 + ) 1587 + self.assertEqual(response.status_code, 200) 1588 + self.assertEqual(response.data["count"], 1) 1589 + self.assertEqual( 1590 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1591 + ) 1592 + self.assertEqual( 1593 + response.data["results"][0]["status"], 1594 + SupplyDeliveryStatusOptions.in_progress.value, 1595 + ) 1596 + 1597 + def test_filter_supply_delivery_by_status_as_user_without_permissions(self): 1598 + """ 1599 + Test filtering supply deliveries by status as a user without permissions 1600 + """ 1601 + self.client.force_authenticate(user=self.user) 1602 + self.create_supply_delivery( 1603 + order=self.delivery_order_destination_external, 1604 + supplied_item_quantity=Decimal(500), 1605 + supplied_item=self.product, 1606 + status=SupplyDeliveryStatusOptions.in_progress.value, 1607 + supplied_inventory_item=self.inventory_item_destination, 1608 + ) 1609 + response = self.client.get( 1610 + self.base_url, 1611 + { 1612 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1613 + "order": self.delivery_order_destination_external.external_id, 1614 + }, 1615 + format="json", 1616 + ) 1617 + self.assertEqual(response.status_code, 403) 1618 + self.assertContains(response, "Cannot read supply requests", status_code=403) 1619 + 1620 + def test_filter_supply_delivery_as_superuser_without_queryset_filter(self): 1621 + """ 1622 + Test filtering supply deliveries as a superuser without any queryset filter 1623 + """ 1624 + self.client.force_authenticate(user=self.superuser) 1625 + response = self.client.get( 1626 + self.base_url, 1627 + {"status": SupplyDeliveryStatusOptions.in_progress.value}, 1628 + format="json", 1629 + ) 1630 + self.assertEqual(response.status_code, 400) 1631 + self.assertContains(response, "No filters provided", status_code=400) 1632 + 1633 + def test_filter_supply_delivery_as_superuser_with_supplied_item_filter(self): 1634 + """ 1635 + Test filtering supply deliveries as a superuser with supplied_item filter 1636 + """ 1637 + self.client.force_authenticate(user=self.superuser) 1638 + supply_delivery = self.create_supply_delivery( 1639 + order=self.delivery_order_destination_external, 1640 + supplied_item_quantity=Decimal(500), 1641 + supplied_item=self.product, 1642 + status=SupplyDeliveryStatusOptions.in_progress.value, 1643 + supplied_inventory_item=self.inventory_item_destination, 1644 + ) 1645 + response = self.client.get( 1646 + self.base_url, 1647 + { 1648 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1649 + "supplied_item": self.product.external_id, 1650 + "order": self.delivery_order_destination_external.external_id, 1651 + }, 1652 + format="json", 1653 + ) 1654 + self.assertEqual(response.status_code, 200) 1655 + self.assertEqual(response.data["count"], 1) 1656 + self.assertEqual( 1657 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1658 + ) 1659 + self.assertEqual( 1660 + response.data["results"][0]["status"], 1661 + SupplyDeliveryStatusOptions.in_progress.value, 1662 + ) 1663 + self.assertEqual( 1664 + response.data["results"][0]["supplied_item"]["id"], 1665 + str(self.product.external_id), 1666 + ) 1667 + 1668 + def test_filter_supply_delivery_as_superuser_with_supplied_inventory_item_product_knowledge( 1669 + self, 1670 + ): 1671 + """ 1672 + Test filtering supply deliveries as a superuser with filtering by product knowledge from product of supplied_inventory_item 1673 + """ 1674 + self.client.force_authenticate(user=self.superuser) 1675 + supply_delivery = self.create_supply_delivery( 1676 + order=self.delivery_order_destination_external, 1677 + supplied_item_quantity=Decimal(500), 1678 + supplied_item=self.product, 1679 + status=SupplyDeliveryStatusOptions.in_progress.value, 1680 + supplied_inventory_item=self.inventory_item_destination, 1681 + ) 1682 + response = self.client.get( 1683 + self.base_url, 1684 + { 1685 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1686 + "supplied_inventory_item_product_knowledge": self.product_knowledge.external_id, 1687 + "order": self.delivery_order_destination_external.external_id, 1688 + }, 1689 + format="json", 1690 + ) 1691 + self.assertEqual(response.status_code, 200) 1692 + self.assertEqual(response.data["count"], 1) 1693 + self.assertEqual( 1694 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1695 + ) 1696 + self.assertEqual( 1697 + response.data["results"][0]["status"], 1698 + SupplyDeliveryStatusOptions.in_progress.value, 1699 + ) 1700 + self.assertEqual( 1701 + response.data["results"][0]["supplied_inventory_item"]["id"], 1702 + str(self.inventory_item_destination.external_id), 1703 + ) 1704 + 1705 + def test_filter_supply_delivery_as_superuser_with_supplied_item(self): 1706 + """ 1707 + Test filtering supply deliveries as a superuser with filtering by supplied_item(product) 1708 + """ 1709 + self.client.force_authenticate(user=self.superuser) 1710 + supply_delivery = self.create_supply_delivery( 1711 + order=self.delivery_order_destination_external, 1712 + supplied_item_quantity=Decimal(500), 1713 + supplied_item=self.product, 1714 + status=SupplyDeliveryStatusOptions.in_progress.value, 1715 + supplied_inventory_item=self.inventory_item_destination, 1716 + ) 1717 + response = self.client.get( 1718 + self.base_url, 1719 + { 1720 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1721 + "supplied_item": self.product.external_id, 1722 + "order": self.delivery_order_destination_external.external_id, 1723 + }, 1724 + format="json", 1725 + ) 1726 + self.assertEqual(response.status_code, 200) 1727 + self.assertEqual(response.data["count"], 1) 1728 + self.assertEqual( 1729 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1730 + ) 1731 + self.assertEqual( 1732 + response.data["results"][0]["status"], 1733 + SupplyDeliveryStatusOptions.in_progress.value, 1734 + ) 1735 + self.assertEqual( 1736 + response.data["results"][0]["supplied_item"]["id"], 1737 + str(self.product.external_id), 1738 + ) 1739 + 1740 + def test_filter_supply_delivery_as_superuser_with_supplied_item_product_knowledge( 1741 + self, 1742 + ): 1743 + """ 1744 + Test filtering supply deliveries as a superuser with filtering by product knowledge from supplied_item(product) 1745 + """ 1746 + self.client.force_authenticate(user=self.superuser) 1747 + supply_delivery = self.create_supply_delivery( 1748 + order=self.delivery_order_destination_external, 1749 + supplied_item_quantity=Decimal(500), 1750 + supplied_item=self.product, 1751 + status=SupplyDeliveryStatusOptions.in_progress.value, 1752 + supplied_inventory_item=self.inventory_item_destination, 1753 + ) 1754 + response = self.client.get( 1755 + self.base_url, 1756 + { 1757 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1758 + "supplied_item_product_knowledge": self.product_knowledge.external_id, 1759 + "order": self.delivery_order_destination_external.external_id, 1760 + }, 1761 + format="json", 1762 + ) 1763 + self.assertEqual(response.status_code, 200) 1764 + self.assertEqual(response.data["count"], 1) 1765 + self.assertEqual( 1766 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1767 + ) 1768 + self.assertEqual( 1769 + response.data["results"][0]["status"], 1770 + SupplyDeliveryStatusOptions.in_progress.value, 1771 + ) 1772 + self.assertEqual( 1773 + response.data["results"][0]["supplied_item"]["id"], 1774 + str(self.product.external_id), 1775 + ) 1776 + 1777 + def test_filter_supply_delivery_as_superuser_with_supply_request_filter(self): 1778 + """ 1779 + Test filtering supply deliveries as a superuser with filtering by supply_request 1780 + """ 1781 + self.client.force_authenticate(user=self.superuser) 1782 + supply_delivery = self.create_supply_delivery( 1783 + order=self.delivery_order_destination_external, 1784 + supplied_item_quantity=Decimal(500), 1785 + supplied_item=self.product, 1786 + status=SupplyDeliveryStatusOptions.in_progress.value, 1787 + supplied_inventory_item=self.inventory_item_destination, 1788 + supply_request=self.supply_request_destination_external, 1789 + ) 1790 + response = self.client.get( 1791 + self.base_url, 1792 + { 1793 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1794 + "supply_request": self.supply_request_destination_external.external_id, 1795 + "order": self.delivery_order_destination_external.external_id, 1796 + }, 1797 + format="json", 1798 + ) 1799 + self.assertEqual(response.status_code, 200) 1800 + self.assertEqual(response.data["count"], 1) 1801 + self.assertEqual( 1802 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1803 + ) 1804 + self.assertEqual( 1805 + response.data["results"][0]["status"], 1806 + SupplyDeliveryStatusOptions.in_progress.value, 1807 + ) 1808 + self.assertEqual( 1809 + response.data["results"][0]["supplied_item"]["id"], 1810 + str(self.product.external_id), 1811 + ) 1812 + 1813 + def test_filter_supply_delivery_as_superuser_with_origin_is_null_filter(self): 1814 + """ 1815 + Test filtering supply deliveries as a superuser with filtering by origin is null 1816 + """ 1817 + self.client.force_authenticate(user=self.superuser) 1818 + supply_delivery = self.create_supply_delivery( 1819 + order=self.delivery_order_destination_external, 1820 + supplied_item_quantity=Decimal(500), 1821 + supplied_item=self.product, 1822 + status=SupplyDeliveryStatusOptions.in_progress.value, 1823 + supplied_inventory_item=self.inventory_item_destination, 1824 + ) 1825 + response = self.client.get( 1826 + self.base_url, 1827 + { 1828 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1829 + "origin_is_null": "true", 1830 + "order": self.delivery_order_destination_external.external_id, 1831 + }, 1832 + format="json", 1833 + ) 1834 + self.assertEqual(response.status_code, 200) 1835 + self.assertEqual(response.data["count"], 1) 1836 + self.assertEqual( 1837 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1838 + ) 1839 + self.assertEqual( 1840 + response.data["results"][0]["status"], 1841 + SupplyDeliveryStatusOptions.in_progress.value, 1842 + ) 1843 + self.assertEqual( 1844 + response.data["results"][0]["supplied_item"]["id"], 1845 + str(self.product.external_id), 1846 + ) 1847 + 1848 + def test_filter_supply_delivery_as_superuser_with_supplier_filter(self): 1849 + """ 1850 + Test filtering supply deliveries as a superuser with filtering by supplier 1851 + """ 1852 + self.client.force_authenticate(user=self.superuser) 1853 + supply_delivery = self.create_supply_delivery( 1854 + order=self.delivery_order_destination_external, 1855 + supplied_item_quantity=Decimal(500), 1856 + supplied_item=self.product, 1857 + status=SupplyDeliveryStatusOptions.in_progress.value, 1858 + supplied_inventory_item=self.inventory_item_destination, 1859 + ) 1860 + response = self.client.get( 1861 + self.base_url, 1862 + { 1863 + "status": SupplyDeliveryStatusOptions.in_progress.value, 1864 + "supplier": self.supplier.external_id, 1865 + "order": self.delivery_order_destination_external.external_id, 1866 + }, 1867 + format="json", 1868 + ) 1869 + self.assertEqual(response.status_code, 200) 1870 + self.assertEqual(response.data["count"], 1) 1871 + self.assertEqual( 1872 + response.data["results"][0]["id"], str(supply_delivery.external_id) 1873 + ) 1874 + self.assertEqual( 1875 + response.data["results"][0]["status"], 1876 + SupplyDeliveryStatusOptions.in_progress.value, 1877 + ) 1878 + self.assertEqual( 1879 + response.data["results"][0]["supplied_item"]["id"], 1880 + str(self.product.external_id), 1881 + )

Configure Feed

Configure Feed