"""Test auth0_client.py."""
from auth0.v3.authentication import GetToken
from auth0.v3.exceptions import Auth0Error
from auth0.v3.management.users import Users
from auth0.v3.management.users_by_email import UsersByEmail
import pytest
from requests.exceptions import ConnectionError


from sync_env.models import auth0_client


@pytest.mark.parametrize(
    ', '.join([
        'token_result',
        'expected_message',
        'exception',
        'exception_status'
    ]), [
        (
            {'access_token': 'whatever'},
            {'access_token': 'whatever'},
            False,
            None
        ),
        (
            Auth0Error(401, 'die', 'you are dead'),
            None,
            True,
            401
        ),
        (
            ConnectionError(),
            None,
            True,
            400
        )
    ]
)
def test_get_auth0_management_token(
    mocker,
    token_result,
    expected_message,
    exception,
    exception_status
):
    """Test get Auth0 management token."""
    if exception:
        mocker.patch.object(
            GetToken, 'client_credentials', side_effect=token_result)
    else:
        mocker.patch.object(
            GetToken, 'client_credentials', return_value=token_result)

    result = auth0_client.get_auth0_management_token(
        'auth0-domain', 'auth0-url', 'client-id', 'client-secret')

    assert GetToken.client_credentials.called

    if not exception:
        assert result.message == expected_message
    else:
        assert result.status == exception_status


def test_auth0_users_paginated(mocker):
    """Test get a page of Auth0 users."""
    mocker.patch.object(
        Users, 'list', return_value={
            'users': [{'pizza': 'party'}]})
    result = auth0_client.get_auth0_users_paginated(
        'auth0-domain', 'access-token', 'connection', 0, 100)
    assert Users.list.called
    assert result.message == [{'pizza': 'party'}]


def test_delete_auth0_user(mocker):
    """Test delete an Auth0 user."""
    mocker.patch.object(
        Users, 'delete', return_value=None)
    auth0_client.delete_auth0_user(
        'auth0-domain', 'access-token', 'auth0|12345')
    assert Users.delete.called


@pytest.mark.parametrize(
    ', '.join([
        'token_result',
        'expected_message',
        'exception',
        'exception_status'
    ]), [
        (
            {'pizza': 'party'},
            {'pizza': 'party'},
            False,
            None
        ),
        (
            Auth0Error(401, 'die', 'you are dead'),
            None,
            True,
            401
        )
    ]
)
def test_create_auth0_user(
    mocker,
    token_result,
    expected_message,
    exception,
    exception_status
):
    """Test create an Auth0 user."""
    if exception:
        mocker.patch.object(
            Users, 'create', side_effect=token_result)
    else:
        mocker.patch.object(
            Users, 'create', return_value=token_result)

    result = auth0_client.create_auth0_user(
        'auth0-domain', 'access-token', {'pizza': 'party'})

    assert Users.create.called

    if not exception:
        assert result.message == expected_message
    else:
        assert result.status == exception_status


@pytest.mark.parametrize(
    ', '.join([
        'get_result',
        'expected_message',
        'exception',
        'exception_status'
    ]), [
        (
            {'pizza': 'party'},
            {'pizza': 'party'},
            False,
            None
        ),
        (
            Auth0Error(401, 'die', 'you are dead'),
            None,
            True,
            401
        )
    ]
)
def test_get_auth0_user(
    mocker,
    get_result,
    expected_message,
    exception,
    exception_status
):
    """Test getting an Auth0 user."""
    if exception:
        mocker.patch.object(
            Users, 'get', side_effect=get_result)
    else:
        mocker.patch.object(
            Users, 'get', return_value=get_result)

    result = auth0_client.get_auth0_user(
        'auth0-domain', 'access-token', 'auth0|1111')

    assert Users.get.called

    if not exception:
        assert result.message == expected_message
    else:
        assert result.status == exception_status


@pytest.mark.parametrize(
    ', '.join([
        'search_result',
        'expected_message',
        'exception',
        'exception_status'
    ]), [
        (
            [{'pizza': 'party'}],
            [{'pizza': 'party'}],
            False,
            None
        ),
        (
            Auth0Error(401, 'die', 'you are dead'),
            None,
            True,
            401
        )
    ]
)
def test_search_auth0_users_by_email(
    mocker,
    search_result,
    expected_message,
    exception,
    exception_status
):
    """Test getting an Auth0 user."""
    if exception:
        mocker.patch.object(
            UsersByEmail, 'search_users_by_email', side_effect=search_result)
    else:
        mocker.patch.object(
            UsersByEmail, 'search_users_by_email', return_value=search_result)

    result = auth0_client.search_auth0_users_by_email(
        'auth0-domain', 'access-token', 'test@test.com')

    assert UsersByEmail.search_users_by_email.called

    if not exception:
        assert result.message == expected_message
    else:
        assert result.status == exception_status