project initialization

backend/tests/contract/test_healthcare_appointments_get.py

@@ -0,0 +1,336 @@
+"""
+Contract test for GET /healthcare/appointments endpoint.
+This test MUST fail before implementation.
+"""
+
+import pytest
+from django.test import TestCase
+from django.urls import reverse
+from rest_framework.test import APIClient
+from rest_framework import status
+import json
+
+
+class HealthcareAppointmentsGetContractTest(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.appointments_url = '/api/v1/healthcare/appointments/'
+
+        # Tenant authentication header
+        self.tenant_auth = {'HTTP_AUTHORIZATION': 'Bearer tenant_token'}
+
+    def test_get_appointments_success(self):
+        """Test successful retrieval of appointments list."""
+        response = self.client.get(
+            self.appointments_url,
+            **self.tenant_auth
+        )
+
+        # This should fail before implementation
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        assert 'appointments' in data
+        assert isinstance(data['appointments'], list)
+
+        # Check pagination structure
+        assert 'pagination' in data
+        pagination = data['pagination']
+        assert 'page' in pagination
+        assert 'limit' in pagination
+        assert 'total' in pagination
+        assert 'pages' in pagination
+
+    def test_get_appointments_unauthorized(self):
+        """Test appointments list retrieval without authentication."""
+        response = self.client.get(self.appointments_url)
+
+        assert response.status_code == status.HTTP_401_UNAUTHORIZED
+
+    def test_get_appointments_with_pagination(self):
+        """Test appointments list retrieval with pagination parameters."""
+        params = {
+            'page': 2,
+            'limit': 20
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        assert data['pagination']['page'] == 2
+        assert data['pagination']['limit'] == 20
+
+    def test_get_appointments_with_search(self):
+        """Test appointments list retrieval with search parameter."""
+        params = {
+            'search': 'ahmad'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # All returned appointments should match search criteria
+        for appointment in data['appointments']:
+            search_match = (
+                'ahmad' in appointment['patient_name'].lower() or
+                'ahmad' in appointment['doctor_name'].lower() or
+                'ahmad' in appointment['notes'].lower()
+            )
+            assert search_match
+
+    def test_get_appointments_filter_by_date_range(self):
+        """Test appointments list retrieval filtered by date range."""
+        params = {
+            'start_date': '2024-01-01',
+            'end_date': '2024-01-31'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # All returned appointments should be within the date range
+        for appointment in data['appointments']:
+            appointment_date = appointment['appointment_datetime'].split('T')[0]
+            assert '2024-01-01' <= appointment_date <= '2024-01-31'
+
+    def test_get_appointments_filter_by_status(self):
+        """Test appointments list retrieval filtered by status."""
+        params = {
+            'status': 'CONFIRMED'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # All returned appointments should have the specified status
+        for appointment in data['appointments']:
+            assert appointment['status'] == 'CONFIRMED'
+
+    def test_get_appointments_filter_by_doctor(self):
+        """Test appointments list retrieval filtered by doctor."""
+        params = {
+            'doctor_id': 'doctor-001'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # All returned appointments should be with the specified doctor
+        for appointment in data['appointments']:
+            assert appointment['doctor_id'] == 'doctor-001'
+
+    def test_get_appointments_filter_by_patient(self):
+        """Test appointments list retrieval filtered by patient."""
+        params = {
+            'patient_id': 'patient-001'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # All returned appointments should be for the specified patient
+        for appointment in data['appointments']:
+            assert appointment['patient_id'] == 'patient-001'
+
+    def test_get_appointments_data_structure(self):
+        """Test that appointment data structure matches the contract."""
+        response = self.client.get(
+            self.appointments_url,
+            **self.tenant_auth
+        )
+
+        if response.status_code == status.HTTP_200_OK and len(response.json()['appointments']) > 0:
+            appointment = response.json()['appointments'][0]
+
+            # Required fields according to contract
+            required_fields = [
+                'id', 'patient_id', 'patient_name', 'doctor_id', 'doctor_name',
+                'appointment_datetime', 'duration', 'status', 'type',
+                'reason', 'notes', 'tenant_id', 'created_at', 'updated_at'
+            ]
+
+            for field in required_fields:
+                assert field in appointment
+
+            # Field types and enums
+            assert isinstance(appointment['id'], str)
+            assert isinstance(appointment['patient_id'], str)
+            assert isinstance(appointment['patient_name'], str)
+            assert isinstance(appointment['doctor_id'], str)
+            assert isinstance(appointment['doctor_name'], str)
+            assert isinstance(appointment['appointment_datetime'], str)
+            assert isinstance(appointment['duration'], int)
+            assert appointment['status'] in ['SCHEDULED', 'CONFIRMED', 'IN_PROGRESS', 'COMPLETED', 'CANCELLED', 'NO_SHOW']
+            assert appointment['type'] in ['CONSULTATION', 'FOLLOW_UP', 'PROCEDURE', 'EMERGENCY', 'CHECKUP']
+
+    def test_get_appointments_with_patient_details(self):
+        """Test that appointment data includes patient details."""
+        response = self.client.get(
+            self.appointments_url,
+            data={'include_patient_details': 'true'},
+            **self.tenant_auth
+        )
+
+        if response.status_code == status.HTTP_200_OK and len(response.json()['appointments']) > 0:
+            appointment = response.json()['appointments'][0]
+
+            # Should include patient details
+            assert 'patient_details' in appointment
+            patient_details = appointment['patient_details']
+
+            # Patient details should include relevant fields
+            expected_patient_fields = ['ic_number', 'phone', 'email', 'age', 'gender']
+            for field in expected_patient_fields:
+                assert field in patient_details
+
+    def test_get_appointments_with_doctor_details(self):
+        """Test that appointment data includes doctor details."""
+        response = self.client.get(
+            self.appointments_url,
+            data={'include_doctor_details': 'true'},
+            **self.tenant_auth
+        )
+
+        if response.status_code == status.HTTP_200_OK and len(response.json()['appointments']) > 0:
+            appointment = response.json()['appointments'][0]
+
+            # Should include doctor details
+            assert 'doctor_details' in appointment
+            doctor_details = appointment['doctor_details']
+
+            # Doctor details should include relevant fields
+            expected_doctor_fields = ['specialization', 'license_number', 'department']
+            for field in expected_doctor_fields:
+                assert field in doctor_details
+
+    def test_get_appointments_sorting(self):
+        """Test appointments list retrieval with sorting."""
+        params = {
+            'sort_by': 'appointment_datetime',
+            'sort_order': 'asc'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # Appointments should be sorted by datetime in ascending order
+        appointment_datetimes = [appointment['appointment_datetime'] for appointment in data['appointments']]
+        assert appointment_datetimes == sorted(appointment_datetimes)
+
+    def test_get_appointments_tenant_isolation(self):
+        """Test that appointments are isolated by tenant."""
+        response = self.client.get(
+            self.appointments_url,
+            **self.tenant_auth
+        )
+
+        if response.status_code == status.HTTP_200_OK:
+            data = response.json()
+            # All returned appointments should belong to the authenticated tenant
+            for appointment in data['appointments']:
+                assert 'tenant_id' in appointment
+                # This will be validated once implementation exists
+
+    def test_get_appointments_upcoming_only(self):
+        """Test appointments list retrieval for upcoming appointments only."""
+        params = {
+            'upcoming_only': 'true'
+        }
+
+        response = self.client.get(
+            self.appointments_url,
+            data=params,
+            **self.tenant_auth
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+
+        data = response.json()
+        # All returned appointments should be in the future
+        # This will be validated once implementation exists
+        pass
+
+    def test_get_appointments_with_reminders(self):
+        """Test that appointment data includes reminder information."""
+        response = self.client.get(
+            self.appointments_url,
+            data={'include_reminders': 'true'},
+            **self.tenant_auth
+        )
+
+        if response.status_code == status.HTTP_200_OK and len(response.json()['appointments']) > 0:
+            appointment = response.json()['appointments'][0]
+
+            # Should include reminder information
+            assert 'reminders' in appointment
+            reminders = appointment['reminders']
+
+            # Should be a list
+            assert isinstance(reminders, list)
+
+            if len(reminders) > 0:
+                reminder = reminders[0]
+                expected_reminder_fields = ['type', 'sent_at', 'status']
+                for field in expected_reminder_fields:
+                    assert field in reminder
+
+    def test_get_appointments_with_virtual_info(self):
+        """Test that appointment data includes virtual consultation information."""
+        response = self.client.get(
+            self.appointments_url,
+            data={'include_virtual_info': 'true'},
+            **self.tenant_auth
+        )
+
+        if response.status_code == status.HTTP_200_OK and len(response.json()['appointments']) > 0:
+            appointment = response.json()['appointments'][0]
+
+            # Should include virtual consultation info if applicable
+            if appointment.get('is_virtual', False):
+                assert 'virtual_consultation' in appointment
+                virtual_info = appointment['virtual_consultation']
+                expected_virtual_fields = ['platform', 'link', 'instructions']
+                for field in expected_virtual_fields:
+                    assert field in virtual_info