tests.py

import pytest

class TestFileUploadView:
    # File upload with valid image and valid data returns HTTP_200_OK
    def test_valid_file_upload(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('api.core.views.FileSerializer')
        mocker.patch('api.core.views.detect_faces')
        mocker.patch('api.core.views.Response')

        # Create a mock request object
        request = mocker.Mock()
        request.META = {'CONTENT_LENGTH': '1000000'}
        request.data = {'file': 'valid_image.jpg'}

        # Create a mock file serializer
        file_serializer_mock = mocker.Mock()
        file_serializer_mock.is_valid.return_value = True
        file_serializer_mock.data = {'file': 'valid_image.jpg'}
        api.core.views.FileSerializer.return_value = file_serializer_mock

        # Create a mock response object
        response_mock = mocker.Mock()
        api.core.views.Response.return_value = response_mock

        # Invoke the code under test
        code_under_test.FileUploadView.post(request)

        # Assert that the file serializer is called with the correct data
        api.core.views.FileSerializer.assert_called_once_with(data=request.data)

        # Assert that the file serializer is saved
        file_serializer_mock.save.assert_called_once()

        # Assert that detect_faces is called with the correct image path
        api.core.views.detect_faces.assert_called_once_with('valid_image.jpg')

        # Assert that the response is returned with HTTP_200_OK status
        api.core.views.Response.assert_called_once_with(api.core.views.detect_faces.return_value, status=api.core.views.HTTP_200_OK)

    # File upload with invalid image returns HTTP_400_BAD_REQUEST
    def test_invalid_file_upload(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('api.core.views.FileSerializer')
        mocker.patch('api.core.views.Response')

        # Create a mock request object
        request = mocker.Mock()
        request.META = {'CONTENT_LENGTH': '1000000'}
        request.data = {'file': 'invalid_image.jpg'}

        # Create a mock file serializer
        file_serializer_mock = mocker.Mock()
        file_serializer_mock.is_valid.return_value = False
        api.core.views.FileSerializer.return_value = file_serializer_mock

        # Create a mock response object
        response_mock = mocker.Mock()
        api.core.views.Response.return_value = response_mock

        # Invoke the code under test
        code_under_test.FileUploadView.post(request)

        # Assert that the file serializer is called with the correct data
        api.core.views.FileSerializer.assert_called_once_with(data=request.data)

        # Assert that the response is returned with HTTP_400_BAD_REQUEST status
        api.core.views.Response.assert_called_once_with({"message": "Did not receive the correct data"}, status=api.core.views.HTTP_400_BAD_REQUEST)

class TestUserEmailView:
    # UserEmailView returns email of authenticated user
    def test_user_email_view_returns_email(self, mocker):
        # Mock the get_user_from_token function
        mocker.patch('api.core.views.get_user_from_token')
        # Create a mock user object
        user = mocker.Mock()
        # Set the email attribute of the user object
        user.email = 'test@example.com'
        # Set the return value of the get_user_from_token function to be the mock user object
        api.core.views.get_user_from_token.return_value = user
        # Create an instance of the UserEmailView class
        view = api.core.views.UserEmailView()
        # Create a mock request object
        request = mocker.Mock()
        # Call the get method of the UserEmailView instance with the mock request object
        response = view.get(request)
        # Assert that the response contains the expected email value
        assert response.data['email'] == 'test@example.com'

    # FileUploadView returns error if image size is greater than 5MB
    def test_file_upload_view_returns_error_if_image_size_greater_than_5MB(self, mocker):
        # Create an instance of the FileUploadView class
        view = api.core.views.FileUploadView()
        # Create a mock request object
        request = mocker.Mock()
        # Set the CONTENT_LENGTH attribute of the mock request object to a value greater than 5MB
        request.META.get.return_value = '5000001'
        # Call the post method of the FileUploadView instance with the mock request object
        response = view.post(request)
        # Assert that the response contains the expected error message
        assert response.data['message'] == 'Image size is greater than 5MB'


    # APIView is imported correctly
    def test_import_api_view(self):
        from api.core.views import APIView
        assert APIView is not None

    # FileUploadView returns error if image size is greater than 5MB
    def test_file_upload_image_size_error(self, mocker):
        from api.core.views import FileUploadView, Response, HTTP_400_BAD_REQUEST
        from rest_framework.request import Request
        from rest_framework.parsers import MultiPartParser

        # Mock the request object
        request = Request()
        request.META = {'CONTENT_LENGTH': '6000000'}
        request.data = {'file': 'test_image.jpg'}

        # Mock the FileSerializer
        file_serializer_mock = mocker.Mock()
        file_serializer_mock.is_valid.return_value = True
        file_serializer_mock.data = {'file': 'test_image.jpg'}
        mocker.patch('api.core.views.FileSerializer', return_value=file_serializer_mock)

        # Mock the detect_faces function
        mocker.patch('api.core.views.detect_faces')

        # Create an instance of FileUploadView
        view = FileUploadView()

        # Invoke the post method
        response = view.post(request)

        # Assert that the response is as expected
        assert response == Response({"message": "Image size is greater than 5MB"}, status=HTTP_400_BAD_REQUEST)


class TestChangeEmailView:
    # ChangeEmailView returns 200 OK and changes user email when valid email and confirm_email are provided
    def test_change_email_valid(self, mocker):
        # Mock the necessary dependencies
        request = mocker.Mock()
        request.META.get.return_value = "Bearer token"
        token = mocker.Mock()
        token.user_id = 1
        Token.objects.get.return_value = token
        user = mocker.Mock()
        User.objects.get.return_value = user

        # Set up the test data
        data = {
            'email': 'newemail@example.com',
            'confirm_email': 'newemail@example.com'
        }

        # Invoke the code under test
        response = code_under_test.ChangeEmailView().post(request, data)

        # Assert the response status code and user email
        assert response.status_code == 200
        assert user.email == 'newemail@example.com'

class TestChangePasswordView:

    # Valid image file is uploaded and processed successfully
    def test_valid_image_file_uploaded(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('api.core.views.FileSerializer')
        mocker.patch('api.core.views.detect_faces')
        mocker.patch('api.core.views.Response')

        # Create a mock request object
        request = mocker.Mock()
        request.META.get.return_value = 'Bearer token'

        # Create a mock file serializer
        file_serializer = mocker.Mock()
        file_serializer.is_valid.return_value = True
        file_serializer.data.get.return_value = 'image_path'
        api.core.views.FileSerializer.return_value = file_serializer

        # Create a mock response object
        response = mocker.Mock()
        api.core.views.Response.return_value = response

        # Invoke the code under test
        code_under_test.FileUploadView.post(request)

        # Assert that the necessary functions and methods were called
        api.core.views.FileSerializer.assert_called_once_with(data=request.data)
        file_serializer.save.assert_called_once()
        api.core.views.detect_faces.assert_called_once_with('image_path')
        api.core.views.Response.assert_called_once_with(api.core.views.detect_faces.return_value, status=HTTP_200_OK)

    # Image file size is greater than 5MB
    def test_image_file_size_greater_than_5MB(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('api.core.views.FileSerializer')
        mocker.patch('api.core.views.Response')

        # Create a mock request object
        request = mocker.Mock()
        request.META.get.return_value = 'Bearer token'
        request.META.get.return_value = '5000001'  # Set content length to be greater than 5MB

        # Create a mock file serializer
        file_serializer = mocker.Mock()
        file_serializer.is_valid.return_value = True
        api.core.views.FileSerializer.return_value = file_serializer

        # Create a mock response object
        response = mocker.Mock()
        api.core.views.Response.return_value = response

        # Invoke the code under test
        code_under_test.FileUploadView.post(request)

        # Assert that the necessary functions and methods were called
        api.core.views.FileSerializer.assert_called_once_with(data=request.data)
        api.core.views.Response.assert_called_once_with({"message": "Image size is greater than 5MB"}, status=HTTP_400_BAD_REQUEST)

class TestUserDetailsView:

    # APIView classes return expected HTTP responses
    def test_api_view_responses(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('code_under_test.get_user_from_token')
        mocker.patch('code_under_test.TrackedRequest.objects.filter')
        mocker.patch('code_under_test.stripe.Invoice.upcoming')
    
        # Initialize the code under test
        view = UserDetailsView()
    
        # Invoke the code under test
        response = view.get(request=None)
    
        # Assert the expected HTTP response
        assert response.status_code == 200
        assert response.data == {
            'membershipType': '...',
            'free_trial_end_date': '...',
            'next_billing_date': '...',
            'api_request_count': '...',
            'api_request_count_p': '...',
            'api_request_count_pp': '...',
            'api_request_count_ppp': '...',
            'api_request_count_pppp': '...',
            'api_request_count_ppppp': '...',
            'amount_due': '...',
            'user_name': '...'
        }

    # FileUploadView returns expected HTTP responses for large and small image files
    def test_file_upload_responses(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('code_under_test.FileSerializer')
        mocker.patch('code_under_test.detect_faces')
    
        # Initialize the code under test
        view = FileUploadView()
    
        # Invoke the code under test with a small image file
        request = mocker.Mock()
        request.META = {'CONTENT_LENGTH': '1000000'}
        response = view.post(request=request)
    
        # Assert the expected HTTP response
        assert response.status_code == 200
        assert response.data == '...'
    
        # Invoke the code under test with a large image file
        request = mocker.Mock()
        request.META = {'CONTENT_LENGTH': '6000000'}
        response = view.post(request=request)
    
        # Assert the expected HTTP response
        assert response.status_code == 400
        assert response.data == {'message': 'Image size is greater than 5MB'}

class TestSubscribeView:

    # APIView classes return expected HTTP responses
    def test_api_view_responses(self, mocker):
        # Mock the necessary dependencies
        mock_get_user_from_token = mocker.patch('api.core.views.get_user_from_token')
        mock_get_user_from_token.return_value = User()

        # Create a request object
        request = RequestFactory().get('/')

        # Create an instance of the APIView class
        view = SubscribeView.as_view()

        # Invoke the APIView class
        response = view(request)

        # Assert that the response status code is 200 OK
        assert response.status_code == 200

class TestCancelSubscription:

    # Successful file upload with valid data
    def test_successful_file_upload(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('api.core.views.FileSerializer')
        mocker.patch('api.core.views.detect_faces')
        mocker.patch('api.core.views.Response')

        # Create a mock request object
        request = mocker.Mock()
        request.META.get.return_value = 'Bearer token'

        # Create a mock file serializer object
        file_serializer = mocker.Mock()
        file_serializer.is_valid.return_value = True
        file_serializer.data.get.return_value = {'file': 'image_path'}

        # Create a mock response object
        response = mocker.Mock()

        # Patch the code under test to use the mock objects
        mocker.patch('api.core.views.FileUploadView.permission_classes', new=(AllowAny,))
        mocker.patch('api.core.views.FileUploadView.serializer_class', new=file_serializer)
        mocker.patch('api.core.views.FileUploadView.post', new=lambda self, request, *args, **kwargs: response)

        # Invoke the code under test
        code_under_test.FileUploadView().post(request)

        # Assert that the necessary methods were called with the correct arguments
        file_serializer.save.assert_called_once()
        detect_faces.assert_called_once_with('image_path')
        response.assert_called_once_with(recognition, status=HTTP_200_OK)

    # Unsuccessful file upload with invalid data
    def test_unsuccessful_file_upload(self, mocker):
        # Mock the necessary dependencies
        mocker.patch('api.core.views.FileSerializer')
        mocker.patch('api.core.views.Response')

        # Create a mock request object
        request = mocker.Mock()
        request.META.get.return_value = 'Bearer token'

        # Create a mock file serializer object
        file_serializer = mocker.Mock()
        file_serializer.is_valid.return_value = False

        # Create a mock response object
        response = mocker.Mock()

        # Patch the code under test to use the mock objects
        mocker.patch('api.core.views.FileUploadView.permission_classes', new=(AllowAny,))
        mocker.patch('api.core.views.FileUploadView.serializer_class', new=file_serializer)
        mocker.patch('api.core.views.FileUploadView.post', new=lambda self, request, *args, **kwargs: response)

        # Invoke the code under test
        code_under_test.FileUploadView().post(request)

        # Assert that the necessary methods were called with the correct arguments
        response.assert_called_once_with({"message": "Did not receive the correct data"}, status=HTTP_400_BAD_REQUEST)

class TestImageRecognitionView:

    # The 'FileUploadView' API view should successfully receive a POST request with a valid image file and return a HTTP_200_OK response with the recognition data.
    def test_file_upload_success(self, mocker):
        # Mock the FileSerializer class
        mock_file_serializer = mocker.Mock()
        mock_file_serializer.is_valid.return_value = True
        mock_file_serializer.data = {'file': 'image.jpg'}
        mocker.patch('code_under_test.FileSerializer', return_value=mock_file_serializer)

        # Mock the detect_faces function
        mocker.patch('code_under_test.detect_faces', return_value={'recognition': 'data'})

        # Create a POST request with a valid image file
        request = mocker.Mock()
        request.META = {'CONTENT_LENGTH': '1000000'}
        request.data = {'file': 'image.jpg'}

        # Invoke the code under test
        view = code_under_test.FileUploadView()
        response = view.post(request)

        # Assert that the response status code is HTTP_200_OK
        assert response.status_code == HTTP_200_OK
        # Assert that the response data contains the recognition data
        assert response.data == {'recognition': 'data'}

class TestAPIKeyView:

    # APIKeyView returns HTTP_200_OK with valid token
    def test_api_key_view_valid_token(self, mocker):
        # Mock the necessary dependencies
        request = mocker.Mock()
        request.META.get.return_value = 'Bearer valid_token'
        Token.objects.get.return_value = mocker.Mock(user_id=1)
        User.objects.get.return_value = mocker.Mock(email='test@example.com')

        # Invoke the code under test
        view = APIKeyView()
        response = view.get(request)

        # Assert the response status code
        assert response.status_code == HTTP_200_OK
        # Assert the response data
        assert response.data == {'email': 'test@example.com'}

    # APIKeyView returns HTTP_400_BAD_REQUEST with invalid token
    def test_api_key_view_invalid_token(self, mocker):
        # Mock the necessary dependencies
        request = mocker.Mock()
        request.META.get.return_value = 'Bearer invalid_token'

        # Invoke the code under test
        view = APIKeyView()
        response = view.get(request)

        # Assert the response status code
        assert response.status_code == HTTP_400_BAD_REQUEST

class TestUser:

    # User model inherits from AbstractUser
    def test_user_model_inherits_from_abstractuser(self):
        assert issubclass(User, AbstractUser)

    # Membership model has a char field 'type' with max length 1 and choices, which should be tested with all possible choices
    def test_membership_model_type_field_choices(self):
        membership = Membership()
        for choice in MEMBERSHIP_CHOICES:
            membership.type = choice[0]
            assert membership.type in dict(MEMBERSHIP_CHOICES).keys()

class TestMembership:

    # A new user is created with a free trial membership and a stripe customer ID is generated.
    def test_new_user_created_with_free_trial_membership(self, mocker):
        # Mock the stripe.Customer.create method
        mocker.patch('stripe.Customer.create')

        # Create a new user
        user = User.objects.create(username='test_user', email='test@example.com')

        # Check that the stripe.Customer.create method was called with the correct arguments
        stripe.Customer.create.assert_called_once_with(email=user.email)

        # Check that the user has a stripe customer ID
        assert user.stripe_customer_id is not None

        # Check that a membership object was created for the user with the correct type and start/end dates
        membership = Membership.objects.get(user=user)
        assert membership.type == 'F'
        assert membership.start_date is not None
        assert membership.end_date is not None

    # A user is created without an email address and an error is raised.
    def test_user_created_without_email_address_raises_error(self):
        # Create a new user without an email address
        with pytest.raises(Exception):
            User.objects.create(username='test_user')

class TestPayment:

    # Payment model can be created successfully with required fields
    def test_payment_model_creation_success(self):
        payment = Payment.objects.create(user=User(), timestamp=timezone.now(), amount=10.0)
        assert isinstance(payment, Payment)
        assert payment.user is not None
        assert payment.timestamp is not None
        assert payment.amount is not None

    # Payment model cannot be created without required fields
    def test_payment_model_creation_failure(self):
        with pytest.raises(Exception):
            Payment.objects.create()

class TestTrackedRequest:

    # A new user is created with a free trial membership and a stripe customer id
    def test_new_user_created_with_free_trial_membership(self, mocker):
        # Mock the stripe.Customer.create method
        mocker.patch('stripe.Customer.create')

        # Create a new user
        user = User.objects.create(username='test_user', email='test@example.com')

        # Assert that the stripe.Customer.create method was called with the correct arguments
        stripe.Customer.create.assert_called_once_with(email=user.email)

        # Assert that the user has a stripe customer id
        assert user.stripe_customer_id is not None

        # Assert that a membership object was created for the user with the correct type and start/end dates
        membership = Membership.objects.get(user=user)
        assert membership.type == 'F'
        assert membership.start_date is not None
        assert membership.end_date is not None

    # A user is created without an email address
    def test_user_created_without_email_address(self, mocker):
        # Mock the stripe.Customer.create method
        mocker.patch('stripe.Customer.create')

        # Create a new user without an email address
        user = User.objects.create(username='test_user')

        # Assert that the stripe.Customer.create method was not called
        stripe.Customer.create.assert_not_called()

        # Assert that the user does not have a stripe customer id
        assert user.stripe_customer_id is None

        # Assert that no membership object was created for the user
        with pytest.raises(Membership.DoesNotExist):
            Membership.objects.get(user=user)