"""Features tests."""
from unittest.mock import Mock

from oto import response
from owsrequest import request as requests
import pytest
from requests import Response

from salessheets import config
from salessheets import features
from salessheets.constants import features as features_constants
from salessheets.constants import ows_services


@pytest.mark.parametrize(
    ('ows_features_status', 'ows_features_message', 'expected_status',
     'expected_message', 'expected_errors'), [
        (200, b'enabled', 200, 'enabled', None),
        (200, b'control', 200, 'control', None),
        (404, None, 404, None, {'code': 'feature_flag_error', 'message': None})
    ])
def test_get_active_variant(
        mocker, ows_features_status, ows_features_message, expected_status,
        expected_message, expected_errors):
    """Test get_active_variant."""
    ows_features_response = Response()
    ows_features_response.status_code = ows_features_status
    ows_features_response._content = ows_features_message
    mocker.patch.object(
        requests, 'process', return_value=ows_features_response)

    response = features.get_active_variant('applesauce_bananas')

    assert response.status == expected_status
    assert response.message == expected_message
    assert response.errors == expected_errors


def test_get_user_features_success(mocker):
    """Test retrieving all the user's features for successful result."""
    test_user_id = 'alw:25824'
    expected_result = {'feature_1': 'enabled'}

    mock_response = Mock()
    mock_response.status_code = 200
    mock_response.json = lambda: {'feature_1': 'enabled'}
    mocker.patch.object(
        requests,
        'process',
        return_value=mock_response)

    result = features.get_user_features(test_user_id)
    assert result.message == expected_result
    requests.process.assert_called_with(
        'daemon-sales-sheets',
        config.ENVIRONMENT,
        'GET',
        ows_services.OWS_FEATURES,
        '/features/user/{user_id}'.format(user_id=test_user_id),
        authorization_header=None, isDaemon=True)


def test_get_user_features_no_user_success(mocker):
    """Test retrieving all the user's features for successful result."""
    expected_result = {'feature_1': 'enabled'}

    mock_response = Mock()
    mock_response.status_code = 200
    mock_response.json = lambda: {'feature_1': 'enabled'}
    mocker.patch.object(
        requests,
        'process',
        return_value=mock_response)

    result = features.get_user_features(None)
    assert result.message == expected_result
    requests.process.assert_called_with(
        'daemon-sales-sheets',
        config.ENVIRONMENT,
        'GET',
        ows_services.OWS_FEATURES,
        '/features',
        authorization_header=None, isDaemon=True)


def test_get_user_features_ows_features_returned_error(mocker):
    """Test retrieving all the user's features errors handling."""
    test_user_id = 'alw:25824'
    error_msg = 'Something went wrong'

    mock_response = Mock()
    mock_response.status_code = 400
    mock_response.content = error_msg
    mocker.patch.object(
        requests,
        'process',
        return_value=mock_response)

    result = features.get_user_features(test_user_id)
    assert result.errors['message'] == error_msg
    requests.process.assert_called_with(
        'daemon-sales-sheets',
        config.ENVIRONMENT,
        'GET',
        ows_services.OWS_FEATURES,
        '/features/user/{user_id}'.format(user_id=test_user_id),
        authorization_header=None, isDaemon=True)


@pytest.mark.parametrize(
    'feature_status, expected_result', (('enabled', True), ('control', False)))
def test_feature_engine_flag(mocker, feature_status, expected_result):
    """Test is_example_feature_enabled works."""
    test_user_id = 'alw:25824'

    mock_response = Mock()
    mock_response.status_code = 200
    mock_response.json = lambda: {
        features_constants.EXAMPLE_FEATURE: feature_status}
    mocker.patch.object(
        requests,
        'process',
        return_value=mock_response)

    result = features.is_example_feature_enabled(test_user_id)
    assert result == expected_result
    requests.process.assert_called_with(
        'daemon-sales-sheets',
        config.ENVIRONMENT,
        'GET',
        ows_services.OWS_FEATURES,
        '/features/user/{user_id}'.format(user_id=test_user_id),
        authorization_header=None, isDaemon=True)


def test_check_user_features_success(mocker):
    """Test check_user_features when it succeeds."""
    user_id = 'oa:123'

    mocker.patch.object(
        features,
        'get_user_features',
        return_value=response.Response({
            features_constants.JAPAN_SALES_SHEETS: 'enabled',
            features_constants.GLOBAL_SYNC_HIGHLIGHTS: 'enabled'
        }))

    result = features.check_user_features(user_id)

    features.get_user_features.assert_called_once_with(user_id)
    assert result.message == {
        'is_japan_sales_sheets_enabled': True,
        'is_global_sync_highlights_enabled': True}


def test_check_user_features_error(mocker):
    """Test check_user_features when it fails."""
    user_id = 'oa:123'

    mocker.patch.object(
        features,
        'get_user_features',
        return_value=response.create_fatal_response())

    result = features.check_user_features(user_id)

    features.get_user_features.assert_called_once_with(user_id)
    assert not result