"""Functional tests for creating a track role.

Test endpoint:
    POST /track/<tuid>/<role>
"""

import json

from oto import status as response_code

from backend.constants import error
from backend.constants import track_field as tf
from tests.testutils import db
from tests.testutils import mocks


def _create_role(client, headers, tuid, subrole, data):
    """Make POST request to create role."""
    endpoint = 'track/{}/{}'.format(tuid, subrole)
    return client.post(endpoint, headers=headers, data=json.dumps(data))


@db.test_schema
def test_create_track_artist_role(
        mocker, client, client_headers, test_track, validate_role_saved):
    """Test create track artist role is successful."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, client_headers, tuid,
        subrole='performer', data={'name': 'Some artist'})

    res_body = json.loads(res.data.decode())
    assert res.status_code == response_code.CREATED
    assert 'track_artist_id' in res_body
    assert res_body['type'] == 'performer'
    assert res_body['name'] == 'Some artist'

    validate_role_saved(
        client_headers, tuid, 'artist', res_body['track_artist_id'])


@db.test_schema
def test_create_track_artist_role_without_grass_headers(
        mocker, client, valid_headers, test_track, validate_role_saved):
    """Test create track artist role is successful without grass headers."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, valid_headers, tuid,
        subrole='performer', data={'name': 'Some artist'})

    res_body = json.loads(res.data.decode())
    assert res.status_code == response_code.CREATED
    assert 'track_artist_id' in res_body
    assert res_body['type'] == 'performer'
    assert res_body['name'] == 'Some artist'

    validate_role_saved(
        valid_headers, tuid, 'artist', res_body['track_artist_id'])


@db.test_schema
def test_create_track_artist_role_with_invalid_grass_headers(
        mocker, client, invalid_grass_headers, test_track):
    """Test create track artist role fails with invalid grass headers."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, invalid_grass_headers, tuid,
        subrole='performer', data={'name': 'Some artist'})

    assert res.status_code == response_code.BAD_REQUEST


@db.test_schema
def test_create_track_writer_role(
        mocker, client, client_headers, test_track, validate_role_saved):
    """Test create track writer role is successful."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, client_headers, tuid,
        subrole='writer', data={'name': 'Some writer'})

    res_body = json.loads(res.data.decode())
    assert res.status_code == response_code.CREATED
    assert 'track_writer_id' in res_body
    assert res_body['name'] == 'Some writer'

    validate_role_saved(
        client_headers, tuid, 'writer', res_body['track_writer_id'])


@db.test_schema
def test_create_track_writer_role_without_grass_headers(
        mocker, client, valid_headers, test_track, validate_role_saved):
    """Test create track writer role is successful without grass headers."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, valid_headers, tuid,
        subrole='writer', data={'name': 'Some writer'})

    res_body = json.loads(res.data.decode())
    assert res.status_code == response_code.CREATED
    assert 'track_writer_id' in res_body
    assert res_body['name'] == 'Some writer'

    validate_role_saved(
        valid_headers, tuid, 'writer', res_body['track_writer_id'])


@db.test_schema
def test_create_track_writer_role_with_invalid_grass_headers(
        mocker, client, invalid_grass_headers, test_track):
    """Test create track writer role fails with invalid grass headers."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, invalid_grass_headers, tuid,
        subrole='writer', data={'name': 'Some writer'})

    assert res.status_code == response_code.BAD_REQUEST


@db.test_schema
def test_create_track_invalid_role(
        mocker, client, client_headers, test_track):
    """Test create track role with invalid role returns error response."""
    tuid = test_track[tf.TUID]
    mocks.head_response(mocker)

    res = _create_role(
        client, client_headers, tuid,
        subrole='publisher', data={'name': 'Some really bad role'})

    res_body = json.loads(res.data.decode())
    assert res.status_code == response_code.BAD_REQUEST
    assert res_body['code'] == error.INVALID_ROLE_ERROR_CODE