"""Unit tests for handlers.py."""

from unittest.mock import Mock, patch
from unittest.mock import MagicMock
from owsresponse import response
import pytest

from owsrequest import error_response

from features import handlers
from features import server
from features import config
from features.connectors import redis
from features.constants import error
from features.constants import header
from features.models import ows_users
from features.utils import parser


def existing_feature():
    """Return feature name that exists in all_feature_data."""
    return 'feature_1'


def header_user():
    """Return valid ochard_user_id for use in mocked grass headers."""
    return 'oa:123'


def users_data():
    """Return data for multiple split features."""
    user_response_message = {
        'type': 'alw',
        'user_id': 'alw:16088',
        'account': {'vendor_id': 7123, 'subaccount_id': None},
    }

    mock_response = MagicMock()
    mock_response.status = 200
    mock_response.json = MagicMock(return_value=user_response_message)
    return mock_response


@pytest.yield_fixture
def in_prod():
    """Force prod environment for duration of test."""
    config.ENVIRONMENT = config.PROD_ENVIRONMENT
    yield


def test_get_features_without_headers(client, all_feature_data):
    """Verify that get_feature returns feature without user context."""
    resp = client.get('/features', headers={})
    assert resp.status_code == 200
    assert resp.get_json() == all_feature_data


def test_get_features_with_invalid_headers(client):
    """Verify that get_features returns error."""
    resp = client.get('/features', headers={'Grass-Account-Type': 'vendor'})
    assert resp.status_code == 400
    assert resp.json == (
        error_response.create_error_incomplete_profile_headers().errors
    )


def test_get_features_with_vendor_headers(monkeypatch, client, forced_feature_data):
    """Verify that get_features returns features with vendor context."""
    monkeypatch.setattr(
        handlers.features_logic,
        'get_all_split_features_with_profile_context',  # noqa
        MagicMock(return_value=response.Response(forced_feature_data)),
    )

    monkeypatch.setattr(
        ows_users, 'get_user_details_by_user_id', MagicMock(return_value=users_data())
    )

    resp = client.get(
        '/features',
        headers={
            'Grass-Account-Type': 'vendor',
            'Grass-Account-Id': 7123,
            'Orchard-User-Id': 'alw:16888',
        },
    )
    assert resp.status_code == 200
    assert resp.json == forced_feature_data


def test_get_features_with_subaccount_headers(monkeypatch, client, all_feature_data):
    """Verify that get_features returns features with vendor context."""
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'alw',
            'user_id': 'alw:16092',
            'account': {'vendor_id': 21989, 'subaccount_id': 1},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get(
        '/features',
        headers={
            'Grass-Account-Type': 'subaccount',
            'Grass-Account-Id': 1,
            'Orchard-User-Id': 'alw:16092',
        },
    )
    assert resp.status_code == 200
    assert resp.json == all_feature_data


def test_get_features_with_query_params_and_without_headers(
    client, forced_feature_data
):  # noqa
    """Verify that get_features returns features with vendor context."""
    resp = client.get('/features?account_id=7123&account_type=vendor', headers={})
    assert resp.status_code == 200
    assert resp.json == forced_feature_data


def test_get_features_with_query_params_and_with_valid_headers(
    monkeypatch, client, forced_feature_data
):  # noqa
    """Verify that get_features returns features with vendor context."""
    monkeypatch.setattr(
        handlers.features_logic,
        'get_all_split_features_with_profile_context',  # noqa
        MagicMock(return_value=response.Response(forced_feature_data)),
    )

    monkeypatch.setattr(
        ows_users, 'get_user_details_by_user_id', MagicMock(return_value=users_data())
    )

    resp = client.get(
        '/features?account_id=7123&account_type=vendor',
        headers={
            'Grass-Account-Type': 'vendor',
            'Grass-Account-Id': 7123,
            'Orchard-User-Id': 'alw:16888',
        },
    )
    assert resp.status_code == 200
    assert resp.json == forced_feature_data


def test_get_features_with_query_params_and_with_invalid_headers(
    client, all_feature_data
):  # noqa
    """Verify that an error message is returned."""
    resp = client.get(
        '/features?account_id=7123&account_type=vendor',
        headers={'Grass-Account-Type': 'vendor'},
    )
    assert resp.status_code == 400
    assert resp.json == (
        error_response.create_error_incomplete_profile_headers().errors
    )


def test_get_features_for_user_without_headers(monkeypatch, client, all_feature_data):
    """Verify that get_features_for_user returns feature in passed context."""
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'oa',
            'user_id': 'oa:456',
            'account': {'vendor_id': None, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get('/features/user/oa:456', headers={})
    assert resp.status_code == 200
    assert resp.get_json() == all_feature_data


def test_get_features_for_user_with_invalid_headers(monkeypatch, client):
    """Verify that get_feature_for_user returns invalid headers error."""
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'oa',
            'user_id': 'oa:456',
            'account': {'vendor_id': None, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get('/features/user/oa:456', headers={'Grass-Account-Type': 'vendor'})
    assert resp.status_code == 400
    assert resp.json == (
        error_response.create_error_incomplete_account_headers().errors
    )


@pytest.mark.parametrize(
    ('headers', 'expected_status_code', 'expected_json'),
    [
        # no headers
        (None, 200, {'feature_1': 'variant_2', 'feature_2': 'variant_2'}),
        # profile type, profile id
        (
            {
                header.ORCHARD_PROFILE_TYPE: 'ArtistProfile',
                header.ORCHARD_PROFILE_ID: 555,
            },
            200,
            {'feature_1': 'variant_1', 'feature_2': 'variant_2'},
        ),
        # identity id
        (
            {header.ORCHARD_IDENTITY_ID: '5d542f411234a40db1f64010'},
            200,
            {'feature_1': 'variant_2', 'feature_2': 'variant_1'},
        ),
        # all 3
        (
            {
                header.ORCHARD_PROFILE_TYPE: 'ArtistProfile',
                header.ORCHARD_PROFILE_ID: 555,
                header.ORCHARD_IDENTITY_ID: '5d542f411234a40db1f64010',
            },
            200,
            {'feature_1': 'variant_1', 'feature_2': 'variant_1'},
        ),
    ],
)
def test_handler_get_all_features_with_profile_context(
    monkeypatch, headers, expected_status_code, expected_json, client
):
    """Test handler.get_features() with profile context."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.PROFILE_FEATURES_YML_FILE)
    )
    resp = client.get('/features', headers=headers)
    assert resp.status_code == expected_status_code
    assert resp.get_json() == expected_json


def test_get_features_for_user_with_matching_headers(
    monkeypatch, client, forced_feature_data
):
    """Verify that get_features_for_user returns feature in passed context."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'oa',
            'user_id': 'oa:123',
            'account': {'vendor_id': None, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get('/features/user/oa:123', headers={'Orchard-User-Id': 'oa:123'})
    assert resp.status_code == 200
    assert resp.json == forced_feature_data


def test_get_features_for_user_without_matching_headers(monkeypatch, client):
    """Verify that get_feature_for_user returns error."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'oa',
            'user_id': 'oa:456',
            'account': {'vendor_id': None, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    monkeypatch.setattr(
        handlers.features_logic,
        'get_all_split_features_with_user_context',  # noqa
        MagicMock(
            return_value=response.Response(
                message=error_response.create_error_user_mismatch().errors, status=400
            )
        ),
    )

    resp = client.get('/features/user/oa:123', headers={'Orchard-User-Id': 'oa:456'})
    assert resp.status_code == 400
    assert resp.json == (error_response.create_error_user_mismatch().errors)


@pytest.mark.parametrize(
    ('splitio_enabled'),
    [
        # split enabled
        (True)
    ],
)
def test_get_features_for_user_with_user_type_without_headers(
    client, monkeypatch, splitio_enabled
):
    """Test get_features_for_user calls logic layer."""
    if splitio_enabled:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_split_features_with_user_context',  # noqa
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )
    else:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_features_with_user_context',
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )

    url = '/features/user/alw:789'
    if splitio_enabled:
        url = '{}?{}'.format(url, 'splitioEnabled=1')

    client.get(url)

    if splitio_enabled:
        assert handlers.features_logic.get_all_split_features_with_user_context.called  # noqa
        assert (
            handlers.features_logic.get_all_split_features_with_user_context.call_args[
                0
            ]
            == (  # noqa
                'alw:789',
                None,
                None,
                None,
                None,
            )
        )
    else:
        assert handlers.features_logic.get_all_features_with_user_context.called  # noqa
        assert handlers.features_logic.get_all_features_with_user_context.call_args[
            0
        ] == (  # noqa
            'alw:789',
            None,
            None,
        )


@pytest.mark.parametrize(
    ('splitio_enabled'),
    [
        # split enabled
        (True)
    ],
)
def test_get_features_for_user_by_user_type(client, monkeypatch, splitio_enabled):
    """Test get_features_for_user_with_user_type calls logic layer."""
    if splitio_enabled:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_split_features_with_user_context',  # noqa
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )
    else:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_features_with_user_context',
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )

    url = '/features/user_type/alw/user_id/789'
    if splitio_enabled:
        url = '{}?{}'.format(url, 'splitioEnabled=1')

    client.get(url)

    if splitio_enabled:
        assert handlers.features_logic.get_all_split_features_with_user_context.called  # noqa
        assert (
            handlers.features_logic.get_all_split_features_with_user_context.call_args[
                0
            ]
            == (  # noqa
                'alw:789',
                None,
                None,
                None,
                None,
            )
        )
    else:
        assert handlers.features_logic.get_all_features_with_user_context.called  # noqa
        assert handlers.features_logic.get_all_features_with_user_context.call_args[
            0
        ] == (  # noqa
            'alw:789',
            None,
            None,
        )


def test_get_features_for_vendor(monkeypatch, client, forced_feature_data):
    """Verify that get_features_for_vendor returns features in context."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'alw',
            'user_id': 'alw:16888',
            'account': {'vendor_id': 7123, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get('/features/vendor/7123/user_type/alw/user_id/16888', headers={})
    assert resp.status_code == 200
    assert resp.json == forced_feature_data


@pytest.mark.parametrize(
    ('splitio_enabled'),
    [
        # # split enabled
        (True)
    ],
)
def test_get_features_for_vendor_orchard_user_type(
    client, monkeypatch, splitio_enabled
):
    """Test get_features_for_vendor_with_user_type calls logic layer."""
    if splitio_enabled:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_split_features_with_user_context',  # noqa
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )
    else:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_features_with_user_context',
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )

    url = '/features/vendor/100/user_type/alw/user_id/789'
    if splitio_enabled:
        url = '{}?{}'.format(url, 'splitioEnabled=1')

    client.get(url)

    if splitio_enabled:
        assert handlers.features_logic.get_all_split_features_with_user_context.called  # noqa
        assert (
            handlers.features_logic.get_all_split_features_with_user_context.call_args[
                0
            ]
            == (  # noqa
                'alw:789',
                None,
                '100',
                None,
                None,
            )
        )
    else:
        assert handlers.features_logic.get_all_features_with_user_context.called  # noqa
        assert handlers.features_logic.get_all_features_with_user_context.call_args[
            0
        ] == (  # noqa
            'alw:789',
            None,
            '100',
        )


def test_get_feature_without_headers(client, single_feature_data):
    """Verify that get_feature returns feature without user context."""
    resp = client.get('/features/feature_1', headers={})
    assert resp.status_code == 200
    # assert resp.data.decode('utf8') == single_feature_data
    # to do need to change to assert


def test_get_feature_with_invalid_headers(client):
    """Verify that get_feature returns error."""
    resp = client.get('/features/feature_1', headers={'Grass-Account-Type': 'vendor'})
    assert resp.status_code == 400
    assert resp.json == (
        error_response.create_error_incomplete_account_headers().errors
    )


def test_get_feature_with_headers(monkeypatch, client, single_feature_data):
    """Verify that get_feature returns feature with user context."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'alw',
            'user_id': 'alw:16888',
            'account': {'vendor_id': 7123, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    monkeypatch.setattr(
        handlers.features_logic,
        'get_single_split_feature_with_profile_context',  # noqa
        MagicMock(return_value=response.Response({single_feature_data})),
    )

    resp = client.get(
        '/features/feature_1',
        headers={
            'Grass-Account-Type': 'vendor',
            'Grass-Account-Id': 7123,
            'Orchard-User-Id': 'alw:16888',
        },
    )

    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data


def test_get_feature_with_profile_context(client, single_feature_data):
    """Verify get_feature for profile headers."""
    headers = {'ORCHARD_IDENTITY_ID': '5d542f411234a40db1f64010'}
    resp = client.get('/features/feature_1', headers=headers)
    assert resp.status_code == 200
    # assert resp.data.decode('utf8') == single_feature_data
    # todo(jpenner) - mock response


@patch('features.logic.get_single_split_feature_with_user_context')
def test_get_feature_with_splitio_param(
    mock_splitio_logic, single_feature_data, client
):
    """Verify get_feature calls splitio logic when param is set to true."""
    mock_response = response.Response(message=single_feature_data)
    mock_splitio_logic.return_value = mock_response
    resp = client.get('/features/feature_1?splitioEnabled=true', headers={})
    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data
    mock_splitio_logic.assert_called_once()


@patch('features.logic.get_single_split_feature_with_profile_context')
def test_get_feature_with_profile_context_splitio_param(
    mock_splitio_logic, single_feature_data, client
):
    """Verify get_feature calls splitio logic when param is set to true."""
    headers = {
        'ORCHARD_PROFILE_TYPE': 'ArtistProfile',
        'ORCHARD_PROFILE_ID': 555,
        'ORCHARD_IDENTITY_ID': '5d542f411234a40db1f64010',
    }
    mock_response = response.Response(message=single_feature_data)
    mock_splitio_logic.return_value = mock_response
    resp = client.get('/features/feature_1?splitioEnabled=true', headers=headers)
    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data
    mock_splitio_logic.assert_called_once()


@patch('features.logic.get_single_split_feature_with_user_context')
def test_get_feature_with_splitio_env_var(
    mock_splitio_logic, single_feature_data, client
):
    """Verify get_feature calls splitio logic when env var is set."""
    mock_response = response.Response(message=single_feature_data)
    mock_splitio_logic.return_value = mock_response
    resp = client.get('/features/feature_1', headers={})
    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data
    mock_splitio_logic.assert_called_once()


@patch('features.logic.get_single_split_feature_with_profile_context')
def test_get_feature_with_splitio_env_var_profile_context(
    mock_splitio_logic, single_feature_data, client
):
    """Verify get_feature calls splitio logic when env var is set."""
    headers = {
        'ORCHARD_PROFILE_TYPE': 'ArtistProfile',
        'ORCHARD_PROFILE_ID': 555,
        'ORCHARD_IDENTITY_ID': '5d542f411234a40db1f64010',
    }
    mock_response = response.Response(message=single_feature_data)
    mock_splitio_logic.return_value = mock_response
    resp = client.get('/features/feature_1', headers=headers)
    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data
    mock_splitio_logic.assert_called_once()


def test_get_feature_for_user_without_headers(monkeypatch, single_feature_data, client):
    """Verify that get_feature_for_user returns feature in passed context."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'alw',
            'user_id': 'alw:16888',
            'account': {'vendor_id': 7123, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get('/features/feature_1/user/alw:16888', headers={})

    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data


def test_get_feature_for_user_with_invalid_headers(
    monkeypatch, single_feature_data, client
):
    """Verify that get_feature_for_user returns error."""
    resp = client.get(
        '/features/feature_1/user/alw:16888', headers={'Grass-Account-Type': 'vendor'}
    )

    assert resp.status_code == 400
    assert resp.json == (
        error_response.create_error_incomplete_account_headers().errors
    )


def test_get_feature_for_user_with_matching_headers(
    monkeypatch, single_feature_data, client
):
    """Verify that get_feature_for_user returns feature in passed context."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'alw',
            'user_id': 'alw:16888',
            'account': {'vendor_id': 7123, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get(
        '/features/feature_1/user/alw:16888', headers={'Orchard-User-Id': 'alw:16888'}
    )

    assert resp.status_code == 200
    assert resp.data.decode('utf8') == single_feature_data


def test_get_feature_for_user_without_matching_headers(
    monkeypatch, single_feature_data, client
):
    """Verify that get_feature_for_user returns error."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 200
    mock_response.json = Mock(
        return_value={
            'type': 'alw',
            'user_id': 'alw:16888',
            'account': {'vendor_id': 7123, 'subaccount_id': None},
        }
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    monkeypatch.setattr(
        handlers.features_logic,
        'get_single_feature_with_user_context',  # noqa
        MagicMock(
            return_value=response.Response(
                message=error_response.create_error_user_mismatch().errors, status=400
            )
        ),
    )

    resp = client.get(
        '/features/feature_1/user/alw:555', headers={'Orchard-User-Id': 'alw:16888'}
    )

    assert resp.status_code == 400
    assert resp.json == (error_response.create_error_user_mismatch().errors)


@pytest.mark.parametrize(
    ('headers'),
    [
        # vendor
        (
            {
                header.GRASS_ACCOUNT_TYPE: 'vendor',
                header.GRASS_ACCOUNT_ID: '25825',
                header.ORCHARD_USER_ID: 'alw:123',
            }
        ),
        # subaccount
        (
            {
                header.GRASS_ACCOUNT_TYPE: 'subaccount',
                header.GRASS_ACCOUNT_ID: '13450',
                header.ORCHARD_USER_ID: 'alw:123',
            }
        ),
        # oa user
        ({header.ORCHARD_USER_ID: 'oa:555'}),
    ],
)
def test_get_single_feature_splitio(client, monkeypatch, headers):
    """Test get_feature calls logic layer."""
    monkeypatch.setattr(
        handlers.features_logic,
        'get_single_split_feature_with_profile_context',  # noqa
        MagicMock(return_value=response.Response({'enabled'})),
    )

    monkeypatch.setattr(
        ows_users, 'get_user_details_by_user_id', MagicMock(return_value=users_data())
    )

    url = '/features/ows_features_example?splitioEnabled=1'
    resp = client.get(url, headers=headers)

    assert resp.get_data().decode() == 'enabled'
    grass_account_type = headers.get(header.GRASS_ACCOUNT_TYPE, None)
    if grass_account_type is not None:
        if grass_account_type == 'vendor':
            assert handlers.features_logic.get_single_split_feature_with_profile_context.called  # noqa
            assert (
                handlers.features_logic.get_single_split_feature_with_profile_context.call_args[
                    0
                ]
                == (  # noqa
                    'ows_features_example',
                    'LabelProfile',
                    123,
                    None,
                    None,
                )
            )
        elif grass_account_type == 'subaccount':
            assert handlers.features_logic.get_single_split_feature_with_profile_context.called  # noqa
            assert (
                handlers.features_logic.get_single_split_feature_with_profile_context.call_args[
                    0
                ]
                == (  # noqa
                    'ows_features_example',
                    'LabelProfile',
                    123,
                    None,
                    None,
                )
            )
    else:
        # oa user
        assert (
            handlers.features_logic.get_single_split_feature_with_profile_context.called
        )  # noqa
        assert (
            handlers.features_logic.get_single_split_feature_with_profile_context.call_args[
                0
            ]
            == (  # noqa
                'ows_features_example',
                'OrchAdminProfile',
                555,
                None,
                None,
            )
        )


def test_health(client):
    """Get health check."""
    result = client.get('/hello/')
    assert result.status_code == 200


def test_get_features_for_user_invalid_user_id(monkeypatch, all_feature_data, client):
    """Verify that get_feature_for_user returns error for invalid userid."""
    server.features.clear()
    server.features.update(
        parser.parse_features_from_yaml_file(config.FEATURES_YML_FILE)
    )
    mock_response = MagicMock()
    mock_response.status_code = 404
    mock_response.json = Mock(
        return_value={'code': 'not_found_error', 'message': 'User not found.'}
    )

    monkeypatch.setattr(
        'features.models.ows_users.requests.get', MagicMock(return_value=mock_response)
    )

    monkeypatch.setattr(redis.client, 'get', MagicMock(return_value=None))

    monkeypatch.setattr(redis.client, 'set', MagicMock())

    resp = client.get('/features/user/oa:123', headers={'Orchard-User-Id': 'oa:123'})
    assert resp.status_code == 404
    assert resp.json == {
        'code': error.ERROR_CODE_USER_DOES_NOT_EXIST,
        'message': error.ERROR_MESSAGE_USER_DOES_NOT_EXIST,
    }


@pytest.mark.parametrize(
    ('splitio_enabled'),
    [
        # # split enabled
        (True)
    ],
)
def test_get_features_for_vendor_orchard_user(client, monkeypatch, splitio_enabled):
    """Test get_features_for_vendor calls logic layer."""
    if splitio_enabled:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_split_features_with_user_context',  # noqa
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )
    else:
        monkeypatch.setattr(
            handlers.features_logic,
            'get_all_features_with_user_context',
            MagicMock(return_value=response.Response({'pizza': 'party'})),
        )

    url = '/features/vendor/100/user/alw:789'
    if splitio_enabled:
        url = '{}?{}'.format(url, 'splitioEnabled=1')

    client.get(url)

    if splitio_enabled:
        assert handlers.features_logic.get_all_split_features_with_user_context.called  # noqa
        assert (
            handlers.features_logic.get_all_split_features_with_user_context.call_args[
                0
            ]
            == (  # noqa
                'alw:789',
                None,
                '100',
                None,
                None,
            )
        )
    else:
        assert handlers.features_logic.get_all_features_with_user_context.called  # noqa
        assert handlers.features_logic.get_all_features_with_user_context.call_args[
            0
        ] == (  # noqa
            'alw:789',
            None,
            '100',
        )


def test_get_features_for_vendor_invalid_user_id(monkeypatch, all_feature_data):
    """Test get_features_for_vendor returns error for invalid userid."""
    feature_data_mock = MagicMock(return_value=response.Response(all_feature_data))

    monkeypatch.setattr(
        handlers.features_logic, 'get_all_features_with_user_context', feature_data_mock
    )
    result = handlers.get_features_for_vendor(7123, 'dummy')
    assert feature_data_mock.not_called
    assert result.status_code == 404
    assert result.json == (error_response.create_error_user_does_not_exist().errors)