"""Tests for ows_abacus_account."""
import httpx
from owsclient.test import OwsClientMock

from unittest.mock import patch

from json_contract_file_import import ows_royalties
from json_contract_file_import.constants import constants


def test_create_run_controller(
        ows_client_mock: OwsClientMock,
) -> None:
    """Test successful create account."""
    mock_response = {
        'some': 123
    }
    run_controller_contract_data = {
        'account_id': 1,
        'contract_id': 2,
        'run_controller': 3,
    }

    ows_client_mock.post(
        'ows-royalties',
        '/run-controller/contract',
        json=run_controller_contract_data,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_run_controller_contract(
        run_controller_contract_data
    )

    assert response.status_code == 201
    assert response.json() == mock_response


@patch('json_contract_file_import.ows_royalties.logger')
def test_create_run_controller_failed(
        mock_logger,
        ows_client_mock: OwsClientMock,
) -> None:
    """Test failed create run controller with status code not 201."""
    mock_response = {
        'error': 'Failed to create run controller.',
    }
    run_controller_contract_data = {
        'account_id': 1,
        'contract_id': 2,
        'run_controller': 3,
    }
    ows_client_mock.post(
        'ows-royalties',
        '/run-controller/contract',
        json=run_controller_contract_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_run_controller_contract(
        run_controller_contract_data
    )

    assert response.status_code == 500
    assert response.json() == mock_response

    mock_logger.error.assert_called_once_with(
        'ows-royalties error: {"error": "Failed to create run controller."}')


def test_get_run_controller(
        ows_client_mock: OwsClientMock,
) -> None:
    """Test successful get run controller."""
    mock_response = {
        'some': 123
    }
    contract_id = 1

    ows_client_mock.get(
        'ows-royalties',
        f'/run-controller-by-contract/{contract_id}',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_run_controller(contract_id)

    assert response.status_code == 200
    assert response.json() == mock_response


@patch('json_contract_file_import.ows_royalties.logger')
def test_get_run_controller_failed(
        mock_logger,
        ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get run controller with status code not 200."""
    mock_response = {
        'error': 'Failed to get run controller.',
    }
    contract_id = 1

    ows_client_mock.get(
        'ows-royalties',
        f'/run-controller-by-contract/{contract_id}',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_run_controller(contract_id)

    assert response.status_code == 500
    assert response.json() == mock_response

    mock_logger.error.assert_called_once_with(
        'ows-royalties error: {"error": "Failed to get run controller."}')


contract_term_condition_sample_request = [
    {
        'contract_term_condition_name': 'Condition name2',
        'conditions': {
            'countries': [
                'ESP'
            ],
            'stores': [
                '2'
            ],
            'transaction_types': [
                'CV'
            ]
        },
        'priority': 2,
        'term_rate': 20.2,
        'commission': 79.8
    }
]


def test_create_contract(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test successful create contract."""
    mock_response = {
        'contract_type': constants.CONTRACT_TYPES.DISTRIBUTION,
        'execution_date': None,
        'reference_signing_entity_id': 2,
        'term_end': '2019-12-31',
        'term_start': '2019-06-01',
        'summary_note': 'This is for the test',
        'general_note': 'This is for the test (general_note)',
        'contract_id': 3,
        'contract_name': 'Test',
        'oa_contract_id': None,
        'account_id': 1,
        'sap_created_at': None,
        'initial_start_date': None,
        'is_excluded_from_accounting_run': False
    }

    contract_data = {
        'contract_name': 'Test contract',
        'contract_type': constants.CONTRACT_TYPES.DISTRIBUTION,
        'contract_id': 100,
        'term_end': '2024-06-01',
        'term_start': '2019-06-01',
        'account_id': 2,
        'summary_note': 'This contract is imported using '
                        'json-contract-file-import lambda.',
        'general_note': None
    }
    ows_client_mock.post(
        'ows-royalties',
        '/contract',
        json=contract_data,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract(contract_data)

    assert response.status_code == 201
    assert response.json() == mock_response


@patch('json_contract_file_import.ows_royalties.logger')
def test_create_contract_not_status_201(
    mock_logger,
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed create contract with status code not 201."""
    mock_response = {
        'error': 'Failed to create contract.',
    }
    contract_data = {
        'contract_name': 'Test contract',
        'contract_type': constants.CONTRACT_TYPES.DISTRIBUTION,
        'contract_id': 100,
        'term_end': '2024-06-01',
        'term_start': '2019-06-01',
        'account_id': 2,
        'summary_note': 'This contract is imported using '
                        'json-contract-file-import lambda.',
        'general_note': None
    }

    ows_client_mock.post(
        'ows-royalties',
        '/contract',
        json=contract_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract(contract_data)

    assert response.status_code == 500
    assert response.json() == mock_response

    mock_logger.error.assert_called_once_with(
        'ows-royalties error: {"error": "Failed to create contract."}')


def test_create_contract_term(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test successful create contract term."""
    contract_id = 123
    mock_response = {
        'contract_term_id': 198,
        'contract_id': contract_id,
        'contract_term_name': 'Test contract term',
        'term_type': 'product',
        'attachments': [
            '101',
            '182'
        ],
        'attachments_relations': {
            'label_ids': [
                '12',
                '25'
            ],
            'upcs': []
        },
        'is_base_term': False
    }
    contract_term_data = {
        'contract_term_name': 'Test contract term',
        'term_type': 'product',
        'attachments': [
            '101',
            '182'
        ],
        'attachments_relations': {
            'label_ids': [
                '12',
                '25'
            ],
            'upcs': []
        }
    }

    ows_client_mock.post(
        'ows-royalties',
        f'/contract/{contract_id}/contract-term/',
        json=contract_term_data,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_term(contract_id, contract_term_data)

    assert response.status_code == 201
    assert response.json() == mock_response


@patch('json_contract_file_import.ows_royalties.logger')
def test_create_contract_term_failed(
    mock_logger,
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed creation of the contract term."""
    contract_id = 123
    mock_response = {
        'error': 'Some error info.'
    }
    contract_term_data = {
        'contract_term_name': 'Test contract term',
        'term_type': 'product',
        'attachments': [
            '101',
            '182'
        ],
        'attachments_relations': {
            'label_ids': [
                '12',
                '25'
            ],
            'upcs': []
        }
    }

    ows_client_mock.post(
        'ows-royalties',
        f'/contract/{contract_id}/contract-term/',
        json=contract_term_data,
    ).mock(
        return_value=httpx.Response(
            400,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_term(contract_id, contract_term_data)

    assert response.status_code == 400
    assert response.json() == mock_response

    mock_logger.error.assert_called_once_with(
        'ows-royalties error: {"error": "Some error info."}')


def test_create_contract_term_conditions(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success creation of the contract term condition."""
    contract_term_id = 123
    mock_response = [
        {
            'contract_term_condition_id': 17,
            'contract_term_condition_name': 'Condition name2',
            'contract_term_id': contract_term_id,
            'conditions': {
                'countries': [
                    'ESP'
                ],
                'stores': [
                    '2'
                ],
                'transaction_types': [
                    'CV'
                ]
            },
            'priority': 2,
            'term_rate': '20.20',
            'commission': '79.80'
        }
    ]
    ows_client_mock.post(
        'ows-royalties',
        f'/contract-term/{contract_term_id}/conditions/',
        json=contract_term_condition_sample_request,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_term_conditions(
        contract_term_id,
        contract_term_condition_sample_request
    )

    assert response.status_code == 201
    assert response.json() == mock_response


def test_create_contract_term_conditions_failed_response(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed creation of the contract term condition."""
    contract_term_id = 123
    mock_response = [
        {
            'error': 'Failed to create condition.'
        }
    ]
    ows_client_mock.post(
        'ows-royalties',
        f'/contract-term/{contract_term_id}/conditions/',
        json=contract_term_condition_sample_request,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_term_conditions(
        contract_term_id,
        contract_term_condition_sample_request
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_create_contract_reserve(
    ows_client_mock: OwsClientMock,
):
    """Test success creation of the contract reserves."""
    contract_id = 2
    mock_response = {
        'contract_id': contract_id,
        'contract_reserve_id': 2,
        'installments_in_months': 1,
        'reserve_rate': '20.00',
        'reserve_release_offset_in_months': 3,
        'release_schedule': [
            '1'
        ]
    }
    contract_reserve_data = {
        'reserve_rate': 20,
        'reserve_release_offset_in_months': 3,
        'installments_in_months': 1,
        'release_schedule': [1]
    }

    ows_client_mock.post(
        'ows-royalties',
        f'/contract/{contract_id}/reserves/',
        json=contract_reserve_data,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_reserve(
        contract_id,
        contract_reserve_data,
    )

    assert response.status_code == 201
    assert response.json() == mock_response


def test_create_contract_reserve_failed_response(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed creation of the contract reserves."""
    contract_id = 2
    mock_response = [
        {
            'error': 'Failed to create reserve.'
        }
    ]
    contract_reserve_data = {
        'reserve_rate': 20,
        'reserve_release_offset_in_months': 3,
        'installments_in_months': 1,
        'release_schedule': [1]
    }

    ows_client_mock.post(
        'ows-royalties',
        f'/contract/{contract_id}/reserves/',
        json=contract_reserve_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_reserve(
        contract_id,
        contract_reserve_data,
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_reference_transaction_types(
    ows_client_mock: OwsClientMock,
    mock_transaction_types_response
) -> None:
    """Test fetching list of transaction types."""
    mock_response = mock_transaction_types_response.json()
    ows_client_mock.get(
        'ows-royalties',
        '/reference-transaction-types',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_reference_transaction_types()

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_reference_transaction_types_failed(
    ows_client_mock: OwsClientMock,
    mock_transaction_types_response
) -> None:
    """Test failed fetching list of transaction types."""
    mock_response = mock_transaction_types_response.json()
    ows_client_mock.get(
        'ows-royalties',
        '/reference-transaction-types',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_reference_transaction_types()

    assert response.status_code == 500
    assert response.json() == mock_response


def test_update_contract_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success updating contract."""
    mock_response = {'message': 'Some response.'}
    contract_data = {
        'contract_id': 100
    }

    ows_client_mock.put(
        'ows-royalties',
        '/contract/100',
        json=contract_data,
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.update_contract(100, contract_data)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_update_contract_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed updating contract."""
    mock_response = {'message': 'Some response.'}
    contract_data = {
        'contract_id': 100
    }
    ows_client_mock.put(
        'ows-royalties',
        '/contract/100',
        json=contract_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.update_contract(100, contract_data)

    assert response.status_code == 500
    assert response.json() == mock_response


def test_create_contract_lifecycle_schedules_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success create contract lifecycle schedules."""
    mock_response = {'message': 'Some response.'}
    lifecycle_schedules = [
        {
            'termination_notice_detail_interval': 1,
            'termination_notice_detail_type': 'month',
            'renewal_type': 'continuously_active',
            'schedule_end': '2028-06-01'
        }
    ]

    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedules?allow_end_date_in_past=true',
        json=lifecycle_schedules,
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_lifecycle_schedules(
        100,
        lifecycle_schedules
    )

    assert response.status_code == 200
    assert response.json() == mock_response


def test_create_contract_lifecycle_schedules_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed create contract lifecycle schedules."""
    mock_response = {'message': 'Some response.'}
    lifecycle_schedules = [
        {
            'termination_notice_detail_interval': 1,
            'termination_notice_detail_type': 'month',
            'renewal_type': 'continuously_active',
            'schedule_end': '2028-06-01'
        }
    ]
    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedules?allow_end_date_in_past=true',
        json=lifecycle_schedules
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_lifecycle_schedules(
        100,
        lifecycle_schedules
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_update_contract_lifecycle_schedules_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success update contract lifecycle schedules."""
    mock_response = {'message': 'Some response.'}
    lifecycle_schedules = [
        {
            'termination_notice_detail_interval': 1,
            'termination_notice_detail_type': 'month',
            'renewal_type': 'continuously_active',
            'schedule_end': '2028-06-01'
        }
    ]

    ows_client_mock.put(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedules?allow_end_date_in_past=true',
        json=lifecycle_schedules,
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.update_contract_lifecycle_schedules(
        100,
        lifecycle_schedules
    )

    assert response.status_code == 200
    assert response.json() == mock_response


def test_update_contract_lifecycle_schedules_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed update contract lifecycle schedules."""
    mock_response = {'message': 'Some response.'}
    lifecycle_schedules = [
        {
            'termination_notice_detail_interval': 1,
            'termination_notice_detail_type': 'month',
            'renewal_type': 'continuously_active',
            'schedule_end': '2028-06-01'
        }
    ]
    ows_client_mock.put(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedules?allow_end_date_in_past=true',
        json=lifecycle_schedules,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.update_contract_lifecycle_schedules(
        100,
        lifecycle_schedules
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_contract_lifecycle_schedules_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success get contract lifecycle schedules."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedules/',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_lifecycle_schedules(100)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_contract_lifecycle_schedules_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get contract lifecycle schedules."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedules/',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_lifecycle_schedules(100)

    assert response.status_code == 500
    assert response.json() == mock_response


def test_create_contract_lifecycle_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success create contract lifecycle."""
    mock_response = {'message': 'Some response.'}
    lifecycle_data = {
        'lifecycle_term_start': '2024-07-03'
    }

    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedule/1/contract-lifecycle/',
        json=lifecycle_data,
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_lifecycle(
        100,
        1,
        lifecycle_data,
    )

    assert response.status_code == 200
    assert response.json() == mock_response


def test_create_contract_lifecycle_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed create contract lifecycle."""
    mock_response = {'message': 'Some response.'}
    lifecycle_data = {
        'lifecycle_term_start': '2024-07-03'
    }
    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-lifecycle-schedule/1/contract-lifecycle/',
        json=lifecycle_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_lifecycle(
        100,
        1,
        lifecycle_data,
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_update_contract_reserve_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success updating contract reserve."""
    mock_response = {'message': 'Some response.'}
    contract_reserves_data = {
        'contract_id': 100
    }
    ows_client_mock.put(
        'ows-royalties',
        '/contract/100/reserves/',
        json=contract_reserves_data,
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.update_contract_reserve(
        100,
        contract_reserves_data
    )

    assert response.status_code == 200
    assert response.json() == mock_response


def test_update_contract_reserve_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed updating contract reserve."""
    mock_response = {'message': 'Some response.'}
    contract_reserves_data = {
        'contract_id': 100
    }
    ows_client_mock.put(
        'ows-royalties',
        '/contract/100/reserves/',
        json=contract_reserves_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.update_contract_reserve(
        100,
        contract_reserves_data
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_contract_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success get contract."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract(100)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_contract_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get contract."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract(
        100
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_contract_terms_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success get contract terms."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contracts/100/contract-terms',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_terms(100)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_contract_terms_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get contract terms."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contracts/100/contract-terms',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_terms(
        100
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_contract_reserves_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success get contract reserves."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100/reserves/',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_reserves(100)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_contract_reserves_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get contract reserves."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100/reserves/',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_reserves(
        100
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_transaction_types_for_group_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success get transaction types for group."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/reference-transaction-type-group/2/reference-transaction-types/',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_transaction_types_for_group(2)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_transaction_types_for_group_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get transaction types for group."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/reference-transaction-type-group/2/reference-transaction-types/',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_transaction_types_for_group(2)

    assert response.status_code == 500
    assert response.json() == mock_response


def test_get_contract_mechanical_deductions_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success get contract mechanical deductions."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100/contract-mechanical-deductions/',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_mechanical_deductions(100)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_get_contract_mechanical_deductions_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed get contract mechanical deductions."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.get(
        'ows-royalties',
        '/contract/100/contract-mechanical-deductions/',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.get_contract_mechanical_deductions(100)

    assert response.status_code == 500
    assert response.json() == mock_response


def test_delete_contract_mechanical_deduction_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success delete contract mechanical deduction."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.delete(
        'ows-royalties',
        '/contract-mechanical-deduction/300',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.delete_contract_mechanical_deduction(300)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_delete_contract_mechanical_deduction_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed delete contract mechanical deduction."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.delete(
        'ows-royalties',
        '/contract-mechanical-deduction/300',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.delete_contract_mechanical_deduction(300)

    assert response.status_code == 500
    assert response.json() == mock_response


def test_create_contract_mechanical_deduction_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success create contract mechanical deduction."""
    mock_response = {'message': 'Some response.'}
    mechanical_deduction_data = {
        'deduction_type': 'digital',
        'admin_fee': 20.20,
    }
    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-mechanical-deduction/',
        json=mechanical_deduction_data,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_mechanical_deduction(
        100,
        mechanical_deduction_data
    )

    assert response.status_code == 201
    assert response.json() == mock_response


def test_create_contract_mechanical_deduction_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed create contract mechanical deduction."""
    mock_response = {'message': 'Some response.'}
    mechanical_deduction_data = {
        'deduction_type': 'digital',
        'admin_fee': 20.20,
    }
    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-mechanical-deduction/',
        json=mechanical_deduction_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_contract_mechanical_deduction(
        100,
        mechanical_deduction_data
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_create_worldwide_contract_mechanical_deduction_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success create worldwide contract mechanical deduction."""
    mock_response = {'message': 'Some response.'}
    worldwide_deduction_data = {
        'deduction_type': 'digital',
        'admin_fee': 20.20,
    }
    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-mechanical-deductions/worldwide/',
        json=worldwide_deduction_data,
    ).mock(
        return_value=httpx.Response(
            201,
            json=mock_response,
        )
    )

    response = ows_royalties.create_worldwide_contract_mechanical_deduction(
        100,
        worldwide_deduction_data
    )

    assert response.status_code == 201
    assert response.json() == mock_response


def test_create_worldwide_contract_mechanical_deduction_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed create worldwide contract mechanical deduction."""
    mock_response = {'message': 'Some response.'}
    worldwide_deduction_data = {
        'deduction_type': 'digital',
        'admin_fee': 20.20,
    }
    ows_client_mock.post(
        'ows-royalties',
        '/contract/100/contract-mechanical-deductions/worldwide/',
        json=worldwide_deduction_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.create_worldwide_contract_mechanical_deduction(
        100,
        worldwide_deduction_data
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_delete_contract_term_success(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test success delete contract term."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.delete(
        'ows-royalties',
        '/contract-term/200',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.delete_contract_term(200)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_delete_contract_term_failed(
    ows_client_mock: OwsClientMock,
) -> None:
    """Test failed delete contract term."""
    mock_response = {'message': 'Some response.'}
    ows_client_mock.delete(
        'ows-royalties',
        '/contract-term/200',
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.delete_contract_term(
        200
    )

    assert response.status_code == 500
    assert response.json() == mock_response


def test_terminate_contract_success(
        ows_client_mock: OwsClientMock,
) -> None:
    """Test success terminate contract."""
    mock_response = {'message': 'Some response.'}
    request_data = {
        'termination_effective': '2025-01-01'
    }
    ows_client_mock.put(
        'ows-royalties',
        '/contract/100/terminate',
        json=request_data,
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_response,
        )
    )

    response = ows_royalties.terminate_contract(100, request_data)

    assert response.status_code == 200
    assert response.json() == mock_response


def test_terminate_contract_failed(
        ows_client_mock: OwsClientMock,
) -> None:
    """Test failed terminate contract."""
    mock_response = {'message': 'Some response.'}
    request_data = {
        'termination_effective': '2025-01-01'
    }
    ows_client_mock.put(
        'ows-royalties',
        '/contract/100/terminate',
        json=request_data,
    ).mock(
        return_value=httpx.Response(
            500,
            json=mock_response,
        )
    )

    response = ows_royalties.terminate_contract(100, request_data)

    assert response.status_code == 500
    assert response.json() == mock_response