Test cases for Token queue api (#3349) · satanvysakh.tngl.sh/care@024240b

+2731 -1

2 changed files

expand all

care

emr

api

viewsets

scheduling

token_queue.py

tests

test_token_queue_api.py

+1 -1

care/emr/api/viewsets/scheduling/token_queue.py

··· 98 98 resource, 99 99 self.request.user, 100 100 ): 101 - raise PermissionDenied("You do not have permission to create token queue") 101 + raise PermissionDenied("You do not have permission to update token queue") 102 102 103 103 def authorize_destroy(self, instance): 104 104 self.authorize_update({}, instance)

+2730

care/emr/tests/test_token_queue_api.py

··· 1 + from datetime import timedelta 2 + from uuid import uuid4 3 + 4 + from django.urls import reverse 5 + from django.utils import timezone 6 + from model_bakery import baker 7 + 8 + from care.emr.models import FacilityLocation, FacilityLocationOrganization 9 + from care.emr.models.healthcare_service import HealthcareService 10 + from care.emr.models.scheduling.token import ( 11 + Token, 12 + TokenCategory, 13 + TokenQueue, 14 + TokenSubQueue, 15 + ) 16 + from care.emr.resources.scheduling.token.spec import ( 17 + SchedulableResourceTypeOptions, 18 + TokenStatusOptions, 19 + ) 20 + from care.security.permissions.token import TokenPermissions 21 + from care.utils.tests.base import CareAPITestBase 22 + 23 + 24 + class TokenQueueAPITestCase(CareAPITestBase): 25 + def setUp(self): 26 + self.user = self.create_user(username="testuser") 27 + self.superuser = self.create_super_user(username="superuser") 28 + self.facility = self.create_facility(user=self.superuser) 29 + self.facility_organization = self.create_facility_organization( 30 + facility=self.facility, org_type="root" 31 + ) 32 + self.facility_location = self.create_facility_location( 33 + facility=self.facility, facility_organization=self.facility_organization 34 + ) 35 + self.superuser_resource = self.create_schedule_resource( 36 + facility=self.facility, 37 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 38 + user=self.superuser, 39 + ) 40 + self.patient = self.create_patient() 41 + self.role = self.create_role_with_permissions( 42 + permissions=[ 43 + TokenPermissions.can_list_token.name, 44 + TokenPermissions.can_write_token.name, 45 + ], 46 + ) 47 + self.base_url = reverse( 48 + "token-queue-list", 49 + kwargs={"facility_external_id": self.facility.external_id}, 50 + ) 51 + 52 + def create_schedule_resource(self, **kwargs): 53 + return baker.make("emr.SchedulableResource", **kwargs) 54 + 55 + def generate_token_queue_data(self, **kwargs): 56 + """ 57 + Generate data for creating a TokenQueue instance. 58 + 59 + fields: 60 + - resource_type: The type of schedulable resource type for the token queue. 61 + - resource_id: The external ID of the resource for the token queue. 62 + 63 + These fields are required to validate schedulable resource based on the resource type 64 + """ 65 + data = { 66 + "name": "Test Token Queue", 67 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 68 + "resource_type": kwargs.get( 69 + "resource_type", SchedulableResourceTypeOptions.practitioner.value 70 + ), 71 + "resource_id": kwargs.get("resource_id", str(self.superuser.external_id)), 72 + } 73 + data.update(kwargs) 74 + return data 75 + 76 + def create_token_queue(self, facility, **kwargs): 77 + return baker.make(TokenQueue, facility=facility, **kwargs) 78 + 79 + def generate_detail_url(self, facility_external_id, external_id): 80 + return reverse( 81 + "token-queue-detail", 82 + kwargs={ 83 + "facility_external_id": facility_external_id, 84 + "external_id": external_id, 85 + }, 86 + ) 87 + 88 + def create_facility_location(self, facility, facility_organization, **kwargs): 89 + location = baker.make(FacilityLocation, facility=facility, **kwargs) 90 + baker.make( 91 + FacilityLocationOrganization, 92 + location=location, 93 + organization=facility_organization, 94 + ) 95 + return location 96 + 97 + def create_healthcare_service(self, facility, **kwargs): 98 + return baker.make(HealthcareService, facility=facility, **kwargs) 99 + 100 + def create_token(self, facility, **kwargs): 101 + return baker.make(Token, facility=facility, **kwargs) 102 + 103 + def create_token_category(self, facility, **kwargs): 104 + return baker.make(TokenCategory, facility=facility, **kwargs) 105 + 106 + # Tests for create token queue 107 + 108 + def test_create_token_queue_with_resource_type_be_practitioner_as_superuser(self): 109 + """ 110 + Test creating a token queue with resource type be practitioner as superuser. 111 + """ 112 + self.client.force_authenticate(user=self.superuser) 113 + data = self.generate_token_queue_data() 114 + response = self.client.post(self.base_url, data, format="json") 115 + self.assertEqual(response.status_code, 200) 116 + get_response = self.client.get( 117 + self.generate_detail_url( 118 + facility_external_id=self.facility.external_id, 119 + external_id=response.data["id"], 120 + ) 121 + ) 122 + self.assertEqual(get_response.status_code, 200) 123 + self.assertEqual(get_response.data["id"], response.data["id"]) 124 + self.assertEqual(get_response.data["name"], data["name"]) 125 + self.assertEqual(get_response.data["date"], data["date"]) 126 + 127 + def test_create_token_queue_with_resource_type_be_practitioner_as_user_with_permissions( 128 + self, 129 + ): 130 + """ 131 + Test creating a token queue with resource type be practitioner as a user with the required permissions. 132 + """ 133 + self.client.force_authenticate(user=self.user) 134 + self.attach_role_facility_organization_user( 135 + user=self.user, 136 + role=self.role, 137 + facility_organization=self.facility_organization, 138 + ) 139 + data = self.generate_token_queue_data(resource_id=str(self.user.external_id)) 140 + response = self.client.post(self.base_url, data, format="json") 141 + self.assertEqual(response.status_code, 200) 142 + get_response = self.client.get( 143 + self.generate_detail_url( 144 + facility_external_id=self.facility.external_id, 145 + external_id=response.data["id"], 146 + ) 147 + ) 148 + self.assertEqual(get_response.status_code, 200) 149 + self.assertEqual(get_response.data["id"], response.data["id"]) 150 + self.assertEqual(get_response.data["name"], data["name"]) 151 + 152 + def test_create_token_queue_with_resource_type_be_practitioner_as_user_without_write_permissions( 153 + self, 154 + ): 155 + """ 156 + Test creating a token queue with resource type be practitioner as a user without 'can_write_token' permissions. 157 + But is a part of facility organization. 158 + """ 159 + role = self.create_role_with_permissions( 160 + permissions=[ 161 + TokenPermissions.can_list_token.name, 162 + ], 163 + ) 164 + self.attach_role_facility_organization_user( 165 + user=self.user, role=role, facility_organization=self.facility_organization 166 + ) 167 + self.client.force_authenticate(user=self.user) 168 + data = self.generate_token_queue_data(resource_id=str(self.user.external_id)) 169 + response = self.client.post(self.base_url, data, format="json") 170 + self.assertEqual(response.status_code, 403) 171 + self.assertIn( 172 + "You do not have permission to create token queue", str(response.data) 173 + ) 174 + 175 + def test_create_token_queue_with_resource_type_be_practitioner_as_user_outside_facility_organization( 176 + self, 177 + ): 178 + """ 179 + Test creating a token queue with resource type be practitioner as a user without being part of facility organization. 180 + """ 181 + self.client.force_authenticate(user=self.user) 182 + data = self.generate_token_queue_data(resource_id=str(self.user.external_id)) 183 + response = self.client.post(self.base_url, data, format="json") 184 + self.assertEqual(response.status_code, 400) 185 + self.assertIn("Schedule User is not part of the facility", str(response.data)) 186 + 187 + def test_create_token_queue_with_resource_type_be_location_as_superuser(self): 188 + """ 189 + Test creating a token queue with resource type be location as superuser. 190 + """ 191 + self.client.force_authenticate(user=self.superuser) 192 + data = self.generate_token_queue_data( 193 + resource_type=SchedulableResourceTypeOptions.location.value, 194 + resource_id=str(self.facility_location.external_id), 195 + ) 196 + response = self.client.post(self.base_url, data, format="json") 197 + self.assertEqual(response.status_code, 200) 198 + get_response = self.client.get( 199 + self.generate_detail_url( 200 + facility_external_id=self.facility.external_id, 201 + external_id=response.data["id"], 202 + ) 203 + ) 204 + self.assertEqual(get_response.status_code, 200) 205 + self.assertEqual(get_response.data["id"], response.data["id"]) 206 + self.assertEqual(get_response.data["name"], data["name"]) 207 + self.assertEqual(get_response.data["date"], data["date"]) 208 + 209 + def test_create_token_queue_with_resource_type_be_location_as_user_with_permissions( 210 + self, 211 + ): 212 + """ 213 + Test creating a token queue with resource type be location as a user with the required permissions. 214 + """ 215 + self.client.force_authenticate(user=self.user) 216 + self.attach_role_facility_organization_user( 217 + user=self.user, 218 + role=self.role, 219 + facility_organization=self.facility_organization, 220 + ) 221 + data = self.generate_token_queue_data( 222 + resource_type=SchedulableResourceTypeOptions.location.value, 223 + resource_id=str(self.facility_location.external_id), 224 + ) 225 + response = self.client.post(self.base_url, data, format="json") 226 + self.assertEqual(response.status_code, 200) 227 + get_response = self.client.get( 228 + self.generate_detail_url( 229 + facility_external_id=self.facility.external_id, 230 + external_id=response.data["id"], 231 + ) 232 + ) 233 + self.assertEqual(get_response.status_code, 200) 234 + self.assertEqual(get_response.data["id"], response.data["id"]) 235 + self.assertEqual(get_response.data["name"], data["name"]) 236 + self.assertEqual(get_response.data["date"], data["date"]) 237 + 238 + def test_create_token_queue_with_resource_type_be_location_as_user_without_write_permissions( 239 + self, 240 + ): 241 + """ 242 + Test creating a token queue with resource type be location as a user without 'can_write_token' permissions. 243 + But is a part of facility organization. 244 + """ 245 + role = self.create_role_with_permissions( 246 + permissions=[ 247 + TokenPermissions.can_list_token.name, 248 + ], 249 + ) 250 + self.attach_role_facility_organization_user( 251 + user=self.user, role=role, facility_organization=self.facility_organization 252 + ) 253 + self.client.force_authenticate(user=self.user) 254 + data = self.generate_token_queue_data( 255 + resource_type=SchedulableResourceTypeOptions.location.value, 256 + resource_id=str(self.facility_location.external_id), 257 + ) 258 + response = self.client.post(self.base_url, data, format="json") 259 + self.assertEqual(response.status_code, 403) 260 + self.assertIn( 261 + "You do not have permission to create token queue", str(response.data) 262 + ) 263 + 264 + def test_create_token_queue_with_resource_type_be_location_as_user_outside_facility_organization( 265 + self, 266 + ): 267 + """ 268 + Test creating a token queue with resource type be location as a user without being part of facility organization. 269 + """ 270 + another_facility = self.create_facility(user=self.superuser) 271 + another_facility_organization = self.create_facility_organization( 272 + facility=another_facility, org_type="root" 273 + ) 274 + another_facility_location = self.create_facility_location( 275 + facility=another_facility, 276 + facility_organization=another_facility_organization, 277 + ) 278 + self.client.force_authenticate(user=self.user) 279 + data = self.generate_token_queue_data( 280 + resource_id=str(another_facility_location.external_id), 281 + resource_type=SchedulableResourceTypeOptions.location.value, 282 + ) 283 + response = self.client.post(self.base_url, data, format="json") 284 + self.assertEqual(response.status_code, 400) 285 + self.assertIn("Location is not part of the facility", str(response.data)) 286 + 287 + def test_create_token_queue_with_resource_type_be_healthcare_service_as_superuser( 288 + self, 289 + ): 290 + """ 291 + Test creating a token queue with resource type be healthcare service as superuser. 292 + """ 293 + healthcare_service = self.create_healthcare_service(facility=self.facility) 294 + self.client.force_authenticate(user=self.superuser) 295 + data = self.generate_token_queue_data( 296 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 297 + resource_id=str(healthcare_service.external_id), 298 + ) 299 + response = self.client.post(self.base_url, data, format="json") 300 + self.assertEqual(response.status_code, 200) 301 + get_response = self.client.get( 302 + self.generate_detail_url( 303 + facility_external_id=self.facility.external_id, 304 + external_id=response.data["id"], 305 + ) 306 + ) 307 + self.assertEqual(get_response.status_code, 200) 308 + self.assertEqual(get_response.data["id"], response.data["id"]) 309 + self.assertEqual(get_response.data["name"], data["name"]) 310 + self.assertEqual(get_response.data["date"], data["date"]) 311 + 312 + def test_create_token_queue_with_resource_type_be_healthcare_service_as_user_with_permissions( 313 + self, 314 + ): 315 + """ 316 + Test creating a token queue with resource type be healthcare service as a user with the required permissions. 317 + """ 318 + healthcare_service = self.create_healthcare_service(facility=self.facility) 319 + self.client.force_authenticate(user=self.user) 320 + self.attach_role_facility_organization_user( 321 + user=self.user, 322 + role=self.role, 323 + facility_organization=self.facility_organization, 324 + ) 325 + data = self.generate_token_queue_data( 326 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 327 + resource_id=str(healthcare_service.external_id), 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.generate_detail_url( 333 + facility_external_id=self.facility.external_id, 334 + external_id=response.data["id"], 335 + ) 336 + ) 337 + self.assertEqual(get_response.status_code, 200) 338 + self.assertEqual(get_response.data["id"], response.data["id"]) 339 + self.assertEqual(get_response.data["name"], data["name"]) 340 + self.assertEqual(get_response.data["date"], data["date"]) 341 + 342 + def test_create_token_queue_with_resource_type_be_healthcare_service_as_user_without_write_permissions( 343 + self, 344 + ): 345 + """ 346 + Test creating a token queue with resource type be healthcare service as a user without 'can_write_token' permissions. 347 + But is a part of facility organization. 348 + """ 349 + healthcare_service = self.create_healthcare_service(facility=self.facility) 350 + role = self.create_role_with_permissions( 351 + permissions=[ 352 + TokenPermissions.can_list_token.name, 353 + ], 354 + ) 355 + self.attach_role_facility_organization_user( 356 + user=self.user, role=role, facility_organization=self.facility_organization 357 + ) 358 + self.client.force_authenticate(user=self.user) 359 + data = self.generate_token_queue_data( 360 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 361 + resource_id=str(healthcare_service.external_id), 362 + ) 363 + response = self.client.post(self.base_url, data, format="json") 364 + self.assertEqual(response.status_code, 403) 365 + self.assertIn( 366 + "You do not have permission to create token queue", str(response.data) 367 + ) 368 + 369 + def test_create_token_queue_with_resource_type_be_healthcare_service_as_user_outside_facility_organization( 370 + self, 371 + ): 372 + """ 373 + Test creating a token queue with resource type be healthcare service as a user without being part of facility organization. 374 + """ 375 + another_facility = self.create_facility(user=self.superuser) 376 + healthcare_service = self.create_healthcare_service(facility=another_facility) 377 + self.client.force_authenticate(user=self.user) 378 + data = self.generate_token_queue_data( 379 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 380 + resource_id=str(healthcare_service.external_id), 381 + ) 382 + response = self.client.post(self.base_url, data, format="json") 383 + self.assertEqual(response.status_code, 400) 384 + self.assertIn( 385 + "Healthcare Service is not part of the facility", str(response.data) 386 + ) 387 + 388 + def test_create_token_queue_with_an_existing_primary_queue(self): 389 + """ 390 + Test creating a token queue with an existing primary queue. 391 + """ 392 + self.create_token_queue( 393 + facility=self.facility, 394 + name="Token Queue 1", 395 + date=(timezone.now() + timedelta(days=1)).date(), 396 + resource=self.superuser_resource, 397 + is_primary=True, 398 + ) 399 + self.client.force_authenticate(user=self.superuser) 400 + data = self.generate_token_queue_data() 401 + response = self.client.post(self.base_url, data, format="json") 402 + self.assertEqual(response.status_code, 200) 403 + get_response = self.client.get( 404 + self.generate_detail_url( 405 + facility_external_id=self.facility.external_id, 406 + external_id=response.data["id"], 407 + ) 408 + ) 409 + self.assertEqual(get_response.status_code, 200) 410 + self.assertEqual(get_response.data["id"], str(response.data["id"])) 411 + self.assertEqual(get_response.data["name"], data["name"]) 412 + self.assertEqual(get_response.data["is_primary"], False) 413 + 414 + def test_update_token_queue_with_resource_type_be_practitioner_as_user_with_permissions( 415 + self, 416 + ): 417 + """ 418 + Test updating a token queue with resource type be practitioner as a user with the required permissions. 419 + """ 420 + user_resource = self.create_schedule_resource( 421 + facility=self.facility, 422 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 423 + user=self.user, 424 + ) 425 + token_queue = self.create_token_queue( 426 + facility=self.facility, 427 + name="Initial Token Queue", 428 + date=(timezone.now() + timedelta(days=1)).date(), 429 + resource=user_resource, 430 + is_primary=True, 431 + ) 432 + self.client.force_authenticate(user=self.user) 433 + self.attach_role_facility_organization_user( 434 + user=self.user, 435 + role=self.role, 436 + facility_organization=self.facility_organization, 437 + ) 438 + update_data = { 439 + "name": "Updated Token Queue", 440 + } 441 + response = self.client.put( 442 + self.generate_detail_url( 443 + facility_external_id=self.facility.external_id, 444 + external_id=token_queue.external_id, 445 + ), 446 + update_data, 447 + format="json", 448 + ) 449 + self.assertEqual(response.status_code, 200) 450 + self.assertEqual(response.data["name"], update_data["name"]) 451 + get_response = self.client.get( 452 + self.generate_detail_url( 453 + facility_external_id=self.facility.external_id, 454 + external_id=token_queue.external_id, 455 + ) 456 + ) 457 + self.assertEqual(get_response.status_code, 200) 458 + self.assertEqual(get_response.data["id"], str(token_queue.external_id)) 459 + self.assertEqual(get_response.data["name"], update_data["name"]) 460 + 461 + def test_update_token_queue_with_resource_type_be_practitioner_as_user_without_write_permissions( 462 + self, 463 + ): 464 + """ 465 + Test updating a token queue with resource type be practitioner as a user without 'can_write_token' permissions. 466 + But is a part of facility organization. 467 + """ 468 + user_resource = self.create_schedule_resource( 469 + facility=self.facility, 470 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 471 + user=self.user, 472 + ) 473 + token_queue = self.create_token_queue( 474 + facility=self.facility, 475 + name="Initial Token Queue", 476 + date=(timezone.now() + timedelta(days=1)).date(), 477 + resource=user_resource, 478 + is_primary=True, 479 + ) 480 + role = self.create_role_with_permissions( 481 + permissions=[ 482 + TokenPermissions.can_list_token.name, 483 + ], 484 + ) 485 + self.attach_role_facility_organization_user( 486 + user=self.user, role=role, facility_organization=self.facility_organization 487 + ) 488 + self.client.force_authenticate(user=self.user) 489 + update_data = { 490 + "name": "Updated Token Queue", 491 + } 492 + response = self.client.put( 493 + self.generate_detail_url( 494 + facility_external_id=self.facility.external_id, 495 + external_id=token_queue.external_id, 496 + ), 497 + update_data, 498 + format="json", 499 + ) 500 + self.assertEqual(response.status_code, 403) 501 + self.assertIn( 502 + "You do not have permission to update token queue", str(response.data) 503 + ) 504 + 505 + def test_update_token_queue_with_resource_type_be_practitioner_as_user_outside_facility_organization( 506 + self, 507 + ): 508 + """ 509 + Test updating a token queue with resource type be practitioner as a user outside the facility organization. 510 + But the user is a part of another facility organization with write permissions. 511 + 512 + """ 513 + another_facility = self.create_facility(user=self.superuser) 514 + another_facility_organization = self.create_facility_organization( 515 + facility=another_facility, org_type="root" 516 + ) 517 + self.attach_role_facility_organization_user( 518 + user=self.user, 519 + role=self.role, 520 + facility_organization=another_facility_organization, 521 + ) 522 + user_resource = self.create_schedule_resource( 523 + facility=self.facility, 524 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 525 + user=self.user, 526 + ) 527 + token_queue = self.create_token_queue( 528 + facility=self.facility, 529 + name="Initial Token Queue", 530 + date=(timezone.now() + timedelta(days=1)).date(), 531 + resource=user_resource, 532 + is_primary=True, 533 + ) 534 + self.client.force_authenticate(user=self.user) 535 + update_data = { 536 + "name": "Updated Token Queue", 537 + } 538 + response = self.client.put( 539 + self.generate_detail_url( 540 + facility_external_id=another_facility.external_id, 541 + external_id=token_queue.external_id, 542 + ), 543 + update_data, 544 + format="json", 545 + ) 546 + self.assertEqual(response.status_code, 403) 547 + self.assertIn( 548 + "You do not have permission to update token queue", str(response.data) 549 + ) 550 + 551 + def test_update_token_queue_with_resource_type_be_healthcare_as_superuser(self): 552 + """ 553 + Test updating a token queue with resource type be healthcare service as superuser. 554 + """ 555 + healthcare_service = self.create_healthcare_service(facility=self.facility) 556 + healthcare_service_resource = self.create_schedule_resource( 557 + facility=self.facility, 558 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 559 + healthcare_service=healthcare_service, 560 + ) 561 + token_queue = self.create_token_queue( 562 + facility=self.facility, 563 + name="Initial Token Queue", 564 + date=(timezone.now() + timedelta(days=1)).date(), 565 + resource=healthcare_service_resource, 566 + is_primary=True, 567 + ) 568 + self.client.force_authenticate(user=self.superuser) 569 + update_data = { 570 + "name": "Updated Token Queue", 571 + } 572 + response = self.client.put( 573 + self.generate_detail_url( 574 + facility_external_id=self.facility.external_id, 575 + external_id=token_queue.external_id, 576 + ), 577 + update_data, 578 + format="json", 579 + ) 580 + self.assertEqual(response.status_code, 200) 581 + self.assertEqual(response.data["name"], update_data["name"]) 582 + get_response = self.client.get( 583 + self.generate_detail_url( 584 + facility_external_id=self.facility.external_id, 585 + external_id=token_queue.external_id, 586 + ) 587 + ) 588 + self.assertEqual(get_response.status_code, 200) 589 + self.assertEqual(get_response.data["id"], str(token_queue.external_id)) 590 + self.assertEqual(get_response.data["name"], update_data["name"]) 591 + 592 + def test_update_token_queue_with_resource_type_be_healthcare_service_as_user_with_permissions( 593 + self, 594 + ): 595 + """ 596 + Test updating a token queue with resource type be healthcare_service as a user with the required permissions. 597 + """ 598 + healthcare_service = self.create_healthcare_service(facility=self.facility) 599 + healthcare_service_resource = self.create_schedule_resource( 600 + facility=self.facility, 601 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 602 + healthcare_service=healthcare_service, 603 + ) 604 + token_queue = self.create_token_queue( 605 + facility=self.facility, 606 + name="Initial Token Queue", 607 + date=(timezone.now() + timedelta(days=1)).date(), 608 + resource=healthcare_service_resource, 609 + is_primary=True, 610 + ) 611 + self.attach_role_facility_organization_user( 612 + user=self.user, 613 + role=self.role, 614 + facility_organization=self.facility_organization, 615 + ) 616 + self.client.force_authenticate(user=self.user) 617 + update_data = { 618 + "name": "Updated Token Queue", 619 + } 620 + response = self.client.put( 621 + self.generate_detail_url( 622 + facility_external_id=self.facility.external_id, 623 + external_id=token_queue.external_id, 624 + ), 625 + update_data, 626 + format="json", 627 + ) 628 + self.assertEqual(response.status_code, 200) 629 + get_response = self.client.get( 630 + self.generate_detail_url( 631 + facility_external_id=self.facility.external_id, 632 + external_id=token_queue.external_id, 633 + ), 634 + format="json", 635 + ) 636 + self.assertEqual(get_response.status_code, 200) 637 + self.assertIn("Updated Token Queue", str(get_response.data)) 638 + 639 + def test_update_token_queue_with_resource_type_be_healthcare_service_as_user_without_write_permissions( 640 + self, 641 + ): 642 + """ 643 + Test updating a token queue with resource type be healthcare_service as a user without 'can_write_token' permissions. 644 + But is a part of facility organization. 645 + """ 646 + healthcare_service = self.create_healthcare_service(facility=self.facility) 647 + healthcare_service_resource = self.create_schedule_resource( 648 + facility=self.facility, 649 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 650 + healthcare_service=healthcare_service, 651 + ) 652 + token_queue = self.create_token_queue( 653 + facility=self.facility, 654 + name="Initial Token Queue", 655 + date=(timezone.now() + timedelta(days=1)).date(), 656 + resource=healthcare_service_resource, 657 + is_primary=True, 658 + ) 659 + role = self.create_role_with_permissions( 660 + permissions=[ 661 + TokenPermissions.can_list_token.name, 662 + ], 663 + ) 664 + self.attach_role_facility_organization_user( 665 + user=self.user, role=role, facility_organization=self.facility_organization 666 + ) 667 + self.client.force_authenticate(user=self.user) 668 + update_data = { 669 + "name": "Updated Token Queue", 670 + } 671 + response = self.client.put( 672 + self.generate_detail_url( 673 + facility_external_id=self.facility.external_id, 674 + external_id=token_queue.external_id, 675 + ), 676 + update_data, 677 + format="json", 678 + ) 679 + self.assertEqual(response.status_code, 403) 680 + self.assertIn( 681 + "You do not have permission to update token queue", str(response.data) 682 + ) 683 + 684 + def test_update_token_queue_with_resource_type_be_location_as_superuser(self): 685 + """ 686 + Test updating a token queue with resource type be location as superuser. 687 + """ 688 + location_resource = self.create_schedule_resource( 689 + facility=self.facility, 690 + resource_type=SchedulableResourceTypeOptions.location.value, 691 + location=self.facility_location, 692 + ) 693 + token_queue = self.create_token_queue( 694 + facility=self.facility, 695 + name="Initial Token Queue", 696 + date=(timezone.now() + timedelta(days=1)).date(), 697 + resource=location_resource, 698 + is_primary=True, 699 + ) 700 + self.client.force_authenticate(user=self.superuser) 701 + update_data = { 702 + "name": "Updated Token Queue", 703 + } 704 + response = self.client.put( 705 + self.generate_detail_url( 706 + facility_external_id=self.facility.external_id, 707 + external_id=token_queue.external_id, 708 + ), 709 + update_data, 710 + format="json", 711 + ) 712 + self.assertEqual(response.status_code, 200) 713 + self.assertEqual(response.data["name"], update_data["name"]) 714 + get_response = self.client.get( 715 + self.generate_detail_url( 716 + facility_external_id=self.facility.external_id, 717 + external_id=token_queue.external_id, 718 + ) 719 + ) 720 + self.assertEqual(get_response.status_code, 200) 721 + self.assertEqual(get_response.data["id"], str(token_queue.external_id)) 722 + self.assertEqual(get_response.data["name"], update_data["name"]) 723 + 724 + def test_update_token_queue_with_resource_type_be_location_as_user_with_permissions( 725 + self, 726 + ): 727 + """ 728 + Test updating a token queue with resource type be location as a user with the required permissions. 729 + """ 730 + location_resource = self.create_schedule_resource( 731 + facility=self.facility, 732 + resource_type=SchedulableResourceTypeOptions.location.value, 733 + location=self.facility_location, 734 + ) 735 + token_queue = self.create_token_queue( 736 + facility=self.facility, 737 + name="Initial Token Queue", 738 + date=(timezone.now() + timedelta(days=1)).date(), 739 + resource=location_resource, 740 + is_primary=True, 741 + ) 742 + self.client.force_authenticate(user=self.user) 743 + self.attach_role_facility_organization_user( 744 + user=self.user, 745 + role=self.role, 746 + facility_organization=self.facility_organization, 747 + ) 748 + update_data = { 749 + "name": "Updated Token Queue", 750 + } 751 + response = self.client.put( 752 + self.generate_detail_url( 753 + facility_external_id=self.facility.external_id, 754 + external_id=token_queue.external_id, 755 + ), 756 + update_data, 757 + format="json", 758 + ) 759 + self.assertEqual(response.status_code, 200) 760 + get_response = self.client.get( 761 + self.generate_detail_url( 762 + facility_external_id=self.facility.external_id, 763 + external_id=token_queue.external_id, 764 + ) 765 + ) 766 + self.assertEqual(get_response.status_code, 200) 767 + self.assertEqual(get_response.data["id"], str(token_queue.external_id)) 768 + self.assertEqual(get_response.data["name"], update_data["name"]) 769 + 770 + def test_update_token_queue_with_resource_type_be_location_as_user_without_write_permissions( 771 + self, 772 + ): 773 + """ 774 + Test updating a token queue with resource type be location as a user without 'can_write_token' permissions. 775 + But is a part of facility organization. 776 + """ 777 + location_resource = self.create_schedule_resource( 778 + facility=self.facility, 779 + resource_type=SchedulableResourceTypeOptions.location.value, 780 + location=self.facility_location, 781 + ) 782 + token_queue = self.create_token_queue( 783 + facility=self.facility, 784 + name="Initial Token Queue", 785 + date=(timezone.now() + timedelta(days=1)).date(), 786 + resource=location_resource, 787 + is_primary=True, 788 + ) 789 + role = self.create_role_with_permissions( 790 + permissions=[ 791 + TokenPermissions.can_list_token.name, 792 + ], 793 + ) 794 + self.attach_role_facility_organization_user( 795 + user=self.user, role=role, facility_organization=self.facility_organization 796 + ) 797 + self.client.force_authenticate(user=self.user) 798 + update_data = { 799 + "name": "Updated Token Queue", 800 + } 801 + response = self.client.put( 802 + self.generate_detail_url( 803 + facility_external_id=self.facility.external_id, 804 + external_id=token_queue.external_id, 805 + ), 806 + update_data, 807 + format="json", 808 + ) 809 + self.assertEqual(response.status_code, 403) 810 + self.assertIn( 811 + "You do not have permission to update token queue", str(response.data) 812 + ) 813 + 814 + # Tests for delete token queue 815 + 816 + def test_delete_token_queue_with_resource_type_be_practitioner_as_superuser(self): 817 + """dsss 818 + Test deleting a token queue with resource type be practitioner as superuser. 819 + """ 820 + token_queue = self.create_token_queue( 821 + facility=self.facility, 822 + name="Initial Token Queue", 823 + date=(timezone.now() + timedelta(days=1)).date(), 824 + resource=self.superuser_resource, 825 + is_primary=True, 826 + ) 827 + self.client.force_authenticate(user=self.superuser) 828 + response = self.client.delete( 829 + self.generate_detail_url( 830 + facility_external_id=self.facility.external_id, 831 + external_id=token_queue.external_id, 832 + ) 833 + ) 834 + self.assertEqual(response.status_code, 204) 835 + get_response = self.client.get( 836 + self.generate_detail_url( 837 + facility_external_id=self.facility.external_id, 838 + external_id=token_queue.external_id, 839 + ) 840 + ) 841 + self.assertEqual(get_response.status_code, 404) 842 + self.assertIn( 843 + "No TokenQueue matches the given query.", 844 + str(get_response.data["errors"][0]["msg"]), 845 + ) 846 + 847 + def test_delete_token_queue_with_resource_type_be_practitioner_as_user_with_permissions( 848 + self, 849 + ): 850 + """ 851 + Test deleting a token queue with resource type be practitioner as a user with the required permissions. 852 + """ 853 + user_resource = self.create_schedule_resource( 854 + facility=self.facility, 855 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 856 + user=self.user, 857 + ) 858 + token_queue = self.create_token_queue( 859 + facility=self.facility, 860 + name="Initial Token Queue", 861 + date=(timezone.now() + timedelta(days=1)).date(), 862 + resource=user_resource, 863 + is_primary=True, 864 + ) 865 + self.client.force_authenticate(user=self.user) 866 + self.attach_role_facility_organization_user( 867 + user=self.user, 868 + role=self.role, 869 + facility_organization=self.facility_organization, 870 + ) 871 + response = self.client.delete( 872 + self.generate_detail_url( 873 + facility_external_id=self.facility.external_id, 874 + external_id=token_queue.external_id, 875 + ) 876 + ) 877 + self.assertEqual(response.status_code, 204) 878 + get_response = self.client.get( 879 + self.generate_detail_url( 880 + facility_external_id=self.facility.external_id, 881 + external_id=token_queue.external_id, 882 + ) 883 + ) 884 + self.assertEqual(get_response.status_code, 404) 885 + self.assertIn( 886 + "No TokenQueue matches the given query.", 887 + str(get_response.data["errors"][0]["msg"]), 888 + ) 889 + 890 + def test_delete_token_queue_with_resource_type_be_practitioner_as_user_without_write_permissions( 891 + self, 892 + ): 893 + """ 894 + Test deleting a token queue with resource type be practitioner as a user without 'can_write_token' permissions. 895 + But is a part of facility organization. 896 + """ 897 + user_resource = self.create_schedule_resource( 898 + facility=self.facility, 899 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 900 + user=self.user, 901 + ) 902 + token_queue = self.create_token_queue( 903 + facility=self.facility, 904 + name="Initial Token Queue", 905 + date=(timezone.now() + timedelta(days=1)).date(), 906 + resource=user_resource, 907 + is_primary=True, 908 + ) 909 + role = self.create_role_with_permissions( 910 + permissions=[ 911 + TokenPermissions.can_list_token.name, 912 + ], 913 + ) 914 + self.attach_role_facility_organization_user( 915 + user=self.user, role=role, facility_organization=self.facility_organization 916 + ) 917 + self.client.force_authenticate(user=self.user) 918 + response = self.client.delete( 919 + self.generate_detail_url( 920 + facility_external_id=self.facility.external_id, 921 + external_id=token_queue.external_id, 922 + ) 923 + ) 924 + self.assertEqual(response.status_code, 403) 925 + self.assertIn( 926 + "You do not have permission to update token queue", str(response.data) 927 + ) 928 + 929 + def test_delete_token_queue_with_resource_type_be_healthcare_service_as_superuser( 930 + self, 931 + ): 932 + """ 933 + Test deleting a token queue with resource type be healthcare_service as superuser. 934 + """ 935 + healthcare_service = self.create_healthcare_service(facility=self.facility) 936 + healthcare_service_resource = self.create_schedule_resource( 937 + facility=self.facility, 938 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 939 + healthcare_service=healthcare_service, 940 + ) 941 + token_queue = self.create_token_queue( 942 + facility=self.facility, 943 + name="Initial Token Queue", 944 + date=(timezone.now() + timedelta(days=1)).date(), 945 + resource=healthcare_service_resource, 946 + is_primary=True, 947 + ) 948 + self.client.force_authenticate(user=self.superuser) 949 + response = self.client.delete( 950 + self.generate_detail_url( 951 + facility_external_id=self.facility.external_id, 952 + external_id=token_queue.external_id, 953 + ) 954 + ) 955 + self.assertEqual(response.status_code, 204) 956 + get_response = self.client.get( 957 + self.generate_detail_url( 958 + facility_external_id=self.facility.external_id, 959 + external_id=token_queue.external_id, 960 + ) 961 + ) 962 + self.assertEqual(get_response.status_code, 404) 963 + self.assertIn( 964 + "No TokenQueue matches the given query.", 965 + str(get_response.data["errors"][0]["msg"]), 966 + ) 967 + 968 + def test_delete_token_queue_with_resource_type_be_healthcare_service_as_user_with_permissions( 969 + self, 970 + ): 971 + """ 972 + Test deleting a token queue with resource type be healthcare_service as a user with the required permissions. 973 + """ 974 + healthcare_service = self.create_healthcare_service(facility=self.facility) 975 + healthcare_service_resource = self.create_schedule_resource( 976 + facility=self.facility, 977 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 978 + healthcare_service=healthcare_service, 979 + ) 980 + token_queue = self.create_token_queue( 981 + facility=self.facility, 982 + name="Initial Token Queue", 983 + date=(timezone.now() + timedelta(days=1)).date(), 984 + resource=healthcare_service_resource, 985 + is_primary=True, 986 + ) 987 + self.client.force_authenticate(user=self.user) 988 + self.attach_role_facility_organization_user( 989 + user=self.user, 990 + role=self.role, 991 + facility_organization=self.facility_organization, 992 + ) 993 + response = self.client.delete( 994 + self.generate_detail_url( 995 + facility_external_id=self.facility.external_id, 996 + external_id=token_queue.external_id, 997 + ) 998 + ) 999 + self.assertEqual(response.status_code, 204) 1000 + get_response = self.client.get( 1001 + self.generate_detail_url( 1002 + facility_external_id=self.facility.external_id, 1003 + external_id=token_queue.external_id, 1004 + ) 1005 + ) 1006 + self.assertEqual(get_response.status_code, 404) 1007 + self.assertIn( 1008 + "No TokenQueue matches the given query.", 1009 + str(get_response.data["errors"][0]["msg"]), 1010 + ) 1011 + 1012 + def test_delete_token_queue_with_resource_type_be_healthcare_service_as_user_without_write_permissions( 1013 + self, 1014 + ): 1015 + """ 1016 + Test deleting a token queue with resource type be healthcare_service as a user without 'can_write_token' permissions. 1017 + But is a part of facility organization. 1018 + """ 1019 + healthcare_service = self.create_healthcare_service(facility=self.facility) 1020 + healthcare_service_resource = self.create_schedule_resource( 1021 + facility=self.facility, 1022 + resource_type=SchedulableResourceTypeOptions.healthcare_service.value, 1023 + healthcare_service=healthcare_service, 1024 + ) 1025 + token_queue = self.create_token_queue( 1026 + facility=self.facility, 1027 + name="Initial Token Queue", 1028 + date=(timezone.now() + timedelta(days=1)).date(), 1029 + resource=healthcare_service_resource, 1030 + is_primary=True, 1031 + ) 1032 + role = self.create_role_with_permissions( 1033 + permissions=[ 1034 + TokenPermissions.can_list_token.name, 1035 + ], 1036 + ) 1037 + self.attach_role_facility_organization_user( 1038 + user=self.user, role=role, facility_organization=self.facility_organization 1039 + ) 1040 + self.client.force_authenticate(user=self.user) 1041 + response = self.client.delete( 1042 + self.generate_detail_url( 1043 + facility_external_id=self.facility.external_id, 1044 + external_id=token_queue.external_id, 1045 + ) 1046 + ) 1047 + self.assertEqual(response.status_code, 403) 1048 + self.assertIn( 1049 + "You do not have permission to update token queue", str(response.data) 1050 + ) 1051 + 1052 + def test_delete_token_queue_with_resource_type_be_location_as_superuser(self): 1053 + """ 1054 + Test deleting a token queue with resource type be location as superuser. 1055 + """ 1056 + location_resource = self.create_schedule_resource( 1057 + facility=self.facility, 1058 + resource_type=SchedulableResourceTypeOptions.location.value, 1059 + location=self.facility_location, 1060 + ) 1061 + token_queue = self.create_token_queue( 1062 + facility=self.facility, 1063 + name="Initial Token Queue", 1064 + date=(timezone.now() + timedelta(days=1)).date(), 1065 + resource=location_resource, 1066 + is_primary=True, 1067 + ) 1068 + self.client.force_authenticate(user=self.superuser) 1069 + response = self.client.delete( 1070 + self.generate_detail_url( 1071 + facility_external_id=self.facility.external_id, 1072 + external_id=token_queue.external_id, 1073 + ) 1074 + ) 1075 + self.assertEqual(response.status_code, 204) 1076 + get_response = self.client.get( 1077 + self.generate_detail_url( 1078 + facility_external_id=self.facility.external_id, 1079 + external_id=token_queue.external_id, 1080 + ) 1081 + ) 1082 + self.assertEqual(get_response.status_code, 404) 1083 + self.assertIn( 1084 + "No TokenQueue matches the given query.", 1085 + str(get_response.data["errors"][0]["msg"]), 1086 + ) 1087 + 1088 + def test_delete_token_queue_with_resource_type_be_location_as_user_with_permissions( 1089 + self, 1090 + ): 1091 + """ 1092 + Test deleting a token queue with resource type be location as a user with the required permissions. 1093 + """ 1094 + location_resource = self.create_schedule_resource( 1095 + facility=self.facility, 1096 + resource_type=SchedulableResourceTypeOptions.location.value, 1097 + location=self.facility_location, 1098 + ) 1099 + token_queue = self.create_token_queue( 1100 + facility=self.facility, 1101 + name="Initial Token Queue", 1102 + date=(timezone.now() + timedelta(days=1)).date(), 1103 + resource=location_resource, 1104 + is_primary=True, 1105 + ) 1106 + self.client.force_authenticate(user=self.user) 1107 + self.attach_role_facility_organization_user( 1108 + user=self.user, 1109 + role=self.role, 1110 + facility_organization=self.facility_organization, 1111 + ) 1112 + response = self.client.delete( 1113 + self.generate_detail_url( 1114 + facility_external_id=self.facility.external_id, 1115 + external_id=token_queue.external_id, 1116 + ) 1117 + ) 1118 + self.assertEqual(response.status_code, 204) 1119 + get_response = self.client.get( 1120 + self.generate_detail_url( 1121 + facility_external_id=self.facility.external_id, 1122 + external_id=token_queue.external_id, 1123 + ) 1124 + ) 1125 + self.assertEqual(get_response.status_code, 404) 1126 + self.assertIn( 1127 + "No TokenQueue matches the given query.", 1128 + str(get_response.data["errors"][0]["msg"]), 1129 + ) 1130 + 1131 + def test_delete_token_queue_with_resource_type_be_location_as_user_without_write_permissions( 1132 + self, 1133 + ): 1134 + """ 1135 + Test deleting a token queue with resource type be location as a user without 'can_write_token' permissions. 1136 + But is a part of facility organization. 1137 + """ 1138 + location_resource = self.create_schedule_resource( 1139 + facility=self.facility, 1140 + resource_type=SchedulableResourceTypeOptions.location.value, 1141 + location=self.facility_location, 1142 + ) 1143 + token_queue = self.create_token_queue( 1144 + facility=self.facility, 1145 + name="Initial Token Queue", 1146 + date=(timezone.now() + timedelta(days=1)).date(), 1147 + resource=location_resource, 1148 + is_primary=True, 1149 + ) 1150 + role = self.create_role_with_permissions( 1151 + permissions=[ 1152 + TokenPermissions.can_list_token.name, 1153 + ], 1154 + ) 1155 + self.attach_role_facility_organization_user( 1156 + user=self.user, role=role, facility_organization=self.facility_organization 1157 + ) 1158 + self.client.force_authenticate(user=self.user) 1159 + response = self.client.delete( 1160 + self.generate_detail_url( 1161 + facility_external_id=self.facility.external_id, 1162 + external_id=token_queue.external_id, 1163 + ) 1164 + ) 1165 + self.assertEqual(response.status_code, 403) 1166 + self.assertIn( 1167 + "You do not have permission to update token queue", str(response.data) 1168 + ) 1169 + 1170 + # tests for retrieve token queue 1171 + 1172 + def test_retrieve_token_queue_as_superuser(self): 1173 + """ 1174 + Test retrieving a token queue as superuser. 1175 + """ 1176 + token_queue = self.create_token_queue( 1177 + facility=self.facility, 1178 + name="Initial Token Queue", 1179 + date=(timezone.now() + timedelta(days=1)).date(), 1180 + resource=self.superuser_resource, 1181 + is_primary=True, 1182 + ) 1183 + self.client.force_authenticate(user=self.superuser) 1184 + response = self.client.get( 1185 + self.generate_detail_url( 1186 + facility_external_id=self.facility.external_id, 1187 + external_id=token_queue.external_id, 1188 + ) 1189 + ) 1190 + self.assertEqual(response.status_code, 200) 1191 + self.assertEqual(response.data["id"], str(token_queue.external_id)) 1192 + self.assertEqual(response.data["name"], token_queue.name) 1193 + 1194 + def test_retrieve_token_queue_as_user_with_permissions(self): 1195 + """ 1196 + Test retrieving a token queue as a user with the required permissions. 1197 + """ 1198 + user_resource = self.create_schedule_resource( 1199 + facility=self.facility, 1200 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1201 + user=self.user, 1202 + ) 1203 + token_queue = self.create_token_queue( 1204 + facility=self.facility, 1205 + name="Initial Token Queue", 1206 + date=(timezone.now() + timedelta(days=1)).date(), 1207 + resource=user_resource, 1208 + is_primary=True, 1209 + ) 1210 + self.client.force_authenticate(user=self.user) 1211 + self.attach_role_facility_organization_user( 1212 + user=self.user, 1213 + role=self.role, 1214 + facility_organization=self.facility_organization, 1215 + ) 1216 + response = self.client.get( 1217 + self.generate_detail_url( 1218 + facility_external_id=self.facility.external_id, 1219 + external_id=token_queue.external_id, 1220 + ) 1221 + ) 1222 + self.assertEqual(response.status_code, 200) 1223 + self.assertEqual(response.data["id"], str(token_queue.external_id)) 1224 + self.assertEqual(response.data["name"], token_queue.name) 1225 + 1226 + def test_retrieve_token_queue_as_user_without_permissions(self): 1227 + """ 1228 + Test retrieving a token queue as a user without the required permissions. 1229 + """ 1230 + user_resource = self.create_schedule_resource( 1231 + facility=self.facility, 1232 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1233 + user=self.user, 1234 + ) 1235 + token_queue = self.create_token_queue( 1236 + facility=self.facility, 1237 + name="Initial Token Queue", 1238 + date=(timezone.now() + timedelta(days=1)).date(), 1239 + resource=user_resource, 1240 + is_primary=True, 1241 + ) 1242 + self.client.force_authenticate(user=self.user) 1243 + response = self.client.get( 1244 + self.generate_detail_url( 1245 + facility_external_id=self.facility.external_id, 1246 + external_id=token_queue.external_id, 1247 + ) 1248 + ) 1249 + self.assertEqual(response.status_code, 403) 1250 + self.assertIn( 1251 + "You do not have permission to list token queue", str(response.data) 1252 + ) 1253 + 1254 + # tests for list token queue 1255 + 1256 + def test_list_token_queues_with_resource_type_be_practitioner_as_superuser(self): 1257 + """ 1258 + Test listing token queues with resource_type as practitioner for superuser. 1259 + """ 1260 + token_queue1 = self.create_token_queue( 1261 + facility=self.facility, 1262 + name="Token Queue 1", 1263 + date=(timezone.now() + timedelta(days=1)).date(), 1264 + resource=self.superuser_resource, 1265 + is_primary=True, 1266 + ) 1267 + token_queue2 = self.create_token_queue( 1268 + facility=self.facility, 1269 + name="Token Queue 2", 1270 + date=(timezone.now() + timedelta(days=2)).date(), 1271 + resource=self.superuser_resource, 1272 + is_primary=False, 1273 + ) 1274 + self.client.force_authenticate(user=self.superuser) 1275 + response = self.client.get( 1276 + self.base_url, 1277 + { 1278 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1279 + "resource_id": self.superuser.external_id, 1280 + }, 1281 + ) 1282 + self.assertEqual(response.status_code, 200) 1283 + returned_ids = {item["id"] for item in response.data["results"]} 1284 + self.assertIn(str(token_queue1.external_id), returned_ids) 1285 + self.assertIn(str(token_queue2.external_id), returned_ids) 1286 + 1287 + def test_list_token_queues_as_user_with_permissions(self): 1288 + """ 1289 + Test listing token queues as a user with the required permissions. 1290 + """ 1291 + user_resource = self.create_schedule_resource( 1292 + facility=self.facility, 1293 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1294 + user=self.user, 1295 + ) 1296 + self.attach_role_facility_organization_user( 1297 + user=self.user, 1298 + role=self.role, 1299 + facility_organization=self.facility_organization, 1300 + ) 1301 + token_queue1 = self.create_token_queue( 1302 + facility=self.facility, 1303 + name="Token Queue 1", 1304 + date=(timezone.now() + timedelta(days=1)).date(), 1305 + resource=user_resource, 1306 + is_primary=True, 1307 + ) 1308 + token_queue2 = self.create_token_queue( 1309 + facility=self.facility, 1310 + name="Token Queue 2", 1311 + date=(timezone.now() + timedelta(days=2)).date(), 1312 + resource=user_resource, 1313 + is_primary=False, 1314 + ) 1315 + self.client.force_authenticate(user=self.user) 1316 + response = self.client.get( 1317 + self.base_url, 1318 + { 1319 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1320 + "resource_id": self.user.external_id, 1321 + }, 1322 + ) 1323 + self.assertEqual(response.status_code, 200) 1324 + returned_ids = {item["id"] for item in response.data["results"]} 1325 + self.assertIn(str(token_queue1.external_id), returned_ids) 1326 + self.assertIn(str(token_queue2.external_id), returned_ids) 1327 + 1328 + def test_list_token_queues_as_user_without_permissions(self): 1329 + """ 1330 + Test listing token queues as a user without the required permissions. 1331 + """ 1332 + user_resource = self.create_schedule_resource( 1333 + facility=self.facility, 1334 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1335 + user=self.user, 1336 + ) 1337 + role = self.create_role_with_permissions( 1338 + permissions=[ 1339 + TokenPermissions.can_write_token.name, 1340 + ] 1341 + ) 1342 + self.attach_role_facility_organization_user( 1343 + user=self.user, 1344 + role=role, 1345 + facility_organization=self.facility_organization, 1346 + ) 1347 + 1348 + self.create_token_queue( 1349 + facility=self.facility, 1350 + name="Token Queue 1", 1351 + date=(timezone.now() + timedelta(days=1)).date(), 1352 + resource=user_resource, 1353 + is_primary=True, 1354 + ) 1355 + self.create_token_queue( 1356 + facility=self.facility, 1357 + name="Token Queue 2", 1358 + date=(timezone.now() + timedelta(days=2)).date(), 1359 + resource=user_resource, 1360 + is_primary=False, 1361 + ) 1362 + self.client.force_authenticate(user=self.user) 1363 + response = self.client.get( 1364 + self.base_url, 1365 + { 1366 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1367 + "resource_id": self.user.external_id, 1368 + }, 1369 + ) 1370 + self.assertEqual(response.status_code, 403) 1371 + self.assertIn( 1372 + "You do not have permission to list token queue", str(response.data) 1373 + ) 1374 + 1375 + def test_list_token_queues_without_resource_type_and_resource_id(self): 1376 + """ 1377 + Test listing token queues without resource_type and resource_id. 1378 + """ 1379 + self.client.force_authenticate(user=self.superuser) 1380 + response = self.client.get(self.base_url) 1381 + self.assertEqual(response.status_code, 400) 1382 + self.assertIn( 1383 + "resource_type and resource_id is required", 1384 + str(response.data), 1385 + ) 1386 + 1387 + def test_list_token_queues_without_resource(self): 1388 + """ 1389 + Test listing token queues for a resource with no token queues. 1390 + """ 1391 + self.attach_role_facility_organization_user( 1392 + user=self.user, 1393 + role=self.role, 1394 + facility_organization=self.facility_organization, 1395 + ) 1396 + self.client.force_authenticate(user=self.user) 1397 + response = self.client.get( 1398 + self.base_url, 1399 + { 1400 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1401 + "resource_id": self.user.external_id, 1402 + }, 1403 + ) 1404 + self.assertEqual(response.status_code, 200) 1405 + self.assertEqual(len(response.data["results"]), 0) 1406 + 1407 + def test_list_token_queue_with_name_filter(self): 1408 + """ 1409 + Test listing token queues with a name filter. 1410 + """ 1411 + user_resource = self.create_schedule_resource( 1412 + facility=self.facility, 1413 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1414 + user=self.user, 1415 + ) 1416 + self.attach_role_facility_organization_user( 1417 + user=self.user, 1418 + role=self.role, 1419 + facility_organization=self.facility_organization, 1420 + ) 1421 + token_queue1 = self.create_token_queue( 1422 + facility=self.facility, 1423 + name="Token Queue 1", 1424 + date=(timezone.now() + timedelta(days=1)).date(), 1425 + resource=user_resource, 1426 + is_primary=True, 1427 + ) 1428 + self.create_token_queue( 1429 + facility=self.facility, 1430 + name="Token Queue 2", 1431 + date=(timezone.now() + timedelta(days=2)).date(), 1432 + resource=user_resource, 1433 + is_primary=False, 1434 + ) 1435 + self.client.force_authenticate(user=self.user) 1436 + response = self.client.get( 1437 + self.base_url, 1438 + { 1439 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1440 + "resource_id": self.user.external_id, 1441 + "name": "Token Queue 1", 1442 + }, 1443 + ) 1444 + self.assertEqual(response.status_code, 200) 1445 + self.assertEqual(len(response.data["results"]), 1) 1446 + self.assertEqual( 1447 + response.data["results"][0]["id"], str(token_queue1.external_id) 1448 + ) 1449 + 1450 + def test_list_token_queue_with_date_filter(self): 1451 + """ 1452 + Test listing token queues with a date filter. 1453 + """ 1454 + user_resource = self.create_schedule_resource( 1455 + facility=self.facility, 1456 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1457 + user=self.user, 1458 + ) 1459 + self.attach_role_facility_organization_user( 1460 + user=self.user, 1461 + role=self.role, 1462 + facility_organization=self.facility_organization, 1463 + ) 1464 + token_queue1 = self.create_token_queue( 1465 + facility=self.facility, 1466 + name="Token Queue 1", 1467 + date=(timezone.now() + timedelta(days=1)).date(), 1468 + resource=user_resource, 1469 + is_primary=True, 1470 + ) 1471 + self.create_token_queue( 1472 + facility=self.facility, 1473 + name="Token Queue 2", 1474 + date=(timezone.now() + timedelta(days=2)).date(), 1475 + resource=user_resource, 1476 + is_primary=False, 1477 + ) 1478 + self.client.force_authenticate(user=self.user) 1479 + filter_date = (timezone.now() + timedelta(days=1)).date().isoformat() 1480 + response = self.client.get( 1481 + self.base_url, 1482 + { 1483 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1484 + "resource_id": self.user.external_id, 1485 + "date": filter_date, 1486 + }, 1487 + ) 1488 + self.assertEqual(response.status_code, 200) 1489 + self.assertEqual(len(response.data["results"]), 1) 1490 + self.assertEqual( 1491 + response.data["results"][0]["id"], str(token_queue1.external_id) 1492 + ) 1493 + 1494 + # Test cases for is primary field behavior 1495 + 1496 + def test_create_token_queue_sets_is_primary_true_as_superuser(self): 1497 + """ 1498 + Test that creating a token queue the primary queue with an existing queue as primary. 1499 + """ 1500 + self.client.force_authenticate(user=self.superuser) 1501 + token_queue1 = self.create_token_queue( 1502 + facility=self.facility, 1503 + name="Token Queue 1", 1504 + date=(timezone.now() + timedelta(days=1)).date(), 1505 + resource=self.superuser_resource, 1506 + is_primary=True, 1507 + ) 1508 + token_queue2 = self.create_token_queue( 1509 + facility=self.facility, 1510 + name="Token Queue 2", 1511 + date=(timezone.now() + timedelta(days=1)).date(), 1512 + resource=self.superuser_resource, 1513 + is_primary=False, 1514 + ) 1515 + self.url = reverse( 1516 + "token-queue-set-primary", 1517 + kwargs={ 1518 + "facility_external_id": self.facility.external_id, 1519 + "external_id": token_queue2.external_id, 1520 + }, 1521 + ) 1522 + self.client.force_authenticate(user=self.superuser) 1523 + response = self.client.post(self.url) 1524 + self.assertEqual(response.status_code, 200) 1525 + token_queue1.refresh_from_db() 1526 + token_queue2.refresh_from_db() 1527 + self.assertFalse(token_queue1.is_primary) 1528 + self.assertTrue(token_queue2.is_primary) 1529 + 1530 + def test_create_token_queue_sets_is_primary_true_as_user_with_permissions(self): 1531 + """ 1532 + Test that creating a token queue the primary queue with an existing queue as primary by a user with permissions. 1533 + """ 1534 + user_resource = self.create_schedule_resource( 1535 + facility=self.facility, 1536 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1537 + user=self.user, 1538 + ) 1539 + token_queue1 = self.create_token_queue( 1540 + facility=self.facility, 1541 + name="Token Queue 1", 1542 + date=(timezone.now() + timedelta(days=1)).date(), 1543 + resource=user_resource, 1544 + is_primary=True, 1545 + ) 1546 + token_queue2 = self.create_token_queue( 1547 + facility=self.facility, 1548 + name="Token Queue 2", 1549 + date=(timezone.now() + timedelta(days=1)).date(), 1550 + resource=user_resource, 1551 + is_primary=False, 1552 + ) 1553 + self.attach_role_facility_organization_user( 1554 + user=self.user, 1555 + role=self.role, 1556 + facility_organization=self.facility_organization, 1557 + ) 1558 + self.url = reverse( 1559 + "token-queue-set-primary", 1560 + kwargs={ 1561 + "facility_external_id": self.facility.external_id, 1562 + "external_id": token_queue2.external_id, 1563 + }, 1564 + ) 1565 + self.client.force_authenticate(user=self.user) 1566 + response = self.client.post(self.url) 1567 + self.assertEqual(response.status_code, 200) 1568 + token_queue1.refresh_from_db() 1569 + token_queue2.refresh_from_db() 1570 + self.assertFalse(token_queue1.is_primary) 1571 + self.assertTrue(token_queue2.is_primary) 1572 + 1573 + def test_create_token_queue_sets_is_primary_true_as_user_without_permissions(self): 1574 + """ 1575 + Test that creating a token queue the primary queue with an existing queue as primary by a user without permissions. 1576 + """ 1577 + user_resource = self.create_schedule_resource( 1578 + facility=self.facility, 1579 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1580 + user=self.user, 1581 + ) 1582 + token_queue1 = self.create_token_queue( 1583 + facility=self.facility, 1584 + name="Token Queue 1", 1585 + date=(timezone.now() + timedelta(days=1)).date(), 1586 + resource=user_resource, 1587 + is_primary=True, 1588 + ) 1589 + token_queue2 = self.create_token_queue( 1590 + facility=self.facility, 1591 + name="Token Queue 2", 1592 + date=(timezone.now() + timedelta(days=1)).date(), 1593 + resource=user_resource, 1594 + is_primary=False, 1595 + ) 1596 + self.url = reverse( 1597 + "token-queue-set-primary", 1598 + kwargs={ 1599 + "facility_external_id": self.facility.external_id, 1600 + "external_id": token_queue2.external_id, 1601 + }, 1602 + ) 1603 + self.client.force_authenticate(user=self.user) 1604 + response = self.client.post(self.url) 1605 + self.assertEqual(response.status_code, 403) 1606 + token_queue1.refresh_from_db() 1607 + token_queue2.refresh_from_db() 1608 + self.assertTrue(token_queue1.is_primary) 1609 + self.assertFalse(token_queue2.is_primary) 1610 + 1611 + # Tests for generate summary endpoint 1612 + 1613 + def test_generate_summary_for_token_as_superuser(self): 1614 + """ 1615 + Test generating summary for tokens as superuser. 1616 + """ 1617 + token_category = self.create_token_category( 1618 + facility=self.facility, 1619 + name="General", 1620 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1621 + shorthand="GEN", 1622 + default=True, 1623 + ) 1624 + 1625 + token_queue = self.create_token_queue( 1626 + facility=self.facility, 1627 + name="Token Queue 1", 1628 + date=(timezone.now() + timedelta(days=1)).date(), 1629 + resource=self.superuser_resource, 1630 + is_primary=True, 1631 + ) 1632 + self.create_token( 1633 + facility=self.facility, 1634 + queue=token_queue, 1635 + category=token_category, 1636 + number=1, 1637 + status=TokenStatusOptions.CREATED.value, 1638 + ) 1639 + self.create_token( 1640 + facility=self.facility, 1641 + queue=token_queue, 1642 + category=token_category, 1643 + number=2, 1644 + status=TokenStatusOptions.IN_PROGRESS.value, 1645 + ) 1646 + self.create_token( 1647 + facility=self.facility, 1648 + queue=token_queue, 1649 + category=token_category, 1650 + number=3, 1651 + status=TokenStatusOptions.FULFILLED.value, 1652 + ) 1653 + self.client.force_authenticate(user=self.superuser) 1654 + url = reverse( 1655 + "token-queue-summary", 1656 + kwargs={ 1657 + "facility_external_id": self.facility.external_id, 1658 + "external_id": token_queue.external_id, 1659 + }, 1660 + ) 1661 + response = self.client.get(url) 1662 + self.assertEqual(response.status_code, 200) 1663 + self.assertIn("General", response.data) 1664 + category_summary = response.data["General"] 1665 + self.assertEqual(category_summary["CREATED"], 1) 1666 + self.assertEqual(category_summary["IN_PROGRESS"], 1) 1667 + self.assertEqual(category_summary["FULFILLED"], 1) 1668 + 1669 + def test_generate_summary_for_token_as_user_with_permission(self): 1670 + """ 1671 + Test generating summary for tokens as a user with the required permissions. 1672 + """ 1673 + token_category = self.create_token_category( 1674 + facility=self.facility, 1675 + name="General", 1676 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1677 + shorthand="GEN", 1678 + default=True, 1679 + ) 1680 + 1681 + user_resource = self.create_schedule_resource( 1682 + facility=self.facility, 1683 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1684 + user=self.user, 1685 + ) 1686 + 1687 + token_queue = self.create_token_queue( 1688 + facility=self.facility, 1689 + name="Token Queue 1", 1690 + date=(timezone.now() + timedelta(days=1)).date(), 1691 + resource=user_resource, 1692 + is_primary=True, 1693 + ) 1694 + self.create_token( 1695 + facility=self.facility, 1696 + queue=token_queue, 1697 + category=token_category, 1698 + number=1, 1699 + status=TokenStatusOptions.CREATED.value, 1700 + ) 1701 + self.create_token( 1702 + facility=self.facility, 1703 + queue=token_queue, 1704 + category=token_category, 1705 + number=2, 1706 + status=TokenStatusOptions.IN_PROGRESS.value, 1707 + ) 1708 + self.create_token( 1709 + facility=self.facility, 1710 + queue=token_queue, 1711 + category=token_category, 1712 + number=3, 1713 + status=TokenStatusOptions.FULFILLED.value, 1714 + ) 1715 + self.attach_role_facility_organization_user( 1716 + user=self.user, 1717 + role=self.role, 1718 + facility_organization=self.facility_organization, 1719 + ) 1720 + self.client.force_authenticate(user=self.user) 1721 + url = reverse( 1722 + "token-queue-summary", 1723 + kwargs={ 1724 + "facility_external_id": self.facility.external_id, 1725 + "external_id": token_queue.external_id, 1726 + }, 1727 + ) 1728 + response = self.client.get(url) 1729 + self.assertEqual(response.status_code, 200) 1730 + self.assertIn("General", response.data) 1731 + category_summary = response.data["General"] 1732 + self.assertEqual(category_summary["CREATED"], 1) 1733 + self.assertEqual(category_summary["IN_PROGRESS"], 1) 1734 + self.assertEqual(category_summary["FULFILLED"], 1) 1735 + 1736 + def test_generate_summary_for_token_as_user_without_permission(self): 1737 + """ 1738 + Test generating summary for tokens as a user without the required permissions. 1739 + """ 1740 + token_category = self.create_token_category( 1741 + facility=self.facility, 1742 + name="General", 1743 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1744 + shorthand="GEN", 1745 + default=True, 1746 + ) 1747 + 1748 + user_resource = self.create_schedule_resource( 1749 + facility=self.facility, 1750 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1751 + user=self.user, 1752 + ) 1753 + 1754 + token_queue = self.create_token_queue( 1755 + facility=self.facility, 1756 + name="Token Queue 1", 1757 + date=(timezone.now() + timedelta(days=1)).date(), 1758 + resource=user_resource, 1759 + is_primary=True, 1760 + ) 1761 + self.create_token( 1762 + facility=self.facility, 1763 + queue=token_queue, 1764 + category=token_category, 1765 + number=1, 1766 + status=TokenStatusOptions.CREATED.value, 1767 + ) 1768 + self.create_token( 1769 + facility=self.facility, 1770 + queue=token_queue, 1771 + category=token_category, 1772 + number=2, 1773 + status=TokenStatusOptions.IN_PROGRESS.value, 1774 + ) 1775 + self.create_token( 1776 + facility=self.facility, 1777 + queue=token_queue, 1778 + category=token_category, 1779 + number=3, 1780 + status=TokenStatusOptions.FULFILLED.value, 1781 + ) 1782 + self.client.force_authenticate(user=self.user) 1783 + url = reverse( 1784 + "token-queue-summary", 1785 + kwargs={ 1786 + "facility_external_id": self.facility.external_id, 1787 + "external_id": token_queue.external_id, 1788 + }, 1789 + ) 1790 + response = self.client.get(url) 1791 + self.assertEqual(response.status_code, 403) 1792 + self.assertIn( 1793 + "You do not have permission to list token queue", str(response.data) 1794 + ) 1795 + 1796 + 1797 + class TokenQueueAPIGenerateTokenTestCase(CareAPITestBase): 1798 + """ 1799 + Test case for generating tokens via the generate token endpoint. 1800 + 1801 + fields: 1802 + - patient: UUID4 1803 + - category: UUID4 1804 + - note: str 1805 + - sub_queue: UUID4 1806 + 1807 + - resource_type: SchedulableResourceTypeOptions 1808 + - resource_id: UUID4 1809 + - date: date 1810 + 1811 + 'can_write_token' permission is required to generate tokens. 1812 + 1813 + resource types supported: 1814 + - practitioner 1815 + - healthcare_service 1816 + - location 1817 + 1818 + """ 1819 + 1820 + def setUp(self): 1821 + self.user = self.create_user(username="testuser") 1822 + self.superuser = self.create_super_user(username="superuser") 1823 + self.facility = self.create_facility(user=self.superuser) 1824 + self.facility_organization = self.create_facility_organization( 1825 + facility=self.facility, org_type="root" 1826 + ) 1827 + self.facility_location = self.create_facility_location( 1828 + facility=self.facility, facility_organization=self.facility_organization 1829 + ) 1830 + self.superuser_resource = self.create_schedule_resource( 1831 + facility=self.facility, 1832 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1833 + user=self.superuser, 1834 + ) 1835 + self.patient = self.create_patient() 1836 + self.role = self.create_role_with_permissions( 1837 + permissions=[ 1838 + TokenPermissions.can_list_token.name, 1839 + TokenPermissions.can_write_token.name, 1840 + ], 1841 + ) 1842 + 1843 + self.token_category = self.create_token_category( 1844 + name="General", 1845 + facility=self.facility, 1846 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 1847 + shorthand="GEN", 1848 + default=True, 1849 + ) 1850 + self.base_url = reverse( 1851 + "token-queue-generate-token", 1852 + kwargs={"facility_external_id": self.facility.external_id}, 1853 + ) 1854 + 1855 + def create_facility_location(self, facility, facility_organization, **kwargs): 1856 + from care.emr.models import FacilityLocation, FacilityLocationOrganization 1857 + 1858 + location = baker.make(FacilityLocation, facility=facility, **kwargs) 1859 + baker.make( 1860 + FacilityLocationOrganization, 1861 + location=location, 1862 + organization=facility_organization, 1863 + ) 1864 + return location 1865 + 1866 + def create_token_category(self, facility, **kwargs): 1867 + return baker.make(TokenCategory, facility=facility, **kwargs) 1868 + 1869 + def create_schedule_resource(self, **kwargs): 1870 + return baker.make("emr.SchedulableResource", **kwargs) 1871 + 1872 + def create_healthcare_service(self, facility, **kwargs): 1873 + return baker.make(HealthcareService, facility=facility, **kwargs) 1874 + 1875 + def create_token_queue(self, facility, **kwargs): 1876 + return baker.make(TokenQueue, facility=facility, **kwargs) 1877 + 1878 + def test_generate_token_for_resource_type_be_practitioner_as_superuser(self): 1879 + """ 1880 + Test generating a token for resource type 'practitioner' as superuser. 1881 + """ 1882 + 1883 + self.client.force_authenticate(user=self.superuser) 1884 + response = self.client.post( 1885 + self.base_url, 1886 + { 1887 + "patient": str(self.patient.external_id), 1888 + "category": str(self.token_category.external_id), 1889 + "note": "Test token note", 1890 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1891 + "resource_id": str(self.superuser.external_id), 1892 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 1893 + }, 1894 + format="json", 1895 + ) 1896 + self.assertEqual(response.status_code, 200) 1897 + self.assertEqual(response.data["note"], "Test token note") 1898 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 1899 + self.assertEqual(response.data["number"], 1) 1900 + 1901 + def test_generate_token_for_resource_type_be_practitioner_as_user_with_permissions( 1902 + self, 1903 + ): 1904 + """ 1905 + Test generating a token for resource type 'practitioner' as a user with the required permissions. 1906 + """ 1907 + self.attach_role_facility_organization_user( 1908 + user=self.user, 1909 + role=self.role, 1910 + facility_organization=self.facility_organization, 1911 + ) 1912 + self.client.force_authenticate(user=self.user) 1913 + response = self.client.post( 1914 + self.base_url, 1915 + { 1916 + "patient": str(self.patient.external_id), 1917 + "category": str(self.token_category.external_id), 1918 + "note": "Test token note", 1919 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1920 + "resource_id": str(self.user.external_id), 1921 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 1922 + }, 1923 + format="json", 1924 + ) 1925 + self.assertEqual(response.status_code, 200) 1926 + self.assertEqual(response.data["note"], "Test token note") 1927 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 1928 + self.assertEqual(response.data["number"], 1) 1929 + 1930 + def test_generate_token_for_resource_type_be_practitioner_as_user_without_permissions( 1931 + self, 1932 + ): 1933 + """ 1934 + Test generating a token for resource type 'practitioner' as a user without the 'can_write_token' permissions. 1935 + But the user is part of the facility organization. 1936 + """ 1937 + role = self.create_role_with_permissions( 1938 + permissions=[ 1939 + TokenPermissions.can_list_token.name, 1940 + ], 1941 + ) 1942 + self.attach_role_facility_organization_user( 1943 + user=self.user, role=role, facility_organization=self.facility_organization 1944 + ) 1945 + self.client.force_authenticate(user=self.user) 1946 + response = self.client.post( 1947 + self.base_url, 1948 + { 1949 + "patient": str(self.patient.external_id), 1950 + "category": str(self.token_category.external_id), 1951 + "note": "Test token note", 1952 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1953 + "resource_id": str(self.user.external_id), 1954 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 1955 + }, 1956 + format="json", 1957 + ) 1958 + self.assertEqual(response.status_code, 403) 1959 + self.assertIn( 1960 + "You do not have permission to create token queue", str(response.data) 1961 + ) 1962 + 1963 + def test_generate_token_for_resource_type_be_practitioner_as_user_not_in_facility_organization( 1964 + self, 1965 + ): 1966 + """ 1967 + Test generating a token for resource type 'practitioner' as a user without the 'can_write_token' permissions. 1968 + And the user is not part of the facility organization. 1969 + """ 1970 + self.client.force_authenticate(user=self.user) 1971 + response = self.client.post( 1972 + self.base_url, 1973 + { 1974 + "patient": str(self.patient.external_id), 1975 + "category": str(self.token_category.external_id), 1976 + "note": "Test token note", 1977 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1978 + "resource_id": str(self.user.external_id), 1979 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 1980 + }, 1981 + format="json", 1982 + ) 1983 + self.assertEqual(response.status_code, 400) 1984 + self.assertIn("Schedule User is not part of the facility", str(response.data)) 1985 + 1986 + def test_generate_token_creates_primary_queue_if_not_exists(self): 1987 + """ 1988 + Test that generating a token creates a primary token queue if it does not exist. 1989 + """ 1990 + self.client.force_authenticate(user=self.superuser) 1991 + response = self.client.post( 1992 + self.base_url, 1993 + { 1994 + "patient": str(self.patient.external_id), 1995 + "category": str(self.token_category.external_id), 1996 + "note": "Test token note", 1997 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 1998 + "resource_id": str(self.superuser.external_id), 1999 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2000 + }, 2001 + format="json", 2002 + ) 2003 + self.assertEqual(response.status_code, 200) 2004 + token_queue_id = response.data["queue"]["id"] 2005 + token_queue = TokenQueue.objects.get(external_id=token_queue_id) 2006 + self.assertTrue(token_queue.is_primary) 2007 + self.assertEqual(token_queue.resource, self.superuser_resource) 2008 + self.assertEqual(token_queue.date, (timezone.now() + timedelta(days=1)).date()) 2009 + self.assertEqual(token_queue.name, "System Generated") 2010 + self.assertTrue(token_queue.system_generated) 2011 + 2012 + def test_generate_token_creates_with_primary_queue(self): 2013 + """ 2014 + Test that generating a token uses the existing primary token queue. 2015 + """ 2016 + token_queue = self.create_token_queue( 2017 + facility=self.facility, 2018 + name="Primary Token Queue", 2019 + date=(timezone.now() + timedelta(days=1)).date(), 2020 + resource=self.superuser_resource, 2021 + is_primary=True, 2022 + ) 2023 + self.client.force_authenticate(user=self.superuser) 2024 + response = self.client.post( 2025 + self.base_url, 2026 + { 2027 + "patient": str(self.patient.external_id), 2028 + "category": str(self.token_category.external_id), 2029 + "note": "Test token note", 2030 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 2031 + "resource_id": str(self.superuser.external_id), 2032 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2033 + }, 2034 + format="json", 2035 + ) 2036 + self.assertEqual(response.status_code, 200) 2037 + queue = response.data["queue"] 2038 + self.assertEqual(queue["id"], str(token_queue.external_id)) 2039 + self.assertTrue(queue["is_primary"]) 2040 + self.assertFalse(queue["system_generated"]) 2041 + 2042 + def test_generate_token_assigns_incremental_token_numbers(self): 2043 + """ 2044 + Test that generating multiple tokens assigns incremental token numbers within the same queue and category. 2045 + """ 2046 + self.client.force_authenticate(user=self.superuser) 2047 + for i in range(1, 6): 2048 + response = self.client.post( 2049 + self.base_url, 2050 + { 2051 + "patient": str(self.patient.external_id), 2052 + "category": str(self.token_category.external_id), 2053 + "note": f"Test token note {i}", 2054 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 2055 + "resource_id": str(self.superuser.external_id), 2056 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2057 + }, 2058 + format="json", 2059 + ) 2060 + self.assertEqual(response.status_code, 200) 2061 + self.assertEqual(response.data["number"], i) 2062 + self.assertEqual(response.data["note"], f"Test token note {i}") 2063 + 2064 + def test_generate_token_with_invalid_category(self): 2065 + """ 2066 + Test generating a token with an invalid category UUID. 2067 + """ 2068 + self.client.force_authenticate(user=self.superuser) 2069 + response = self.client.post( 2070 + self.base_url, 2071 + { 2072 + "patient": str(self.patient.external_id), 2073 + "category": str(uuid4()), # Invalid category 2074 + "note": "Test token note", 2075 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 2076 + "resource_id": str(self.superuser.external_id), 2077 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2078 + }, 2079 + format="json", 2080 + ) 2081 + self.assertEqual(response.status_code, 404) 2082 + self.assertIn("No TokenCategory matches the given query.", str(response.data)) 2083 + 2084 + def test_generate_token_with_invalid_patient(self): 2085 + """ 2086 + Test generating a token with an invalid patient UUID. 2087 + """ 2088 + self.client.force_authenticate(user=self.superuser) 2089 + response = self.client.post( 2090 + self.base_url, 2091 + { 2092 + "patient": str(uuid4()), # Invalid patient 2093 + "category": str(self.token_category.external_id), 2094 + "note": "Test token note", 2095 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 2096 + "resource_id": str(self.superuser.external_id), 2097 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2098 + }, 2099 + format="json", 2100 + ) 2101 + self.assertEqual(response.status_code, 404) 2102 + self.assertIn("No Patient matches the given query.", str(response.data)) 2103 + 2104 + def test_generate_token_without_patient(self): 2105 + """ 2106 + Test generating a token without providing a patient UUID. 2107 + """ 2108 + self.client.force_authenticate(user=self.superuser) 2109 + response = self.client.post( 2110 + self.base_url, 2111 + { 2112 + "category": str(self.token_category.external_id), 2113 + "note": "Test token note", 2114 + "resource_type": SchedulableResourceTypeOptions.practitioner.value, 2115 + "resource_id": str(self.superuser.external_id), 2116 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2117 + }, 2118 + format="json", 2119 + ) 2120 + self.assertEqual(response.status_code, 200) 2121 + self.assertEqual(response.data["note"], "Test token note") 2122 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 2123 + self.assertEqual(response.data["number"], 1) 2124 + 2125 + def test_generate_token_for_resource_type_be_healthcare_service_as_superuser(self): 2126 + """ 2127 + Test generating a token for resource type 'healthcare_service' as superuser. 2128 + """ 2129 + healthcare_service = self.create_healthcare_service( 2130 + facility=self.facility, 2131 + name="Test Healthcare Service", 2132 + ) 2133 + self.client.force_authenticate(user=self.superuser) 2134 + response = self.client.post( 2135 + self.base_url, 2136 + { 2137 + "patient": str(self.patient.external_id), 2138 + "category": str(self.token_category.external_id), 2139 + "note": "Test token note", 2140 + "resource_type": SchedulableResourceTypeOptions.healthcare_service.value, 2141 + "resource_id": str(healthcare_service.external_id), 2142 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2143 + }, 2144 + format="json", 2145 + ) 2146 + self.assertEqual(response.status_code, 200) 2147 + self.assertEqual(response.data["note"], "Test token note") 2148 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 2149 + self.assertEqual(response.data["number"], 1) 2150 + 2151 + def test_generate_token_for_resource_type_be_healthcare_service_as_user_with_permissions( 2152 + self, 2153 + ): 2154 + """ 2155 + Test generating a token for resource type 'healthcare_service' as a user with the required permissions. 2156 + """ 2157 + healthcare_service = self.create_healthcare_service( 2158 + facility=self.facility, 2159 + name="Test Healthcare Service", 2160 + ) 2161 + self.attach_role_facility_organization_user( 2162 + user=self.user, 2163 + role=self.role, 2164 + facility_organization=self.facility_organization, 2165 + ) 2166 + self.client.force_authenticate(user=self.user) 2167 + response = self.client.post( 2168 + self.base_url, 2169 + { 2170 + "patient": str(self.patient.external_id), 2171 + "category": str(self.token_category.external_id), 2172 + "note": "Test token note", 2173 + "resource_type": SchedulableResourceTypeOptions.healthcare_service.value, 2174 + "resource_id": str(healthcare_service.external_id), 2175 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2176 + }, 2177 + format="json", 2178 + ) 2179 + self.assertEqual(response.status_code, 200) 2180 + self.assertEqual(response.data["note"], "Test token note") 2181 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 2182 + self.assertEqual(response.data["number"], 1) 2183 + 2184 + def test_generate_token_for_resource_type_be_healthcare_service_as_user_without_permissions( 2185 + self, 2186 + ): 2187 + """ 2188 + Test generating a token for resource type 'healthcare_service' as a user without the 'can_write_token' permissions. 2189 + But the user is part of the facility organization. 2190 + """ 2191 + healthcare_service = self.create_healthcare_service( 2192 + facility=self.facility, 2193 + name="Test Healthcare Service", 2194 + ) 2195 + role = self.create_role_with_permissions( 2196 + permissions=[ 2197 + TokenPermissions.can_list_token.name, 2198 + ], 2199 + ) 2200 + self.attach_role_facility_organization_user( 2201 + user=self.user, role=role, facility_organization=self.facility_organization 2202 + ) 2203 + self.client.force_authenticate(user=self.user) 2204 + response = self.client.post( 2205 + self.base_url, 2206 + { 2207 + "patient": str(self.patient.external_id), 2208 + "category": str(self.token_category.external_id), 2209 + "note": "Test token note", 2210 + "resource_type": SchedulableResourceTypeOptions.healthcare_service.value, 2211 + "resource_id": str(healthcare_service.external_id), 2212 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2213 + }, 2214 + format="json", 2215 + ) 2216 + self.assertEqual(response.status_code, 403) 2217 + self.assertIn( 2218 + "You do not have permission to create token queue", str(response.data) 2219 + ) 2220 + 2221 + def test_generate_token_for_resource_type_be_healthcare_service_as_user_not_in_facility_organization( 2222 + self, 2223 + ): 2224 + """ 2225 + Test generating a token for resource type 'healthcare_service' as a user without the 'can_write_token' permissions. 2226 + And the user is not part of the facility organization. 2227 + """ 2228 + healthcare_service = self.create_healthcare_service( 2229 + facility=self.facility, 2230 + name="Test Healthcare Service", 2231 + ) 2232 + self.client.force_authenticate(user=self.user) 2233 + response = self.client.post( 2234 + self.base_url, 2235 + { 2236 + "patient": str(self.patient.external_id), 2237 + "category": str(self.token_category.external_id), 2238 + "note": "Test token note", 2239 + "resource_type": SchedulableResourceTypeOptions.healthcare_service.value, 2240 + "resource_id": str(healthcare_service.external_id), 2241 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2242 + }, 2243 + format="json", 2244 + ) 2245 + self.assertEqual(response.status_code, 403) 2246 + self.assertIn( 2247 + "You do not have permission to create token queue", str(response.data) 2248 + ) 2249 + 2250 + def test_generate_token_for_resource_type_be_healthcare_service_outside_facility_as_user( 2251 + self, 2252 + ): 2253 + """ 2254 + Test generating a token for resource type 'healthcare_service' with service outside the facility as user. 2255 + """ 2256 + another_facility = self.create_facility( 2257 + user=self.superuser, name="Another Facility" 2258 + ) 2259 + healthcare_service = self.create_healthcare_service( 2260 + facility=another_facility, 2261 + name="Outside Healthcare Service", 2262 + ) 2263 + self.attach_role_facility_organization_user( 2264 + user=self.user, 2265 + role=self.role, 2266 + facility_organization=self.facility_organization, 2267 + ) 2268 + self.client.force_authenticate(user=self.user) 2269 + response = self.client.post( 2270 + self.base_url, 2271 + { 2272 + "patient": str(self.patient.external_id), 2273 + "category": str(self.token_category.external_id), 2274 + "note": "Test token note", 2275 + "resource_type": SchedulableResourceTypeOptions.healthcare_service.value, 2276 + "resource_id": str(healthcare_service.external_id), 2277 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2278 + }, 2279 + format="json", 2280 + ) 2281 + self.assertEqual(response.status_code, 400) 2282 + self.assertIn( 2283 + "Healthcare Service is not part of the facility", str(response.data) 2284 + ) 2285 + 2286 + def test_generate_token_for_resource_type_be_location_as_superuser(self): 2287 + """ 2288 + Test generating a token for resource type 'location' as superuser. 2289 + """ 2290 + self.client.force_authenticate(user=self.superuser) 2291 + response = self.client.post( 2292 + self.base_url, 2293 + { 2294 + "patient": str(self.patient.external_id), 2295 + "category": str(self.token_category.external_id), 2296 + "note": "Test token note", 2297 + "resource_type": SchedulableResourceTypeOptions.location.value, 2298 + "resource_id": str(self.facility_location.external_id), 2299 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2300 + }, 2301 + format="json", 2302 + ) 2303 + self.assertEqual(response.status_code, 200) 2304 + self.assertEqual(response.data["note"], "Test token note") 2305 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 2306 + self.assertEqual(response.data["number"], 1) 2307 + 2308 + def test_generate_token_for_resource_type_be_location_as_user_with_permissions( 2309 + self, 2310 + ): 2311 + """ 2312 + Test generating a token for resource type 'location' as a user with the required permissions. 2313 + """ 2314 + self.attach_role_facility_organization_user( 2315 + user=self.user, 2316 + role=self.role, 2317 + facility_organization=self.facility_organization, 2318 + ) 2319 + self.client.force_authenticate(user=self.user) 2320 + response = self.client.post( 2321 + self.base_url, 2322 + { 2323 + "patient": str(self.patient.external_id), 2324 + "category": str(self.token_category.external_id), 2325 + "note": "Test token note", 2326 + "resource_type": SchedulableResourceTypeOptions.location.value, 2327 + "resource_id": str(self.facility_location.external_id), 2328 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2329 + }, 2330 + format="json", 2331 + ) 2332 + self.assertEqual(response.status_code, 200) 2333 + self.assertEqual(response.data["note"], "Test token note") 2334 + self.assertEqual(response.data["status"], TokenStatusOptions.CREATED.value) 2335 + self.assertEqual(response.data["number"], 1) 2336 + 2337 + def test_generate_token_for_resource_type_be_location_as_user_without_permissions( 2338 + self, 2339 + ): 2340 + """ 2341 + Test generating a token for resource type 'location' as a user without the 'can_write_token' permissions. 2342 + But the user is part of the facility organization. 2343 + """ 2344 + role = self.create_role_with_permissions( 2345 + permissions=[ 2346 + TokenPermissions.can_list_token.name, 2347 + ], 2348 + ) 2349 + self.attach_role_facility_organization_user( 2350 + user=self.user, role=role, facility_organization=self.facility_organization 2351 + ) 2352 + self.client.force_authenticate(user=self.user) 2353 + response = self.client.post( 2354 + self.base_url, 2355 + { 2356 + "patient": str(self.patient.external_id), 2357 + "category": str(self.token_category.external_id), 2358 + "note": "Test token note", 2359 + "resource_type": SchedulableResourceTypeOptions.location.value, 2360 + "resource_id": str(self.facility_location.external_id), 2361 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2362 + }, 2363 + format="json", 2364 + ) 2365 + self.assertEqual(response.status_code, 403) 2366 + self.assertIn( 2367 + "You do not have permission to create token queue", str(response.data) 2368 + ) 2369 + 2370 + def test_generate_token_for_resource_type_be_location_as_user_not_in_facility_organization( 2371 + self, 2372 + ): 2373 + """ 2374 + Test generating a token for resource type 'location' as a user without the 'can_write_token' permissions. 2375 + But the user is not part of the facility organization. 2376 + """ 2377 + self.client.force_authenticate(user=self.user) 2378 + response = self.client.post( 2379 + self.base_url, 2380 + { 2381 + "patient": str(self.patient.external_id), 2382 + "category": str(self.token_category.external_id), 2383 + "note": "Test token note", 2384 + "resource_type": SchedulableResourceTypeOptions.location.value, 2385 + "resource_id": str(self.facility_location.external_id), 2386 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2387 + }, 2388 + format="json", 2389 + ) 2390 + self.assertEqual(response.status_code, 403) 2391 + self.assertIn( 2392 + "You do not have permission to create token queue", str(response.data) 2393 + ) 2394 + 2395 + def test_generate_token_for_resource_type_be_location_outside_facility_organization_as_user( 2396 + self, 2397 + ): 2398 + """ 2399 + Test generating a token for resource type 'location' with location outside the facility organization as user. 2400 + """ 2401 + another_facility = self.create_facility( 2402 + user=self.superuser, name="Another Facility" 2403 + ) 2404 + another_facility_organization = self.create_facility_organization( 2405 + facility=another_facility, org_type="root" 2406 + ) 2407 + location = self.create_facility_location( 2408 + facility=another_facility, 2409 + facility_organization=another_facility_organization, 2410 + name="Outside Location", 2411 + ) 2412 + self.attach_role_facility_organization_user( 2413 + user=self.user, 2414 + role=self.role, 2415 + facility_organization=self.facility_organization, 2416 + ) 2417 + self.client.force_authenticate(user=self.user) 2418 + response = self.client.post( 2419 + self.base_url, 2420 + { 2421 + "patient": str(self.patient.external_id), 2422 + "category": str(self.token_category.external_id), 2423 + "note": "Test token note", 2424 + "resource_type": SchedulableResourceTypeOptions.location.value, 2425 + "resource_id": str(location.external_id), 2426 + "date": (timezone.now() + timedelta(days=1)).date().isoformat(), 2427 + }, 2428 + format="json", 2429 + ) 2430 + self.assertEqual(response.status_code, 400) 2431 + self.assertIn("Location is not part of the facility", str(response.data)) 2432 + 2433 + 2434 + class TokenQueueSetNextTokenToSubQueueTestCase(CareAPITestBase): 2435 + """ 2436 + Test case for setting the next token to a sub-queue via the sub-queue next token endpoint. 2437 + 2438 + fields: 2439 + - sub_queue: UUID4 2440 + - category: UUID4 2441 + 2442 + 'can_write_token' permission is required to set the next token to a sub-queue. 2443 + 2444 + Supported resource types: 2445 + 2446 + - practitioner 2447 + - healthcare_service 2448 + - location 2449 + 2450 + """ 2451 + 2452 + def setUp(self): 2453 + self.user = self.create_user(username="testuser") 2454 + self.superuser = self.create_super_user(username="superuser") 2455 + self.facility = self.create_facility(user=self.superuser) 2456 + self.facility_organization = self.create_facility_organization( 2457 + facility=self.facility, org_type="root" 2458 + ) 2459 + self.superuser_resource = self.create_schedule_resource( 2460 + facility=self.facility, 2461 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 2462 + user=self.superuser, 2463 + ) 2464 + self.role = self.create_role_with_permissions( 2465 + permissions=[ 2466 + TokenPermissions.can_list_token.name, 2467 + TokenPermissions.can_write_token.name, 2468 + ], 2469 + ) 2470 + 2471 + self.token_category = self.create_token_category( 2472 + name="General", 2473 + facility=self.facility, 2474 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 2475 + shorthand="GEN", 2476 + default=True, 2477 + ) 2478 + 2479 + def create_token_category(self, facility, **kwargs): 2480 + return baker.make(TokenCategory, facility=facility, **kwargs) 2481 + 2482 + def create_schedule_resource(self, **kwargs): 2483 + return baker.make("emr.SchedulableResource", **kwargs) 2484 + 2485 + def create_token_queue(self, facility, **kwargs): 2486 + return baker.make(TokenQueue, facility=facility, **kwargs) 2487 + 2488 + def create_token_sub_queue(self, facility, resource, **kwargs): 2489 + return baker.make(TokenSubQueue, facility=facility, resource=resource, **kwargs) 2490 + 2491 + def create_token(self, facility, **kwargs): 2492 + return baker.make(Token, facility=facility, **kwargs) 2493 + 2494 + def generate_url(self, facility_external_id, external_id): 2495 + return reverse( 2496 + "token-queue-set-next-token-to-subqueue", 2497 + kwargs={ 2498 + "facility_external_id": str(facility_external_id), 2499 + "external_id": str(external_id), 2500 + }, 2501 + ) 2502 + 2503 + def test_set_next_token_to_subqueue_as_superuser(self): 2504 + """ 2505 + Test setting the next token to a sub-queue as superuser. 2506 + 2507 + needs to create: 2508 + - token queue 2509 + - token sub-queue 2510 + - token 2511 + """ 2512 + token_queue = self.create_token_queue( 2513 + facility=self.facility, 2514 + name="Primary Token Queue", 2515 + date=(timezone.now() + timedelta(days=1)).date(), 2516 + resource=self.superuser_resource, 2517 + is_primary=True, 2518 + ) 2519 + sub_queue = self.create_token_sub_queue( 2520 + facility=self.facility, 2521 + resource=self.superuser_resource, 2522 + name="Sub Queue 1", 2523 + status="active", 2524 + ) 2525 + token = self.create_token( 2526 + facility=self.facility, 2527 + queue=token_queue, 2528 + category=self.token_category, 2529 + number=1, 2530 + status=TokenStatusOptions.CREATED.value, 2531 + ) 2532 + self.client.force_authenticate(user=self.superuser) 2533 + url = self.generate_url(self.facility.external_id, token_queue.external_id) 2534 + response = self.client.post( 2535 + url, 2536 + { 2537 + "sub_queue": str(sub_queue.external_id), 2538 + "category": str(self.token_category.external_id), 2539 + }, 2540 + format="json", 2541 + ) 2542 + self.assertEqual(response.status_code, 200) 2543 + sub_queue.refresh_from_db() 2544 + token.refresh_from_db() 2545 + self.assertEqual(sub_queue.current_token, token) 2546 + self.assertEqual(token.status, TokenStatusOptions.IN_PROGRESS.value) 2547 + 2548 + def test_set_next_token_to_subqueue_as_user_with_permissions(self): 2549 + """ 2550 + Test setting the next token to a sub-queue as a user with the required permissions. 2551 + 2552 + needs to create: 2553 + - token queue 2554 + - token sub-queue 2555 + - token 2556 + """ 2557 + self.attach_role_facility_organization_user( 2558 + user=self.user, 2559 + role=self.role, 2560 + facility_organization=self.facility_organization, 2561 + ) 2562 + user_resource = self.create_schedule_resource( 2563 + facility=self.facility, 2564 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 2565 + user=self.user, 2566 + ) 2567 + token_queue = self.create_token_queue( 2568 + facility=self.facility, 2569 + name="Primary Token Queue", 2570 + date=(timezone.now() + timedelta(days=1)).date(), 2571 + resource=user_resource, 2572 + is_primary=True, 2573 + ) 2574 + sub_queue = self.create_token_sub_queue( 2575 + facility=self.facility, 2576 + resource=user_resource, 2577 + name="Sub Queue 1", 2578 + status="active", 2579 + ) 2580 + token = self.create_token( 2581 + facility=self.facility, 2582 + queue=token_queue, 2583 + category=self.token_category, 2584 + number=1, 2585 + status=TokenStatusOptions.CREATED.value, 2586 + ) 2587 + self.client.force_authenticate(user=self.user) 2588 + url = self.generate_url(self.facility.external_id, token_queue.external_id) 2589 + response = self.client.post( 2590 + url, 2591 + { 2592 + "sub_queue": str(sub_queue.external_id), 2593 + "category": str(self.token_category.external_id), 2594 + }, 2595 + format="json", 2596 + ) 2597 + self.assertEqual(response.status_code, 200) 2598 + sub_queue.refresh_from_db() 2599 + token.refresh_from_db() 2600 + self.assertEqual(sub_queue.current_token, token) 2601 + self.assertEqual(token.status, TokenStatusOptions.IN_PROGRESS.value) 2602 + 2603 + def test_set_next_token_to_subqueue_as_user_without_permissions(self): 2604 + """ 2605 + Test setting the next token to a sub-queue as a user without the 'can_write_token' permissions. 2606 + 2607 + needs to create: 2608 + - token queue 2609 + - token sub-queue 2610 + - token 2611 + """ 2612 + role = self.create_role_with_permissions( 2613 + permissions=[ 2614 + TokenPermissions.can_list_token.name, 2615 + ], 2616 + ) 2617 + self.attach_role_facility_organization_user( 2618 + user=self.user, role=role, facility_organization=self.facility_organization 2619 + ) 2620 + token_queue = self.create_token_queue( 2621 + facility=self.facility, 2622 + name="Primary Token Queue", 2623 + date=(timezone.now() + timedelta(days=1)).date(), 2624 + resource=self.superuser_resource, 2625 + is_primary=True, 2626 + ) 2627 + sub_queue = self.create_token_sub_queue( 2628 + facility=self.facility, 2629 + resource=self.superuser_resource, 2630 + name="Sub Queue 1", 2631 + status="active", 2632 + ) 2633 + self.create_token( 2634 + facility=self.facility, 2635 + queue=token_queue, 2636 + category=self.token_category, 2637 + number=1, 2638 + status=TokenStatusOptions.CREATED.value, 2639 + ) 2640 + self.client.force_authenticate(user=self.user) 2641 + url = self.generate_url(self.facility.external_id, token_queue.external_id) 2642 + response = self.client.post( 2643 + url, 2644 + { 2645 + "sub_queue": str(sub_queue.external_id), 2646 + "category": str(self.token_category.external_id), 2647 + }, 2648 + format="json", 2649 + ) 2650 + self.assertEqual(response.status_code, 403) 2651 + self.assertIn( 2652 + "You do not have permission to update token queue", str(response.data) 2653 + ) 2654 + 2655 + def test_set_next_token_to_subqueue_with_an_category_outside_facility(self): 2656 + """ 2657 + Test setting the next token to a sub-queue with category outside the facility. 2658 + """ 2659 + another_facility = self.create_facility( 2660 + user=self.superuser, name="Another Facility" 2661 + ) 2662 + token_category = self.create_token_category( 2663 + name="Special", 2664 + facility=another_facility, 2665 + resource_type=SchedulableResourceTypeOptions.practitioner.value, 2666 + shorthand="SPC", 2667 + default=False, 2668 + ) 2669 + self.client.force_authenticate(user=self.superuser) 2670 + token_queue = self.create_token_queue( 2671 + facility=self.facility, 2672 + name="Primary Token Queue", 2673 + date=(timezone.now() + timedelta(days=1)).date(), 2674 + resource=self.superuser_resource, 2675 + is_primary=True, 2676 + ) 2677 + sub_queue = self.create_token_sub_queue( 2678 + facility=self.facility, 2679 + resource=self.superuser_resource, 2680 + name="Sub Queue 1", 2681 + status="active", 2682 + ) 2683 + self.create_token( 2684 + facility=self.facility, 2685 + queue=token_queue, 2686 + category=self.token_category, 2687 + number=1, 2688 + status=TokenStatusOptions.CREATED.value, 2689 + ) 2690 + url = self.generate_url(self.facility.external_id, token_queue.external_id) 2691 + response = self.client.post( 2692 + url, 2693 + { 2694 + "sub_queue": str(sub_queue.external_id), 2695 + "category": str(token_category.external_id), 2696 + }, 2697 + format="json", 2698 + ) 2699 + self.assertEqual(response.status_code, 404) 2700 + self.assertIn("No TokenCategory matches the given query.", str(response.data)) 2701 + 2702 + def test_set_next_token_to_subqueue_with_no_available_tokens(self): 2703 + """ 2704 + Test setting the next token to a sub-queue when there are no available tokens in the queue for the given category. 2705 + """ 2706 + self.client.force_authenticate(user=self.superuser) 2707 + token_queue = self.create_token_queue( 2708 + facility=self.facility, 2709 + name="Primary Token Queue", 2710 + date=(timezone.now() + timedelta(days=1)).date(), 2711 + resource=self.superuser_resource, 2712 + is_primary=True, 2713 + ) 2714 + sub_queue = self.create_token_sub_queue( 2715 + facility=self.facility, 2716 + resource=self.superuser_resource, 2717 + name="Sub Queue 1", 2718 + status="active", 2719 + ) 2720 + url = self.generate_url(self.facility.external_id, token_queue.external_id) 2721 + response = self.client.post( 2722 + url, 2723 + { 2724 + "sub_queue": str(sub_queue.external_id), 2725 + "category": str(self.token_category.external_id), 2726 + }, 2727 + format="json", 2728 + ) 2729 + self.assertEqual(response.status_code, 400) 2730 + self.assertIn("No tokens found", str(response.data))

Configure Feed

Configure Feed