import unittest
from unittest.mock import patch

import pytest
from flask import Response
from parameterized import parameterized

from delphi_api.auth import AuthCredentials, ProxyResourceProtector
from delphi_api.errors import AuthError
from tests.mocks import mock_requires_auth, mock_requires_scope


class TestAuth(unittest.TestCase):
    def setUp(self) -> None:
        self.mock_auth = mock_requires_auth()
        self.mock_scope = mock_requires_scope(True)
        self.mock_auth.start()
        self.mock_scope.start()
        from delphi_api.core.app import get_app
        self.app = get_app().app
        self.app.testing = True
        self.client = self.app.test_client()

    def test_get_token_auth_header_valid(self):
        token = 'validtoken'
        with self.app.test_request_context(headers={'Authorization': f'Bearer {token}'}):
            assert ProxyResourceProtector.get_token_auth_header() == token

    @parameterized.expand([
        '',
        'bearer',
        'notbearer butvalidtoken',
        'bearerbutmissingspace',
        'bearer but multiple tokens',
    ])
    def test_get_token_auth_header_invalid_raises(self, token):
        with self.app.test_request_context(headers={'Authorization': token}):
            e: AuthError
            with pytest.raises(AuthError) as e:
                ProxyResourceProtector.get_token_auth_header()
                assert e.status_code == 401

    def test_auth_error_response_handled_json(self):
        with patch('delphi_api.v2.views.amazon.AmazonMusicView.get_tracks_streams',
                   side_effect=AuthError({'code': 'invalid', 'description': 'invalid'}, 401)):
            with self.app.test_request_context(headers={'Authorization': 'invalid'}):
                url = '/v2/amazon/tracks/streams?start_date=2020-01-01&end_date=2020-01-06'
                response: Response = self.client.get(url)
                assert response.status_code == 401
                assert response.is_json is True

    def test_auth_credentials_to_dict(self):
        data = {
            'client_id': 'clientid',
            'client_secret': 'clientsecret',
            'grant_type': 'client_credentials',
        }
        credentials = AuthCredentials.from_dict(data)
        result = credentials.to_dict()
        assert credentials.access_token_url == result.get('access_token_url')
        assert credentials.api_base_url == result.get('api_base_url')
        assert credentials.authorize_url == result.get('authorize_url')
        assert credentials.client_kwargs == result.get('client_kwargs')

    def tearDown(self) -> None:
        self.mock_auth.stop()
        self.mock_scope.stop()