"""Tests for handlers module."""

import json
from unittest.mock import MagicMock, patch

import pytest
from owsrequest import flask_request

from contracts import config, response
from contracts.constants import header, query
from contracts.logic import (
    account,
    advances,
    healthcheck,
    mech_admin,
    service_types,
    vendor_contracts,
)
from contracts.models import subaccount_royalty_collection


@pytest.fixture
def fixture_response_ok():
    """Create a response.Response fixture for generic ok."""
    return response.Response(message='ok', status=200)


@pytest.fixture
def fixture_mechadmin_response():
    """Create a response.Response fixture with status_code 200."""
    return response.Response({'status_code': 200})


@pytest.fixture
def fixture_response_error():
    """Create a response.Response fixture for generic error."""
    return response.create_error_response(code='error_code', message='error_message')


@pytest.fixture
def fixture_account_is_mech_admin():
    """Fixture for mechadmin vendor."""
    return response.Response({'mechadmin_digital': True, 'mechadmin_physical': False})


def test_handler_healthcheck_hello(
    monkeypatch, client, fixture_response_ok, valid_get_header
):
    """Test /hello/ healthcheck endpoint of handler."""
    monkeypatch.setattr(
        healthcheck, 'status', value=MagicMock(return_value=fixture_response_ok)
    )
    result = client.get(config.HEALTH_CHECK, headers=valid_get_header)
    assert result
    assert healthcheck.status.called


def test_handler_db_healthcheck(
    monkeypatch, client, fixture_response_ok, valid_get_header
):
    """Test / endpoint of handler."""
    monkeypatch.setattr(
        healthcheck, 'db_status', value=MagicMock(return_value=fixture_response_ok)
    )
    result = client.get(config.DB_HEALTH_CHECK, headers=valid_get_header)
    assert result
    assert healthcheck.db_status.called


@patch('contracts.handlers.healthcheck.status', side_effect=Exception())
def test_exception_handler(mock_jsonify, client):
    """Test an uncaught Exception results in a 500 status code."""
    result = client.get(config.HEALTH_CHECK)
    assert result.status_code == 500


def test_handler_get_mechadmin_success(
    monkeypatch,
    fixture_response_ok,
    fixture_mechadmin_response,
    client,
    valid_get_header,
):
    """Test HEAD /mechadmin handler success state."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        mech_admin,
        'is_mech_admin',
        value=MagicMock(return_value=fixture_mechadmin_response),
    )
    result = client.head('/mechadmin', headers=valid_get_header)

    assert result
    assert flask_request.verify_grass_access.called


def test_handler_get_mechadmin_invalid(
    monkeypatch, fixture_response_error, client, valid_get_header
):
    """Test HEAD /mechadmin handler fail state."""
    invalid_header = valid_get_header
    invalid_header.pop(header.GRASS_ACCOUNT_ID)
    result = client.head('/mechadmin', headers=valid_get_header)
    assert result.status_code == 400


@pytest.mark.parametrize('grass_account_type', ['vendor', 'subaccount'])
def test_handler_get_account_mechadmin_success(
    mocker, fixture_mechadmin_response, client, grass_account_type
):
    """Test HEAD /<account_type>/<account_id>/mechadmin endpoint of handler."""
    mock_is_mech_admin = mocker.patch.object(
        mech_admin, 'is_mech_admin', return_value=fixture_mechadmin_response
    )

    url = '/{}/1/mechadmin'.format(grass_account_type)
    result = client.head(url)

    assert result.status_code == 200
    mock_is_mech_admin.assert_called_with(grass_account_type, '1')


def test_handler_get_account_mechadmin_invalid(client):
    """Test HEAD /<account_type>/<account_id>/mechadmin invalid state."""
    result = client.head('/invalid_type/1/mechadmin')
    assert result.status_code == 400


def test_handler_get_vendor_advances_success(
    monkeypatch,
    fixture_response_ok,
    fixture_mechadmin_response,
    client,
    valid_get_header,
):
    """Test HEAD /vendor/<vendor_id>/advances endpoint of handler."""
    fixture_code = 200
    fixture_message = 'ok'
    expected_valid_response = response.Response(
        message=fixture_message, status=fixture_code
    )

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        advances, 'get_advances', value=MagicMock(return_value=expected_valid_response)
    )

    result = client.get('/vendor/123/advances', headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert advances.get_advances.called
    assert result.status_code == expected_valid_response.status
    assert result.data == fixture_message.encode('utf-8')


def test_handler_get_vendor_advances_invalid(
    monkeypatch, fixture_mechadmin_response, client, valid_get_header
):
    """Test HEAD /vendor/<vendor_id>/advances invalid state."""
    monkeypatch.setattr(advances, 'get_advances', value=MagicMock())

    result = client.head('/vendor/123/advances', headers=valid_get_header)

    # Assertions
    assert result.status_code == 403
    advances.get_advances.assert_not_called()


def test_handler_get_active_vendor_contract_success(
    monkeypatch,
    fixture_response_ok,
    fixture_active_vendor_contract,
    client,
    valid_get_header,
):
    """Test GET /vendor/<vendor_id>/active endpoint of handler."""
    expected_valid_response = response.Response(message='ok', status=200)

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        vendor_contracts,
        'get_active_vendor_contract',
        value=MagicMock(return_value=fixture_active_vendor_contract),
    )

    result = client.get('/vendor/123/active', headers=valid_get_header)

    assert flask_request.verify_grass_access.called
    assert vendor_contracts.get_active_vendor_contract.called
    assert result.status_code == expected_valid_response.status
    assert json.loads(result.data.decode()) == fixture_active_vendor_contract.message


def test_handler_get_active_vendor_contract_invalid(
    monkeypatch, client, valid_get_header
):
    """Test GET /vendor/<vendor_id>/active invalid state."""
    monkeypatch.setattr(
        vendor_contracts, 'get_active_vendor_contract', value=MagicMock()
    )

    result = client.head('/vendor/123/active', headers=valid_get_header)

    # Assertions
    assert result.status_code == 403
    vendor_contracts.get_active_vendor_contract.assert_not_called()


def test_handler_get_active_vendor_contract_not_found(
    monkeypatch,
    client,
    valid_get_header,
    create_not_found_response,
    fixture_response_ok,
):
    """Test GET /vendor/<vendor_id>/active invalid state."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )

    monkeypatch.setattr(
        vendor_contracts,
        'get_active_vendor_contract',
        value=MagicMock(return_value=create_not_found_response),
    )

    result = client.head('/vendor/123/active', headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert vendor_contracts.get_active_vendor_contract.called
    assert result.status_code == 404


def test_handler_get_vendor_contract_success(
    monkeypatch, fixture_vendor_contract_response, client
):
    """Test GET /contracts/<contract_id> endpoint of handler."""
    expected_valid_response = response.Response(message='ok', status=200)

    monkeypatch.setattr(
        vendor_contracts,
        'get_vendor_contract',
        value=MagicMock(return_value=fixture_vendor_contract_response),
    )

    result = client.get('/contracts/123')

    assert vendor_contracts.get_vendor_contract.called
    assert result.status_code == expected_valid_response.status
    assert json.loads(result.data.decode()) == fixture_vendor_contract_response.message


def test_handler_get_vendor_contract_not_found(
    monkeypatch, client, create_not_found_response
):
    """Test GET /contracts/<contract_id> not found."""
    monkeypatch.setattr(
        vendor_contracts,
        'get_vendor_contract',
        value=MagicMock(return_value=create_not_found_response),
    )

    result = client.get('/contracts/123')

    # Assertions
    assert vendor_contracts.get_vendor_contract.called
    assert result.status_code == 404


def test_handler_get_vendor_booked_contracts_success(
    monkeypatch, fixture_response_ok, client, valid_get_header
):
    """Test GET /booked/vendor/<vendor_id> successful state."""
    fixture_message = 'ok'

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        vendor_contracts,
        'get_booked_contracts',
        value=MagicMock(return_value=fixture_response_ok),
    )

    result = client.get('/booked/vendor/123', headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert vendor_contracts.get_booked_contracts.called
    assert result.status_code == fixture_response_ok.status
    assert result.data == fixture_message.encode('utf-8')


def test_handler_get_vendor_booked_contracts_invalid(
    monkeypatch, client, valid_get_header
):
    """Test GET /booked/vendor/<vendor_id> invalid state."""
    monkeypatch.setattr(vendor_contracts, 'get_booked_contracts', value=MagicMock())

    result = client.get('/booked/vendor/123', headers=valid_get_header)

    # Assertions
    assert result.status_code == 403
    vendor_contracts.get_booked_contracts.assert_not_called()


@patch('contracts.logic.vendor_contracts.get_booked_contracts', side_effect=Exception())
def test_handler_get_vendor_booked_contracts_exception(mock_jsonify, client):
    """Test GET /booked/vendor/<vendor_id> uncaught Exception."""
    result = client.get('/booked/vendor/123')
    assert result.status_code == 500


def test_handler_get_subaccount_booked_contracts_success(
    monkeypatch, fixture_response_ok, client, valid_get_header
):
    """Test GET /booked/subaccount/<subaccount_id> successful state."""
    fixture_message = 'ok'
    expected_vendor = 100

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        account,
        'get_vendor_by_subaccount',
        value=MagicMock(return_value=response.Response(expected_vendor)),
    )
    monkeypatch.setattr(
        vendor_contracts,
        'get_booked_contracts',
        value=MagicMock(return_value=fixture_response_ok),
    )

    result = client.get('/booked/subaccount/123', headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert vendor_contracts.get_booked_contracts.called
    vendor_contracts.get_booked_contracts.assert_called_with(
        expected_vendor, query.DESC, query.PAGE_LIMIT_DEFAULT, query.PAGE_OFFSET_DEFAULT
    )
    assert result.status_code == fixture_response_ok.status
    assert result.data == fixture_message.encode('utf-8')


def test_handler_get_subaccount_booked_contracts_invalid_id(
    monkeypatch, fixture_response_ok, fixture_response_error, client, valid_get_header
):
    """Test GET /booked/subaccount/<subaccount_id> with invalid id."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        account,
        'get_vendor_by_subaccount',
        value=MagicMock(return_value=fixture_response_error),
    )
    monkeypatch.setattr(vendor_contracts, 'get_booked_contracts', value=MagicMock())

    result = client.get('/booked/subaccount/123', headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert result.status_code == 400
    vendor_contracts.get_booked_contracts.assert_not_called()


def test_handler_get_subaccount_booked_contracts_invalid(
    monkeypatch, client, valid_get_header
):
    """Test GET /booked/subaccount/<subaccount_id> invalid state."""
    monkeypatch.setattr(vendor_contracts, 'get_booked_contracts', value=MagicMock())

    result = client.get('/booked/subaccount/123', headers=valid_get_header)

    # Assertions
    assert result.status_code == 403
    vendor_contracts.get_booked_contracts.assert_not_called()


@patch('contracts.logic.vendor_contracts.get_booked_contracts', side_effect=Exception())
def test_handler_get_subaccount_booked_contracts_exception(mock_jsonify, client):
    """Test GET /booked/subaccount/<subaccount_id> uncaught Exception."""
    result = client.get('/booked/subaccount/123')
    assert result.status_code == 500


def test_handler_get_account_mech_admin_for_authorized_success(
    monkeypatch,
    fixture_response_ok,
    fixture_mechadmin_response,
    client,
    valid_get_header,
):
    """Test HEAD /mechadmin_for_account handler success state."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        mech_admin,
        'account_is_mech_admin',
        value=MagicMock(return_value=fixture_mechadmin_response),
    )
    result = client.get('/mechadmin_for_account', headers=valid_get_header)

    assert result
    assert flask_request.verify_grass_access.called


def test_handler_get_account_mech_admin_for_authorized_invalid(
    monkeypatch, fixture_response_error, client, valid_get_header
):
    """Test HEAD /mechadmin_for_account handler fail state."""
    invalid_header = valid_get_header
    invalid_header.pop(header.GRASS_ACCOUNT_ID)
    result = client.get('/mechadmin_for_account', headers=valid_get_header)
    assert result.status_code == 400


@pytest.mark.parametrize('grass_account_type', ['vendor', 'subaccount'])
def test_get_account_mech_admin_success(
    mocker, fixture_account_is_mech_admin, client, grass_account_type
):
    """Test GET /<account_type>/<account_id>/mechadmin_for_account handler."""
    mock_account_is_mech_admin = mocker.patch.object(
        mech_admin, 'account_is_mech_admin', return_value=fixture_account_is_mech_admin
    )
    url = '/{}/1/mechadmin_for_account'.format(grass_account_type)
    result = client.get(url)

    assert result.status_code == 200
    mock_account_is_mech_admin.assert_called_with(grass_account_type, '1')


def test_handler_get_account_mech_admin_invalid(client):
    """Test GET /<account_type>/<account_id>/mechadmin_for_account failure."""
    result = client.get('/invalid_type/1/mechadmin_for_account')
    assert result.status_code == 400


def test_handler_get_service_types_success(
    monkeypatch, fixture_vendor_contract_response, client
):
    """Test GET /contracts/service-types endpoint of handler."""
    expected_valid_response = response.Response(message='ok', status=200)

    monkeypatch.setattr(
        flask_request,
        'verify_rules_access_standalone',
        value=MagicMock(return_value=True),
    )
    monkeypatch.setattr(
        service_types,
        'get_service_types',
        value=MagicMock(return_value=fixture_vendor_contract_response),
    )

    result = client.get('/contracts/service-types')

    assert flask_request.verify_rules_access_standalone.called
    assert service_types.get_service_types.called
    assert result.status_code == expected_valid_response.status
    assert json.loads(result.data.decode()) == fixture_vendor_contract_response.message


def test_handler_get_service_types_invalid(monkeypatch, client):
    """Test GET /contracts/service-types endpoint of handler."""
    monkeypatch.setattr(
        flask_request,
        'verify_rules_access_standalone',
        value=MagicMock(return_value=False),
    )
    result = client.get('/contracts/service-types')

    assert flask_request.verify_rules_access_standalone.called
    assert result.status_code == 403


def test_handler_get_contract_service_type_success(
    monkeypatch, fixture_contract_service_type_response, client
):
    """Test GET /contracts/<contract_id>/service-types endpoint."""
    contract_id = '123'
    expected_valid_response = response.Response(message='ok', status=200)

    monkeypatch.setattr(
        flask_request,
        'verify_rules_access_standalone',
        value=MagicMock(return_value=True),
    )
    monkeypatch.setattr(
        vendor_contracts,
        'get_contract_service_type',
        value=MagicMock(return_value=fixture_contract_service_type_response),
    )

    result = client.get('/contracts/123/service-type')

    vendor_contracts.get_contract_service_type.assert_called_with(contract_id)
    assert flask_request.verify_rules_access_standalone.called
    assert result.status_code == expected_valid_response.status
    assert (
        json.loads(result.data.decode())
        == fixture_contract_service_type_response.message
    )


def test_handler_get_contract_service_type_invalid(monkeypatch, client):
    """Test GET /contracts/<contract_id>/service-types endpoint."""
    monkeypatch.setattr(
        flask_request,
        'verify_rules_access_standalone',
        value=MagicMock(return_value=False),
    )
    result = client.get('/contracts/123/service-type')

    assert flask_request.verify_rules_access_standalone.called
    assert result.status_code == 403


def test_handler_get_product_split(monkeypatch, client, fixture_product_split_response):
    """Test GET product_split."""
    expected_valid_response = response.Response(message='ok', status=200)

    monkeypatch.setattr(
        vendor_contracts,
        'get_product_split',
        value=MagicMock(return_value=fixture_product_split_response),
    )
    result = client.get(
        '/contracts/product_split/3513135135?page_offset=1&page_limit=2'
    )
    vendor_contracts.get_product_split.assert_called_with(
        '3513135135', page_offset=1, page_limit=2
    )
    assert result.status_code == expected_valid_response.status
    assert json.loads(result.data.decode()) == fixture_product_split_response.message


def test_handler_get_track_split(monkeypatch, client, fixture_track_split_response):
    """Test GET track_split."""
    expected_valid_response = response.Response(message='ok', status=200)

    monkeypatch.setattr(
        vendor_contracts,
        'get_track_split',
        value=MagicMock(return_value=fixture_track_split_response),
    )
    result = client.get('/contracts/track_split/123?page_offset=1&page_limit=2')
    vendor_contracts.get_track_split.assert_called_with(
        '123', page_offset=1, page_limit=2
    )

    assert result.status_code == expected_valid_response.status
    assert json.loads(result.data.decode()) == fixture_track_split_response.message


def test_handler_delete_track_split_success(monkeypatch, client):
    """Test DELETE track_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'delete_track_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = {
        'isrc': 'ES20I1310346',
        'oa_user_id': 562,
        'vend_contract_id': 5623,
    }

    result = client.delete(
        '/contracts/track_split/123',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    vendor_contracts.delete_track_split.assert_called_with('123', request_params)
    assert result.status_code == 200


def test_handler_delete_track_split_error(monkeypatch, client, fixture_response_error):
    """Test DELETE track_split for missing parameter."""
    monkeypatch.setattr(
        vendor_contracts,
        'delete_track_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = {'oa_user_id': 562, 'vend_contract_id': 5623}

    result = client.delete(
        '/contracts/track_split/123',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_set_track_split_success(
    monkeypatch, client, fixture_track_split_post_request_parameters
):
    """Test POST track_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'set_track_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = [fixture_track_split_post_request_parameters]

    result = client.post(
        '/contracts/track_split/123',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    vendor_contracts.set_track_split.assert_called_with('123', request_params)
    assert result.status_code == 200


def test_handler_set_track_split_error(
    monkeypatch,
    client,
    fixture_response_error,
    fixture_track_split_post_request_parameters,
):
    """Test POST track_split for missing parameter."""
    monkeypatch.setattr(
        vendor_contracts,
        'set_track_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    del fixture_track_split_post_request_parameters['isrc']
    request_params = [fixture_track_split_post_request_parameters]

    result = client.post(
        '/contracts/track_split/123',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_update_track_split_error(
    monkeypatch,
    client,
    fixture_response_error,
    fixture_track_split_put_request_parameters,
):
    """Test PUT track_split for missing parameter."""
    monkeypatch.setattr(
        vendor_contracts,
        'update_track_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    del fixture_track_split_put_request_parameters['isrc']
    request_params = [fixture_track_split_put_request_parameters]

    result = client.put(
        '/contracts/track_split/123',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_update_track_split_success(
    monkeypatch, client, fixture_track_split_put_request_parameters
):
    """Test PUT track_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'update_track_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = [fixture_track_split_put_request_parameters]

    result = client.put(
        '/contracts/track_split/123',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    vendor_contracts.update_track_split.assert_called_with('123', request_params)
    assert result.status_code == 200


def test_handler_set_product_split_success(
    monkeypatch, client, fixture_product_split_post_request_parameters, valid_get_header
):
    """Test POST product_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'set_product_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = [fixture_product_split_post_request_parameters]
    result = client.post(
        '/contracts/product_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    account_type = valid_get_header['Grass-Account-Type']
    account_id = valid_get_header['Grass-Account-Id']
    vendor_contracts.set_product_split.assert_called_with(
        request_params, account_id, account_type
    )
    assert result.status_code == 200


def test_handler_set_product_split_fail(
    monkeypatch,
    client,
    fixture_product_split_post_request_parameters,
    fixture_response_error,
    valid_get_header,
):
    """Test POST product_split fail."""
    monkeypatch.setattr(
        vendor_contracts,
        'set_product_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = [fixture_product_split_post_request_parameters]
    result = client.post(
        '/contracts/product_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_update_product_split_success(
    monkeypatch, client, fixture_product_split_put_request_parameters, valid_get_header
):
    """Test PUT product_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'update_product_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = [fixture_product_split_put_request_parameters]
    result = client.put(
        '/contracts/product_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    account_type = valid_get_header['Grass-Account-Type']
    account_id = valid_get_header['Grass-Account-Id']
    vendor_contracts.update_product_split.assert_called_with(
        request_params, account_id, account_type
    )
    assert result.status_code == 200


def test_handler_update_product_split_fail(
    monkeypatch,
    client,
    fixture_product_split_put_request_parameters,
    fixture_response_error,
    valid_get_header,
):
    """Test PUT product_split fail."""
    monkeypatch.setattr(
        vendor_contracts,
        'update_product_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = [fixture_product_split_put_request_parameters]
    result = client.put(
        '/contracts/product_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_delete_product_split_success(monkeypatch, client):
    """Test DELETE product_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'delete_product_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )
    request_params = {'vendor_id': 1234, 'oa_user_id': 562, 'vend_contract_id': 5623}

    upc = '546564788'
    result = client.delete(
        '/contracts/product_split/{}'.format(upc),
        data=json.dumps(request_params),
        content_type='application/json',
    )

    vendor_contracts.delete_product_split.assert_called_with(upc, request_params)
    assert result.status_code == 200


def test_handler_delete_product_split_upc_not_found(
    monkeypatch, client, fixture_response_error
):
    """Test DELETE product_split for upc that doesn't exist in table."""
    monkeypatch.setattr(
        vendor_contracts,
        'delete_product_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = {'vendor_id': 1234, 'oa_user_id': 562, 'vend_contract_id': 5623}

    upc = '546564788'
    result = client.delete(
        '/contracts/product_split/{}'.format(upc),
        data=json.dumps(request_params),
        content_type='application/json',
    )

    vendor_contracts.delete_product_split.assert_called_with(upc, request_params)
    assert result.status_code == 400


def test_handler_get_product_territory_split(
    monkeypatch, client, fixture_product_territory_split_response
):
    """Test GET track_split."""
    expected_valid_response = response.Response(message='ok', status=200)
    monkeypatch.setattr(
        vendor_contracts,
        'get_product_territory_split',
        value=MagicMock(return_value=fixture_product_territory_split_response),
    )
    result = client.get(
        '/contracts/product_territory_split/25824?page_offset=1&page_limit=2'
    )
    vendor_contracts.get_product_territory_split.assert_called_with(
        '25824', page_offset=1, page_limit=2
    )
    assert result.status_code == expected_valid_response.status
    assert (
        json.loads(result.data.decode())
        == fixture_product_territory_split_response.message
    )


def test_handler_delete_product_territory_split_success(monkeypatch, client):
    """Test DELETE product territory split."""
    monkeypatch.setattr(
        vendor_contracts,
        'delete_product_territory_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = {
        'country_id': 2,
        'oa_user_id': 562,
        'vend_contract_id': 5623,
        'country_name': 'India',
    }

    result = client.delete(
        '/contracts/product_territory_split/191018337490',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    vendor_contracts.delete_product_territory_split.assert_called_with(
        '191018337490', request_params
    )
    assert result.status_code == 200


def test_handler_delete_product_territory_split_error(
    monkeypatch, client, fixture_response_error
):
    """Test DELETE product territory splitt for missing parameter."""
    monkeypatch.setattr(
        vendor_contracts,
        'delete_product_territory_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = {'oa_user_id': 562, 'vend_contract_id': 5623}

    result = client.delete(
        '/contracts/product_territory_split/191018337490',
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_set_product_territory_split_success(
    monkeypatch,
    client,
    fixture_product_territory_split_post_request_parameters,
    valid_get_header,
):
    """Test POST set_product_territory_split success."""
    monkeypatch.setattr(
        vendor_contracts,
        'set_product_territory_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = [fixture_product_territory_split_post_request_parameters]
    result = client.post(
        '/contracts/product_territory_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    account_type = valid_get_header['Grass-Account-Type']
    account_id = valid_get_header['Grass-Account-Id']
    vendor_contracts.set_product_territory_split.assert_called_with(
        request_params, account_id, account_type
    )
    assert result.status_code == 200


def test_handler_set_product_territory_split_fail(
    monkeypatch,
    client,
    fixture_product_territory_split_post_request_parameters,
    fixture_response_error,
    valid_get_header,
):
    """Test POST set_product_territory_split fail."""
    monkeypatch.setattr(
        vendor_contracts,
        'set_product_territory_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = [fixture_product_territory_split_post_request_parameters]
    result = client.post(
        '/contracts/product_territory_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_update_product_territory_split_success(
    monkeypatch,
    client,
    fixture_product_territory_split_put_request_parameters,
    valid_get_header,
):
    """Test PUT update_product_territory_split."""
    monkeypatch.setattr(
        vendor_contracts,
        'update_product_territory_split',
        value=MagicMock(return_value=response.create_status_ok_response()),
    )

    request_params = [fixture_product_territory_split_put_request_parameters]
    result = client.put(
        '/contracts/product_territory_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    account_type = valid_get_header['Grass-Account-Type']
    account_id = valid_get_header['Grass-Account-Id']
    vendor_contracts.update_product_territory_split.assert_called_with(
        request_params, account_id, account_type
    )
    assert result.status_code == 200


def test_handler_update_product_territory_split_fail(
    monkeypatch,
    client,
    fixture_product_territory_split_put_request_parameters,
    fixture_response_error,
    valid_get_header,
):
    """Test PUT update_product_territory_split fail."""
    monkeypatch.setattr(
        vendor_contracts,
        'update_product_territory_split',
        value=MagicMock(return_value=fixture_response_error),
    )

    request_params = [fixture_product_territory_split_put_request_parameters]
    result = client.put(
        '/contracts/product_territory_split/25257',
        headers=valid_get_header,
        data=json.dumps(request_params),
        content_type='application/json',
    )

    assert result.status_code == 400


def test_handler_get_vendor_currency(
    monkeypatch, client, fixture_vendor_currency_response
):
    """Test GET vendor_currency."""
    expected_valid_response = response.Response(message='ok', status=200)
    monkeypatch.setattr(
        vendor_contracts,
        'get_vendor_currency',
        value=MagicMock(return_value=fixture_vendor_currency_response),
    )
    result = client.get(
        '/contracts/vendor-currency',
        headers={'Grass-Account-Type': 'vendor', 'Grass-Account-Id': '1'},
    )

    vendor_contracts.get_vendor_currency.assert_called_with('1')
    assert result.status_code == expected_valid_response.status
    assert json.loads(result.data.decode()) == fixture_vendor_currency_response.message


def test_handler_get_vendor_currency_error(monkeypatch, client, fixture_response_error):
    """Test GET vendor_currency error."""
    monkeypatch.setattr(
        vendor_contracts,
        'get_vendor_currency',
        value=MagicMock(return_value=fixture_response_error),
    )

    result = client.get(
        '/contracts/vendor-currency',
        headers={'Grass-Account-Type': 'vendor', 'Grass-Account-Id': '1'},
    )

    assert result.status_code == 400


def test_handler_get_vendor_booked_contracts_by_period_range_success(
    monkeypatch, fixture_response_ok, client, valid_get_header
):
    """Test GET get_vendor_booked_contracts_by_period_range successful state."""
    fixture_message = 'ok'

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        vendor_contracts,
        'get_booked_contracts_by_period_range',
        value=MagicMock(return_value=fixture_response_ok),
    )

    result = client.get(
        '/booked/vendor/123/first-period/1/last-period/3', headers=valid_get_header
    )

    # Assertions
    assert flask_request.verify_grass_access.called
    assert vendor_contracts.get_booked_contracts_by_period_range.called
    assert result.status_code == fixture_response_ok.status
    assert result.data == fixture_message.encode('utf-8')


def test_handler_get_subaccount_royalty_collection_territories(
    monkeypatch, fixture_response_ok, client, valid_get_header
):
    """Test GET subaccount royalty collection territories successful state."""
    fixture_message = 'ok'

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        subaccount_royalty_collection,
        'get_subaccount_id_by_royalty_collection_id',
        value=MagicMock(return_value=fixture_response_ok),
    )
    monkeypatch.setattr(
        subaccount_royalty_collection,
        'get_subaccount_royalty_collection_territories',
        value=MagicMock(return_value=fixture_response_ok),
    )

    url = '/subaccount/royalty_collection/456/royalty_collection_territories'

    result = client.get(url, headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert (
        subaccount_royalty_collection.get_subaccount_id_by_royalty_collection_id.called
    )
    assert subaccount_royalty_collection.get_subaccount_royalty_collection_territories.called
    assert result.status_code == fixture_response_ok.status
    assert result.data == fixture_message.encode('utf-8')


def test_update_vendor_contract_service_type_id_success(monkeypatch, client):
    """Test successful update of vendor contract service type ID."""
    vendor_id = 123
    service_type_id = 4
    mock_response = {'vendor_id': 123, 'vendor_uuid': 'abc-123-xyz'}

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )

    monkeypatch.setattr(
        vendor_contracts,
        'update_service_type_by_vendor_id',
        value=MagicMock(return_value=mock_response),
    )

    result = client.patch(
        f'/contracts/service_type/{vendor_id}',
        json={'service_type_id': service_type_id},
    )

    assert flask_request.verify_grass_access.called
    vendor_contracts.update_service_type_by_vendor_id.assert_called_with(
        str(vendor_id), service_type_id
    )
    assert result.status_code == 200


def test_update_vendor_contract_service_type_id_failure_no_active_contract(
    monkeypatch, client
):
    """Test failure when no active vendor contract is found."""
    vendor_id = 123
    service_type_id = 4
    mock_response = response.create_not_found_response(
        f'No active contract found for vendor_id {vendor_id}.'
    )
    expected_valid_response = {
        'code': 'not_found_error',
        'message': f'No active contract found for vendor_id {vendor_id}.',
    }

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )

    monkeypatch.setattr(
        vendor_contracts,
        'update_service_type_by_vendor_id',
        value=MagicMock(return_value=mock_response),
    )

    result = client.patch(
        f'/contracts/service_type/{vendor_id}',
        json={'service_type_id': service_type_id},
    )

    assert flask_request.verify_grass_access.called
    vendor_contracts.update_service_type_by_vendor_id.assert_called_with(
        str(vendor_id), service_type_id
    )
    assert result.status_code == 404
    assert json.loads(result.data) == expected_valid_response


def test_handler_get_royalty_collection(
    monkeypatch, fixture_response_ok, client, valid_get_header
):
    """Test GET subaccount by royalty collection id successful state."""
    subaccount_id = 1
    expected_result = {
        'subaccount_royalty_collection_id': 27571,
        'active': True,
        'subaccount_id': subaccount_id,
        'territories': [1],
    }

    monkeypatch.setattr(
        subaccount_royalty_collection,
        'get_subaccount_id_by_royalty_collection_id',
        value=MagicMock(
            return_value=response.Response(message=subaccount_id, status=200)
        ),
    )

    monkeypatch.setattr(
        subaccount_royalty_collection,
        'get_royalty_collection',
        value=MagicMock(
            return_value=response.Response(message=expected_result, status=200)
        ),
    )

    monkeypatch.setattr(
        flask_request,
        'verify_grass_access',
        value=MagicMock(return_value=fixture_response_ok),
    )

    url = '/subaccount/subaccount_royalty_collection/456'

    result = client.get(url, headers=valid_get_header)

    # Assertions
    assert flask_request.verify_grass_access.called
    assert (
        subaccount_royalty_collection.get_subaccount_id_by_royalty_collection_id.called
    )
    assert subaccount_royalty_collection.get_royalty_collection.called

    assert result.status_code == fixture_response_ok.status
    assert json.loads(result.data.decode('utf-8')) == expected_result