"""Unit tests for the release approval queue model."""

import datetime
from unittest import mock

import pytest

from product_workflow.connectors import mysql
from product_workflow.models import rejection_notes
from product_workflow.models.release_approval_queue import ReleaseApprovalQueue
from product_workflow.utils import error_handling
from tests.factories import rejection_notes as rejection_notes_factory
from tests.factories import release_approval_queue \
    as release_approval_queue_factory
from tests.testutils import db


@pytest.fixture
def release_approval_id():
    """Create a release id for testing."""
    return 123


def test_to_dict(release_approval_id):
    """Test that the expected properties are returned."""
    table_name = 'releases'
    field_name = 'release_name'
    comments = 'This song is too loud.'
    corrected = 'N'
    date_added = datetime.datetime(2017, 6, 10, 0, 0, 0)
    key_id = 4090520

    rejection_note = rejection_notes.RejectionNote(
        release_approval_id=release_approval_id, table_name=table_name,
        field_name=field_name, comments=comments, corrected=corrected,
        date_added=date_added, key_id=key_id)

    assert rejection_note.to_dict() == {
        'rejection_id': rejection_note.rejection_id,
        'table_name': table_name,
        'field_name': field_name,
        'comments': comments,
        'corrected': corrected,
        'key_id': key_id}


@db.test_schema
def test_get_rejection_notes_success(release_approval_id):
    """Test that the notes for the given release_approval_id are returned."""
    rejection_one = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    rejection_two = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    db.seed_models([rejection_one, rejection_two])
    result = rejection_notes.get_rejection_notes(release_approval_id)

    assert result.status == 200
    assert result.message == {'items': [
        rejection_one.to_dict(), rejection_two.to_dict()]}


@db.test_schema
def test_get_rejection_notes_no_records(release_approval_id):
    """Test that a 200 status is returned with empty items when no records."""
    result = rejection_notes.get_rejection_notes(release_approval_id)

    assert result.status == 200
    assert result.message == {'items': []}


def test_get_rejection_notes_db_error(
        db_exception, mocker, release_approval_id):
    """Test that a DB exception is logged and a 500 status is returned."""
    mock_session = db.mock_db_session(mocker)
    mock_session.query.side_effect = db_exception
    mocker.patch.object(error_handling, 'log_db_exception', mock.Mock())
    result = rejection_notes.get_rejection_notes(release_approval_id)

    assert result.status == 500
    error_handling.log_db_exception.assert_called_once_with(db_exception)


@db.test_schema
def test_update_rejection_notes_success(release_approval_id):
    """Test that the notes for the given release_approval_id are returned."""
    release_approval_queue = release_approval_queue_factory \
        .ReleaseApprovalQueueFactory \
        .build(release_approval_id=release_approval_id)
    rejection_one = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    rejection_two = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    rejections = [rejection_one, rejection_two]
    db.seed_models(rejections + [release_approval_queue])
    updated_rejections = [note.to_dict() for note in rejections]
    updated_rejections[1]['corrected'] = 'Y'
    result = rejection_notes.update_rejection_notes(updated_rejections)

    assert result.status == 200
    assert result.message == {'rejections': updated_rejections}


@db.test_schema
def test_update_rejection_notes_ignores_invalid(release_approval_id):
    """Test that the notes for the given release_approval_id are returned."""
    release_approval_queue = release_approval_queue_factory \
        .ReleaseApprovalQueueFactory \
        .build(release_approval_id=release_approval_id)
    rejection_one = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    rejection_two = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    rejection_three = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    rejections = [rejection_one, rejection_two]
    original_rejections = [note.to_dict() for note in rejections]
    db.seed_models(rejections + [release_approval_queue])
    rejections.append(rejection_three)
    updated_rejections = [note.to_dict() for note in rejections]
    result = rejection_notes.update_rejection_notes(updated_rejections)

    assert result.status == 200
    assert result.message == {'rejections': original_rejections}


@db.test_schema
def test_update_rejection_notes_updates_release_approval_queue(
        release_approval_id):
    """Test release approval queue's last updated column is updated."""
    release_approval_queue = release_approval_queue_factory \
        .ReleaseApprovalQueueFactory \
        .build(release_approval_id=release_approval_id)
    rejection_note = rejection_notes_factory.RejectionNoteFactory.build(
        release_approval_id=release_approval_id)
    db.seed_models([release_approval_queue, rejection_note])
    result = rejection_notes.update_rejection_notes([rejection_note.to_dict()])

    assert result.status == 200
    with mysql.db_session() as session:
        updated_release_approval_queue = session.query(ReleaseApprovalQueue)\
            .get(release_approval_queue.release_approval_id)
        assert release_approval_queue.last_updated \
            < updated_release_approval_queue.last_updated