"""Unit tests for the localization logic functions."""
from unittest.mock import Mock

from oto import response

from product.constants import error
from product.constants import service_name
from product.logic import localization as localization_logic
from product.logic import product as product_logic
from product.models import itunes_languages as languages_model
from product.models import language
from product.models import product_localization as localization_model
from product.models import release_artist as release_artist_model
from product.models import \
    release_artist_localized_metadata as artist_localized_model
from product.models import \
    release_localized_metadata as release_localized_model
from product.models import track_artist_localized_metadata
from product.models import track_localized_metadata


def test_delete_success(mocker, test_product, fixture_language):
    """Test delete when it succeeds."""
    expected = response.Response(message='Product was successfully deleted.')
    mocker.patch.object(
        localization_model, 'delete', return_value=expected)
    # Temporary fix for MOV-2363 is to remove the language validation
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message=True))

    result = localization_logic.delete(test_product, fixture_language)
    assert result.status == 200
    assert result.message == 'Product was successfully deleted.'


def test_delete_legacy_success(mocker, test_product, fixture_language):
    """Test delete when it succeeds with legacy flag."""
    expected = response.Response(message='Product was successfully deleted.')
    mocker.patch.object(
        release_localized_model, 'delete_metadata', return_value=expected)
    mocker.patch.object(
        release_artist_model, 'get_artist_ids_for_product',
        return_value=response.Response(message=[1]))
    mocker.patch.object(
        artist_localized_model, 'delete_all_metadata', return_value=expected)
    mocker.patch.object(
        localization_logic, 'validate',
        return_value=response.Response(message=True))

    result = localization_logic.delete(test_product, fixture_language, True)
    assert result.status == 200
    assert result.message == \
        'Successfully deleted release and artist localizations.'


def test_delete_legacy_one_fails(mocker, test_product, fixture_language):
    """Test delete with legacy flag where only artist delete fails."""
    expected = response.Response(message='Product was successfully deleted.')
    mocker.patch.object(
        release_localized_model, 'delete_metadata', return_value=expected)
    mocker.patch.object(
        release_artist_model, 'get_artist_ids_for_product',
        return_value=response.Response(message=[1]))
    mocker.patch.object(
        artist_localized_model, 'delete_all_metadata',
        return_value=response.create_not_found_response(
            'No localizations deleted for artists.'))
    mocker.patch.object(
        localization_logic, 'validate',
        return_value=response.Response(message=True))

    result = localization_logic.delete(test_product, fixture_language, True)
    assert result.status == 200
    assert result.message == \
        'Successfully deleted release and artist localizations.'


def test_delete_legacy_both_fails(mocker, test_product, fixture_language):
    """Test delete with legacy flag where release & artist delete fails."""
    mocker.patch.object(
        release_localized_model, 'delete_metadata',
        return_value=response.create_not_found_response(
            'No localizations deleted for artists.'))
    mocker.patch.object(
        release_artist_model, 'get_artist_ids_for_product',
        return_value=response.Response(message=[1]))
    mocker.patch.object(
        artist_localized_model, 'delete_all_metadata',
        return_value=response.create_not_found_response(
            'No localizations deleted for artists.'))
    mocker.patch.object(
        localization_logic, 'validate',
        return_value=response.Response(message=True))

    result = localization_logic.delete(test_product, fixture_language, True)
    assert result.status == 404


def test_validate_success(mocker, test_product, fixture_language):
    """Test validate when it succeeds."""
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message={'release_id': 1234}))
    mocker.patch.object(
        languages_model, 'get_language_by_id',
        return_value=response.Response(message={'language_id': 12}))

    result = localization_logic.validate(
        test_product, fixture_language)
    assert result.status == 200
    assert result.message == 'success'


def test_validate_with_invalid_product(mocker, test_product, fixture_language):
    """Test validate when product_id does not exist."""
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.create_not_found_response())

    result = localization_logic.validate(
        test_product, fixture_language)
    assert result.status == 404


def test_validate_with_invalid_language(
        mocker, test_product, fixture_language):
    """Test validate when language_id does not exist."""
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message={'release_id': 1234}))
    mocker.patch.object(
        languages_model, 'get_language_by_id',
        return_value=response.create_not_found_response())

    result = localization_logic.validate(
        test_product, fixture_language)
    assert result.status == 404


def test_get_all_itunes_languages_success(
        fixture_all_itunes_languages, fixture_all_languages, mocker):
    """Test response contents upon success."""
    mocker.patch.object(
        languages_model, 'get_all_itunes_languages',
        return_value=response.Response(message=fixture_all_itunes_languages))
    mocker.patch.object(
        language, 'get_languages',
        return_value=response.Response(message=fixture_all_languages))

    result = localization_logic.get_all_itunes_languages()
    assert result
    assert 'items' in result.message
    assert result.message['items'] == [
        {
            'language_code': 'af',
            'language_id': 1,
            'language': 'Afrikaans',
            'meta_language_code': 'AFR'
        },
        {
            'language_code': 'ar',
            'language_id': 2,
            'language': 'Arabic',
            'meta_language_code': None
        },
        {
            'language_code': 'cmn-Hans',
            'language_id': 6,
            'language': 'Chinese (Simplified)',
            'meta_language_code': 'CHI'
        },
        {
            'language_code': 'cmn-Hant',
            'language_id': 7,
            'language': 'Chinese (Traditional)',
            'meta_language_code': 'cmn-Hant'
        }]


def test_get_all_itunes_languages_itunes_language_error(mocker):
    """Test response contents when fetching iTunes languages fails."""
    mocker.patch.object(
        languages_model, 'get_all_itunes_languages',
        return_value=response.Response(status=500))

    result = localization_logic.get_all_itunes_languages()

    assert result.status == 500
    assert result.errors == {
        'code': 'internal_error',
        'message': 'failed to fetch iTunes langauges'}


def test_get_all_itunes_languages_orchard_language_error(
        fixture_all_itunes_languages, mocker):
    """Test response contents when fetching Orchard languages fails."""
    mocker.patch.object(
        languages_model, 'get_all_itunes_languages',
        return_value=response.Response(message=fixture_all_itunes_languages))
    mocker.patch.object(
        language, 'get_languages',
        return_value=response.Response(status=500))

    result = localization_logic.get_all_itunes_languages()

    assert result.status == 500
    assert result.errors == {
        'code': 'internal_error',
        'message': 'failed to fetch Orchard languages'}


def test_get_localization_by_product_id(
        mocker, test_product, fixture_valid_localization):
    """Test get localization by product_id when it succeeds."""
    expected = response.Response(message={'product_id': '123'})
    mocker.patch.object(
        product_logic, 'get_product_by_product_id', return_value=expected)
    mocker.patch.object(
        localization_model, 'get_localization_data',
        return_value=response.Response(message=fixture_valid_localization))

    result = localization_logic.get_localization_by_product_id(test_product)
    assert result.status == 200
    assert result.message == fixture_valid_localization


def test_get_localization_no_records(mocker, test_product):
    """Test get localization by product_id when no records found."""
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message={'product_id': '123'}))
    mocker.patch.object(
        localization_model, 'get_localization_data',
        return_value=response.create_not_found_response())

    result = localization_logic.get_localization_by_product_id(test_product)
    assert result.status == 404


def test_get_localization_invalid_product(mocker, test_product):
    """Test get localization by product_id when product id is invalid."""
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.create_not_found_response())

    result = localization_logic.get_localization_by_product_id(test_product)
    assert result.status == 404


def test_get_localization_by_product_id_legacy(mocker, test_product):
    """Test get localization by product_id when it succeeds."""
    release_metadata = [{'language_id': 1, 'product_name': 'Release-Afr'}]
    artist_metadata = {1: {'remixer': {1: 'one translated'}}}
    final_response = {'language_id': 1, 'product_name': 'Release-Afr',
                      'remixer': {1: 'one translated'}}
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message={'product_id': '123'}))
    mocker.patch.object(
        release_localized_model, 'get_metadata_by_id',
        return_value=response.Response(message=release_metadata))
    mocker.patch.object(
        artist_localized_model, 'get_artist_metadata_by_product',
        return_value=response.Response(message=artist_metadata))

    mocker.patch.object(
        localization_logic, '_format_legacy_get_response',
        return_value=response.Response(message=final_response))

    result = localization_logic.get_localization_by_product_id(
        test_product, True)
    assert result.status == 200
    assert result.message == final_response


def test_get_localization_by_product_id_legacy_no_artist(mocker, test_product):
    """Test get localization by product_id when no artist metadata found."""
    release_metadata = [{'language_id': 1, 'product_name': 'Release-Afr'}]

    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message={'product_id': '123'}))
    mocker.patch.object(
        release_localized_model, 'get_metadata_by_id',
        return_value=response.Response(message=release_metadata))
    mocker.patch.object(
        artist_localized_model, 'get_artist_metadata_by_product',
        return_value=response.create_not_found_response())

    result = localization_logic.get_localization_by_product_id(
        test_product, True)
    assert result.status == 404


def test_format_legacy_get_response(mocker, test_product):
    """Test _format_legacy_get_response formatted response."""
    release_metadata = [{'language_id': 1, 'product_name': 'Release-Afr'}]
    artist_metadata = {
        1: {'remixer': {1: 'one translated'}},
        2: {'performer': {1: 'two translated', 2: 'three translated'}}}
    result = localization_logic._format_legacy_get_response(
        test_product, release_metadata, artist_metadata)
    assert result.status == 200
    assert 'items' in result.message.keys()
    assert 'pagination' in result.message.keys()
    assert len(result.message['items']) == 2  # nos of diff languages


def test_create(
        mocker, test_product, fixture_language, fixture_valid_localization):
    """Test create product's localization with success."""
    # Temporary fix for MOV-2363 is to remove the language validation
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message=True))
    message = {'product_name': 'abc', 'language_id': 12}
    mocker.patch.object(
        localization_model, 'create_update',
        return_value=response.Response(message=message))

    result = localization_logic.create(
        test_product, fixture_language, fixture_valid_localization)
    assert result.status == 200
    assert result.message == message


def test_create_legacy(
        mocker, test_product, fixture_language, fixture_music_localization):
    """Test create legacy product's localization with success."""
    mocker.patch.object(
        localization_logic, 'validate',
        return_value=response.Response(message=True))
    release_response = {'product_name': 'abc', 'language_id': fixture_language}
    artist_response = {
        'performer': [{1: 'performer1 in de', 2: 'performer2 in de'}]}
    mocker.patch.object(
        release_localized_model, 'insert_metadata',
        return_value=response.Response(message=release_response))
    mocker.patch.object(
        artist_localized_model, 'insert_metadata',
        return_value=response.Response(message=artist_response))
    release_artist_ids = [1, 2, 3]
    mocker.patch.object(
        release_artist_model, 'get_artist_ids_for_product',
        return_value=response.Response(message=release_artist_ids))
    delete_response = None
    mocker.patch.object(
        artist_localized_model, 'delete_all_metadata',
        return_value=response.Response(message=delete_response))

    result = localization_logic.create(
        test_product, fixture_language, fixture_music_localization, True)
    assert result.status == 200
    assert 'product_name' in result.message
    assert 'performer' in result.message
    assert 'composer' not in result.message


def test_create_legacy_release_insert_fail(
        mocker, test_product, fixture_language, fixture_music_localization):
    """Test create legacy product's localization when release insert fails."""
    mocker.patch.object(
        localization_logic, 'validate',
        return_value=response.Response(message=True))

    mocker.patch.object(
        release_localized_model, 'insert_metadata',
        return_value=response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'Invalid data sent for save release localization'))

    result = localization_logic.create(
        test_product, fixture_language, fixture_music_localization, True)
    assert result.status == 400


def test_create_no_data(
        mocker, test_product, fixture_language, fixture_valid_localization):
    """Test create product's localization which fails due to no data."""
    # Temporary fix for MOV-2363 is to remove the language validation
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.Response(message=True))
    message = response.create_error_response(
        error.ERROR_CODE_INVALID_DATA, 'No data sent for save.')
    mocker.patch.object(
        localization_model, 'create_update', return_value=message)

    result = localization_logic.create(
        test_product, fixture_language, fixture_valid_localization)
    assert result.status == 400


def test_create_invalid_ids(
        mocker, test_product, fixture_language, fixture_valid_localization):
    """Test create product's localization which fails due to invalid ids."""
    # Temporary fix for MOV-2363 is to remove the language validation
    mocker.patch.object(
        product_logic, 'get_product_by_product_id',
        return_value=response.create_not_found_response())

    result = localization_logic.create(
        test_product, fixture_language, fixture_valid_localization)
    assert result.status == 404


def test_delete_track_localization(mocker):
    """Test delete_track_localization when it succeeds."""
    expected = '1 track localizations deleted.'
    mocker.patch.object(
        track_localized_metadata, 'delete_track_metadata',
        return_value=response.Response(message=expected))

    result = localization_logic.delete_track_localization([100, 200])
    assert result.status == 200
    assert result.message == expected
    track_localized_metadata.delete_track_metadata.assert_called_once_with(
        [100, 200], None)


def test_delete_track_localization_with_language(mocker):
    """Test delete_track_localization when it succeeds."""
    mocker.patch.object(
        languages_model, 'get_language_by_id',
        return_value=response.Response(message={'language_id': 1}))
    expected = '1 track localizations deleted.'
    mocker.patch.object(
        track_localized_metadata, 'delete_track_metadata',
        return_value=response.Response(message=expected))

    result = localization_logic.delete_track_localization([100], 1)
    assert result.status == 200
    assert result.message == expected
    track_localized_metadata.delete_track_metadata.assert_called_once_with(
        [100], 1)


def test_delete_track_localization_with_invalid_language(mocker):
    """Test delete_track_localization with invalid language."""
    expected = response.create_not_found_response(
        message='No Itunes Language found for this language_id.')
    mocker.patch.object(
        languages_model, 'get_language_by_id', return_value=expected)

    result = localization_logic.delete_track_localization([100], 12345)
    assert result.status == 404


def test_get_track_localization(mocker):
    """Test get_track_localization when it succeeds."""
    expected_track_response = {
        1: {21236646: {'track_name': 'Track afr', 'version': 'Version-Afr'}},
        2: {21236646: {'track_name': 'Track name-Fr', 'version': 'Version-Fr'},
            21236647: {'track_name': 'Track-name-ara', 'version': ''}}}
    expected_artist_response = {
        1: {21236646: {67486752: 'Ar for 46'}},
        2: {21236647: {67486761: 'FR for 61'}}}
    mocker.patch.object(
        track_localized_metadata, 'get_tracks_localizations',
        return_value=response.Response(message=expected_track_response))
    mocker.patch.object(
        track_artist_localized_metadata, 'get_metadata_by_id',
        return_value=response.Response(message=expected_artist_response))

    result = localization_logic.get_track_localization([21236646, 21236647])
    assert result.status == 200
    assert len(result.message['items']) == 3
    assert 'pagination' in result.message


def test_update_metadata(mocker):
    """Test update_track_localization localization for success."""
    track_data = {'track_name': 'trans name', 'version': 'trans version'}
    track_artist_data = {100: 'artist 1', 200: 'artist 2'}
    data = track_data.copy()
    data['artists'] = track_artist_data

    mocker.patch.object(
        languages_model, 'get_language_by_id',
        return_value=response.Response(message={'language_id': 1}))
    mocker.patch.object(
        track_localized_metadata, 'update_metadata',
        return_value=response.Response(message=track_data))

    result = localization_logic.update_track_localization(
        tuid=10001, language_id=1, data=data)
    assert result.status == 200
    assert result.message == track_data


def test_update_metadata_invalid_language(mocker):
    """Test update_track_localization localization when language is invalid."""
    data = {'track_name': 'trans name', 'version': 'trans version'}
    mocker.patch.object(
        languages_model, 'get_language_by_id',
        return_value=response.create_not_found_response())

    result = localization_logic.update_track_localization(
        tuid=10001, language_id=1, data=data)
    assert result.status == 404


def test_update_metadata_invalid_data(mocker):
    """Test update_track_localization localization fail due to bad data."""
    data = {'bad': 'data'}
    mocker.patch.object(
        languages_model, 'get_language_by_id',
        return_value=response.Response(message={'language_id': 1}))
    mocker.patch.object(
        track_localized_metadata, 'update_metadata',
        return_value=response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'Invalid data sent for save track localization'))

    result = localization_logic.update_track_localization(
        tuid=10001, language_id=1, data=data)
    assert result.status == 400


def test_update_multiple_localizations(mocker):
    """Test update_multiple_localizations localization for success."""
    track_data1 = {
        'tuid': 10001, 'language_id': 1, 'track_name': 'trans name',
        'version': 'trans version',
        'artists': {100: 'artist 1', 200: 'artist 2'}}
    track_data2 = {
        'tuid': 10002, 'language_id': 12, 'track_name': 'trans name',
        'version': 'trans version'}

    data = {'items': [track_data1, track_data2]}
    mocker.patch.object(
        localization_logic, '_track_localization_has_duplicates',
        return_value=False)
    mocker.patch.object(
        localization_logic, 'update_track_localization',
        return_value=response.Response(message=track_data1))

    result = localization_logic.update_multiple_localizations(data=data)
    assert result.status == 200
    assert result.message == data
    assert localization_logic.update_track_localization.call_count == 2


def test_update_multiple_localizations_no_items(mocker):
    """Test update_multiple_localizations localization when no items."""
    data = {'items': []}
    mocker.patch.object(
        localization_logic, '_track_localization_has_duplicates',
        return_value=False)
    mocker.patch.object(
        localization_logic, 'update_track_localization')

    result = localization_logic.update_multiple_localizations(data=data)
    assert result.status == 200
    assert result.message == data
    assert not localization_logic.update_track_localization.call_count


def test_update_multiple_localizations_error(mocker):
    """Test update_multiple_localizations localization when any item fails."""
    track_data1 = {
        'tuid': 10001, 'language_id': 1, 'track_name': 'trans name',
        'version': 'trans version',
        'artists': {100: 'artist 1', 200: 'artist 2'}}
    track_data2 = {
        'tuid': 10002, 'language_id': 12, 'track_name': 'trans name',
        'version': 'trans version'}

    data = {'items': [track_data1, track_data2]}
    session = Mock()
    session.rollback = Mock(return_value=True)
    mocker.patch.object(
        localization_logic, '_track_localization_has_duplicates',
        return_value=False)
    mocker.patch.object(
        localization_logic, 'update_track_localization',
        return_value=response.create_not_found_response())

    result = localization_logic.update_multiple_localizations(
        data=data, session=session)
    assert result.status == 404
    assert localization_logic.update_track_localization.call_count == 1
    assert session.rollback.call_count == 1


def test_check_duplicate_track_localization(mocker):
    """Test _track_localization_has_duplicates for success."""
    track_data1 = {
        'tuid': 10001, 'language_id': 1, 'track_name': 'trans name',
        'version': 'trans version',
        'artists': {100: 'artist 1', 200: 'artist 2'}}
    track_data2 = {
        'tuid': 10002, 'language_id': 12, 'track_name': 'trans name',
        'version': 'trans version'}

    data = [track_data1, track_data2]
    result = localization_logic._track_localization_has_duplicates(data=data)
    assert not result


def test_check_duplicate_track_fail(mocker):
    """Test _track_localization_has_duplicates with dupe data."""
    track_data1 = {
        'tuid': 10001, 'language_id': 1, 'track_name': 'trans name',
        'version': 'trans version',
        'artists': {100: 'artist 1', 200: 'artist 2'}}
    track_data2 = {
        'tuid': 10001, 'language_id': 1, 'track_name': 'trans name',
        'version': 'trans version'}

    data = [track_data1, track_data2]
    result = localization_logic._track_localization_has_duplicates(data=data)
    assert result


def test_check_duplicate_track_combination(mocker):
    """Test _track_localization_has_duplicates with diff data combination."""
    track_data1 = {
        'tuid': 10001, 'language_id': 1, 'track_name': 'trans name',
        'version': 'trans version',
        'artists': {100: 'artist 1', 200: 'artist 2'}}
    track_data2 = {
        'tuid': 10001, 'language_id': 2, 'track_name': 'trans name',
        'version': 'trans version'}
    track_data3 = {
        'tuid': 10002, 'language_id': 2, 'track_name': 'second name',
        'version': 'second version'}

    data = [track_data1, track_data2, track_data3]
    result = localization_logic._track_localization_has_duplicates(data=data)
    assert not result


def test_copy_localizations_success(mocker):
    """Test copy_localization success."""
    source_product_id = 1
    destination_product_id = 2
    product_localizations = {'items': [
        {'language_id': 1, 'product_name': 'Release-Afr',
         'delivered_version': 'test123',
         'remixer': {1: 'one translated'}},
        {'language_id': 2, 'product_name': 'Release-Ar',
         'delivered_version': 'None',
         'remixer': {1: 'another translated'}}]}
    items_to_copy_count = len(product_localizations['items'])
    mocker.patch.object(
        localization_logic, 'get_localization_by_product_id',
        return_value=response.Response(product_localizations))
    mocker.patch.object(
        localization_logic, '_get_source_to_copied_artists_mapping',
        return_value=response.Response({1: 1}))
    mocker.patch.object(
        localization_logic, 'create', return_value=response.Response())
    result = localization_logic.copy_localization(
        source_product_id, destination_product_id)
    assert result
    assert localization_logic.create.call_count == items_to_copy_count


def test_copy_localizations_get_localizations_failed(mocker):
    """Test copy_localization failed on get_localizations for source."""
    source_product_id = 1
    destination_product_id = 2
    error_msg = 'Failed to get localization!'
    mocker.patch.object(
        localization_logic, 'get_localization_by_product_id',
        return_value=response.create_fatal_response(error_msg))
    mocker.patch.object(
        localization_logic, 'create', return_value=response.Response())
    result = localization_logic.copy_localization(
        source_product_id, destination_product_id)
    assert not result
    assert result.errors.get('message') == error_msg
    localization_logic.create.assert_not_called()


def test_copy_localizations_get_mapping_failed(mocker):
    """Test copy_localization failed on getting artists mapping."""
    source_product_id = 1
    destination_product_id = 2
    error_msg = 'Failed to get artists mapping!'
    product_localizations = {'items': [
        {'language_id': 1, 'product_name': 'Release-Afr',
         'remixer': {1: 'one translated'}},
        {'language_id': 2, 'product_name': 'Release-Ar',
         'remixer': {1: 'another translated'}}]}
    mocker.patch.object(
        localization_logic, 'get_localization_by_product_id',
        return_value=response.Response(product_localizations))
    mocker.patch.object(
        localization_logic, '_get_source_to_copied_artists_mapping',
        return_value=response.create_fatal_response(error_msg))
    mocker.patch.object(
        localization_logic, 'create', return_value=response.Response())
    result = localization_logic.copy_localization(
        source_product_id, destination_product_id)
    assert not result
    assert result.errors.get('message') == error_msg
    localization_logic.create.assert_not_called()


def test_copy_localizations_create_new_localizations_failed(mocker):
    """Test copy_localization failed on create new localizations."""
    source_product_id = 1
    destination_product_id = 2
    error_msg = 'Failed to create new localizations!'
    product_localizations = {'items': [
        {'language_id': 1, 'product_name': 'Release-Afr',
         'remixer': {1: 'one translated'}},
        {'language_id': 2, 'product_name': 'Release-Ar',
         'remixer': {1: 'another translated'}}]}
    mocker.patch.object(
        localization_logic, 'get_localization_by_product_id',
        return_value=response.Response(product_localizations))
    mocker.patch.object(
        localization_logic, '_get_source_to_copied_artists_mapping',
        return_value=response.Response({1: 1}))
    mocker.patch.object(
        localization_logic, 'create',
        return_value=response.create_fatal_response(error_msg))
    result = localization_logic.copy_localization(
        source_product_id, destination_product_id)
    assert not result
    assert result.errors.get('message') == error_msg


def test_get_source_to_copied_artists_mapping(ows_request_mocker):
    """Test create mapping of source and copied artists ids success."""
    source_product_id = 1
    copied_product_id = 2
    expected_result = {4305953: 135186, 4305955: 196182}
    source_product_artists = {
        'product_artists': [
            {
                'role': 'primary_artist',
                'name': 'Denis',
                'id': 4305953
            },
            {
                'role': 'remixer',
                'name': 'Roh',
                'id': 4305955}]}
    copied_product_artists = {
        'product_artists': [
            {
                'role': 'primary_artist',
                'name': 'Denis',
                'id': 135186
            },
            {
                'role': 'remixer',
                'name': 'Roh',
                'id': 196182}]}

    ows_request_mocker.add({
        'method': 'get',
        'service': service_name.OWS_PRODUCT_DIGITAL,
        'path': '/product/audio/{}'.format(source_product_id),
        'status': 200,
        'json': source_product_artists
    })
    ows_request_mocker.add({
        'method': 'get',
        'service': service_name.OWS_PRODUCT_DIGITAL,
        'path': '/product/audio/{}'.format(copied_product_id),
        'status': 200,
        'json': copied_product_artists
    })
    ows_request_mocker.apply()

    result = localization_logic._get_source_to_copied_artists_mapping(
        source_product_id, copied_product_id)
    assert result.message == expected_result


def test_get_source_to_copied_artists_mapping_source_artist_fetch_failed(
        ows_request_mocker):
    """Test create mapping of source and copied artists ids 1st fetch fail."""
    source_product_id = 1
    copied_product_id = 2
    expected_response = {'oops': 'i did an error'}
    ows_request_mocker.add({
        'method': 'get',
        'service': service_name.OWS_PRODUCT_DIGITAL,
        'path': '/product/audio/{}'.format(source_product_id),
        'status': 500,
        'json': expected_response
    })

    ows_request_mocker.apply()

    result = localization_logic._get_source_to_copied_artists_mapping(
        source_product_id, copied_product_id)
    assert not result
    assert result.message == expected_response


def test_get_source_to_copied_artists_mapping_copied_artist_fetch_failed(
        ows_request_mocker):
    """Test create mapping of source and copied artists ids 2nd fetch fail."""
    source_product_id = 1
    copied_product_id = 2
    expected_response = {'oops': 'i did an error in copied product fetch'}
    source_product_artists = {
        'product_artists': [
            {
                'role': 'primary_artist',
                'name': 'Denis',
                'id': 4305953
            },
            {
                'role': 'remixer',
                'name': 'Roh',
                'id': 4305955}]}

    ows_request_mocker.add({
        'method': 'get',
        'service': service_name.OWS_PRODUCT_DIGITAL,
        'path': '/product/audio/{}'.format(source_product_id),
        'status': 200,
        'json': source_product_artists
    })

    ows_request_mocker.add({
        'method': 'get',
        'service': service_name.OWS_PRODUCT_DIGITAL,
        'path': '/product/audio/{}'.format(copied_product_id),
        'status': 500,
        'json': expected_response
    })

    ows_request_mocker.apply()

    result = localization_logic._get_source_to_copied_artists_mapping(
        source_product_id, copied_product_id)
    assert not result
    assert result.message == expected_response