"""Test for asset_upload model."""

from flexmock import flexmock
import pytest
from sqlalchemy.exc import SQLAlchemyError

from assets.connectors import mysql
from assets.models import asset_upload
from tests.models import au_operations


@pytest.fixture
def valid_asset_upload_data():
    """Get valid data for create_asset_upload."""
    return {
        'user_id': 'oa:123',
        'filename': 'unique_filename',
        'token': 'sts_s3_session_token'
    }


@pytest.fixture
def existing_asset_upload():
    """Get search params for existing asset_upload record."""
    return {
        'filename': 'unique_filename_1',
        'user_id': 'oa:123456',
        'token': 'session_token_1'
    }


@pytest.fixture
def update_asset_upload_data(existing_asset_upload):
    """Get search params for existing asset_upload record."""
    existing_asset_upload.update(
        {
            'product_id': 12345,
            'track_unique_id': 321,
            'upc': 123
        }
    )
    return existing_asset_upload


@pytest.fixture
def data():
    """Get data to seed asset_upload table."""
    return [
        {
            'filename': 'unique_filename_1',
            'user_id': 'oa:123456',
            'token': 'session_token_1'.encode()
        },
        {
            'filename': 'unique_filename_2',
            'user_id': 'oa:654321',
            'token': 'session_token_2'.encode()
        }
    ]


@pytest.fixture
def db_fixture(data):
    """Set up the asset received queue table."""
    au_operations.create_tables()
    au_operations.seed_asset_upload_table(data)


def test_create_new_asset_upload(db_fixture, valid_asset_upload_data):
    """Test successful create of new asset_upload."""
    response = asset_upload.create_asset_upload(**valid_asset_upload_data)

    assert response.status == 200
    assert response.message['user_id'] == valid_asset_upload_data['user_id']
    assert response.message['filename'] == valid_asset_upload_data['filename']
    assert response.message['token'] == valid_asset_upload_data['token']


def test_create_new_asset_upload_unique_failure(
        db_fixture, valid_asset_upload_data):
    """Test create new aset_upload fail if token is not unique."""
    expected_error = 'token_generation_integrity_error'

    asset_upload_response_1 = asset_upload.create_asset_upload(
        **valid_asset_upload_data)
    asset_upload_response_2 = asset_upload.create_asset_upload(
        **valid_asset_upload_data)

    assert asset_upload_response_1
    assert asset_upload_response_1.status == 200
    assert asset_upload_response_2.status == 500
    assert asset_upload_response_2.errors['code'] == expected_error


def test_create_new_asset_upload_sql_error(
        db_fixture, valid_asset_upload_data):
    """Test successful create of new asset_upload."""
    (flexmock(mysql)
     .should_receive('au_db_session')
     .and_raise(SQLAlchemyError(500)))

    asset_upload_1 = asset_upload.create_asset_upload(
        **valid_asset_upload_data)

    assert asset_upload_1.status == 500


def test_get_asset_upload_success(db_fixture, existing_asset_upload):
    """Test successful get of existing asset_upload."""
    response = asset_upload.get_asset_upload(**existing_asset_upload)

    assert response
    assert response.message['id'] == 1


def test_get_asset_upload_no_user_id_no_token_success(
        db_fixture, existing_asset_upload):
    """Test successful get of existing asset_upload with no user_id filter."""
    del existing_asset_upload['user_id']
    del existing_asset_upload['token']
    response = asset_upload.get_asset_upload(**existing_asset_upload)

    assert response
    assert response.message['id'] == 1


@pytest.mark.parametrize('search_condition', ['filename', 'user_id', 'token'])
def test_get_asset_upload_failures(
        db_fixture, existing_asset_upload, search_condition):
    """Test get_asset_upload fail if one of fields is wrong."""
    existing_asset_upload[search_condition] = 'some_wrong_value'
    response = asset_upload.get_asset_upload(**existing_asset_upload)

    assert response.status == 404
    assert response.errors['message'] == 'asset_not_found'


def test_get_asset_upload_sql_error(db_fixture, existing_asset_upload):
    """Test SQLAlchemyError failure."""
    (flexmock(mysql)
     .should_receive('au_db_session')
     .and_raise(SQLAlchemyError(500)))

    response = asset_upload.get_asset_upload(**existing_asset_upload)

    assert response.status == 500


def test_update_asset_upload_success(db_fixture, update_asset_upload_data):
    """Test successful update of existing asset_upload."""
    response = asset_upload.update_asset_upload(
        asset_type='WAV', **update_asset_upload_data)

    assert response
    assert response.message['asset_type'] == 'WAV'

    token = update_asset_upload_data['token'].encode()
    user_id = update_asset_upload_data['user_id']
    filename = update_asset_upload_data['filename']
    assert au_operations.session.query(asset_upload.AssetUpload).filter(
        asset_upload.AssetUpload.user_id == user_id,
        asset_upload.AssetUpload.filename == filename,
        asset_upload.AssetUpload.token == token,
        asset_upload.AssetUpload.asset_type == 'WAV'
    ).first() is not None


def test_update_asset_upload_by_filename_only_success(
        db_fixture, update_asset_upload_data):
    """Test successful update of existing asset_upload."""
    update_args = update_asset_upload_data.copy()
    del update_args['user_id']
    del update_args['token']
    response = asset_upload.update_asset_upload(
        asset_type='WAV', **update_args)

    assert response
    assert response.message['asset_type'] == 'WAV'

    token = update_asset_upload_data['token'].encode()
    user_id = update_asset_upload_data['user_id']
    filename = update_asset_upload_data['filename']
    assert au_operations.session.query(asset_upload.AssetUpload).filter(
        asset_upload.AssetUpload.user_id == user_id,
        asset_upload.AssetUpload.filename == filename,
        asset_upload.AssetUpload.token == token,
        asset_upload.AssetUpload.asset_type == 'WAV'
    ).first() is not None


@pytest.mark.parametrize('search_condition', ['filename', 'user_id', 'token'])
def test_update_asset_upload_failure(
        db_fixture, search_condition, update_asset_upload_data):
    """Test failure of get_asset_upload with wrong search condition."""
    update_asset_upload_data[search_condition] = 'wrong_value'
    response = asset_upload.update_asset_upload(
        asset_type='WAV', **update_asset_upload_data)

    assert response.status == 500


def test_update_asset_upload_sql_error(db_fixture, update_asset_upload_data):
    """Test SQLAlchemyError failure."""
    (flexmock(mysql)
     .should_receive('au_db_session')
     .and_raise(SQLAlchemyError(500)))

    response = asset_upload.update_asset_upload(
        asset_type='WAV', **update_asset_upload_data)

    assert response.status == 500