"""Test for the ows_project_manager module."""

import json

from flexmock import flexmock
from owsrequest import request
from owsrequest import test_utils

import pytest
import requests

from label_copy_export.connectors import loggly
from label_copy_export.constants import ows_services
from label_copy_export.models import ows_project_manager

logger = loggly.get_current_logger()

TEST_PROJECT_ID = '1234567890'
MOCK_MODEL_FUNCTION = 'get_project_manager_response'


def test_get_project_manager_response_404_json(monkeypatch):
    """Ensure that 404 response doesn't breaks the flow.

    Test that error message is propagated in response.errors.
    """
    error_json = {'text': 'not found'}
    call_spec = {
        'service': ows_services.OWS_PROJECT_MANAGER,
        'path': '/project/None',
        'status': 404,
        'json': error_json
    }
    mocked_process = test_utils.mock_ows_requests([call_spec])
    monkeypatch.setattr(
        request, 'process', mocked_process, raising=False)

    result = ows_project_manager.get_project_manager_response(
        call_spec['path'])
    assert not result
    assert json.loads(result.errors['message']) == error_json
    assert result.status == call_spec['status']


def test_get_project_manager_response_with_valid_data(monkeypatch):
    """Test that with valid data the result will be successful."""
    valid_json = {'project_name': 'NewOne'}
    call_spec = {
        'service': ows_services.OWS_PROJECT_MANAGER,
        'path': '/project/{}'.format(TEST_PROJECT_ID),
        'status': 200,
        'json': valid_json
    }
    mocked_process = test_utils.mock_ows_requests([call_spec])
    monkeypatch.setattr(
        request, 'process', mocked_process, raising=False)

    result = ows_project_manager.get_project_manager_response(
        call_spec['path'])
    assert result
    assert result.message == valid_json


def test_get_project_manager_response_invalid_json():
    """Test get_product_physical_data with invalid JSON in response.

    Tested function should return decoded original message on JSON decode
    exception.
    """
    not_valid_json = b'non-JSON content'
    response = flexmock(requests.models.Response())
    response.status_code = 401
    flexmock(response).should_receive('_content').and_return(not_valid_json)
    flexmock(request).should_receive('process').and_return(response)

    result = ows_project_manager.get_project_manager_response(TEST_PROJECT_ID)
    assert not result
    assert result.errors['message'] == not_valid_json.decode('utf8')


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_project_with_valid_response(valid_response):
    """Ensure valid response doesn't cause exceptions."""
    result = ows_project_manager.get_project(TEST_PROJECT_ID)
    assert result == valid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_project_with_invalid_response(invalid_response):
    """Test that no exceptions occur if response is not 200."""
    ows_project_manager.logger = flexmock(loggly.get_current_logger())
    flexmock(ows_project_manager.logger).should_receive('warning').once()
    result = ows_project_manager.get_project(TEST_PROJECT_ID)
    assert result == invalid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_products_for_project_with_valid_response(valid_response):
    """Ensure valid response doesn't cause exceptions."""
    result = ows_project_manager.get_products_for_project(TEST_PROJECT_ID)
    assert result == valid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_products_for_project_with_invalid_response(invalid_response):
    """Test that no exceptions occur if response is not 200."""
    ows_project_manager.logger = flexmock(loggly.get_current_logger())
    flexmock(ows_project_manager.logger).should_receive('warning').once()
    result = ows_project_manager.get_products_for_project(TEST_PROJECT_ID)
    assert result == invalid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_project_genres_with_valid_response(valid_response):
    """Ensure valid response doesn't cause exceptions."""
    result = ows_project_manager.get_project_genres()
    assert result == valid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_project_genres_with_invalid_response(invalid_response):
    """Test that no exceptions occur if response is not 200."""
    ows_project_manager.logger = flexmock(loggly.get_current_logger())
    flexmock(ows_project_manager.logger).should_receive('warning').once()
    result = ows_project_manager.get_project_genres()
    assert result == invalid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_project_subgenres_with_valid_response(valid_response):
    """Ensure valid response doesn't cause exceptions."""
    result = ows_project_manager.get_project_subgenres(genre_id=1)
    assert result == valid_response


@pytest.mark.parametrize(
    'model_function, model_module',
    [(MOCK_MODEL_FUNCTION, ows_project_manager)])
def test_get_project_subgenres_with_invalid_response(invalid_response):
    """Test that no exceptions occur if response is not 200."""
    ows_project_manager.logger = flexmock(loggly.get_current_logger())
    flexmock(ows_project_manager.logger).should_receive('warning').once()

    result = ows_project_manager.get_project_subgenres(genre_id=1)
    assert result == invalid_response