"""Tests for lookup handlers (lookups.py)."""

import json
from typing import Any
from unittest.mock import MagicMock, patch
from uuid import UUID

import pytest
from flask.testing import FlaskClient
from owsresponse import response

from account.constants.constants import FETCH_TENANT_HIERARCHY
from account.logic import company_brand, feature, subaccount, vendor


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_uuids(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by uuids."""
    expected = {'vendors': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)
    result = fixture_client.post(
        '/lookup/vendors/uuids/',
        json={
            'uuids': [
                '497ee208-e2c1-11ed-b5ea-0242ac120002',
                '51b169be-e2c1-11ed-b5ea-0242ac120002',
            ]
        },
    )

    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with(
        [
            UUID('497ee208-e2c1-11ed-b5ea-0242ac120002'),
            UUID('51b169be-e2c1-11ed-b5ea-0242ac120002'),
        ],
        [],
    )


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_uuids_not_a_uuid(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by uuids errors invalid uuid."""
    expected = {
        'code': 'input_validation_error',
        'message': {'uuids': {'0': ['Not a valid UUID.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/vendors/uuids/', json={'uuids': ['a']})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_uuids_empty_list(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by uuids errors for empty list of uuids."""
    expected = {'code': 'invalid_input', 'message': 'Request payload is not valid'}
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/vendors/uuids/', json={'uuids': []})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_uuids_unknown_field(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by uuids errors for unknown field in payload."""
    expected = {
        'code': 'input_validation_error',
        'message': {'not_uuids': ['Unknown field.']},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/vendors/uuids/', json={'not_uuids': ['a', 'b', 'c']})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_uuids_fetch_flags(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by uuids with a fetch flag."""
    expected = {'vendors': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post(
        '/lookup/vendors/uuids/',
        json={
            'uuids': ['497ee208-e2c1-11ed-b5ea-0242ac120002'],
            'fetch_flags': ['TENANT_HIERARCHY'],
        },
    )
    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with(
        [UUID('497ee208-e2c1-11ed-b5ea-0242ac120002')],
        [FETCH_TENANT_HIERARCHY],
    )


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_uuids_fetch_flags_invalid_enum(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by uuids with invalid fetch flag."""
    expected = {
        'code': 'input_validation_error',
        'message': {'fetch_flags': {'0': ['Must be one of: TENANT_HIERARCHY.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post(
        '/lookup/vendors/uuids/',
        json={
            'uuids': ['497ee208-e2c1-11ed-b5ea-0242ac120002'],
            'fetch_flags': ['NOT_A_FLAG'],
        },
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_vendor_ids(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by vendor_ids."""
    expected = {'vendors': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(vendor, 'lookup_vendors_by_vendor_ids', mock_lookup)
    result = fixture_client.post('/lookup/vendors/vendor-ids/', json={'vendor_ids': ['7', 89, 32]})

    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with([7, 89, 32], [])


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_vendor_ids_uncastable(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by vendor ids errors for non integer input."""
    expected = {
        'code': 'input_validation_error',
        'message': {'vendor_ids': {'0': ['Not a valid integer.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_vendor_ids', mock_lookup)
    result = fixture_client.post(
        '/lookup/vendors/vendor-ids/',
        json={'vendor_ids': ['uncastable string', '7', 89, 32]},
    )

    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_vendor_ids_unknown_field_payload(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by vendor ids errors for unknown field in payload."""
    expected = {
        'code': 'input_validation_error',
        'message': {'not_vendor_ids': ['Unknown field.']},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/vendors/vendor-ids/', json={'not_vendor_ids': ['a']})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_vendor_ids_empty_list_payload(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by vendor ids errors for empty list of vendor ids."""
    expected = {'code': 'invalid_input', 'message': 'Request payload is not valid'}
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/vendors/vendor-ids/', json={'vendor_ids': []})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_vendor_ids_fetch_flags(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by vendor_ids with a fetch flag."""
    expected = {'vendors': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(vendor, 'lookup_vendors_by_vendor_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/vendors/vendor-ids/',
        json={
            'vendor_ids': [111],
            'fetch_flags': ['TENANT_HIERARCHY'],
        },
    )
    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with(
        [111],
        [FETCH_TENANT_HIERARCHY],
    )


@patch('connector_neo4j.Neo4jSession')
@patch('connector_neo4j.Neo4jSession.__enter__')
@patch('connector_neo4j.Neo4jSession.__exit__')
def test_lookup_vendors_by_vendor_ids_fetch_flags_invalid_enum(
    mock_session, neo4j_enter, neo4j_exit, monkeypatch, fixture_client
):
    """Test lookup vendors by vendor_ids with invalid fetch flag."""
    expected = {
        'code': 'input_validation_error',
        'message': {'fetch_flags': {'0': ['Must be one of: TENANT_HIERARCHY.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(vendor, 'lookup_vendors_by_vendor_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/vendors/vendor-ids/',
        json={
            'vendor_ids': [222],
            'fetch_flags': ['NOT_A_FLAG'],
        },
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


@pytest.mark.parametrize(
    'payload, expected_status, expected_response, expected_call_args',
    [
        pytest.param(
            {
                'uuids': [
                    '497ee208-e2c1-11ed-b5ea-0242ac120002',
                    '51b169be-e2c1-11ed-b5ea-0242ac120002',
                ]
            },
            200,
            {'vendors': []},
            [
                '497ee208-e2c1-11ed-b5ea-0242ac120002',
                '51b169be-e2c1-11ed-b5ea-0242ac120002',
            ],
            id='valid_uuids',
        ),
        pytest.param(
            {'uuids': []},
            400,
            {'code': 'invalid_input', 'message': 'Request payload is not valid'},
            None,
            id='empty_uuids',
        ),
        pytest.param(
            {'uuids': ['a']},
            400,
            {'code': 'input_validation_error', 'message': {'uuids': {'0': ['Not a valid UUID.']}}},
            None,
            id='not_a_uuid',
        ),
        pytest.param(
            {'not_uuids': ['a', 'b', 'c']},
            400,
            {'code': 'input_validation_error', 'message': {'not_uuids': ['Unknown field.']}},
            None,
            id='unknown_field',
        ),
    ],
)
def test_lookup_vendors_features_by_uuids(
    payload, expected_status, expected_response, expected_call_args, monkeypatch, fixture_client
):
    """Test lookup vendor features by uuids."""
    mock_lookup = MagicMock(return_value=response.Response({'vendors': []}))
    monkeypatch.setattr(feature, 'lookup_features_by_vendor_uuids', mock_lookup)

    result = fixture_client.post('/lookup/vendors/features/uuids/', json=payload)

    assert result.status_code == expected_status
    assert json.loads(result.data) == expected_response
    if expected_call_args is not None:
        mock_lookup.assert_called_once_with(expected_call_args)
    else:
        mock_lookup.assert_not_called()


@pytest.mark.parametrize(
    'payload, expected_status, expected_response, expected_call_args',
    [
        pytest.param(
            {
                'uuids': [
                    '3b95f877-c798-45de-9918-0f195c6a6a99',
                    'baf96e30-0287-11ef-94e4-4a2888760683',
                ]
            },
            200,
            {'subaccounts': []},
            [
                '3b95f877-c798-45de-9918-0f195c6a6a99',
                'baf96e30-0287-11ef-94e4-4a2888760683',
            ],
            id='valid_uuids',
        ),
        pytest.param(
            {'uuids': []},
            400,
            {'code': 'invalid_input', 'message': 'Request payload is not valid'},
            None,
            id='empty_uuids',
        ),
        pytest.param(
            {'uuids': ['a']},
            400,
            {'code': 'input_validation_error', 'message': {'uuids': {'0': ['Not a valid UUID.']}}},
            None,
            id='not_a_uuid',
        ),
        pytest.param(
            {'not_uuids': ['a', 'b', 'c']},
            400,
            {'code': 'input_validation_error', 'message': {'not_uuids': ['Unknown field.']}},
            None,
            id='unknown_field',
        ),
    ],
)
def test_lookup_subaccount_features_by_uuids(
    payload, expected_status, expected_response, expected_call_args, monkeypatch, fixture_client
):
    """Test lookup subaccount features by uuids."""
    mock_lookup = MagicMock(return_value=response.Response({'subaccounts': []}))
    monkeypatch.setattr(feature, 'lookup_features_by_subaccount_uuids', mock_lookup)

    result = fixture_client.post('/lookup/subaccounts/features/uuids/', json=payload)

    assert result.status_code == expected_status
    assert json.loads(result.data) == expected_response
    if expected_call_args is not None:
        mock_lookup.assert_called_once_with(expected_call_args)
    else:
        mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_uuids(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts by subaccount_uuids"""
    expected = {'subaccounts': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_uuids', mock_lookup)
    result = fixture_client.post(
        '/lookup/subaccounts/uuids/',
        json={
            'uuids': [
                '3b95f877-c798-45de-9918-0f195c6a6a99',
                'baf96e30-0287-11ef-94e4-4a2888760683',
            ]
        },
    )

    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with(
        [
            UUID('3b95f877-c798-45de-9918-0f195c6a6a99'),
            UUID('baf96e30-0287-11ef-94e4-4a2888760683'),
        ],
        [],
    )


def test_lookup_subaccounts_by_uuids_not_a_uuid(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts with an invalid uuid."""
    expected = {
        'code': 'input_validation_error',
        'message': {'uuids': {'0': ['Not a valid UUID.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/subaccounts/uuids/', json={'uuids': ['a']})

    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_uuids_empty_list(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts with an empty list."""
    expected = {'code': 'invalid_input', 'message': 'Request payload is not valid'}
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/subaccounts/uuids/', json={'uuids': []})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_uuids_unknown_field(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts with an unknown field in the payload."""
    expected = {
        'code': 'input_validation_error',
        'message': {'not_uuids': ['Unknown field.']},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/subaccounts/uuids/', json={'not_uuids': ['a', 'b', 'c']})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_uuids_fetch_flags(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts with a fetch flag."""
    expected = {'subaccounts': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_uuids', mock_lookup)

    result = fixture_client.post(
        '/lookup/subaccounts/uuids/',
        json={
            'uuids': ['3b95f877-c798-45de-9918-0f195c6a6a99'],
            'fetch_flags': ['TENANT_HIERARCHY'],
        },
    )
    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with(
        [UUID('3b95f877-c798-45de-9918-0f195c6a6a99')],
        [FETCH_TENANT_HIERARCHY],
    )


def test_lookup_subaccounts_by_uuids_fetch_flags_invalid_enum(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts with an invalid fetch flag"""
    expected = {
        'code': 'input_validation_error',
        'message': {'fetch_flags': {'0': ['Must be one of: TENANT_HIERARCHY.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_uuids', mock_lookup)

    result = fixture_client.post(
        '/lookup/subaccounts/uuids/',
        json={
            'uuids': ['3b95f877-c798-45de-9918-0f195c6a6a99'],
            'fetch_flags': ['NO.SUCH.FLAG'],
        },
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_subaccount_ids(monkeypatch, fixture_client):
    """Test lookup subaccounts by subaccount_ids."""
    expected = {'subaccounts': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_subaccount_ids', mock_lookup)
    result = fixture_client.post(
        '/lookup/subaccounts/subaccount-ids/', json={'subaccount_ids': ['7', 89, 32]}
    )

    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with([7, 89, 32], [])


def test_lookup_subaccounts_by_subaccount_ids_empty_list(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts by id with an empty list."""
    expected = {'code': 'invalid_input', 'message': 'Request payload is not valid'}
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_subaccount_ids', mock_lookup)

    result = fixture_client.post('/lookup/subaccounts/subaccount-ids/', json={'subaccount_ids': []})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_subaccount_ids_unknown_field(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts by id with an unknown field in the payload."""
    expected = {
        'code': 'input_validation_error',
        'message': {'something_unexpected': ['Unknown field.']},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_subaccount_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/subaccounts/subaccount-ids/', json={'something_unexpected': []}
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_subaccounts_by_subaccount_ids_fetch_flags(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts by id with a fetch flag."""
    expected = {'subaccounts': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_subaccount_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/subaccounts/subaccount-ids/',
        json={'subaccount_ids': ['7', 89, 32], 'fetch_flags': ['TENANT_HIERARCHY']},
    )
    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with([7, 89, 32], [FETCH_TENANT_HIERARCHY])


def test_lookup_subaccounts_by_subaccount_ids_fetch_flags_invalid_enum(
    monkeypatch: Any,
    fixture_client: FlaskClient,
) -> None:
    """Test lookup subaccounts by id with an invalid fetch flag."""
    expected = {
        'code': 'input_validation_error',
        'message': {'fetch_flags': {'0': ['Must be one of: TENANT_HIERARCHY.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(subaccount, 'lookup_subaccounts_by_subaccount_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/subaccounts/subaccount-ids/',
        json={'subaccount_ids': ['7', 89, 32], 'fetch_flags': ['NO.SUCH.FLAG']},
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    mock_lookup.assert_not_called()


def test_lookup_company_brands_by_uuids(monkeypatch, fixture_client):
    """Test lookup company brands by uuids."""
    expected = {'company_brands': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_uuids', mock_lookup)
    result = fixture_client.post(
        '/lookup/company-brands/uuids/',
        json={
            'uuids': [
                '497ee208-e2c1-11ed-b5ea-0242ac120002',
                '51b169be-e2c1-11ed-b5ea-0242ac120002',
            ]
        },
    )

    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with(
        [
            UUID('497ee208-e2c1-11ed-b5ea-0242ac120002'),
            UUID('51b169be-e2c1-11ed-b5ea-0242ac120002'),
        ],
    )


def test_lookup_company_brands_by_uuids_not_a_uuid(monkeypatch, fixture_client):
    """Test lookup company brands by uuids errors invalid uuid."""
    expected = {
        'code': 'input_validation_error',
        'message': {'uuids': {'0': ['Not a valid UUID.']}},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/company-brands/uuids/', json={'uuids': ['a']})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


def test_lookup_company_brands_by_uuids_empty_list(monkeypatch, fixture_client):
    """Test lookup company brands by uuids errors for empty list of uuids."""
    expected = {'code': 'invalid_input', 'message': 'Request payload is not valid'}
    mock_lookup = MagicMock()
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/company-brands/uuids/', json={'uuids': []})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


def test_lookup_company_brands_by_uuids_unknown_field(monkeypatch, fixture_client):
    """Test lookup company brands by uuids errors for unknown field in payload."""
    expected = {
        'code': 'input_validation_error',
        'message': {'not_uuids': ['Unknown field.']},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_uuids', mock_lookup)

    result = fixture_client.post('/lookup/company-brands/uuids/', json={'not_uuids': ['a']})
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


def test_lookup_company_brands_by_ids(monkeypatch, fixture_client):
    """Test lookup company brands by ids."""
    expected = {'company_brands': []}
    mock_lookup = MagicMock(return_value=response.Response(expected))
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_ids', mock_lookup)
    result = fixture_client.post(
        '/lookup/company-brands/company-brand-ids/',
        json={
            'company_brand_ids': [
                1,
                2,
            ]
        },
    )

    assert result.status_code == 200
    assert json.loads(result.data) == expected
    mock_lookup.assert_called_once_with([1, 2])


def test_lookup_company_brands_by_ids_empty_list(monkeypatch, fixture_client) -> None:
    """Test lookup company brands by ids errors for empty list of ids."""
    expected = {'code': 'invalid_input', 'message': 'Request payload is not valid'}
    mock_lookup = MagicMock()
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/company-brands/company-brand-ids/', json={'company_brand_ids': []}
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0


def test_lookup_company_brands_by_ids_unknown_field(monkeypatch, fixture_client) -> None:
    """Test lookup company brands by ids errors for unknown field in payload."""
    expected = {
        'code': 'input_validation_error',
        'message': {'not_company_brand_ids': ['Unknown field.']},
    }
    mock_lookup = MagicMock()
    monkeypatch.setattr(company_brand, 'lookup_company_brands_by_ids', mock_lookup)

    result = fixture_client.post(
        '/lookup/company-brands/company-brand-ids/', json={'not_company_brand_ids': ['a']}
    )
    assert result.status_code == 400
    assert json.loads(result.data) == expected
    assert mock_lookup.call_count == 0