"""Functional tests for GET /product/<product_id>/tracks/grats endpoint."""
import json
from unittest.mock import MagicMock

from flexmock import flexmock
from owsrequest import request

from product_digital.constants import services


def test_get_product_microservice_call(
        client, product_id, valid_headers, instant_grats_message):
    """Test fetch instant grats success."""
    get_grats_response = MagicMock(status_code=200)
    get_grats_response.json = MagicMock(return_value=instant_grats_message)

    (flexmock(request)
        .should_receive('get')
        .with_args(
            services.OWS_TRACK,
            '/product/{}/tracks/grats'.format(product_id))
        .and_return(get_grats_response))

    for instant_grat in instant_grats_message.get('items'):
        tuid = instant_grat['tuid']
        get_track_response = MagicMock(status_code=200)
        get_track_response.json = MagicMock(return_value={
            'track_name': 'Track_name_{}'.format(tuid), 'tuid': tuid})

        (flexmock(request)
            .should_receive('get')
            .with_args(
                services.OWS_TRACK,
                '/track/{}'.format(tuid))
            .and_return(get_track_response))

    get_grats_stores_message = {
        str(grat['store_id']): 'Store{}'.format(grat['store_id'])
        for grat in instant_grats_message.get('items')[0].get('grats')}

    get_stores_response = MagicMock(status_code=200)
    get_stores_response.json = MagicMock(return_value=get_grats_stores_message)
    (flexmock(request)
        .should_receive('get')
        .with_args(
            services.OWS_CARVEOUTS,
            '/stores/grats')
        .and_return(get_stores_response))
    get_response = client.get(
        '/product/{}/tracks/grats'.format(
            product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())
    assert get_response.status_code == 200
    assert response_body == {
        'items': [
            {'track': {'tuid': '1', 'track_name': 'Track_name_1'},
             'date': '2017-09-26T22:27:52.695829',
             'stores': [
                 {'store_id': 1, 'store_name': 'Store1'},
                 {'store_id': 2, 'store_name': 'Store2'}]},
            {'track': {'tuid': '3', 'track_name': 'Track_name_3'},
             'date': '2017-09-26T22:27:52.29', 'stores': [
                {'store_id': 1, 'store_name': 'Store1'}]},
            {'track': {'tuid': '3', 'track_name': 'Track_name_3'},
             'date': '2018-09-26T22:27:52.695829',
             'stores': [{'store_id': 2, 'store_name': 'Store2'}]}]}


def test_get_product_microservice_call_no_instant_grats_found(
        client, product_id, valid_headers, instant_grats_message):
    """Test fetch instant grats, grats data not found."""
    grats_error = {'code': 'not_found_error', 'message': 'Grats not found'}
    get_grats_response = MagicMock(status_code=404)
    get_grats_response.json = MagicMock(
        return_value=grats_error)

    (flexmock(request)
        .should_receive('get')
        .with_args(
            services.OWS_TRACK,
            '/product/{}/tracks/grats'.format(product_id))
        .and_return(get_grats_response))

    for instant_grat in instant_grats_message.get('items'):
        tuid = instant_grat['tuid']
        (flexmock(request)
         .should_receive('get')
         .with_args(
            services.OWS_TRACK,
            '/track/{}'.format(tuid))
         .never())
    get_response = client.get(
        '/product/{}/tracks/grats'.format(
            product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())
    assert get_response.status_code == 404
    assert response_body == grats_error


def test_get_product_microservice_call_track_data_not_found(
        client, product_id, valid_headers, instant_grats_message):
    """Test fetch instant grats success."""
    get_grats_response = MagicMock(status_code=200)
    get_grats_response.json = MagicMock(return_value=instant_grats_message)

    (flexmock(request)
        .should_receive('get')
        .with_args(
            services.OWS_TRACK,
            '/product/{}/tracks/grats'.format(product_id))
        .and_return(get_grats_response))

    tuid_without_data = instant_grats_message.get('items')[0]['tuid']
    tuid_not_fetched = instant_grats_message.get('items')[1]['tuid']

    track_error = {'code': 'not_found_error', 'message': 'Track not found'}
    get_track_response = MagicMock(status_code=404)
    get_track_response.json = MagicMock(
        return_value=track_error)
    (flexmock(request)
        .should_receive('get')
        .with_args(
            services.OWS_TRACK,
            '/track/{}'.format(tuid_without_data))
        .and_return(get_track_response))
    (flexmock(request)
     .should_receive('get')
     .with_args(
        services.OWS_TRACK,
        '/track/{}'.format(tuid_not_fetched))
     .never())

    get_response = client.get(
        '/product/{}/tracks/grats'.format(
            product_id), headers=valid_headers)
    response_body = json.loads(get_response.data.decode())
    assert get_response.status_code == 404
    assert response_body == track_error


def test_get_instant_grats_when_not_owner(
        client, product_id, valid_headers_for_vendor, mocker):
    """Test that error returned when requestor is not the product owner."""
    head_response = MagicMock(status_code=403)
    mocker.patch.object(request, 'head', return_value=head_response)
    get_response = client.get(
        '/product/{}/tracks/grats'.format(product_id),
        headers=valid_headers_for_vendor)

    assert get_response.status_code == 403