"""Test for the validation access module."""

from unittest.mock import MagicMock

import pytest

from images.constants import header
from images.validation import access


@pytest.fixture
def fixture_empty_grass_headers():
    """Fixture for empty grass headers."""
    return (None, None)


@pytest.fixture
def fixture_missing_grass_account_type():
    """Fixture for missing account type."""
    return (None, 'anything')


@pytest.fixture
def fixture_missing_grass_account_id():
    """Fixture for missing grass account id."""
    return (header.GRASS_ACCOUNT_TYPE_VENDOR, None)


@pytest.fixture(params=[123, '123'])
def fixture_grass_headers_vendor(request):
    """Fixture with a valid vendor grass header."""
    vendor_id = request.param
    return (header.GRASS_ACCOUNT_TYPE_VENDOR, vendor_id)


@pytest.fixture(params=[456, '456'])
def fixture_grass_headers_subaccount(request):
    """Fixture with a valid subaccount grass header."""
    subaccount_id = request.param
    return (header.GRASS_ACCOUNT_TYPE_SUBACCOUNT, subaccount_id)


def test_get_grass_headers(monkeypatch):
    """Test relevant Grass headers are returned as a tuple."""
    expected_type = 'account-type'
    expected_id = 'account-id'

    mockRequest = MagicMock()
    mockRequest.headers.get.side_effect = [expected_type, expected_id]
    result = access.get_grass_headers(
        request=mockRequest)
    assert result == (expected_type, expected_id)


@pytest.mark.parametrize('headers', [
    (fixture_empty_grass_headers()),
    (fixture_missing_grass_account_type()),
    (fixture_missing_grass_account_id())])
def test_verify_grass_access_requires_headers(monkeypatch, headers):
    """Test headers are required."""
    monkeypatch.setattr(access, 'get_grass_headers', MagicMock(
        return_value=headers))
    result = access.verify_grass_access(request='request', required=True)
    assert not result


def test_verify_grass_access_does_not_require_headers(
        monkeypatch, fixture_empty_grass_headers):
    """Test headers are not required."""
    monkeypatch.setattr(access, 'get_grass_headers', MagicMock(
        return_value=fixture_empty_grass_headers))
    result = access.verify_grass_access(request='request', required=False)
    assert result


@pytest.mark.parametrize('headers', [
    (fixture_missing_grass_account_type()),
    (fixture_missing_grass_account_id())])
def test_verify_grass_access_fails_incomplete_headers(monkeypatch, headers):
    """Test incomplete headers are invalid."""
    monkeypatch.setattr(access, 'get_grass_headers', MagicMock(
        return_value=headers))
    result = access.verify_grass_access(request='request', required=False)
    assert not result


def test_verify_grass_access_consistency_vendor(
        monkeypatch, fixture_grass_headers_vendor):
    """Test consistency upheld between Grass headers and validation kwargs."""
    vendor_id = fixture_grass_headers_vendor[1]
    monkeypatch.setattr(access, 'get_grass_headers', MagicMock(
        return_value=fixture_grass_headers_vendor))
    result = access.verify_grass_access(
        request='request', vendor=vendor_id)
    assert result

    result = access.verify_grass_access(
        request='request',
        vendor=vendor_id,
        subaccount='anything')
    assert result

    result = access.verify_grass_access(
        request='request',
        vendor=int(vendor_id),
        subaccount='anything')
    assert result

    result = access.verify_grass_access(request='request', vendor='not valid')
    assert not result
    assert result.status == 403

    result = access.verify_grass_access(
        request='request', subaccount=vendor_id)
    assert not result
    assert result.status == 403


def test_verify_grass_access_consistency_subaccount(
        monkeypatch, fixture_grass_headers_subaccount):
    """Test consistency upheld between Grass headers and validation kwargs."""
    subaccount_id = fixture_grass_headers_subaccount[1]

    monkeypatch.setattr(access, 'get_grass_headers', MagicMock(
        return_value=fixture_grass_headers_subaccount))
    result = access.verify_grass_access(
        request='request', subaccount=subaccount_id)
    assert result

    result = access.verify_grass_access(
        request='request',
        vendor='anything',
        subaccount=subaccount_id)
    assert result

    result = access.verify_grass_access(
        request='request',
        vendor='anything',
        subaccount=int(subaccount_id))
    assert result

    result = access.verify_grass_access(
        request='request', subaccount='not_valid')
    assert not result
    assert result.status == 403

    result = access.verify_grass_access(
        request='request', vendor=subaccount_id)
    assert not result
    assert result.status == 403