"""Tests for Handlers."""
import json
from unittest.mock import MagicMock, patch

from flexmock import flexmock

from oto import response

from owsrequest import flask_request

from pricing import api
from pricing import config
from pricing import handlers
from pricing import test_handlers  # noqa: F401
from pricing.constants import header
from pricing.logic import default_account_pricing_tier as default_pricing_tier, orchard_pricing_tier_value
from pricing.logic import legacy_product_mapping
from pricing.logic import orchard_pricing_tier
from pricing.logic import pricing_copy as pricing_copy_logic
from pricing.logic import pricing_family
from pricing.logic import pricing_helper
from pricing.logic import product_orchard_pricing_tier
from pricing.logic import product_pricing_override
from pricing.logic import product_store_effective_price_code
from pricing.logic import product_store_pricing
from pricing.logic import store_pricing_scheme
from pricing.logic import store_pricing_tier
from pricing.logic import store_pricing_tier_code
from pricing.logic import track
from pricing.logic import track_pricing_override
from pricing.logic import product_pricing_validator

import pytest


@pytest.fixture
def fixture_client():
    """Create an api test fixture."""
    return api.app.test_client()


@pytest.fixture
def fixture_success():
    """Create a success response."""
    return response.Response('a-ok')


@pytest.fixture
def fixture_fatal():
    """Create a fatal response."""
    return response.create_fatal_response()


@pytest.fixture
def fixture_success_track():
    """Create a success response."""
    return response.Response(
        message={
            'track_id': 1,
            'product_id': 1
        }, status=200)


@patch('pricing.handlers.g', spec=['log'])
def test_exception_handler(mock_g, app_context):
    """Verify exception_Handler returns 500 status code and json payload."""
    message = (
        'The server encountered an internal error '
        'and was unable to complete your request.')
    mock_error = MagicMock()
    server_response = handlers.exception_handler(mock_error)
    mock_g.log.exception.assert_called_with(mock_error)

    # assert status code is 500
    assert server_response.status_code == 500

    # assert json payload
    response_message = json.loads(server_response.data.decode())
    assert response_message['message'] == message
    assert response_message['code'] == response.error.ERROR_CODE_INTERNAL_ERROR


def test_get_pricing_families(monkeypatch, fixture_client, fixture_success):
    """Test pricing family response."""
    monkeypatch.setattr(
        pricing_family, 'get_pricing_families', MagicMock(
            return_value=fixture_success))
    result = fixture_client.get('/pricing-families')

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_orchard_pricing_tier_by_pricing_family_id(
        monkeypatch, fixture_client, fixture_success):
    """Test Orchard pricing tier response."""
    monkeypatch.setattr(
        orchard_pricing_tier, 'get_orchard_pricing_tier_by_pricing_family_id',
        MagicMock(return_value=fixture_success))
    result = fixture_client.get('/pricing-family/1/orchard-pricing-tier')

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_public_get_orchard_pricing_tier_by_pricing_family_id(
        monkeypatch, fixture_client, fixture_success):
    """Test Orchard pricing tier response."""
    monkeypatch.setattr(
        orchard_pricing_tier, 'get_orchard_pricing_tier_by_pricing_family_id',
        MagicMock(return_value=fixture_success))
    result = fixture_client.get(
        '/public/pricing-family/1/orchard-pricing-tier')

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_pricing_family(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Pricing Family response."""
    monkeypatch.setattr(
        pricing_family, 'create_pricing_family',
        MagicMock(return_value=fixture_success))
    data = {'name': 'A Pricing Family'}

    result = fixture_client.post(
        '/admin/pricing-family', data=json.dumps(data))

    pricing_family.create_pricing_family.assert_called_with(data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_pricing_family_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Pricing Family response for empty data."""
    monkeypatch.setattr(
        pricing_family, 'create_pricing_family',
        MagicMock(wraps=pricing_family.create_pricing_family))

    result = fixture_client.post('/admin/pricing-family')

    pricing_family.create_pricing_family.assert_called_with({})
    assert result.status_code == 400


def test_create_orchard_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Orchard Pricing tier response."""
    monkeypatch.setattr(
        orchard_pricing_tier, 'create_orchard_pricing_tier',
        MagicMock(return_value=fixture_success))
    data = {'name': 'An Orchard Pricing Tier'}

    result = fixture_client.post(
        '/admin/orchard-pricing-tier', data=json.dumps(data))

    orchard_pricing_tier.create_orchard_pricing_tier.assert_called_with(data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_orchard_pricing_tier_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Orchard Pricing tier response for empty data."""
    monkeypatch.setattr(
        orchard_pricing_tier, 'create_orchard_pricing_tier',
        MagicMock(wraps=orchard_pricing_tier.create_orchard_pricing_tier))

    result = fixture_client.post('/admin/orchard-pricing-tier')

    orchard_pricing_tier.create_orchard_pricing_tier.assert_called_with({})
    assert result.status_code == 400


def test_update_orchard_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Orchard Pricing Tier response."""
    monkeypatch.setattr(
        orchard_pricing_tier, 'update_orchard_pricing_tier_by_id',
        MagicMock(return_value=fixture_success))
    data = {'name': 'An Orchard Pricing Tier'}

    result = fixture_client.put(
        '/admin/orchard-pricing-tier/1', data=json.dumps(data))

    orchard_pricing_tier.update_orchard_pricing_tier_by_id.assert_called_with(
        '1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_orchard_pricing_tier_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Orchard Pricing Tier response for empty data."""
    monkeypatch.setattr(
        orchard_pricing_tier, 'update_orchard_pricing_tier_by_id',
        MagicMock(
            wraps=orchard_pricing_tier.update_orchard_pricing_tier_by_id))

    result = fixture_client.put('/admin/orchard-pricing-tier/1')

    orchard_pricing_tier.update_orchard_pricing_tier_by_id.assert_called_with(
        '1', {})
    assert result.status_code == 400


def test_get_store_pricing_scheme_by_id(
        monkeypatch, fixture_client, fixture_success):
    """Test Get Store Pricing Scheme response."""
    monkeypatch.setattr(
        store_pricing_scheme, 'get_store_pricing_scheme_by_id', MagicMock(
            return_value=fixture_success))
    result = fixture_client.get('/store-pricing-scheme/1')

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_store_pricing_scheme_by_store_id(
        monkeypatch, fixture_client, fixture_success):
    """Test Get Store Pricing Schemes by Store ID response."""
    monkeypatch.setattr(
        store_pricing_scheme,
        'get_by_store_id',
        MagicMock(return_value=fixture_success))

    store_id = 1

    url = '/store/{0}/store-pricing-scheme'.format(store_id)
    result = fixture_client.get(url)

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_store_pricing_scheme_by_pricing_family_id(
        monkeypatch, fixture_client, fixture_success):
    """Test Get Store Pricing Schemes by pricing family ID response."""
    monkeypatch.setattr(
        store_pricing_scheme,
        'get_by_pricing_family_id',
        MagicMock(return_value=fixture_success))

    pricing_family_id = 1

    url = '/pricing-family/{0}/store-pricing-scheme'.format(pricing_family_id)
    result = fixture_client.get(url)

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_store_pricing_scheme(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Store Pricing Scheme response."""
    monkeypatch.setattr(
        store_pricing_scheme, 'create_store_pricing_scheme', MagicMock(
            return_value=fixture_success))
    data = {'name': 'A Store Pricing Scheme'}

    result = fixture_client.post(
        '/admin/store-pricing-scheme', data=json.dumps(data))

    store_pricing_scheme.create_store_pricing_scheme.assert_called_with(data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_store_pricing_scheme_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Store Pricing Scheme response for empty data."""
    monkeypatch.setattr(
        store_pricing_scheme, 'create_store_pricing_scheme',
        MagicMock(wraps=store_pricing_scheme.create_store_pricing_scheme))

    result = fixture_client.post('/admin/store-pricing-scheme')

    store_pricing_scheme.create_store_pricing_scheme.assert_called_with({})
    assert result.status_code == 400


def test_update_store_pricing_scheme(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Store Pricing Scheme response."""
    monkeypatch.setattr(
        store_pricing_scheme, 'update_store_pricing_scheme_by_id', MagicMock(
            return_value=fixture_success))
    data = {'name': 'A Store Pricing Scheme'}

    result = fixture_client.put(
        '/admin/store-pricing-scheme/1', data=json.dumps(data))

    store_pricing_scheme.update_store_pricing_scheme_by_id.assert_called_with(
        '1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_store_pricing_scheme_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Store Pricing Scheme response for empty data."""
    monkeypatch.setattr(
        store_pricing_scheme, 'update_store_pricing_scheme_by_id', MagicMock(
            wraps=store_pricing_scheme.update_store_pricing_scheme_by_id))

    result = fixture_client.put('/admin/store-pricing-scheme/1')

    store_pricing_scheme.update_store_pricing_scheme_by_id.assert_called_with(
        '1', {})
    assert result.status_code == 400


def test_create_store_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Store Pricing Tier response."""
    monkeypatch.setattr(
        store_pricing_tier, 'create_store_pricing_tier', MagicMock(
            return_value=fixture_success))
    data = {'name': 'A Store Pricing Tier'}

    result = fixture_client.post(
        '/admin/store-pricing-scheme/1/store-pricing-tier',
        data=json.dumps(data))

    store_pricing_tier.create_store_pricing_tier.assert_called_with('1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_store_pricing_tier_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Store Pricing Tier response for empty data."""
    monkeypatch.setattr(
        store_pricing_tier, 'create_store_pricing_tier',
        MagicMock(wraps=store_pricing_tier.create_store_pricing_tier))

    result = fixture_client.post(
        '/admin/store-pricing-scheme/1/store-pricing-tier')

    store_pricing_tier.create_store_pricing_tier.assert_called_with('1', {})
    assert result.status_code == 400


def test_update_store_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Store Pricing Tier response."""
    monkeypatch.setattr(
        store_pricing_tier, 'update_store_pricing_tier_by_id', MagicMock(
            return_value=fixture_success))
    data = {'name': 'A Store Pricing Tier'}

    result = fixture_client.put(
        '/admin/store-pricing-scheme/store-pricing-tier/1',
        data=json.dumps(data))

    store_pricing_tier.update_store_pricing_tier_by_id.assert_called_with(
        '1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_store_pricing_tier_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Store Pricing Tier response for empty data."""
    monkeypatch.setattr(
        store_pricing_tier, 'update_store_pricing_tier_by_id', MagicMock(
            wraps=store_pricing_tier.update_store_pricing_tier_by_id))

    result = fixture_client.put(
        '/admin/store-pricing-scheme/store-pricing-tier/1')

    store_pricing_tier.update_store_pricing_tier_by_id.assert_called_with(
        '1', {})
    assert result.status_code == 400


def test_delete_store_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test Delete Store Pricing Tier response."""
    monkeypatch.setattr(
        store_pricing_tier, 'delete', MagicMock(
            return_value=fixture_success))

    result = fixture_client.delete(
        '/admin/store-pricing-scheme/store-pricing-tier/1')

    store_pricing_tier.delete.assert_called_with('1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_store_pricing_tier_code(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Store Pricing tier code response."""
    monkeypatch.setattr(
        store_pricing_tier_code,
        'create',
        MagicMock(return_value=fixture_success))

    data = {
        'price_code': '100',
        'resolution': 'HD'}

    store_pricing_tier_id = '1'
    url = '/admin/store-pricing-tier/{0}/store-pricing-tier-code'.format(
        store_pricing_tier_id)

    result = fixture_client.post(url, data=json.dumps(data))

    store_pricing_tier_code.create.assert_called_with(
        store_pricing_tier_id, data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_store_pricing_tier_code_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Store Pricing tier code response for empty data."""
    monkeypatch.setattr(
        store_pricing_tier_code,
        'create',
        MagicMock(wraps=store_pricing_tier_code.create))

    store_pricing_tier_id = '1'
    url = '/admin/store-pricing-tier/{0}/store-pricing-tier-code'.format(
        store_pricing_tier_id)

    result = fixture_client.post(url)

    store_pricing_tier_code.create.assert_called_with(
        store_pricing_tier_id, {})
    assert result.status_code == 400


def test_update_store_pricing_tier_code(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Store Pricing tier code response."""
    monkeypatch.setattr(
        store_pricing_tier_code,
        'update',
        MagicMock(return_value=fixture_success))

    data = {
        'price_code': '100',
        'resolution': 'HD'}

    store_pricing_tier_id = '1'
    store_pricing_tier_code_id = '2'
    url = '/admin/store-pricing-tier/{0}/store-pricing-tier-code/{1}'.format(
        store_pricing_tier_id, store_pricing_tier_code_id)

    result = fixture_client.put(url, data=json.dumps(data))

    store_pricing_tier_code.update.assert_called_with(
        store_pricing_tier_id, store_pricing_tier_code_id, data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_store_pricing_tier_code_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Store Pricing tier code response for empty data."""
    monkeypatch.setattr(
        store_pricing_tier_code,
        'update',
        MagicMock(wraps=store_pricing_tier_code.update))

    store_pricing_tier_id = '1'
    store_pricing_tier_code_id = '2'
    url = '/admin/store-pricing-tier/{0}/store-pricing-tier-code/{1}'.format(
        store_pricing_tier_id, store_pricing_tier_code_id)

    result = fixture_client.put(url)

    store_pricing_tier_code.update.assert_called_with(
        store_pricing_tier_id, store_pricing_tier_code_id, {})
    assert result.status_code == 400


@pytest.mark.parametrize('method, path', [
    ('get', '/product/1/pricing-family/1/orchard_pricing_tier'),
    ('put', '/product/1/pricing-family/1/orchard_pricing_tier'),
    ('get', '/product/1/override'),
    ('post', '/product/1/override'),
    ('put', '/product/1/override/1'),
    ('get', '/pricing_family/1/product/2/store/3/pricing'),
    ('delete', '/legacy/product/2/unmigrate'),
    ('get', '/product/1/digital/bff'),
    ('get', '/product/1/track-overrides'),
])
def test_respects_verify_grass_ownership_failure(
        monkeypatch, fixture_client, fixture_fatal, method, path):
    """Test handlers immediately return on failed verify_grass_ownership."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_fatal))

    test_method = getattr(fixture_client, method)
    result = test_method(path)

    assert result.status_code == fixture_fatal.status


def test_get_product_orchard_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test get product with orchard pricing tier response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_orchard_pricing_tier,
        'get_by_product_id_and_pricing_family_id', MagicMock(
            return_value=fixture_success))
    result = fixture_client.get(
        '/product/1/pricing-family/1/orchard_pricing_tier')

    product_orchard_pricing_tier.get_by_product_id_and_pricing_family_id.\
        assert_called_with('1', '1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_product_with_orchard_price_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test Update Product with orchard pricing tier response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_orchard_pricing_tier,
        'update_product_with_orchard_pricing_tier', MagicMock(
            return_value=fixture_success))
    data = {'orchard_pricing_tier_id': 1}

    result = fixture_client.put(
        '/product/1/pricing-family/1/orchard_pricing_tier',
        data=json.dumps(data))

    product_orchard_pricing_tier.\
        update_product_with_orchard_pricing_tier.assert_called_with(
            '1', '1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_product_pricing_overrides(
        monkeypatch, fixture_client, fixture_success):
    """Test Get product pricing overrides response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override,
        'get_by_product_id', MagicMock(
            return_value=fixture_success))
    product_id = 1
    url = '/product/{0}/override'.format(product_id)

    result = fixture_client.get(url)

    product_pricing_override.get_by_product_id.assert_called_with('1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_product_pricing_override(
        monkeypatch, fixture_client, fixture_success):
    """Test Create product pricing override response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override,
        'create_product_pricing_override_with_change_detection',
        MagicMock(return_value=fixture_success))
    data = {
        'product_id': '1',
        'resolution': 'HD',
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }
    product_id = 1
    url = '/product/{0}/override'.format(product_id)

    result = fixture_client.post(url, data=json.dumps(data))

    product_pricing_override.\
        create_product_pricing_override_with_change_detection.\
        assert_called_with('1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_bulk_create_product_pricing_override(
        monkeypatch, fixture_client, fixture_success):
    """Test bulk create product pricing override response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override, 'bulk_create_product_pricing_override',
        MagicMock(return_value=fixture_success))
    data = {
        'items': [
            {
                'product_id': '1',
                'resolution': 'HD',
                'applies_worldwide': True,
                'store_id': 1,
                'orchard_pricing_tier_id': 3
            },
            {
                'product_id': '1',
                'resolution': 'SD',
                'applies_worldwide': True,
                'store_id': 1,
                'orchard_pricing_tier_id': 4
            }
        ]
    }
    product_id = 1
    url = '/product/{0}/override/bulk'.format(product_id)

    result = fixture_client.post(url, data=json.dumps(data))

    product_pricing_override.bulk_create_product_pricing_override\
        .assert_called_with('1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_bulk_update_create_product_pricing_override(
        monkeypatch, fixture_client, fixture_success):
    """Test bulk create product pricing override response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override,
        'bulk_update_create_product_pricing_override',
        MagicMock(return_value=fixture_success))
    data = {
        'items': [
            {
                'product_id': '1',
                'resolution': 'HD',
                'applies_worldwide': True,
                'store_id': 1,
                'orchard_pricing_tier_id': 3
            },
            {
                'product_id': '1',
                'resolution': 'SD',
                'applies_worldwide': True,
                'store_id': 1,
                'orchard_pricing_tier_id': 4
            }
        ]
    }
    product_id = 1
    url = '/product/{0}/override/bulk'.format(product_id)

    result = fixture_client.put(url, data=json.dumps(data))

    product_pricing_override.bulk_update_create_product_pricing_override\
        .assert_called_with('1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_product_pricing_override_empty_data(
        monkeypatch, fixture_client, fixture_success):
    """Test Create Product Pricing Override response for empty data."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override, 'create_product_pricing_override', MagicMock(
            wraps=product_pricing_override.create_product_pricing_override))
    product_id = 1
    url = '/product/{0}/override'.format(product_id)

    result = fixture_client.post(url)

    data = {}
    product_pricing_override.create_product_pricing_override.\
        assert_called_with('1', data)
    assert result.status_code == 400


def test_update_product_pricing_override(
        monkeypatch, fixture_client, fixture_success):
    """Test Update product pricing override response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override,
        'update_product_pricing_override', MagicMock(
            return_value=fixture_success))
    data = {
        'product_id': '1',
        'product_pricing_override_id': '1',
        'resolution': 'HD',
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }
    product_id = 1
    product_pricing_override_id = 2
    url = '/product/{0}/override/{1}'.format(
        product_id, product_pricing_override_id)

    result = fixture_client.put(url, data=json.dumps(data))

    product_pricing_override. \
        update_product_pricing_override.assert_called_with('1', '2', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_product_pricing_override_empty_body(
        monkeypatch, fixture_client, fixture_success):
    """Test Update product pricing override response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_override,
        'update_product_pricing_override', MagicMock(
            wraps=product_pricing_override.update_product_pricing_override))
    data = {}
    product_id = 1
    product_pricing_override_id = 2
    url = '/product/{0}/override/{1}'.format(
        product_id, product_pricing_override_id)

    result = fixture_client.put(url, data=json.dumps(data))

    product_pricing_override. \
        update_product_pricing_override.assert_called_with('1', '2', data)
    assert result.status_code == 400


def test_get_product_pricing_by_store_id(
        monkeypatch, fixture_client, fixture_success):
    """Test Get Products By Store Id response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_store_pricing,
        'get_product_store_pricing', MagicMock(return_value=fixture_success))
    pricing_family_id = 1
    product_id = 2
    store_id = 3
    url = '/pricing_family/{0}/product/{1}/store/{2}/pricing'.format(
        pricing_family_id, product_id, store_id)

    result = fixture_client.get(url)

    product_store_pricing.get_product_store_pricing.assert_called_with(
        '1', '2', '3')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_track_pricing_overrides(
        monkeypatch, fixture_client, fixture_success, fixture_success_track):
    """Test Get track pricing overrides response."""
    monkeypatch.setattr(track, 'get_track_by_track_id', MagicMock(
        return_value=fixture_success_track))

    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        track_pricing_override,
        'get_by_track_id', MagicMock(return_value=fixture_success))
    track_id = 1
    url = '/track/{0}/override'.format(track_id)

    result = fixture_client.get(url)

    track_pricing_override.get_by_track_id.assert_called_with('1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_track_pricing_override(
        monkeypatch, fixture_client, fixture_success, fixture_success_track):
    """Test Create track pricing override response."""
    monkeypatch.setattr(track, 'get_track_by_track_id', MagicMock(
        return_value=fixture_success_track))

    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        track_pricing_override, 'create_track_pricing_override', MagicMock(
            return_value=fixture_success))
    data = {
        'track_id': '1',
        'resolution': 'HD',
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }
    track_id = 1
    url = '/track/{0}/override'.format(track_id)

    result = fixture_client.post(url, data=json.dumps(data))

    track_pricing_override.create_track_pricing_override \
        .assert_called_with('1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_create_track_pricing_override_empty_data(
        monkeypatch, fixture_client, fixture_success, fixture_success_track):
    """Test Create Product Pricing Override response for empty data."""
    monkeypatch.setattr(track, 'get_track_by_track_id', MagicMock(
        return_value=fixture_success_track))

    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        track_pricing_override, 'create_track_pricing_override', MagicMock(
            wraps=track_pricing_override.create_track_pricing_override))
    track_id = 1
    url = '/track/{0}/override'.format(track_id)

    result = fixture_client.post(url)

    data = {}
    track_pricing_override.create_track_pricing_override. \
        assert_called_with('1', data)
    assert result.status_code == 400


def test_update_track_pricing_override(
        monkeypatch, fixture_client, fixture_success, fixture_success_track):
    """Test Update track pricing override response."""
    monkeypatch.setattr(track, 'get_track_by_track_id', MagicMock(
        return_value=fixture_success_track))

    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        track_pricing_override,
        'update_track_pricing_override', MagicMock(
            return_value=fixture_success))
    data = {
        'track_id': '1',
        'track_pricing_override_id': '1',
        'resolution': 'HD',
        'applies_worldwide': True,
        'store_id': 1,
        'orchard_pricing_tier_id': 3
    }
    track_id = 1
    track_pricing_override_id = 2
    url = '/track/{0}/override/{1}'.format(
        track_id, track_pricing_override_id)

    result = fixture_client.put(url, data=json.dumps(data))

    track_pricing_override. \
        update_track_pricing_override.assert_called_with('1', '2', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_update_track_pricing_override_empty_body(
        monkeypatch, fixture_client, fixture_success, fixture_success_track):
    """Test Update track pricing override response."""
    monkeypatch.setattr(track, 'get_track_by_track_id', MagicMock(
        return_value=fixture_success_track))

    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        track_pricing_override,
        'update_track_pricing_override', MagicMock(
            wraps=track_pricing_override.update_track_pricing_override))
    data = {}
    track_id = 1
    track_pricing_override_id = 2
    url = '/track/{0}/override/{1}'.format(
        track_id, track_pricing_override_id)

    result = fixture_client.put(url, data=json.dumps(data))

    track_pricing_override. \
        update_track_pricing_override.assert_called_with('1', '2', data)
    assert result.status_code == 400


def test_bulk_update_create_track_pricing_override(
        monkeypatch, fixture_client, fixture_success):
    """Test bulk create track pricing override response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        track_pricing_override,
        'bulk_update_create_track_pricing_override',
        MagicMock(return_value=fixture_success))
    data = {
        'items': [
            {
                'track_id': '1',
                'resolution': 'HD',
                'applies_worldwide': True,
                'store_id': 1,
                'orchard_pricing_tier_id': 3
            },
            {
                'track_id': '1',
                'resolution': 'SD',
                'applies_worldwide': True,
                'store_id': 1,
                'orchard_pricing_tier_id': 4
            }
        ]
    }
    product_id = 1
    url = '/product/{0}/track-override/bulk'.format(product_id)

    result = fixture_client.put(url, data=json.dumps(data))

    track_pricing_override.bulk_update_create_track_pricing_override\
        .assert_called_with('1', data)
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_map_legacy_product_pricing_data_to_new_structure(
        monkeypatch, fixture_client, fixture_success):
    """Test map_legacy_product_pricing_data_to_new_structure handler."""
    monkeypatch.setattr(
        legacy_product_mapping,
        'map_legacy_product_pricing_data', MagicMock(
            return_value=fixture_success))

    pricing_family_id = 1
    product_id = 1
    url = '/legacy/{0}/product/{1}'.format(pricing_family_id, product_id)

    result = fixture_client.get(url)

    legacy_product_mapping.map_legacy_product_pricing_data\
        .assert_called_with('1', '1')
    assert result
    assert result.status_code == fixture_success.status


def test_handler_delete_store_pricing_tier_code(
        monkeypatch, fixture_client, fixture_success):
    """Test delete store pricing tier code handler."""
    monkeypatch.setattr(
        store_pricing_tier_code, 'delete', MagicMock(
            return_value=fixture_success))

    store_pricing_tier_code_id = 2
    url = '/admin/store_pricing_tier_code/{0}'.format(
        store_pricing_tier_code_id)

    result = fixture_client.delete(url)

    store_pricing_tier_code.delete.assert_called_with(
        str(store_pricing_tier_code_id))

    assert result
    assert result.status_code == fixture_success.status


def test_unmigrate_product(monkeypatch, fixture_client, fixture_success):
    """Test unmigrating a product handler."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        legacy_product_mapping, 'unmigrate_product', MagicMock(
            return_value=fixture_success))

    product_id = 2
    url = '/legacy/product/{0}/unmigrate'.format(product_id)

    result = fixture_client.delete(url)

    legacy_product_mapping.unmigrate_product.assert_called_with(
        str(product_id))

    assert result
    assert result.status_code == fixture_success.status


def test_unmigrate_track(monkeypatch, fixture_client, fixture_success):
    """Test unmigrating a track handler."""
    monkeypatch.setattr(legacy_product_mapping, 'unmigrate_track', MagicMock(
        return_value=fixture_success))

    track_id = 1
    url = '/legacy/track/{0}/unmigrate'.format(track_id)

    result = fixture_client.delete(url)

    legacy_product_mapping.unmigrate_track.assert_called_with(str(track_id))

    assert result
    assert result.status_code == fixture_success.status


def test_bulk_migrate_film_products(
        monkeypatch, fixture_client, fixture_success):
    """Test bulk migrate film products handler."""
    monkeypatch.setattr(
        legacy_product_mapping, 'bulk_migrate_film_products', MagicMock(
            return_value=fixture_success))

    url = '/legacy/bulk/migrate'

    result = fixture_client.get(url)

    assert result
    assert result.status_code == fixture_success.status


def test_count_bulk_migrate_film_products(
        monkeypatch, fixture_client, fixture_success):
    """Test count bulk migrate film products handler."""
    monkeypatch.setattr(
        legacy_product_mapping, 'count_bulk_migrate_film_products', MagicMock(
            return_value=fixture_success))

    url = '/legacy/bulk/count-migration'

    result = fixture_client.get(url)

    assert result
    assert result.status_code == fixture_success.status


def test_jit_music_migration(monkeypatch, fixture_client, fixture_success):
    """Test jit music migration handler."""
    monkeypatch.setattr(
        legacy_product_mapping, 'jit_music_migration', MagicMock(
            return_value=fixture_success))

    product_id = 1
    url = '/legacy/music/product/{0}/jit'.format(product_id)

    result = fixture_client.get(url)

    legacy_product_mapping.jit_music_migration.assert_called_with(
        str(product_id))

    assert result
    assert result.status_code == fixture_success.status


def test_preview_music_migration(monkeypatch, fixture_client, fixture_success):
    """Test preview music migration handler."""
    monkeypatch.setattr(
        legacy_product_mapping, 'preview_music_migration', MagicMock(
            return_value=fixture_success))

    product_id = 1
    url = '/legacy/music/product/{0}/preview'.format(product_id)

    result = fixture_client.get(url)

    legacy_product_mapping.preview_music_migration.assert_called_with(
        str(product_id))

    assert result
    assert result.status_code == fixture_success.status


def test_execute_music_migration(monkeypatch, fixture_client, fixture_success):
    """Test execute music migration handler."""
    monkeypatch.setattr(
        legacy_product_mapping, 'execute_music_migration', MagicMock(
            return_value=fixture_success))

    product_id = 1
    url = '/legacy/music/product/{0}/execute'.format(product_id)

    result = fixture_client.get(url)

    legacy_product_mapping.execute_music_migration.assert_called_with(
        str(product_id))

    assert result
    assert result.status_code == fixture_success.status


def test_handler_copy_digital_product_pricing(
        monkeypatch, fixture_client, fixture_success):
    """Test copy_digital_product_pricing handler is successful."""
    monkeypatch.setattr(
        pricing_copy_logic, 'copy_pricing_for_digital_product', MagicMock(
            return_value=fixture_success))

    source_product_id = 1
    destination_product_id = 2
    url = '/product/{0}/pricing/copy/{1}'.format(
        source_product_id, destination_product_id)

    result = fixture_client.post(url)

    pricing_copy_logic.copy_pricing_for_digital_product.assert_called_with(
        source_product_id=source_product_id,
        destination_product_id=destination_product_id)

    assert result
    assert result.status_code == fixture_success.status


def test_handler_copy_digital_product_pricing_failed(
        monkeypatch, fixture_client, fixture_fatal):
    """Test copy_digital_product_pricing handler fails."""
    monkeypatch.setattr(
        pricing_copy_logic, 'copy_pricing_for_digital_product', MagicMock(
            return_value=fixture_fatal))

    source_product_id = 1
    destination_product_id = 2
    url = '/product/{0}/pricing/copy/{1}'.format(
        source_product_id, destination_product_id)

    result = fixture_client.post(url)

    pricing_copy_logic.copy_pricing_for_digital_product.assert_called_with(
        source_product_id=source_product_id,
        destination_product_id=destination_product_id)

    assert result
    assert result.status_code == fixture_fatal.status


def test_get_default_account_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test default account pricing tier response when success."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_headers',
        MagicMock(return_value=fixture_success)
    )
    monkeypatch.setattr(
        default_pricing_tier,
        'get_default_account_pricing_tier',
        MagicMock(return_value=fixture_success)
    )
    result = fixture_client.get('/vendor/25824/2/default')

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_default_account_pricing_tier_failed(
        monkeypatch, fixture_client, fixture_fatal):
    """Test default account pricing tier response when failed."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_headers',
        MagicMock(return_value=fixture_fatal)
    )
    monkeypatch.setattr(
        default_pricing_tier,
        'get_default_account_pricing_tier',
        MagicMock(return_value=fixture_fatal)
    )
    result = fixture_client.get('/vendor/25824/2/default')

    assert result.status_code == 500


def test_handler_set_default_account_pricing(
        monkeypatch, fixture_client, fixture_success):
    """Test set_default_account_pricing_tier handler is successful."""
    monkeypatch.setattr(flask_request, 'verify_grass_headers', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        default_pricing_tier, 'set_default_account_pricing_tier', MagicMock(
            return_value=fixture_success))

    account_type = 'vendor'
    account_id = 1234
    pricing_family_id = 2
    data = {'orchard_pricing_tier_id': 123, 'created_by': 'alw:123'}

    url = '/{0}/{1}/{2}/default'.format(
        account_type, account_id, pricing_family_id)

    result = fixture_client.put(
        url, data=json.dumps(data),
        headers={header.GRASS_ORCHARD_USER_ID: 'alw:123'})

    default_pricing_tier.set_default_account_pricing_tier.assert_called_with(
        account_type,
        account_id,
        pricing_family_id,
        data)

    assert result
    assert result.status_code == fixture_success.status


def test_handler_set_default_account_pricing_failed(
        monkeypatch, fixture_client, fixture_fatal):
    """Test set_default_account_pricing_tier handler fails."""
    monkeypatch.setattr(flask_request, 'verify_grass_headers', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        default_pricing_tier, 'set_default_account_pricing_tier', MagicMock(
            return_value=fixture_fatal))

    account_type = 'vendor'
    account_id = 1234
    pricing_family_id = 2
    data = {'orchard_pricing_tier_id': 123, 'created_by': 'alw:123'}

    url = '/{0}/{1}/{2}/default'.format(
        account_type, account_id, pricing_family_id)

    result = fixture_client.put(
        url, data=json.dumps(data),
        headers={header.GRASS_ORCHARD_USER_ID: 'alw:123'})

    default_pricing_tier.set_default_account_pricing_tier.assert_called_with(
        account_type,
        account_id,
        pricing_family_id,
        data)

    assert result
    assert result.status_code == fixture_fatal.status


def test_handler_set_default_account_pricing_grass_failure(
        monkeypatch, fixture_client, fixture_fatal):
    """Test set_default_account_pricing_tier handler for GRASS failure."""
    monkeypatch.setattr(flask_request, 'verify_grass_headers', MagicMock(
        return_value=fixture_fatal))

    monkeypatch.setattr(
        default_pricing_tier, 'set_default_account_pricing_tier', MagicMock(
            return_value=fixture_fatal))

    account_type = 'vendor'
    account_id = 1234
    pricing_family_id = 2
    data = {'orchard_pricing_tier_id': 123, 'created_by': 'alw:123'}

    url = '/{0}/{1}/{2}/default'.format(
        account_type, account_id, pricing_family_id)

    result = fixture_client.put(
        url, data=json.dumps(data),
        headers={header.GRASS_ORCHARD_USER_ID: 'alw:123'})

    assert result
    assert result.status_code == fixture_fatal.status


@pytest.mark.parametrize('input_data', [({}), (''), ('randomText'), (None)])
def test_handler_set_default_account_pricing_empty_data(
        input_data, monkeypatch, fixture_client, fixture_success):
    """Test set_default_account_pricing_tier handler for empty data."""
    monkeypatch.setattr(flask_request, 'verify_grass_headers', MagicMock(
        return_value=fixture_success))

    account_type = 'vendor'
    account_id = 1234
    pricing_family_id = 2

    url = '/{0}/{1}/{2}/default'.format(
        account_type, account_id, pricing_family_id)
    headers = {header.GRASS_ORCHARD_USER_ID: 'alw:123'}
    result = fixture_client.put(url, data=input_data, headers=headers)

    assert result
    assert result.status_code == 400


def test_handler_soft_delete_default_account_pricing_tier(
        monkeypatch, fixture_client, fixture_success):
    """Test soft_delete_default_account_pricing_tier handler is successful."""
    monkeypatch.setattr(flask_request, 'verify_grass_headers', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        default_pricing_tier,
        'soft_delete_default_account_pricing_tier',
        MagicMock(
            return_value=fixture_success))

    account_type = 'vendor'
    account_id = 1234
    pricing_family_id = 2
    data = {'created_by': 'alw:123'}

    url = '/{0}/{1}/{2}/default'.format(
        account_type, account_id, pricing_family_id)

    result = fixture_client.delete(
        url, data=json.dumps(data),
        headers={header.GRASS_ORCHARD_USER_ID: 'alw:123'})

    default_pricing_tier.soft_delete_default_account_pricing_tier.\
        assert_called_with(account_type, account_id, pricing_family_id, data)

    assert result
    assert result.status_code == fixture_success.status


def test_handler_soft_delete_default_account_pricing_tier_grass_failure(
        monkeypatch, fixture_client, fixture_fatal):
    """Test soft delete default pricing tier handler for GRASS failure."""
    monkeypatch.setattr(flask_request, 'verify_grass_headers', MagicMock(
        return_value=fixture_fatal))

    account_type = 'vendor'
    account_id = 1234
    pricing_family_id = 2
    data = {'created_by': 'alw:123'}

    url = '/{0}/{1}/{2}/default'.format(
        account_type, account_id, pricing_family_id)

    result = fixture_client.delete(
        url, data=json.dumps(data),
        headers={header.GRASS_ORCHARD_USER_ID: 'alw:123'})

    assert result
    assert result.status_code == fixture_fatal.status


def test_get_product_store_effective_price_code(
        monkeypatch, fixture_client, fixture_success):
    """Test get product store effective price response."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_store_effective_price_code,
        'get_by_product_id', MagicMock(return_value=fixture_success))
    product_id = 1
    url = '/product/{0}/effective-price-codes'.format(product_id)

    result = fixture_client.get(url)

    product_store_effective_price_code.get_by_product_id.assert_called_with(
        '1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


NO_HEADERS = {'None': ''}
OA_HEADERS = {'Orchard-User-Id': 'oa:12345'}
ALW_HEADERS = {
    'Orchard-User-Id': 'alw:12345',
    'Grass-Account-Id': '234234',
    'Grass-Account-Type': 'vendor'
}


@pytest.fixture
def fixture_upload_token_data():
    """Return upload_token data."""
    return {
        'credentials': {
            'token': 'a real token',
            'aws_secret_access_key': 'a real secret',
            'aws_secret_key_id': 'a real key',
            'expiration': '2017-02-28 21:14:43'
        },
        'bucket': 'test-orcd-pricing-csv',
        'filename': 'fred123',
        'foldername': 'test-pricing-updater'
    }


@pytest.mark.parametrize('headers', [
    OA_HEADERS, ALW_HEADERS,
])
@pytest.mark.parametrize('method', ['GET'])
def test_get_upload_token_success(
        fixture_client,
        headers,
        method,
        fixture_upload_token_data):
    """Test route that gets the upload token."""
    mock_logic_response = response.Response(fixture_upload_token_data)
    (flexmock(pricing_helper)
     .should_receive('get_upload_permission')
     .with_args(headers.get('Orchard-User-Id'), config.STS_TOKEN_DURATION)
     .and_return(mock_logic_response))

    result = fixture_client.open(
        '/upload-token', method=method, headers=headers)
    assert result.status_code == 200
    assert result.headers.get('Correlation-Id')

    upload_token = json.loads(result.data.decode('utf-8'))
    assert upload_token.get('credentials')
    assert upload_token.get('bucket')
    assert upload_token.get('filename')
    assert upload_token.get('foldername')


@pytest.mark.parametrize('headers', [NO_HEADERS])
@pytest.mark.parametrize('method', ['GET'])
def test_get_upload_token_failure(
        fixture_client,
        headers,
        method):
    """Test for empty user_id failure."""
    mock_logic_response = response.create_error_response(
        'authorization_error', 'Failed to identify user')
    (flexmock(pricing_helper)
     .should_receive('get_upload_permission')
     .with_args(headers.get('None'), config.STS_TOKEN_DURATION)
     .and_return(mock_logic_response))

    result = fixture_client.open(
        '/upload-token', method=method, headers=headers)
    assert result.status_code == 401


@pytest.mark.parametrize('headers', [
    OA_HEADERS,
    ALW_HEADERS
])
@pytest.mark.parametrize('duration,expected_duration', [
    (900, 900), (1800, 1800), (700, 900)])
@pytest.mark.parametrize('method', ['GET'])
def test_get_upload_token_uses_duration(
        fixture_client, headers, duration, expected_duration, method,
        fixture_upload_token_data):
    """Test route uses the duration parameter to get upload permission."""
    mock_logic_response = response.Response(fixture_upload_token_data)
    (flexmock(pricing_helper)
     .should_receive('get_upload_permission')
     .with_args(headers.get('Orchard-User-Id'), expected_duration)
     .and_return(mock_logic_response))

    request_url = '/upload-token?duration={}'.format(duration)
    data = None
    if method == 'POST':
        request_url = '/upload-token'
        data = json.dumps({config.DURATION: duration})

    result = fixture_client.open(
        request_url, method=method, data=data, headers=headers)
    assert result.status_code == 200
    assert result.headers.get('Correlation-Id')

    upload_token = json.loads(result.data.decode('utf-8'))
    assert upload_token.get('credentials')
    assert upload_token.get('bucket')
    assert upload_token.get('filename')


@pytest.mark.parametrize('headers', [
    OA_HEADERS,
    ALW_HEADERS
])
@pytest.mark.parametrize('method', ['GET'])
def test_get_upload_token_logic_layer_failure(
        fixture_client, headers, method):
    """Test route fails when there is logic layer failure."""
    mock_logic_response = response.create_fatal_response('fatal_error')
    (flexmock(pricing_helper)
     .should_receive('get_upload_permission')
     .with_args(headers.get('Orchard-User-Id'), config.STS_TOKEN_DURATION)
     .and_return(mock_logic_response))

    headers = headers.copy()
    headers['Correlation-id'] = 'correlation_id'
    result = fixture_client.open(
        '/upload-token', method=method, headers=headers)

    assert result.status_code == 500

    response_message = json.loads(result.data.decode())
    assert response_message['code'] == 'internal_error'
    assert response_message['message'] == 'fatal_error'
    assert result.headers.get('Correlation-Id') == 'correlation_id'


@pytest.fixture
def fixture_presigned_urls_data():
    """Return presigned_urls data."""
    return {
        'filename': 'test.json',
        'upload_token': 'upload-id-test',
        'presigned_urls': [
            {
                'part_number': 1,
                'url': 'https://aws.com/upload_url'
            },
            {
                'part_number': 2,
                'url': 'https://aws.com/upload_url'
            }
        ]
    }


@pytest.mark.parametrize('headers', [
    OA_HEADERS, ALW_HEADERS,
])
@pytest.mark.parametrize('method', ['GET'])
def test_get_presigned_urls_success(
        fixture_client,
        headers,
        method,
        fixture_presigned_urls_data):
    """Test route that gets the presigned_urls."""
    mock_logic_response = response.Response(fixture_presigned_urls_data)
    (flexmock(pricing_helper)
     .should_receive('get_presigned_urls')
     .with_args(2)
     .and_return(mock_logic_response))

    headers['content-type'] = 'application/json'
    result = fixture_client.open(
        '/upload/presigned-urls?parts=2', method=method, headers=headers)
    assert result.status_code == 200
    assert result.headers.get('Correlation-Id')

    data = json.loads(result.data.decode('utf-8'))
    assert data.get('filename') == fixture_presigned_urls_data['filename']
    assert data.get('upload_token') == fixture_presigned_urls_data['upload_token']
    assert data.get('presigned_urls') == fixture_presigned_urls_data['presigned_urls']


@pytest.mark.parametrize('headers', [NO_HEADERS])
@pytest.mark.parametrize('method', ['GET'])
def test_get_presigned_urls_auth_failure(
        fixture_client,
        headers,
        method):
    """Test for empty user_id failure."""
    result = fixture_client.open(
        '/upload/presigned-urls', method=method, headers=headers)
    assert result.status_code == 401


@pytest.fixture
def fixture_complete_upload_request_body():
    """Return complete_multipart_upload request body."""
    return {
        'filename': 'test.json',
        'upload_token': 'upload-id-test',
        'parts': [
            {
                'part_number': 1,
                'etag': 'test-etag'
            },
            {
                'part_number': 2,
                'etag': 'test-etag2'
            }
        ]
    }


@pytest.mark.parametrize('headers', [
    OA_HEADERS, ALW_HEADERS,
])
@pytest.mark.parametrize('method', ['PUT'])
def test_complete_multipart_upload_success(
        fixture_client,
        headers,
        method,
        fixture_complete_upload_request_body):
    """Test route that gets the completes the multipart upload."""
    mock_logic_response = response.Response({'status': 'success'})
    (flexmock(pricing_helper)
     .should_receive('complete_multipart_upload')
     .with_args(fixture_complete_upload_request_body)
     .and_return(mock_logic_response))

    headers['content-type'] = 'application/json'
    result = fixture_client.open(
        '/upload/complete', method=method, headers=headers, data=json.dumps(fixture_complete_upload_request_body)
    )
    assert result.status_code == 200
    assert result.headers.get('Correlation-Id')

    data = json.loads(result.data.decode('utf-8'))
    assert data.get('status') == 'success'


@pytest.mark.parametrize('headers', [NO_HEADERS])
@pytest.mark.parametrize('method', ['PUT'])
def test_complete_multipart_upload_auth_failure(
        fixture_client,
        headers,
        method):
    """Test for empty user_id failure."""
    result = fixture_client.open(
        '/upload/complete', method=method, headers=headers)
    assert result.status_code == 401


@pytest.mark.parametrize('headers', [
    OA_HEADERS, ALW_HEADERS,
])
@pytest.mark.parametrize('method', ['PUT'])
def test_complete_multipart_upload_incomplete_body_failure(
        fixture_client,
        headers,
        method):
    """Test for incomplete body failure."""
    headers['content-type'] = 'application/json'
    result = fixture_client.open(
        '/upload/complete', method=method, headers=headers)
    assert result.status_code == 400


def test_get_all_digital_product_pricing_success(
        monkeypatch, fixture_client, fixture_success):
    """Test Orchard pricing tier response."""
    monkeypatch.setattr(
        pricing_helper, 'get_all_digital_product_pricing',
        MagicMock(return_value=fixture_success))
    product_id = 1
    url = '/product/{0}/digital/bff'.format(product_id)

    result = fixture_client.get(url)

    pricing_helper.get_all_digital_product_pricing.assert_called_with('1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


@pytest.mark.parametrize('method, path', [
    ('get', '/product/1/track-overrides'),
    ('get', '/product/1/override'),
    ('get', '/product/1/pricing-family/1/orchard_pricing_tier'),
])
@patch('pricing.handlers.product.is_owner')
def test_orchard_user_id_skips_is_owner_check(
        mock_is_owner, fixture_client, method, path):
    """Test OA bypasses ownership checks on supported handlers."""
    test_method = getattr(fixture_client, method)
    test_method(path, headers={header.GRASS_ORCHARD_USER_ID: 'oa:1234'})
    mock_is_owner.assert_not_called()


@pytest.mark.parametrize('method, path', [
    ('get', '/product/1/track-overrides'),
    ('get', '/product/1/override'),
    ('get', '/product/1/pricing-family/1/orchard_pricing_tier'),
])
def test_grass_type_vendor_triggers_ownership_check(
        monkeypatch, fixture_client, method, path):
    """Test vendor bypasses ownership checks on supported handlers."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock())
    test_method = getattr(fixture_client, method)
    test_method(path, headers={header.GRASS_ACCOUNT_ID: 1234,
                               header.GRASS_ACCOUNT_TYPE:
                               header.GRASS_ACCOUNT_TYPE_VENDOR})

    flask_request.verify_grass_ownership.assert_called_once()


@pytest.mark.parametrize('method, path', [
    ('get', '/product/1/track-overrides'),
    ('get', '/product/1/override'),
    ('get', '/product/1/pricing-family/1/orchard_pricing_tier'),
])
def test_grass_type_subaccount_triggers_ownership_check(
        monkeypatch, fixture_client, method, path):
    """Test vendor bypasses ownership checks on supported handlers."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock())
    test_method = getattr(fixture_client, method)
    test_method(path, headers={header.GRASS_ACCOUNT_ID: 1234,
                               header.GRASS_ACCOUNT_TYPE:
                               header.GRASS_ACCOUNT_TYPE_SUBACCOUNT})

    flask_request.verify_grass_ownership.assert_called_once()


@pytest.mark.parametrize('method, path', [
    ('get', '/product/1/track-overrides'),
    ('get', '/product/1/override'),
    ('get', '/product/1/pricing-family/1/orchard_pricing_tier'),
])
def test_no_grass_triggers_ownership_check(
        monkeypatch, fixture_client, method, path):
    """Test ownership check is hit even when not provided with grass."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock())
    test_method = getattr(fixture_client, method)
    test_method(path)

    flask_request.verify_grass_ownership.assert_called_once()


def test_validate_product_pricing(
        monkeypatch, fixture_client, fixture_success):
    """Test validate product pricing."""
    monkeypatch.setattr(flask_request, 'verify_grass_ownership', MagicMock(
        return_value=fixture_success))

    monkeypatch.setattr(
        product_pricing_validator,
        'validate_product_by_id', MagicMock(
            return_value=fixture_success))
    product_id = 1
    url = '/product/{0}/validate'.format(product_id)

    result = fixture_client.get(url)

    product_pricing_validator.validate_product_by_id.assert_called_with('1')
    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message


def test_get_all_orchard_pricing_tier_values(monkeypatch, fixture_client, fixture_success):
    """Test orchard pricing tier values response."""
    monkeypatch.setattr(
        orchard_pricing_tier_value, 'get_all_pricing_tier_values', MagicMock(
            return_value=fixture_success))
    result = fixture_client.get('/orchard-pricing-tier-values')

    assert result.status_code == 200
    assert result.data.decode() == fixture_success.message