"""Tests for ows-users service."""

from unittest.mock import MagicMock, patch

import pytest
from flexmock import flexmock

from analytics.api import app
from analytics.constants import service as service_constants
from analytics.services import ows_users, request


class TestOWSUsersIsUserHasAccessGoodResponse:
    """Test call to ows-users with good response."""

    account_type = "vendor"
    account_id = "1"
    user_id = "alw:1"

    response = {"role_ids": [4], "role_names": ["Administrator"]}

    @pytest.fixture
    def mock_response(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=200)
        mock_response.json = MagicMock(return_value=self.response)
        return mock_response

    @pytest.fixture
    def mock_request(self, mock_response):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_ROLES_RESOURCE,
            headers={
                "Grass-Account-Type": self.account_type,
                "Grass-Account-Id": self.account_id,
                "Orchard-User-Id": self.user_id,
            },
        ).and_return(mock_response)

    def test_success(self, mock_request):
        """Test 200 response is returned."""
        result = ows_users.user_has_access(
            self.account_id, self.account_type, self.user_id
        )
        assert result.message is True


class TestOWSUsersIsUserHasAccessBadResponse:
    """Test call to ows-users with bad response."""

    account_type = "vendor"
    account_id = "1"
    user_id = "alw:1"

    response_no_feature = {"role_ids": [4], "role_names": ["blah"]}

    @pytest.fixture
    def mock_response_error(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=404)
        return mock_response

    @pytest.fixture
    def mock_response_no_feature(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=200)
        mock_response.json = MagicMock(return_value=self.response_no_feature)
        return mock_response

    @pytest.fixture
    def mock_request_error(self, mock_response_error):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_ROLES_RESOURCE,
            headers={
                "Grass-Account-Type": self.account_type,
                "Grass-Account-Id": self.account_id,
                "Orchard-User-Id": self.user_id,
            },
        ).and_return(mock_response_error)

    @pytest.fixture
    def mock_request_no_feature(self, mock_response_no_feature):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_ROLES_RESOURCE,
            headers={
                "Grass-Account-Type": self.account_type,
                "Grass-Account-Id": self.account_id,
                "Orchard-User-Id": self.user_id,
            },
        ).and_return(mock_response_no_feature)

    def test_failure_of_ows_users(self, mock_request_error):
        """Test Exception raised."""
        with pytest.raises(Exception):
            ows_users.user_has_access(self.account_id, self.account_type, self.user_id)

    def test_failure_because_of_no_feature(self, mock_request_no_feature):
        """Test Exception raised."""
        assert (
            ows_users.user_has_access(
                self.account_id, self.account_type, self.user_id
            ).message
            is False
        )


class TestOWSUsersMetadataResourceGoodResponse:
    """Test good OWS_USERS_METADATA_RESOURCE response."""

    headers = {
        "Grass-Account-Type": "vendor",
        "Grass-Account-Id": "1",
        "Orchard-User-Id": "alw:1",
    }

    response = {"vend_contact_roles": [{"role": {"role": "Analytics"}}]}

    @pytest.fixture
    def mock_response(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=200)
        mock_response.json = MagicMock(return_value=self.response)
        return mock_response

    @pytest.fixture
    def mock_request(self, mock_response):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_METADATA_RESOURCE,
            headers=self.headers,
        ).and_return(mock_response)

    def test_success(self, mock_request):
        """Test 200 response is returned."""
        result = ows_users._check_session_endpoint(self.headers)
        assert result.json() == self.response


class TestOWSUsersMetadataResourceBadResponse:
    """Test bad OWS_USERS_METADATA_RESOURCE response."""

    headers = {
        "Grass-Account-Type": "vendor",
        "Grass-Account-Id": "1",
        "Orchard-User-Id": "alw:1",
    }

    @pytest.fixture
    def mock_response_error(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=404)
        return mock_response

    @pytest.fixture
    def mock_request_error(self, mock_response_error):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_METADATA_RESOURCE,
            headers=self.headers,
        ).and_return(mock_response_error)

    def test_failure_of_metadata_resource(self, mock_request_error):
        """Test Exception raised."""
        with pytest.raises(Exception):
            ows_users._check_session_endpoint(self.headers)


class TestOWSUsersIsUserHasAccessWithMetadataGoodResponse:
    """Test call to ows-users with good Metadata response."""

    account_type = "vendor"
    account_id = "1"
    user_id = "alw:1"

    headers = {
        "Grass-Account-Type": "vendor",
        "Grass-Account-Id": "1",
        "Orchard-User-Id": "alw:1",
    }

    metadata_response = {"vend_contact_roles": [{"role": {"role": "Analytics"}}]}

    @pytest.fixture
    def mock_response_error(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=404)
        return mock_response

    @pytest.fixture
    def mock_response(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=200)
        mock_response.json = MagicMock(return_value=self.metadata_response)
        return mock_response

    @pytest.fixture
    def mock_request(self, mock_response_error, mock_response):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_ROLES_RESOURCE,
            headers=self.headers,
        ).and_return(mock_response_error)

        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_METADATA_RESOURCE,
            headers=self.headers,
        ).and_return(mock_response)

    def test_success_metadata(self, mock_request):
        """Test 200 response is returned."""
        with app.app_context(), patch("analytics.services.ows_users.g"):
            result = ows_users.user_has_access(
                self.account_id, self.account_type, self.user_id
            )
            assert result.message is True


class TestOWSUsersGetLinkedAccountsGoodResponse:
    """Test call to ows-users for linked accounts."""

    user_id = "alw:1"
    response = ["alw:2"]

    @pytest.fixture
    def mock_response(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=200)
        mock_response.json = MagicMock(return_value=self.response)
        return mock_response

    @pytest.fixture
    def mock_request(self, mock_response):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_LINKED_ACCOUNTS_RESOURCE.format(
                user_id=self.user_id.lstrip("alw:")
            ),
        ).and_return(mock_response)

    def test_success(self, mock_request):
        """Test linked accounts are returned."""
        result = ows_users.get_linked_accounts(self.user_id)
        assert len(result) == 1


class TestOWSUsersGetLinkedAccountsBadResponse:
    """Test call to ows-users for linked accounts with bad response."""

    user_id = "alw:1"
    response = []

    @pytest.fixture
    def mock_response_error(self):
        """Return mock response of ows-users."""
        mock_response = MagicMock(status_code=404)
        return mock_response

    @pytest.fixture
    def mock_request_error(self, mock_response_error):
        """Mock GET request."""
        flexmock(request).should_receive("get").with_args(
            service_constants.OWS_USERS,
            service_constants.OWS_USERS_LINKED_ACCOUNTS_RESOURCE.format(
                user_id=self.user_id.lstrip("alw:")
            ),
        ).and_return(mock_response_error)

    def test_failure_of_ows_users(self, mock_request_error):
        """Test Exception raised."""
        with pytest.raises(Exception):
            ows_users.get_linked_accounts(self.user_id)