"""Test for ProductLocalization model."""
from unittest.mock import Mock

import boto3
from moto import mock_dynamodb

from product.models import product_localization
from tests.factories.product_localization import ProductLocalizationFactory
from tests.testutils import db


@mock_dynamodb
def test_get_localization_data(mocker, test_product):
    """Test getting localization data succeeds."""
    boto3.client('dynamodb', region_name='us-east-1')
    db.create_product_localization_table()
    db.seed_dynamodb_models(ProductLocalizationFactory.build(
        product_id=str(test_product)))

    actual = product_localization.get_localization_data(test_product)
    assert 'product_id' in actual.message
    assert 'items' in actual.message
    assert 1 == len(actual.message['items'])
    assert 'pagination' in actual.message


@mock_dynamodb
def test_get_localization_data_batch(mocker, test_product):
    """Test getting localization data succeeds."""
    boto3.client('dynamodb', region_name='us-east-1')
    db.create_product_localization_table()
    db.seed_dynamodb_models(ProductLocalizationFactory.build_batch(
        10, product_id='1'))

    actual = product_localization.get_localization_data(test_product)
    assert 'product_id' in actual.message
    assert 'items' in actual.message
    assert 10 == len(actual.message['items'])
    assert 'pagination' in actual.message


def test_not_found_localization_data(mocker, test_product):
    """Test getting localization data when no data found."""
    mocker.patch.object(
        product_localization.ProductLocalization, 'query',
        return_value=[])

    actual = product_localization.get_localization_data(test_product)
    assert product_localization.ProductLocalization.query.call_count == 1
    assert actual.status == 404


def test_create_update(
        mocker, test_product, fixture_language, fixture_valid_localization):
    """Test creating new localization succeeds."""
    mocker.patch.object(
        product_localization.ProductLocalization, 'save',
        return_value=Mock())

    actual = product_localization.create_update(
        test_product, fixture_language, fixture_valid_localization)

    assert product_localization.ProductLocalization.save.call_count == 1
    assert 'language_id' in actual.message
    assert 'product_name' in actual.message
    assert fixture_valid_localization['product_name'] == \
        actual.message['product_name']


def test_create_update_no_data(test_product, fixture_language):
    """Test creating new localization with no data."""
    actual = product_localization.create_update(
        test_product, fixture_language, {})
    assert actual.status == 400


def test_delete(
        mocker, test_product, fixture_language):
    """Test delete localization succeeds."""
    mock_localization_model = Mock()
    mock_localization_model.to_dict.return_value = {'foo': 'bar'}
    mocker.patch.object(
        product_localization.ProductLocalization, 'query',
        return_value=[mock_localization_model])
    mocker.patch.object(
        product_localization.ProductLocalization, 'delete',
        return_value=Mock())

    product_localization.delete(
        test_product, fixture_language)

    assert mock_localization_model.delete.call_count == 1


def test_delete_not_found(
        mocker, test_product, fixture_language):
    """Test delete localizations when no record found."""
    mocker.patch.object(
        product_localization.ProductLocalization, 'query',
        return_value=[])

    actual = product_localization.delete(test_product, fixture_language)
    assert actual.status == 404


def test_model_serialize():
    """Test serializing AdditionalData object."""
    additional_data_obj = product_localization.AdditionalData()
    additional_data_obj.product_name = 'test'
    actual = additional_data_obj.serialize(additional_data_obj)
    assert actual == {'product_name': {'S': 'test'}}