"""Functional tests for fetching an audio product."""

import json
from unittest.mock import MagicMock

from owsrequest import request

from product_digital import features
from product_digital.constants import error
from product_digital.constants import header
from product_digital.constants import services
from product_digital.models import ows_product_workflow
from tests.factories import catalog_transfer as catalog_transfer_factory
from tests.factories import release as release_factory
from tests.testutils import db


@db.test_schema
def test_get_product_microservice_call(
        mocker, client, product_id, valid_headers, empty_success):
    """Test fetching an audio product without headers."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)
    mocker.patch.object(request, 'get', return_value=empty_success)
    mocker.patch.object(
        ows_product_workflow, 'get_last_release_approval_queue',
        return_value=MagicMock(status_code=200, message=None))
    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)

    assert get_response.status_code == 200


@db.test_schema
def test_get_product_microservice_call_without_content_type_header(
        mocker, client, product_id, valid_headers, empty_success):
    """Test fetching an audio product without headers."""
    if valid_headers.get('Content-Type'):
        del valid_headers['Content-Type']
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)
    mocker.patch.object(request, 'get', return_value=empty_success)
    mocker.patch.object(
        ows_product_workflow, 'get_last_release_approval_queue',
        return_value=MagicMock(status_code=200, message=None))
    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)

    assert get_response.status_code == 200


@db.test_schema
def test_get_product_as_vendor(
        client, valid_headers_for_vendor, product_id, mocker, empty_success):
    """Test fetching an audio product as a vendor who owns the product."""
    head_response = MagicMock(status_code=200)
    mocker.patch.object(request, 'head', return_value=head_response)
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)
    mocker.patch.object(request, 'get', return_value=empty_success)
    mocker.patch.object(
        ows_product_workflow, 'get_last_release_approval_queue',
        return_value=MagicMock(status_code=200, message=None))
    mocker.patch.object(
        features, 'is_rejections_from_content_review_enabled', return_value=False)
    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers_for_vendor)

    assert get_response.status_code == 200


@db.test_schema
def test_get_product_as_oa(
        client,
        valid_oa_headers_with_orchard_user_id,
        product_id,
        mocker,
        empty_success,
):
    """Test fetching an audio product as an oa who bypasses ownership check."""
    head_response = MagicMock(status_code=200)
    mocker.patch.object(request, 'head', return_value=head_response)
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)
    mocker.patch.object(request, 'get', return_value=empty_success)
    mocker.patch.object(
        ows_product_workflow, 'get_last_release_approval_queue',
        return_value=MagicMock(status_code=200, message=None))
    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_oa_headers_with_orchard_user_id)

    # Ownership check endpoint is not called
    request.head.assert_not_called()
    assert get_response.status_code == 200


@db.test_schema
def test_get_product_json(
        client, valid_headers, product_id, mocker, empty_success):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)
    mocker.patch.object(request, 'get', return_value=empty_success)
    mocker.patch.object(
        ows_product_workflow, 'get_last_release_approval_queue',
        return_value=MagicMock(status_code=200, message=None))
    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())

    assert response_body == {
        'release_status': 'label_processing',
        'is_error_correction_and_action_required': False,
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'delivered_version': None,
        'version': 'Extremely Explicit Version',
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'subaccount_id': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_get_product_json_with_catalog_transfer_info(
        client, valid_headers, product_id, mocker, empty_success):
    """Test that catalog_transfer_info is populated when a record exists."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)
    db.seed_models(catalog_transfer_factory.CatalogTransferFactory.build(
        release_id=product_id,
        original_distributor='Distrokid',
        same_isrc_upc='Y'))
    mocker.patch.object(request, 'get', return_value=empty_success)
    mocker.patch.object(
        ows_product_workflow, 'get_last_release_approval_queue',
        return_value=MagicMock(status_code=200, message=None))
    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())

    assert response_body['catalog_transfer_info'] == {
        'original_distributor': 'Distrokid',
        'same_isrc_upc': True,
    }


@db.test_schema
def test_get_product_orchard_user_id_json(
    client,
    request_engine,
    orchard_user_id,
    product_id,
    product_workflow_rejections_response,
    release_approval_get_message,
    valid_headers,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12321,
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        release_approval_get_message)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/release-approval/{}/rejections'.format(
            release_approval_get_message.get('release_approval_id')),
        product_workflow_rejections_response.json())

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12321', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())

    expected_response = {
        'release_status': 'action_required',
        'is_error_correction_and_action_required': False,
        'rejections': [
            {
                'rejection_id': 1,
                'field': 'description',
                'note': 'Needs more info about Ken',
                'corrected': 'N',
                'key_type': 'releases',
                'key_id': 0
            },
            {
                'rejection_id': 2,
                'field': 'release_name',
                'note': 'Needs to be KEN',
                'corrected': 'N',
                'key_type': 'releases',
                'key_id': 0
            },
            {
                'rejection_id': 3,
                'field': 'general_comments',
                'note': 'blub blub blub',
                'corrected': 'N',
                'key_type': 'releases',
                'key_id': 0
            }
        ],
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'version': 'Extremely Explicit Version',
        'delivered_version': None,
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'subaccount_id': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'release_approval_status': 'rejected',
        'meta_language': 'eng',
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }
    assert response_body == expected_response


@db.test_schema
def test_get_product_ec_and_ar_feature_flag_on_and_orchard_user_id_json(
    client,
    orchard_user_id,
    product_id,
    product_workflow_rejections_response,
    valid_headers,
    empty_success,
    mocker,
    request_engine,
    release_approval_get_message,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    release_approval_get_message = {
        'release_approval_id': 1,
        'release_id': 123,
        'release_correction_id': 132,
        'status': 'rejected'}

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/12345/release-approval',
        release_approval_get_message)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/release-approval/{}/rejections'.format(
            release_approval_get_message.get('release_approval_id')),
        product_workflow_rejections_response.json(),
    )

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/12345/correction')

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
    )
    db.seed_models(existing_release)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())

    assert response_body == {
        'release_status': 'action_required',
        'is_error_correction_and_action_required': True,
        'rejections': [
            {
                'rejection_id': 1,
                'field': 'description',
                'note': 'Needs more info about Ken',
                'corrected': 'N',
                'key_type': 'releases',
                'key_id': 0
            },
            {
                'rejection_id': 2,
                'field': 'release_name',
                'note': 'Needs to be KEN',
                'corrected': 'N',
                'key_type': 'releases',
                'key_id': 0
            },
            {
                'rejection_id': 3,
                'field': 'general_comments',
                'note': 'blub blub blub',
                'corrected': 'N',
                'key_type': 'releases',
                'key_id': 0
            }
        ],
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'delivered_version': None,
        'version': 'Extremely Explicit Version',
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subaccount_id': None,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'release_approval_status': 'rejected',
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_get_product_failure_getting_rejections(
    client,
    orchard_user_id,
    product_id,
    release_approval_get_message,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12321,
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        release_approval_get_message)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/release-approval/{}/rejections'.format(
            release_approval_get_message.get('release_approval_id')),
        {'code': 'some code', 'message': 'some error message'},
        status=400
    )

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12321', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)

    assert get_response.status_code == 400


@db.test_schema
def test_get_product_error_correction_feature_flag_on_and_orchard_user_id_json(
    client,
    product_id,
    orchard_user_id,
    release_correction_get_response,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
        release_status='in_content'
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/correction'.format(product_id),
        release_correction_get_response.json())

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers
    )
    response_body = json.loads(get_response.data.decode())

    assert response_body == {
        'release_status': 'error_correction',
        'is_error_correction_and_action_required': False,
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'version': 'Extremely Explicit Version',
        'delivered_version': None,
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subaccount_id': None,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'corrections': release_correction_get_response.json(),
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_error_correction_feature_flag_on_and_product_not_submitted(
    client,
    product_id,
    orchard_user_id,
    release_correction_get_response,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product.

    A product can only be in error correction if it has been submitted.
    """
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/correction'.format(product_id),
        release_correction_get_response.json())

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers
    )
    response_body = json.loads(get_response.data.decode())

    assert response_body == {
        'release_status': 'label_processing',
        'is_error_correction_and_action_required': False,
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'version': 'Extremely Explicit Version',
        'delivered_version': None,
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subaccount_id': None,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_get_product_error_correction_feature_flag_on_and_no_orchard_user_id(
    client,
    product_id,
    release_correction_get_response,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/correction'.format(product_id),
        release_correction_get_response.json())

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers
    )
    response_body = json.loads(get_response.data.decode())

    # For now the error_correction status is behind a feature flag.
    # Should this be the case?
    assert response_body == {
        'release_status': 'label_processing',
        'is_error_correction_and_action_required': False,
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'version': 'Extremely Explicit Version',
        'delivered_version': None,
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subaccount_id': None,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_get_product_error_correction_feature_flag_off(
    client,
    product_id,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())

    assert response_body == {
        'release_status': 'label_processing',
        'is_error_correction_and_action_required': False,
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'version': 'Extremely Explicit Version',
        'delivered_version': None,
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subaccount_id': None,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'p_line': '2020 PLINE',
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_get_product_error_correction_r(
    client,
    request_engine,
    orchard_user_id,
    product_id,
    valid_headers,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """Test the correct shape of response body when fetching a product."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())

    assert response_body == {
        'release_status': 'label_processing',
        'is_error_correction_and_action_required': False,
        'format': 'Full Length',
        'imprint': 'DIG for Gold Records',
        'product_artists': [],
        'version': 'Extremely Explicit Version',
        'manufacturer_upc': None,
        'release_date': None,
        'artist_id': existing_release.artist_id,
        'product_type_id': None,
        'preorder_date': None,
        'previewable': 'no',
        'upc': existing_release.display_upc,
        'subaccount_id': None,
        'subgenre_id': None,
        'catalog_transfer_info': None,
        'project_id': existing_release.project_id,
        'product_code': existing_release.product_code,
        'genre_id': existing_release.genre_id,
        'distribution_format_id': 1,
        'product_id': int(product_id),
        'product_name': existing_release.release_name,
        'sale_start_date': None,
        'special_instructions': 'Listen to something else instead',
        'vendor_catalog_number': None,
        'description': None,
        'c_line': '2017 Trump',
        'meta_language': 'eng',
        'p_line': '2020 PLINE',
        'delivered_version': None,
        'not_for_distribution': 'N',
    }


@db.test_schema
def test_get_product_error_correction_flag_on_failure_getting_correction(
    client,
    orchard_user_id,
    product_id,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """If there is an error getting correction return status 400."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
        release_status='in_content'
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/correction'.format(product_id),
        {
            'code': 'error code goes here',
            'message': 'inform you of error'
        },
        status=400,
    )

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers
    )

    assert get_response.status_code == 400


@db.test_schema
def test_get_product_error_correction_flag_on_correction_not_found(
    client,
    orchard_user_id,
    product_id,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """If correction not found return original product status."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
        release_status='in_content'
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/correction'.format(product_id),
        {
            'code': 'error code goes here',
            'message': 'inform you of error'
        },
        status=404,
    )

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers
    )
    response_body = json.loads(get_response.data.decode())

    assert get_response.status_code == 200
    assert response_body['release_status'] == 'in_content'


@db.test_schema
def test_get_product_error_correction_flag_on_details_not_found(
    client,
    orchard_user_id,
    product_id,
    release_correction_get_response,
    valid_headers,
    request_engine,
    get_project_response_message,
    mock_vendor_company_brand,
    mock_vendor_response
):
    """If details could not be found the status should be error_correction."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id,
        project_id=12345,
        release_status='in_content'
    )
    db.seed_models(existing_release)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/release-approval'.format(product_id),
        status=404)

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/product/{}/correction'.format(product_id),
        release_correction_get_response.json())

    release_correction_id = release_correction_get_response \
        .json() \
        .get('release_correction_id')

    request_engine[services.OWS_PRODUCT_WORKFLOW].add_spec(
        'GET', '/correction/{}/details'.format(release_correction_id),
        {
            'code': 'not found',
            'message': 'these are not the drones you are looking for'
        },
    )

    request_engine[services.OWS_PROJECT_MANAGER].add_spec(
        'GET', '/project/12345', get_project_response_message)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/brand/9999', mock_vendor_company_brand)

    request_engine[services.OWS_ACCOUNT].add_spec(
        'GET', '/vendor/9999', mock_vendor_response)

    valid_headers[header.ORCHARD_USER_ID] = orchard_user_id

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers
    )
    response_body = json.loads(get_response.data.decode())

    assert get_response.status_code == 200
    assert response_body['release_status'] == 'error_correction'


def test_get_product_missing_one_grass_header(
        client, product_id, valid_headers_for_vendor):
    """Test fetching and audio product with one grass header missing."""
    del valid_headers_for_vendor[header.GRASS_ACCOUNT_TYPE]

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers_for_vendor)
    response_body = json.loads(get_response.data.decode())

    assert get_response.status_code == 400
    assert response_body.get('message') == \
        error.ERROR_MESSAGE_INCOMPLETE_GRASS_HEADERS


@db.test_schema
def test_get_product_when_product_not_found(
        client, product_id, valid_headers):
    """Test fetching an audio when product not found."""
    get_response = client.get(
        '/product/audio/{}'.format(product_id), headers=valid_headers)

    assert get_response.status_code == 404


@db.test_schema
def test_get_product_as_vendor_when_not_owner(
        client, valid_headers_for_vendor, product_id, mocker):
    """Test fetching an audio product as a vendor who is not the owner."""
    head_response = MagicMock(status_code=403)
    mocker.patch.object(request, 'head', return_value=head_response)
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id)
    db.seed_models(existing_release)

    get_response = client.get(
        '/product/audio/{}'.format(product_id),
        headers=valid_headers_for_vendor)

    assert get_response.status_code == 403