wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/tests/signals.py

@@ -0,0 +1,89 @@
+from django.dispatch import receiver
+from wbcompliance.factories import (
+    ComplianceTaskInstanceReviewFactory,
+    ComplianceTaskInstanceReviewNoGroupFactory,
+    ComplianceTaskReviewFactory,
+    ComplianceTaskReviewNoGroupFactory,
+)
+from wbcompliance.viewsets import (
+    CFComplianceFormSignatureModelViewSet,
+    ComplianceFormSignatureModelViewSet,
+    ComplianceFormSignatureSectionRuleViewSet,
+    ComplianceTaskInstanceReviewGroupModelViewSet,
+    ComplianceTaskInstanceReviewNoGroupModelViewSet,
+    ComplianceTaskReviewGroupModelViewSet,
+    ComplianceTaskReviewNoGroupModelViewSet,
+)
+from wbcore.test.signals import (
+    custom_update_data_from_factory,
+    custom_update_kwargs,
+    get_custom_factory,
+)
+
+# =================================================================================================================
+#                                              CUSTOM FACTORY
+# =================================================================================================================
+
+
+@receiver(get_custom_factory, sender=ComplianceTaskReviewNoGroupModelViewSet)
+def receive_factory_compliance_task_review_no_group(sender, *args, **kwargs):
+    return ComplianceTaskReviewNoGroupFactory
+
+
+@receiver(get_custom_factory, sender=ComplianceTaskReviewGroupModelViewSet)
+def receive_factory_compliance_task_review(sender, *args, **kwargs):
+    return ComplianceTaskReviewFactory
+
+
+@receiver(get_custom_factory, sender=ComplianceTaskInstanceReviewNoGroupModelViewSet)
+def receive_factory_compliance_task_instance_review_no_group(sender, *args, **kwargs):
+    return ComplianceTaskInstanceReviewNoGroupFactory
+
+
+@receiver(get_custom_factory, sender=ComplianceTaskInstanceReviewGroupModelViewSet)
+def receive_factory_compliance_task_review_group(sender, *args, **kwargs):
+    return ComplianceTaskInstanceReviewFactory
+
+
+# =================================================================================================================
+#                                              UPDATE DATA
+# =================================================================================================================
+
+
+@receiver(custom_update_data_from_factory, sender=ComplianceFormSignatureSectionRuleViewSet)
+def receive_data_compliance_form_signature_section(sender, *args, **kwargs):
+    if (obj := kwargs.get("obj_factory")) and (user := kwargs.get("user")):
+        obj.section.compliance_form_signature.person = user.profile
+        obj.section.compliance_form_signature.save()
+    return {}
+
+
+@receiver(custom_update_data_from_factory, sender=ComplianceFormSignatureModelViewSet)
+@receiver(custom_update_data_from_factory, sender=CFComplianceFormSignatureModelViewSet)
+def receive_data_compliance_form_signature(sender, *args, **kwargs):
+    if (obj := kwargs.get("obj_factory")) and (user := kwargs.get("user")):
+        obj.person = user.profile
+        obj.signed = None
+        obj.save()
+    return {}
+
+
+# =================================================================================================================
+#                                              UPDATE KWARGS
+# =================================================================================================================
+
+
+@receiver(custom_update_kwargs, sender=ComplianceTaskInstanceReviewNoGroupModelViewSet)
+@receiver(custom_update_kwargs, sender=ComplianceTaskReviewGroupModelViewSet)
+@receiver(custom_update_kwargs, sender=ComplianceTaskReviewNoGroupModelViewSet)
+def receive_kwargs_compliance_task_review(sender, *args, **kwargs):
+    if (obj := kwargs.get("obj_factory")) and obj.review.exists():
+        return {"review_id": obj.review.first().id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=ComplianceTaskInstanceReviewGroupModelViewSet)
+def receive_kwargs_compliance_task_instance_review(sender, *args, **kwargs):
+    if (obj := kwargs.get("obj_factory")) and obj.review.exists():
+        return {"review_id": obj.review.first().id, "group_id": obj.task.group.id}
+    return {}

wbcompliance/tests/test_filters.py

@@ -0,0 +1,23 @@
+import pytest
+from wbcompliance.viewsets import ComplianceFormSignatureModelViewSet
+
+from .mixins import UserTestMixin
+
+
+@pytest.mark.django_db
+class TestSpecificFilters(UserTestMixin):
+    def test_filter_version(self, compliance_form_factory, user):
+        compliance_form = compliance_form_factory(assigned_to=(user.groups.first(),))
+        compliance_form.activationrequested()
+        compliance_form.active()
+        compliance_form.draft()
+        compliance_form.activationrequested()
+        compliance_form.active()
+        mvs = ComplianceFormSignatureModelViewSet()
+        qs = mvs.get_serializer_class().Meta.model.objects.all()
+        assert mvs.filterset_class().filter_version(qs, "", False) == qs
+        assert mvs.filterset_class().filter_version(qs, "", False).count() == 2
+        assert mvs.filterset_class().filter_version(qs, "", True).count() == 1
+
+    def test_not_created_m2m_field_compliance_form_factory(self, compliance_form_factory):
+        assert compliance_form_factory.build()

wbcompliance/tests/test_models.py

@@ -0,0 +1,57 @@
+import pytest
+from wbcompliance.models import ComplianceForm, ComplianceFormSignature
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.permissions.shortcuts import get_internal_users
+
+from .mixins import UserTestMixin
+
+
+@pytest.mark.django_db
+class TestSpecificModels(UserTestMixin):
+    @pytest.mark.parametrize("other_user", [True, False])
+    def test_draft_activationrequested_active(self, compliance_form_factory, other_user):
+        other_user = UserFactory() if other_user else None
+        compliance_form = compliance_form_factory()
+        assert compliance_form.status == ComplianceForm.Status.DRAFT
+        compliance_form.activationrequested(by=other_user)
+        assert compliance_form.status == ComplianceForm.Status.ACTIVATION_REQUESTED
+        compliance_form.active(by=other_user)
+        assert compliance_form.status == ComplianceForm.Status.ACTIVE
+        compliance_form.draft(by=other_user)
+        assert compliance_form.status == ComplianceForm.Status.DRAFT
+
+    def test_create_compliance_form_signature(
+        self,
+        compliance_form_factory,
+        user,
+        compliance_form_section_factory,
+        compliance_form_rule_factory,
+    ):
+        compliance_form = compliance_form_factory(
+            assigned_to=(user.groups.filter(name="Compliance Position").first(),)
+        )
+        section = compliance_form_section_factory(compliance_form=compliance_form)
+        compliance_form_rule_factory(section=section)
+
+        compliance_form.activationrequested()
+        compliance_form.active()
+        assert ComplianceFormSignature.objects.count() == 1
+
+        # test empty assigned_to
+        compliance_form1 = compliance_form_factory(only_internal=True)
+        compliance_form1.activationrequested()
+        compliance_form1.active()
+        assert (
+            ComplianceFormSignature.objects.filter(compliance_form=compliance_form1).count()
+            == get_internal_users().count()
+        )
+
+    # def test_only_internal(self, compliance_form_factory):
+    #     employee.contract_type = EmployeeHumanResource.ContractType.EXTERNAL
+    #     employee.save()
+    #     compliance_form = compliance_form_factory(assigned_to=(user.groups.filter(name="Compliance Position").first(),), only_internal=True)
+    #     assert compliance_form.get_signing_users().count() == 0
+    #
+    #     employee2 = EmployeeHumanResourceFactory(profile=person2)
+    #     compliance_form2 = compliance_form_factory(assigned_to=(employee2.position,), only_internal=False)
+    #     assert compliance_form2.get_signing_users().count() == 1

wbcompliance/tests/test_serializers.py

@@ -0,0 +1,48 @@
+from datetime import date
+
+import pytest
+from dateutil.relativedelta import relativedelta
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+from wbcompliance.viewsets import ComplianceFormModelViewSet
+from wbcore.test.utils import (
+    get_data_from_factory,
+    get_kwargs,
+    get_model_factory,
+    get_or_create_superuser,
+)
+
+from .mixins import UserTestMixin
+
+
+@pytest.mark.django_db
+class TestSpecificSerializers(UserTestMixin):
+    @pytest.mark.parametrize("mvs", [ComplianceFormModelViewSet])
+    def test_update_compliance_form_model_serializer(self, mvs, user):
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory(assigned_to=(user.groups.first(),))
+        user = get_or_create_superuser()
+
+        data = get_data_from_factory(obj, mvs, update=True, superuser=user)
+        request = APIRequestFactory().put("", data)
+        request.user = user
+
+        kwargs = get_kwargs(obj, mvs, request)
+        vs = mvs.as_view({"put": "update"})
+        response = vs(request, **kwargs, pk=obj.pk)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data.get("instance")
+
+    @pytest.mark.parametrize("mvs", [ComplianceFormModelViewSet])
+    def test_validate_date_compliance_form(self, mvs):
+        user = get_or_create_superuser()
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        now = date.today()
+        obj = factory(start=now, end=now - relativedelta(months=+5))
+        data = get_data_from_factory(obj, mvs, update=True, superuser=user)
+        request = APIRequestFactory().post("", data)
+        request.user = user
+        kwargs = get_kwargs(obj, mvs, request)
+        vs = mvs.as_view({"post": "create"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_400_BAD_REQUEST

wbcompliance/tests/test_views.py

@@ -0,0 +1,377 @@
+import pytest
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+from wbcompliance.factories import (
+    ComplianceFormSectionFactory,
+    ComplianceFormSignatureRuleFactory,
+    ComplianceFormSignatureSectionFactory,
+    ComplianceFormTypeFactory,
+)
+from wbcompliance.models import (
+    ComplianceForm,
+    ComplianceFormRule,
+    ComplianceFormSection,
+    ComplianceFormSignature,
+    ComplianceFormType,
+)
+from wbcompliance.viewsets import (
+    CFComplianceFormSignatureModelViewSet,
+    ComplianceFormModelViewSet,
+    ComplianceFormRuleViewSet,
+    ComplianceFormSectionComplianceFormViewSet,
+    ComplianceFormSectionRuleViewSet,
+    ComplianceFormSignatureModelViewSet,
+    ComplianceFormTypeViewSet,
+    ComplianceTaskMatrixPandasViewSet,
+)
+from wbcore.contrib.authentication.factories import InternalUserFactory, UserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.test.utils import (
+    get_data_from_factory,
+    get_kwargs,
+    get_model_factory,
+    get_or_create_superuser,
+)
+
+from .mixins import UserTestMixin
+
+
+@pytest.mark.django_db
+class TestSpecificViewsets(UserTestMixin):
+    @pytest.mark.parametrize(
+        "mvs",
+        [
+            ComplianceFormModelViewSet,
+            ComplianceFormSignatureModelViewSet,
+            ComplianceFormTypeViewSet,
+            ComplianceFormSectionComplianceFormViewSet,
+            ComplianceFormSectionRuleViewSet,
+        ],
+    )
+    def test_get_queryset(self, mvs):
+        request = APIRequestFactory().get("")
+        request.user = UserFactory(is_active=True, is_superuser=False)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+        vs = mvs.as_view({"get": "list"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_403_FORBIDDEN
+
+    @pytest.mark.parametrize(
+        "mvs, signature", [(ComplianceFormModelViewSet, False), (ComplianceFormSignatureModelViewSet, True)]
+    )
+    def test_option_request_declaration_on_honour(self, mvs, signature, compliance_form_factory):
+        request = APIRequestFactory().options("")
+        request.user = UserFactory(is_active=True, is_superuser=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        complianceformtype = ComplianceFormTypeFactory()
+        complianceformtype.type = ComplianceFormType.Type.FORM
+        complianceformtype.save()
+        if signature:
+            cf = compliance_form_factory(form_type=complianceformtype)
+            obj = factory(compliance_form=cf)
+            sign_section = ComplianceFormSignatureSectionFactory(compliance_form_signature=obj)
+            ComplianceFormSignatureRuleFactory(section=sign_section)
+        else:
+            obj = factory(form_type=complianceformtype)
+            ComplianceFormSectionFactory(compliance_form=obj)
+        obj.save()
+        kwargs = get_kwargs(obj, mvs, request)
+        kwargs["pk"] = obj.pk
+        vs = mvs.as_view({"options": "options"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_200_OK
+
+    @pytest.mark.parametrize(
+        "mvs, model, codename, is_queryset_not_empty",
+        [
+            (ComplianceFormTypeViewSet, ComplianceFormType, "view_complianceformtype", False),
+            (ComplianceFormRuleViewSet, ComplianceFormRule, "view_complianceformrule", True),
+            (ComplianceFormSectionComplianceFormViewSet, ComplianceFormSection, "view_complianceformsection", False),
+            (ComplianceFormSectionRuleViewSet, ComplianceFormRule, "view_complianceformrule", False),
+        ],
+    )
+    def test_option_request_no_admin_section_rules(self, mvs, model, codename, is_queryset_not_empty):
+        request = APIRequestFactory().options("")
+        request.user = UserFactory(is_active=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+        kwargs["pk"] = obj.pk
+        content_type = ContentType.objects.get_for_model(model)
+        permission = Permission.objects.get(
+            codename=codename,
+            content_type=content_type,
+        )
+        request.user.user_permissions.add(permission)
+        # permission check caching. -> refetch your object
+        request.user.refresh_from_db()
+        request.user = User.objects.get(pk=request.user.pk)
+
+        view = mvs()
+        view.setup(request, **kwargs)
+
+        assert view.get_queryset().exists() == is_queryset_not_empty
+
+    @pytest.mark.parametrize("mvs", [ComplianceFormModelViewSet])
+    def test_option_request_no_admin_compliance_form(self, mvs, compliance_form_factory):
+        request = APIRequestFactory().options("")
+        request.user = InternalUserFactory(is_active=True)
+        obj = compliance_form_factory.create()
+        kwargs = get_kwargs(obj, mvs, request)
+
+        permission_view = Permission.objects.get(
+            codename="view_complianceform",
+            content_type=ContentType.objects.get_for_model(ComplianceForm),
+        )
+        permission_select = Permission.objects.get(
+            codename="select_complianceform",
+            content_type=ContentType.objects.get_for_model(ComplianceForm),
+        )
+        permission_internal_user = Permission.objects.get(
+            codename="is_internal_user",
+        )
+        request.user.user_permissions.add(permission_view)
+        request.user.user_permissions.add(permission_select)
+        request.user.user_permissions.add(permission_internal_user)
+
+        request.user = User.objects.get(pk=request.user.pk)  # reset cached property and permission cache
+        vs = mvs.as_view({"options": "options"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_200_OK
+
+    @pytest.mark.parametrize(
+        "mvs, model, codename, is_allowed",
+        [
+            (ComplianceFormTypeViewSet, ComplianceFormType, "change_complianceformtype", False),
+            (ComplianceFormRuleViewSet, ComplianceFormRule, "change_complianceformrule", False),
+            (ComplianceFormSectionComplianceFormViewSet, ComplianceFormSection, "change_complianceformsection", False),
+            (ComplianceFormSectionRuleViewSet, ComplianceFormRule, "change_complianceformrule", False),
+        ],
+    )
+    def test_get_instance_endpoint_no_admin_section_rules(self, mvs, model, codename, is_allowed):
+        user = UserFactory(is_active=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        data = get_data_from_factory(obj, mvs, update=True, superuser=user)
+        request = APIRequestFactory().put("", data)
+        request.user = user
+        kwargs = get_kwargs(obj, mvs, request)
+
+        content_type = ContentType.objects.get_for_model(model)
+        permission = Permission.objects.get(
+            codename=codename,
+            content_type=content_type,
+        )
+        request.user.user_permissions.add(permission)
+        # permission check caching. -> refetch your object
+        request.user.refresh_from_db()
+        request.user = User.objects.get(pk=request.user.pk)
+
+        vs = mvs.as_view({"put": "update"})
+        response = vs(request, **kwargs, pk=obj.pk)
+        if is_allowed:
+            assert response.status_code == status.HTTP_200_OK
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
+    @pytest.mark.parametrize("mvs", [ComplianceFormSignatureModelViewSet, CFComplianceFormSignatureModelViewSet])
+    def test_get_create_endpoint_no_admin_compliance_form(self, mvs):
+        user = UserFactory(is_active=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        data = get_data_from_factory(obj, mvs, update=True, superuser=user)
+        request = APIRequestFactory().post("", data)
+        request.user = user
+        kwargs = get_kwargs(obj, mvs, request)
+        content_type = ContentType.objects.get_for_model(ComplianceFormSignature)
+        permission = Permission.objects.get(
+            codename="add_complianceformsignature",
+            content_type=content_type,
+        )
+        request.user.user_permissions.add(permission)
+        request.user.refresh_from_db()
+        request.user = User.objects.get(pk=request.user.pk)
+        vs = mvs.as_view({"post": "create"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
+    @pytest.mark.parametrize(
+        "mvs, model, codename, is_allowed",
+        [
+            (ComplianceFormTypeViewSet, ComplianceFormType, "add_complianceformtype", False),
+            (ComplianceFormRuleViewSet, ComplianceFormRule, "add_complianceformrule", False),
+            (ComplianceFormSectionComplianceFormViewSet, ComplianceFormSection, "add_complianceformsection", False),
+            (ComplianceFormSectionRuleViewSet, ComplianceFormRule, "add_complianceformrule", False),
+        ],
+    )
+    def test_get_create_endpoint_no_admin_section_rules(self, mvs, model, codename, is_allowed):
+        user = UserFactory(is_active=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        data = get_data_from_factory(obj, mvs, update=True, superuser=user)
+        request = APIRequestFactory().post("", data)
+        request.user = user
+        kwargs = get_kwargs(obj, mvs, request)
+
+        content_type = ContentType.objects.get_for_model(model)
+        permission = Permission.objects.get(
+            codename=codename,
+            content_type=content_type,
+        )
+        request.user.user_permissions.add(permission)
+        request.user.refresh_from_db()
+        request.user = User.objects.get(pk=request.user.pk)
+
+        vs = mvs.as_view({"post": "create"})
+        response = vs(request, **kwargs)
+        if is_allowed:
+            assert response.status_code == status.HTTP_201_CREATED
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
+    @pytest.mark.parametrize("mvs", [ComplianceFormSignatureModelViewSet, CFComplianceFormSignatureModelViewSet])
+    def test_get_delete_endpoint_no_admin_compliance_form(self, mvs):
+        request = APIRequestFactory().delete("")
+        request.user = UserFactory(is_active=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+
+        content_type = ContentType.objects.get_for_model(ComplianceFormSignature)
+        permission = Permission.objects.get(
+            codename="delete_complianceformsignature",
+            content_type=content_type,
+        )
+        request.user.user_permissions.add(permission)
+        request.user.refresh_from_db()
+
+        # request.user = User.objects.get(pk=request.user.pk)
+        vs = mvs.as_view({"delete": "destroy"})
+        response = vs(request, **kwargs, pk=obj.pk)
+        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
+    # TODO this should have never worked as Loic remove the delete endpoint excpliticlty, so the returned status code is 405 method not allowed and not 403.
+
+    @pytest.mark.parametrize(
+        "mvs, model, codename, is_allowed",
+        [
+            (ComplianceFormTypeViewSet, ComplianceFormType, "delete_complianceformtype", False),
+            (ComplianceFormRuleViewSet, ComplianceFormRule, "delete_complianceformrule", False),
+            (ComplianceFormSectionComplianceFormViewSet, ComplianceFormSection, "delete_complianceformsection", False),
+            (ComplianceFormSectionRuleViewSet, ComplianceFormRule, "delete_complianceformrule", False),
+        ],
+    )
+    def test_get_delete_endpoint_no_admin_section_rules(self, mvs, model, codename, is_allowed):
+        request = APIRequestFactory().delete("")
+        request.user = UserFactory(is_active=True)
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+
+        content_type = ContentType.objects.get_for_model(model)
+        permission = Permission.objects.get(
+            codename=codename,
+            content_type=content_type,
+        )
+        request.user.user_permissions.add(permission)
+        request.user.refresh_from_db()
+
+        # request.user = User.objects.get(pk=request.user.pk)
+        vs = mvs.as_view({"delete": "destroy"})
+        response = vs(request, **kwargs, pk=obj.pk)
+        if is_allowed:
+            assert response.status_code == status.HTTP_204_NO_CONTENT
+        else:
+            assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
+
+    @pytest.mark.parametrize(
+        "mvs, no_employee", [(ComplianceFormModelViewSet, True), (ComplianceFormModelViewSet, False)]
+    )
+    def test_sendcomplianceformnotification(self, mvs, no_employee, user):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory()
+        if not no_employee:
+            obj.assigned_to.add(user.groups.first())
+            obj.activationrequested()
+            obj.active()
+
+        response = mvs().sendcomplianceformnotification(request, pk=obj.pk)
+        assert response
+        assert response.data
+
+    @pytest.mark.parametrize("mvs", [ComplianceFormSignatureModelViewSet, CFComplianceFormSignatureModelViewSet])
+    def test_signature(self, mvs, user_factory):
+        request = APIRequestFactory().get("")
+        user = user_factory.create(is_superuser=False)
+        superuser = user_factory.create(is_superuser=True)
+        request.user = user
+
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        obj = factory(person=user.profile)
+        obj2 = factory(person=superuser.profile)
+
+        response = mvs().signature(request, pk=obj.pk)
+        response2 = mvs().signature(request, pk=obj2.pk)
+        assert response
+        assert response.data
+        assert response2.status_code == status.HTTP_403_FORBIDDEN
+
+    @pytest.mark.parametrize("mvs, changer", [(ComplianceFormModelViewSet, True), (ComplianceFormModelViewSet, False)])
+    def test_active_compliance_form_viewset_admin(self, mvs, changer):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        if changer:
+            obj = factory()
+        else:
+            obj = factory(changer=None)
+        obj.activationrequested()
+        obj.active()
+        kwargs = get_kwargs(obj, mvs, request)
+        vs = mvs.as_view({"get": "list"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        assert response.data.get("results")
+
+    @pytest.mark.parametrize("mvs", [ComplianceTaskMatrixPandasViewSet])
+    def test_PandasAPIView(self, mvs, compliance_task_factory, compliance_task_instance_factory):
+        request = APIRequestFactory().get("")
+        request.user = get_or_create_superuser()
+
+        compliance_task_instance_factory(task=compliance_task_factory())
+        # kwargs = get_kwargs(obj, mvs, request)
+        vs = mvs.as_view({"get": "list"})
+        response = vs(request)
+        assert response.status_code == status.HTTP_200_OK, str(response.status_code) + " == 200"
+        assert response.data, str(response.data) + " should not be empty"
+        assert response.data.get("results"), str(response.data.get("results")) + " should not be empty"
+
+    def test_queryset_filtering_for_user(self, user_factory, compliance_form_signature_factory):
+        request = APIRequestFactory().get("")
+        user = user_factory.create(is_superuser=False)
+        form_signature = compliance_form_signature_factory.create()
+        form_signature2 = compliance_form_signature_factory.create()
+
+        request.user = user
+        viewset = ComplianceFormSignatureModelViewSet(request=request)
+        queryset = viewset.get_queryset()
+        assert queryset.count() == 0
+
+        form_signature.person = user.profile
+        form_signature.save()
+        queryset = viewset.get_queryset()
+        assert set(queryset) == {form_signature}
+
+        user.is_superuser = True
+        user.save()
+        request.user = user
+        viewset = ComplianceFormSignatureModelViewSet(request=request)
+        queryset = viewset.get_queryset()
+        assert set(queryset) == {form_signature, form_signature2}

wbcompliance/tests/tests.py

@@ -0,0 +1,21 @@
+import pytest
+from wbcore.test import GenerateTest, default_config
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(
+        filter(
+            lambda x: x.__module__.startswith("wbcompliance")
+            and x.__name__
+            not in [
+                "RuleCheckedObjectRelationshipRiskRuleModelViewSet",
+            ],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass