"""Tests for ows-product-digital model."""

from collections import namedtuple

from owsrequest import request as requests
import sentry_sdk

from product.constants import service_name
from product.models import ows_product_digital as opd_models


def test_delete_digital_product_success(mocker, test_product):
    """Test success deletion."""
    response = namedtuple("response", "status_code")
    mocker.patch.object(
        requests, "delete", return_value=response(status_code=200), autospec=True
    )

    assert opd_models.delete_digital_product(test_product, "vendor", 12)


def test_delete_digital_product_fail_exception(monkeypatch, mocker, test_product):
    """Test exception handler."""
    monkeypatch.delattr(requests, "delete")
    mocker.patch.object(sentry_sdk, "capture_exception", return_value="", autospec=True)

    result = opd_models.delete_digital_product(test_product, "vendor", 12)

    assert not result
    assert sentry_sdk.capture_exception.called


def test_delete_digital_product_error_response(mocker, test_product):
    """Test success deletion."""
    response = namedtuple("response", "status_code")
    mocker.patch.object(
        requests, "delete", return_value=response(status_code=500), autospec=True
    )

    assert not opd_models.delete_digital_product(test_product, "vendor", 12)


def test_model_copy_digital_product_success(ows_request_mocker):
    """Test copy digital product success."""
    existing_product_id = 93
    product_data_changes = {"some_key": "some value"}
    new_product_id = 98765
    expected_response = {"product_id": new_product_id}

    ows_request_mocker.add(
        {
            "method": "post",
            "service": service_name.OWS_PRODUCT_DIGITAL,
            "path": "/product/{}/copy".format(existing_product_id),
            "status": 201,
            "json": expected_response,
        }
    )
    ows_request_mocker.apply()

    result = opd_models.copy_digital_product(existing_product_id, product_data_changes)

    assert result.status == 201
    assert result.message == expected_response


def test_model_copy_digital_product_exception(mocker):
    """Test copy digital product when an exception occurs."""
    existing_product_id = 93
    product_data_changes = {"some_key": "some value"}

    mocker.patch.object(sentry_sdk, "capture_exception")

    result = opd_models.copy_digital_product(existing_product_id, product_data_changes)

    assert result.status == 500
    assert sentry_sdk.capture_exception.called


def test_model_copy_digital_product_opd_down(ows_request_mocker):
    """Test copy product when ows-product-digital returns an error."""
    existing_product_id = 93
    product_data_changes = {"some_key": "some value"}
    expected_status = 500
    expected_response = {"oops": "i did an error"}

    ows_request_mocker.add(
        {
            "method": "post",
            "service": service_name.OWS_PRODUCT_DIGITAL,
            "path": "/product/{}/copy".format(existing_product_id),
            "status": 500,
            "json": expected_response,
        }
    )
    ows_request_mocker.apply()

    result = opd_models.copy_digital_product(existing_product_id, product_data_changes)

    assert result.status == expected_status
    assert result.message == expected_response


def test_model_get_digital_product_success(ows_request_mocker):
    """Test get digital product success."""
    product_id = 93
    expected_response = {"product_id": product_id}

    ows_request_mocker.add(
        {
            "method": "get",
            "service": service_name.OWS_PRODUCT_DIGITAL,
            "path": "/product/audio/{}".format(product_id),
            "status": 200,
            "json": expected_response,
        }
    )
    ows_request_mocker.apply()

    result = opd_models.get_digital_product(product_id)
    assert result.status == 200
    assert result.message == expected_response


def test_model_get_digital_product_exception(mocker):
    """Test get digital product when an exception occurs."""
    product_id = ""
    mocker.patch.object(sentry_sdk, "capture_exception")

    result = opd_models.get_digital_product(product_id)
    assert result.status == 500
    assert sentry_sdk.capture_exception.called


def test_model_get_digital_product_opd_down(ows_request_mocker):
    """Test get product when ows-product-digital returns an error."""
    product_id = 93
    expected_status = 500
    expected_response = {"oops": "i did an error"}

    ows_request_mocker.add(
        {
            "method": "get",
            "service": service_name.OWS_PRODUCT_DIGITAL,
            "path": "/product/audio/{}".format(product_id),
            "status": 500,
            "json": expected_response,
        }
    )
    ows_request_mocker.apply()

    result = opd_models.get_digital_product(product_id)

    assert result.status == expected_status
    assert result.message == expected_response


def test_create_digital_product_success(ows_request_mocker):
    """Test copy digital product success."""
    new_product_id = 98765
    expected_response = {"product_id": new_product_id}

    ows_request_mocker.add(
        {
            "method": "post",
            "service": service_name.OWS_PRODUCT_DIGITAL,
            "path": "/product/audio",
            "status": 200,
            "json": expected_response,
        }
    )
    ows_request_mocker.apply()

    result = opd_models.create_digital_product({"stuff": "stuff"})

    assert result.status == 200
    assert result.message == expected_response


def test_create_digital_product_failure(ows_request_mocker, mocker):
    """Test create digital product failure."""
    mocker.patch.object(sentry_sdk, "capture_exception")

    result = opd_models.create_digital_product("")

    assert result.status == 500
    assert sentry_sdk.capture_exception.called


def test_update_digital_product_success(ows_request_mocker):
    """Test copy digital product success."""
    existing_product_id = 98765
    expected_response = {"product_id": existing_product_id}
    fields = {"product_id": existing_product_id}
    account_id = 1
    account_type = "subaccount"

    ows_request_mocker.add(
        {
            "method": "put",
            "service": service_name.OWS_PRODUCT_DIGITAL,
            "path": "/product/audio/{}".format(existing_product_id),
            "status": 200,
            "json": expected_response,
        }
    )
    ows_request_mocker.apply()

    result = opd_models.update_digital_product(
        existing_product_id, account_id, account_type, fields
    )

    assert result.status == 200
    assert result.message == expected_response


def test_update_digital_product_failure(ows_request_mocker, mocker):
    """Test update digital product failure."""
    mocker.patch.object(sentry_sdk, "capture_exception")

    result = opd_models.update_digital_product("", "", "", "")

    assert result.status == 500
    assert sentry_sdk.capture_exception.called