Merge pull request #19 from jazkarta/task/add-unit-test

Feat: Unittest for api

Author: hassanmdsifat

.github/workflows/api-unit-test.yaml

@@ -0,0 +1,51 @@
+name: api-unit-test
+
+on:
+  pull_request:
+    branches:
+      - development
+      - main
+    paths:
+      - 'api/**'
+
+jobs:
+  test:
+    name: Run API Unit Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+          cache: 'pip'
+          cache-dependency-path: 'api/requirements.txt'
+
+      - name: Install dependencies
+        working-directory: api
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+
+      - name: Run unit tests
+        working-directory: api
+        env:
+          # Use SQLite for CI tests to avoid dependency on PostgreSQL
+          DB_ENGINE: django.db.backends.sqlite3
+          DB_NAME: ":memory:"
+          # Dummy values for external integrations (should be mocked in tests)
+          LIBRECHAT_MONGO_URI: mongodb://localhost:27017/LibreChat
+          SECRET_KEY: ci_testing_secret_key
+          DEBUG: "False"
+          KEYCLOAK_SERVER_URL: http://localhost:8080
+          KEYCLOAK_REALM: ayo
+          KEYCLOAK_CLIENT_ID: admin-cli
+          KEYCLOAK_ADMIN_USERNAME: admin
+          KEYCLOAK_ADMIN_PASSWORD: admin
+          DASHBOARD_URL: http://localhost:3000
+          ALLOWED_HOSTS: "*"
+        run: |
+          pytest

api/ayo_api/settings.py

@@ -120,8 +120,8 @@
 # https://docs.djangoproject.com/en/6.0/ref/settings/#databases
 
 DATABASES = {
-     "default": {
-        "ENGINE": "django.db.backends.postgresql",
+    "default": {
+        "ENGINE": os.getenv("DB_ENGINE", "django.db.backends.postgresql"),
         "NAME": os.getenv("DB_NAME"),
         "USER": os.getenv("DB_USER"),
         "PASSWORD": os.getenv("DB_PASSWORD"),

api/chat/tests.py

@@ -0,0 +1,142 @@
+import pytest
+from django.contrib.auth import get_user_model
+from rest_framework.test import APIClient
+from users.models.user import UserRole
+from model_bakery import baker
+
+User = get_user_model()
+
+@pytest.fixture
+def researcher_user(db):
+    """Fixture to create and return a user with RESEARCHER role."""
+    return User.objects.create_user(
+        email="researcher@example.com",
+        password="password123",
+        role=UserRole.RESEARCHER,
+        first_name="Research",
+        last_name="er"
+    )
+
+@pytest.fixture
+def participant_user(db):
+    """Fixture to create and return an inactive user with PARTICIPANT role and profile."""
+    user = User.objects.create_user(
+        email="participant@example.com",
+        username="participant",
+        password="password123",
+        role=UserRole.PARTICIPANT,
+        is_active=False,
+        first_name="Parti",
+        last_name="cipant"
+    )
+    from participant.models import ParticipantProfile
+    ParticipantProfile.objects.get_or_create(
+        user=user,
+        defaults={
+            "date_of_birth": "2010-01-01",
+            "gender": "M"
+        }
+    )
+    return user
+
+@pytest.fixture
+def regular_user(db):
+    """Fixture to create and return a regular user (defaults to PARTICIPANT but active)."""
+    user = User.objects.create_user(
+        email="user@example.com",
+        username="regular_user",
+        password="password123",
+        role=UserRole.PARTICIPANT,
+        is_active=True
+    )
+    from participant.models import ParticipantProfile
+    ParticipantProfile.objects.get_or_create(
+        user=user,
+        defaults={
+            "date_of_birth": "2010-01-01",
+            "gender": "M"
+        }
+    )
+    return user
+
+@pytest.fixture
+def invitation(participant_user, researcher_user):
+    """Fixture for a valid, active invitation."""
+    from participant.models import Invitation
+    from django.utils import timezone
+    from datetime import timedelta
+    return Invitation.objects.create(
+        user=participant_user,
+        invited_by=researcher_user,
+        parent_email="guardian@example.com",
+        expiry_date=timezone.now() + timedelta(days=2),
+        is_active=True,
+        has_accepted=False
+    )
+
+@pytest.fixture
+def expired_invitation(db, researcher_user):
+    """Fixture for an expired invitation."""
+    from participant.models import Invitation
+    from django.utils import timezone
+    from datetime import timedelta
+    
+    user = User.objects.create_user(
+        email="expired@example.com",
+        username="expired",
+        role=UserRole.PARTICIPANT,
+        is_active=False
+    )
+    from participant.models import ParticipantProfile
+    ParticipantProfile.objects.create(user=user, date_of_birth="2010-01-01", gender="M")
+
+    return Invitation.objects.create(
+        user=user,
+        invited_by=researcher_user,
+        parent_email="guardian@example.com",
+        expiry_date=timezone.now() - timedelta(days=1),
+        is_active=True,
+        has_accepted=False
+    )
+
+@pytest.fixture
+def accepted_invitation(db, researcher_user):
+    """Fixture for an already accepted invitation."""
+    from participant.models import Invitation
+    from django.utils import timezone
+    from datetime import timedelta
+    
+    user = User.objects.create_user(
+        email="accepted@example.com",
+        username="accepted",
+        role=UserRole.PARTICIPANT,
+        is_active=False
+    )
+    from participant.models import ParticipantProfile
+    ParticipantProfile.objects.create(user=user, date_of_birth="2010-01-01", gender="M")
+
+    return Invitation.objects.create(
+        user=user,
+        invited_by=researcher_user,
+        parent_email="guardian@example.com",
+        expiry_date=timezone.now() + timedelta(days=2),
+        is_active=True,
+        has_accepted=True
+    )
+
+@pytest.fixture
+def mock_email_manager(mocker):
+    """Fixture to mock EmailManager."""
+    mock_email = mocker.patch("participant.serializers.EmailManager")
+    return mock_email.return_value
+
+@pytest.fixture
+def api_client():
+    """Fixture to provide a DRF APIClient."""
+    return APIClient()
+
+@pytest.fixture
+def mock_keycloak(mocker):
+    """Fixture to mock KeycloakSync."""
+    mock_sync = mocker.patch("participant.serializers.KeycloakSync")
+    return mock_sync.return_value

api/participant/tests.py

@@ -0,0 +1,79 @@
+import pytest
+from django.urls import reverse
+from rest_framework import status
+from participant.models import Invitation, ParticipantProfile, Guardian
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
+User = get_user_model()
+
+@pytest.mark.django_db
+class TestInvitationRetrieve:
+    def test_retrieve_invitation_success(self, api_client, invitation):
+        url = reverse('invitation-detail', kwargs={'pk': invitation.id})
+        response = api_client.get(url)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data['id'] == str(invitation.id)
+        assert response.data['parent_email'] == invitation.parent_email
+
+    def test_retrieve_invitation_not_found(self, api_client):
+        url = reverse('invitation-detail', kwargs={'pk': '00000000-0000-0000-0000-000000000000'})
+        response = api_client.get(url)
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+
+@pytest.mark.django_db
+class TestInvitationAccept:
+    
+    @pytest.fixture
+    def valid_payload(self):
+        return {
+            "first_name": "Guardian",
+            "last_name": "One",
+            "username": "new_participant_user",
+            "phone_number": "1234567890",
+            "email": "guardian@example.com",
+            "address": "123 Test St",
+            "relationship": "Father"
+        }
+
+    def test_accept_invitation_success(self, api_client, invitation, valid_payload, mock_keycloak):
+        # Setup mock behavior
+        mock_keycloak.create_user.return_value = "fake-keycloak-uuid"
+        
+        url = reverse('invitation-accept', kwargs={'pk': invitation.id})
+        response = api_client.post(url, valid_payload)
+        
+        assert response.status_code == status.HTTP_200_OK
+        
+        # Verify invitation status
+        invitation.refresh_from_db()
+        assert invitation.has_accepted is True
+        assert invitation.is_active is False
+        
+        # Verify user status
+        user = invitation.user
+        user.refresh_from_db()
+        assert user.is_active is True
+        assert user.username == "new_participant_user"
+        assert user.keycloak_id == "fake-keycloak-uuid"
+        
+        # Verify guardian creation
+        assert Guardian.objects.filter(email=valid_payload['email']).exists()
+        guardian = Guardian.objects.get(email=valid_payload['email'])
+        assert user.participant_profile.guardian == guardian
+
+    @pytest.mark.parametrize("scenario, invitation_fixture, payload_overrides, expected_status, error_key", [
+        ("already_accepted", "accepted_invitation", {}, status.HTTP_400_BAD_REQUEST, "non_field_errors"),
+        ("expired", "expired_invitation", {}, status.HTTP_400_BAD_REQUEST, "non_field_errors"),
+        ("missing_fields", "invitation", {"first_name": ""}, status.HTTP_400_BAD_REQUEST, "first_name"),
+        ("duplicate_username", "invitation", {"username": "regular_user"}, status.HTTP_400_BAD_REQUEST, "username"),
+    ])
+    def test_accept_invitation_failures(self, api_client, scenario, invitation_fixture, payload_overrides, expected_status, error_key, request, valid_payload, regular_user):
+        invitation = request.getfixturevalue(invitation_fixture)
+        payload = {**valid_payload, **payload_overrides}
+        
+        url = reverse('invitation-accept', kwargs={'pk': invitation.id})
+        response = api_client.post(url, payload)
+        
+        assert response.status_code == expected_status
+        assert error_key in response.data