"""Tests for Track model."""
import sentry_sdk
from sqlalchemy import exc

from ows_product_physical.connector import mysql
from ows_product_physical.connector.mysql import db_session
from ows_product_physical.models import track
from ows_product_physical.models import track_publisher
from ows_product_physical.models.track import Track


def test_track_to_dict():
    """Test Track.to_dict() method."""
    expected_result = {
        'id': 1,
        'release_id': 22,
        'track_number': 3,
        'track_name': 'Test Track Name',
        'isrc': '345678',
        'cd': 2,
        'length_minute': 3,
        'length_seconds': 30,
        'upc': 345456,
        'performer': [],
        'us_publishing_obligation': 'PublicDomain',
        'third_party_publisher': 'Y',
        'publishers': []
    }

    track_obj = track.Track(
        id=1,
        release_id=22,
        track_id=3,
        track_name='Test Track Name',
        isrc='345678',
        cd=2,
        length_minute=3,
        length_seconds=30,
        upc=345456,
        us_publishing_obligation='PublicDomain',
        third_party_publisher='Y'
    )
    assert expected_result == track_obj.to_dict()


def test_track_to_dict_with_data_in_db(
        db_with_data, db_tracks, db_track_artists, db_track_publishers):
    """Assert Track.to_dict() method returns correct result."""
    with db_session() as session:
        track_from_db = session.query(Track).get(1).to_dict()

    expected_result = {
        'third_party_publisher': 'Y',
        'us_publishing_obligation': 'ControlledByYourLabel',
        'publishers': [{
            'type': 'publisher',
            'name': 'Publisher 1',
            'track_publisher_id': 0
        }],
        'isrc': 'SOMEISRC123',
        'track_name': 'First track',
        'cd': 1,
        'length_seconds': None,
        'id': 1,
        'release_id': 1,
        'upc': 111222333444,
        'performer': ['Artist 1'],
        'length_minute': None,
        'track_number': 1
    }
    assert track_from_db == expected_result


def test__update_track_publishers_called(mocker):
    """Test track_publisher model methods called on update."""
    session = mocker.patch.object(mysql, 'db_session')
    mocker.spy(track_publisher, 'delete_by_track_id')
    mocker.spy(track_publisher, 'create')

    track_id = 1
    publishers_for_update = ['Brown', 'White']
    update_track_result = track._update_track_publishers(
        track_id, publishers_for_update, session)

    track_publisher.delete_by_track_id.assert_called_once_with(
        track_id,
        session,
    )
    track_publisher.create.assert_called_once_with(
        publishers_for_update, track_id, session)
    assert update_track_result.status == 200


def test__update_track_publishers_delete_method_fails(mocker):
    """Test track_publisher model delete_by_track_id method failure."""
    session = mocker.patch.object(mysql, 'db_session')
    mocker.spy(track_publisher, 'delete_by_track_id')
    mocker.spy(track_publisher, 'create')
    integrity_error_raised = exc.IntegrityError(
        statement='test', params={},
        orig=Exception('Some exception'))
    mocker.patch.object(
        track_publisher,
        'delete_by_track_id',
        side_effect=integrity_error_raised,
    )

    mocker.patch.object(
        sentry_sdk, 'capture_exception', autospec=True)

    track_id = 1
    publishers_for_update = ['Brown', 'White']
    result = track._update_track_publishers(
        track_id, publishers_for_update, session)

    track_publisher.delete_by_track_id.assert_called_once_with(
        track_id,
        session,
    )
    assert sentry_sdk.capture_exception.called
    assert not track_publisher.create.called
    assert result.status == 500
    assert result.errors['message'] == (
        'mysql error: (builtins.Exception) Some exception\n[SQL: test]\n'
        '(Background on this error at: https://sqlalche.me/e/20/gkpj)')


def test__update_track_publishers_create_method_fails(mocker):
    """Test track_publisher model update method failure."""
    session = mocker.patch.object(mysql, 'db_session')
    mocker.spy(track_publisher, 'delete_by_track_id')
    mocker.spy(track_publisher, 'create')

    mocker.patch.object(
        track_publisher, 'create', side_effect=exc.SQLAlchemyError)
    mocker.patch.object(
        sentry_sdk, 'capture_exception', autospec=True)
    track_id = 1
    publishers_for_update = ['Brown', 'White']
    result = track._update_track_publishers(
        track_id, publishers_for_update, session)

    track_publisher.delete_by_track_id.assert_called_once_with(
        track_id,
        session,
    )
    track_publisher.create.assert_called_once_with(
        publishers_for_update, track_id, session)
    assert sentry_sdk.capture_exception.called
    assert result.status == 500
    assert result.errors['message'] == 'mysql error: ()'


def test__update_track_publishers_success(db_with_data):
    """Assert update publishers for existing track in db is successful."""
    publisher_names_for_update = [
        'Awesome publisher', 'Best publisher ever', 'New publisher']
    with db_session() as session:
        track_from_db = session.query(Track).get(1).to_dict()
        assert [{
            'name': 'Publisher 1',
            'track_publisher_id': 0,
            'type': 'publisher'}] not in track_from_db['publishers']

        track_publisher_update_result = track._update_track_publishers(
            1, publisher_names_for_update, session)
        track_from_db = session.query(Track).get(1).to_dict()
        assert track_publisher_update_result.status == 200
        assert track_from_db['publishers'] == [{
            'name': 'Awesome publisher',
            'track_publisher_id': 2, 'type': 'publisher'},
            {'name': 'Best publisher ever',
             'track_publisher_id': 3, 'type': 'publisher'},
            {'name': 'New publisher',
             'track_publisher_id': 4, 'type': 'publisher'}]


def test__update_track_publishers_no_publishers(mocker, db_with_data):
    """Assert update publishers for existing track in db is successful."""
    mocker.spy(track_publisher, 'delete_by_track_id')
    mocker.spy(track_publisher, 'create')
    publisher_names_for_update = []
    with db_session() as session:
        track_from_db = session.query(Track).get(1).to_dict()
        assert track_from_db['publishers']

        track_publisher_update_result = track._update_track_publishers(
            1, publisher_names_for_update, session)
        track_from_db = session.query(Track).get(1).to_dict()
        assert track_publisher.delete_by_track_id.called
        assert not track_publisher.create.called
        assert track_publisher_update_result.status == 200
        assert track_from_db['publishers'] == []