"""Tests for polling logic of Deezer store."""

import json

import pytest

from availability import datastructures as ds
from availability import exceptions
from availability.constants import models
from availability.logic.polling.stores import deezer

TEST_UPC = '885150341414'


@pytest.fixture
def error_response():
    """JSON loaded response dictionary with error from Deezer."""
    return {
        'error': {
            'type': 'Exception',
            'message': 'Quota limit exceeded',
            'code': 4
        }
    }


@pytest.fixture
def correct_response():
    """Part of correct response from Deezer store that actually needed."""
    return {
         'available': True,
         'id': 11958868  # depends on TEST_UPC
    }


@pytest.fixture
def expected_status(correct_response):
    """Return expected release status."""
    return ds.ReleaseStatus(
        store_release_id=str(correct_response['id']),
        db_release_status=models.RELEASE_STATUS_LIVE,
        live_countries=[])


@pytest.mark.parametrize(
    'error_code', list(range(100, 701, 100)) + [501])
def test_get_status_from_store_handles_deezer_response_errors(
        mocker, error_code, error_response, fake_response):
    """Assert Deezer-specific error codes are handled."""
    error_response['error']['code'] = error_code
    fake_response._content = json.dumps(error_response).encode('latin_1')
    mocker.patch(
        'availability.logic.polling.stores.deezer.deezer.requests.get',
        return_value=fake_response)
    with pytest.raises(exceptions.StoreRequestError):
        deezer.get_status_from_store(upc='test_upc')


def test_process_quota_exceeded_response(error_response):
    """Assert response with exceeded quota is processed correctly."""
    with pytest.raises(exceptions.RateLimitExceeded):
        deezer.process_error_response('test_upc', error_response)


def test_get_status_from_store_happy_path(
        mocker, correct_response, fake_response, expected_status):
    """Assert can get correct ReleaseStatus from valid store response."""
    fake_response._content = json.dumps(correct_response).encode('latin_1')
    mocker.patch(
        'availability.connectors.stores.deezer.requests.get',
        return_value=fake_response)
    status = deezer.get_status_from_store(upc=TEST_UPC)
    assert status == expected_status


def test_process_valid_response(correct_response, expected_status):
    """Assert can process Deezer response that contains valid data."""
    release_status = deezer.process_valid_response(correct_response)
    assert release_status == expected_status


def test_get_status_from_store_not_found(
        error_response, fake_response, mocker):
    """Assert can return notice not found release."""
    error_response['error']['code'] = 800
    fake_response._content = json.dumps(error_response).encode('latin_1')
    mocker.patch(
        'availability.connectors.stores.deezer.requests.get',
        return_value=fake_response)
    release_status = deezer.get_status_from_store(upc=TEST_UPC)
    assert release_status.db_release_status == models.RELEASE_STATUS_DELIVERED


def test_process_valid_response_with_not_live_release(correct_response):
    """Assert can process release status correctly."""
    correct_response['available'] = False
    release_status = deezer.process_valid_response(correct_response)
    assert release_status.db_release_status == models.RELEASE_STATUS_DELIVERED