"""Test get_products_status API endpoint."""
import json

import flask
from oto import response as oto_response
from oto import status as oto_status
import pytest

from availability.constants import error


def test_get_product_status_validates_query_param(client):
    """Assert product_ids parameter is validated."""
    response = client.get('/status?product_ids=not_int,invalid_value')
    assert isinstance(response, flask.Response)
    assert response.status_code == oto_status.BAD_REQUEST


@pytest.mark.parametrize(
    'request_headers',
    [
        ({
            'Grass-Account-Type': 'test',
            'Grass-Account-Id': '1',
            'Correlation-Id': 'some id'
        }),
        ({})
    ]
)
def test_get_store_status_by_product_ids(mocker, client, request_headers):
    """Assert can get status for product IDs."""
    mocker.patch('availability.handlers.ownership.check_products_ownership')
    mock_logic = mocker.patch('availability.handlers.release_fetching')
    mock_logic.get_status_for_products.return_value = oto_response.Response()
    client.get('/status?product_ids=1,2,3', headers=request_headers)
    mock_logic.get_status_for_products.assert_called_with([1, 2, 3])


def test_get_product_status_validates_product_ownership(mocker, client):
    """Assert check_products_ownership is called by handler."""
    mocker.patch('availability.handlers.release_fetching')
    mock_ownership = mocker.patch(
        'availability.handlers.ownership.check_products_ownership')
    headers = {
        'Grass-Account-Type': 'test type',
        'Grass-Account-Id': '1',
        'Correlation-Id': 'test id'
    }
    client.get('/status?product_ids=1,2,3', headers=headers)
    mock_ownership.assert_called_with(
        product_ids=[1, 2, 3], account_type='test type',
        account_id='1', correlation_id='test id')


def test_get_product_status_returns_error_response_for_invalid_params(
        mocker, client):
    """Assert error response returned if query parameters invalid."""
    error_response = oto_response.create_error_response(
        code=error.ERROR_CODE_QUERY_PARAM,
        message=error.ERROR_INVALID_QUERY_PARAM,
        status=oto_status.BAD_REQUEST)
    mocker.patch(
        'availability.handlers.query_params.validate_product_ids_parameter',
        return_value=error_response)
    response = client.get(
        '/status?invalid=param',
        headers={'Grass-Account-Type': 'test', 'Grass-Account-Id': '1'})
    assert isinstance(response, flask.Response)
    assert response.status_code == oto_status.BAD_REQUEST
    response_data = json.loads(response.data.decode())
    assert response_data['message'] == error.ERROR_INVALID_QUERY_PARAM
    assert response_data['code'] == error.ERROR_CODE_QUERY_PARAM


def test_get_product_status_returns_error_response_for_not_owned_products(
        mocker, client):
    """Assert error response is returned if products do not belong to user."""
    error_response = oto_response.create_error_response(
        code=error.ERROR_CODE_AUTHORIZATION,
        message=error.ERROR_MESSAGE_NOT_AUTHORIZED,
        status=oto_status.FORBIDDEN)
    mocker.patch(
        'availability.handlers.ownership.check_products_ownership',
        return_value=error_response)
    response = client.get(
        '/status?product_ids=1,2',
        headers={'Grass-Account-Type': 'test', 'Grass-Account-Id': '1'})
    assert isinstance(response, flask.Response)
    assert response.status_code == oto_status.FORBIDDEN
    response_data = json.loads(response.data.decode())
    assert response_data['message'] == error.ERROR_MESSAGE_NOT_AUTHORIZED
    assert response_data['code'] == error.ERROR_CODE_AUTHORIZATION