"""Tests for copy product tracks logic."""
from oto import response

from ows_product_physical.logic.product_physical_tracks import (
    copy_product_tracks)
from ows_product_physical.models import ows_product
from ows_product_physical.models import track as track_model
from ows_product_physical.utils import track_utils


def test_copy_product_tracks_logic_product_lookup_fail(mocker):
    """Test that error is returned on product lookup fail."""
    product_id = 123
    new_product_id = 456

    error_response = response.create_fatal_response()
    get_product = mocker.patch.object(
        ows_product, 'get_product', return_value=error_response)
    tracks_response = copy_product_tracks(product_id, new_product_id)

    get_product.assert_called_once_with(product_id)
    assert tracks_response is error_response


def test_copy_product_tracks_fails_on_ownership_check(mocker):
    """Test that error is returned on tracks lookup fail."""
    product_id = 123
    new_product_id = 456
    upc = 1239322992

    vendor_id = 32123
    other_vendor_id = 111111
    product_response = response.Response(
        message={
            'product_id': product_id,
            'context_type': 'physical',
            'vendor_id': vendor_id,
            'subaccount_id': None
        })
    new_product_response = response.Response(
        message={
            'product_id': new_product_id,
            'context_type': 'physical',
            'vendor_id': other_vendor_id,
            'subaccount_id': None,
            'upc': upc
        })
    mocker.patch.object(
        ows_product, 'get_product', side_effect=[
            product_response, new_product_response])

    tracks_response = copy_product_tracks(product_id, new_product_id)

    assert tracks_response.status == 400
    assert tracks_response.errors == {
        'code': 'ownership_error',
        'message': 'product ownership inconsistent.'
    }


def test_copy_product_tracks_fails_on_physical_product_check(mocker):
    """Test that error is returned on tracks lookup fail."""
    product_id = 123
    new_product_id = 456
    upc = 1239322992
    vendor_id = 32123
    product_response = response.Response(
        message={
            'product_id': product_id,
            'context_type': 'digital',
            'vendor_id': vendor_id,
            'subaccount_id': None
        })
    new_product_response = response.Response(
        message={
            'product_id': new_product_id,
            'context_type': 'physical',
            'vendor_id': vendor_id,
            'subaccount_id': None,
            'upc': upc
        })
    mocker.patch.object(
        ows_product, 'get_product', side_effect=[
            product_response, new_product_response])

    tracks_response = copy_product_tracks(product_id, new_product_id)

    assert tracks_response.status == 400
    assert tracks_response.errors == {
        'code': 'internal_error',
        'message': 'copy only allowed on physical products.'
    }


def test_copy_product_tracks_logic_tracks_lookup_fail(mocker):
    """Test that error is returned on tracks lookup fail."""
    product_id = 123
    new_product_id = 456
    upc = 1239322992

    vendor_id = 32123
    subaccount_id = 9993
    product_response = response.Response(
        message={
            'product_id': product_id,
            'context_type': 'physical',
            'vendor_id': vendor_id,
            'subaccount_id': subaccount_id
        })
    new_product_response = response.Response(
        message={
            'product_id': new_product_id,
            'context_type': 'physical',
            'vendor_id': vendor_id,
            'subaccount_id': subaccount_id,
            'upc': upc
        })
    mocker.patch.object(
        ows_product, 'get_product', side_effect=[
            product_response, new_product_response])

    error_response = response.create_fatal_response()
    get_tracks = mocker.patch.object(
        track_model, 'get_tracks', return_value=error_response)

    tracks_response = copy_product_tracks(product_id, new_product_id)

    get_tracks.assert_called_once_with(product_id)
    assert tracks_response is error_response


def test_copy_product_tracks_logic_success(mocker):
    """Test that correct code is returned when copy tracks succeeds."""
    product_id = 123
    new_product_id = 456
    upc = 1239322992
    vendor_id = 32123
    subaccount_id = 9993
    product_response = response.Response(
        message={
            'product_id': product_id,
            'context_type': 'physical',
            'vendor_id': vendor_id,
            'subaccount_id': subaccount_id
        })
    new_product_response = response.Response(
        message={
            'product_id': new_product_id,
            'context_type': 'physical',
            'vendor_id': vendor_id,
            'subaccount_id': subaccount_id,
            'upc': upc
        })
    mocker.patch.object(
        ows_product, 'get_product', side_effect=[
            product_response, new_product_response])

    tracks_message = {'items': [{'some': 'tracks'}]}
    mocker.patch.object(
        track_model, 'get_tracks', return_value=response.Response(
            message=tracks_message
        ))

    mapped_tracks = [{'mapped_tracks'}]
    mocker.patch.object(
        track_utils, 'map_tracks_response_to_fields_for_copy',
        return_value=mapped_tracks)

    process_tracks_response = response.Response(status=201, message='Woo')
    mocker.patch.object(
        track_model, 'process_tracks', return_value=process_tracks_response)

    tracks_response = copy_product_tracks(product_id, new_product_id)

    # we don't return full track data response for copy.
    assert tracks_response.message is None
    assert tracks_response.status == 201