"""Tests for orders logic."""
from unittest.mock import MagicMock, call

from sqlalchemy.orm.session import Session

from ows_product_physical.connector import mysql
from ows_product_physical.logic import orders as orders_logic
from ows_product_physical.models import \
    delivery_history as delivery_history_model
from ows_product_physical.models import order as order_model
from ows_product_physical.models import order_product as order_product_model


def test_create_order_model_called(mocker, order):
    """Test that order is being passed to and returned from model layer."""
    product_ids = [23245, 23246]
    delivery_store_id = 1705
    identity_id = '10436b38-5e11-472d-b6a4-bf1ee2b1b438'
    delivery_type = 'update'

    mocker.patch.object(
        order_model, 'create_order', return_value=order
    )
    result = orders_logic.create_order(
        product_ids=product_ids,
        delivery_store_id=delivery_store_id,
        identity_id=identity_id,
        delivery_type=delivery_type)

    order_model.create_order.assert_called_with(
        product_ids,
        delivery_store_id,
        delivery_type, identity_id)
    assert result == order


def test_update_orders_methods_called(
    mocker, orders, db_releases, complete_db_orders_as_object
):
    """Test update orders.

    Test that the methods to update orders, pull products, and
    create delivery history are being called.
    """
    identity_id = '10436b38-5e11-472d-b6a4-bf1ee2b1b438'
    ar_session = Session()
    ar_session.flush = MagicMock(return_value=None)
    delivery_session = Session()
    delivery_session.flush = MagicMock(return_value=None)
    products = db_releases

    mocker.patch.object(
        mysql,
        'delivery_db_session',
        return_value=delivery_session)

    mocker.patch.object(
        mysql,
        'db_session',
        return_value=ar_session)

    mocker.patch.object(
        order_model,
        'update_orders',
        return_value=orders['items'])

    mocker.patch.object(
        order_product_model,
        'get_order_products_by_order_id',
        return_value=products)

    mocker.patch.object(
        order_model,
        'get_order_by_order_id',
        side_effect=complete_db_orders_as_object
    )

    mocker.patch.object(
        delivery_history_model,
        'save_delivery_history',
        return_value=[])

    orders_logic.update_orders(identity_id=identity_id, orders=orders['items'])

    order_model.update_orders.assert_called_with(
        identity_id,
        orders['items'],
        delivery_session
    )

    order_product_model.get_order_products_by_order_id.assert_called()
    assert order_product_model.get_order_products_by_order_id.call_count == 2
    order_product_model.get_order_products_by_order_id.assert_has_calls(
        [call(2, delivery_session), call(5, delivery_session)]
    )

    order_model.get_order_by_order_id.assert_called()
    assert order_model.get_order_by_order_id.call_count == 2
    order_model.get_order_by_order_id.assert_has_calls(
        [call(2, delivery_session), call(5, delivery_session)]
    )

    delivery_history_model.save_delivery_history.assert_called()
    assert delivery_history_model.save_delivery_history.call_count == 2
    delivery_history_model.save_delivery_history.assert_has_calls(
        [call(products, 1705, ar_session), call(products, 1901, ar_session)]
    )

    ar_session.flush.assert_called_once()
    delivery_session.flush.assert_called_once()