"""Integration tests."""


def test_get_blacklist_reasons(api_client):
    """Test GET against blacklist-reasons endpoint."""
    response = api_client.get_blacklist_reasons()
    assert response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(response.status_code)
    reason = response.json()['items'][0]['reason']
    assert type(reason) is str, \
        'Reason data was "{}", expected data to be type string, was {}'.format(reason, type(reason))


def test_get_blacklist_words(api_client):
    """Test GET against blacklist-words endpoint."""
    response = api_client.get_blacklist_words()
    assert response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(response.status_code)
    word = response.json()['items'][0]['word']
    assert type(word) is str, \
        'Word data was "{}", expected data to be type string, was {}'.format(word, type(word))


def test_get_blacklist_words_export(api_client):
    """Test GET against blacklist-words/export endpoint."""
    response = api_client.get_blacklist_words_export()
    assert response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(response.status_code)
    string_export = str(api_client.get_url(response.json()['download_url']).content)
    assert 'word' in string_export, 'Expected to find "word" in stringified export, got {}'.format(string_export)


def test_create_reason(api_client, reason_data):
    """Test POST against blacklist-reason endpoint."""
    response = api_client.create_blacklist_reason(reason_data)
    assert response.status_code == 201, \
        'Result of POST was {}, expected 201.'.format(response.status_code)

    get_response = api_client.get_blacklist_reasons()
    assert get_response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(get_response.status_code)
    result = [item for item in get_response.json()['items'] if item['reason'] == reason_data['reason']]
    assert len(result) >= 1, \
        'Length of result was less than 1, ' \
        'filter data was "{}", ' \
        'get response was "{}"'.format(reason_data['reason'], get_response.json())


def test_update_reason(api_client, reason_data, updated_reason_data):
    """Test PUT against blacklist-reason endpoint."""
    response = api_client.create_blacklist_reason(reason_data)
    assert response.status_code == 201, \
        'Result of POST was {}, expected 201.'.format(response.status_code)

    put_response = api_client.update_blacklist_reason(response.json()['id'], updated_reason_data)
    assert put_response.status_code == 200, \
        'Result of PUT was {}, expected 200.'.format(put_response.status_code)

    get_response = api_client.get_blacklist_reasons()
    result = [item for item in get_response.json()['items'] if item['reason'] == updated_reason_data['reason']]
    assert len(result) >= 1, \
        'Length of result was less than 1, ' \
        'filter data was "{}", ' \
        'get response was "{}"'.format(updated_reason_data['reason'], get_response.json())
    assertions = [result[0][key] == updated_reason_data[key] for key in updated_reason_data.keys()]
    assert all(assertions) is True, 'Not all data matched, expected to find key/pairs {} in {}'.format(
        reason_data, result[0])


def test_create_word(api_client, word_data):
    """Test POST against blacklist-word endpoint."""
    post_response = api_client.create_blacklist_word(word_data)
    assert post_response.status_code == 201, \
        'Result of POST was {}, expected 201.'.format(post_response.status_code)

    get_word_response = api_client.get_blacklist_words()
    assert get_word_response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(get_word_response.status_code)
    result = [item for item in get_word_response.json()['items'] if item['word'] == word_data['word']]
    assert len(result) >= 1, \
        'Length of result was less than 1, ' \
        'filter data was "{}", ' \
        'get response was "{}"'.format(word_data['word'], get_word_response.json())


def test_update_word(api_client, word_data, updated_word_data):
    """Test PUT against blacklist-word endpoint."""
    post_response = api_client.create_blacklist_word(word_data)
    assert post_response.status_code == 201, \
        'Result of POST was {}, expected 201.'.format(post_response.status_code)

    put_response = api_client.update_blacklist_word(post_response.json()['id'], updated_word_data)
    assert put_response.status_code == 200, \
        'Result of PUT was {}, expected 200.'.format(put_response.status_code)

    get_word_response = api_client.get_blacklist_words()
    assert get_word_response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(get_word_response.status_code)
    result = [item for item in get_word_response.json()['items'] if item['word'] == updated_word_data['word']]
    assert len(result) >= 1, \
        'Length of result was less than 1, ' \
        'filter data was "{}", ' \
        'get response was "{}"'.format(updated_word_data['word'], get_word_response.json())

    assert result[0]['blacklist_reason']['id'] == updated_word_data['blacklist_reason_id'], \
        'Expected GET to return blacklist_reason_id of {}, got {}'.format(
            updated_word_data['blacklist_reason_id'], result[0]['blacklist_reason']['id'])

    # Remove before looping over keys
    del updated_word_data['blacklist_reason_id']
    assertions = [result[0][key] == updated_word_data[key] for key in updated_word_data.keys()]
    assert all(assertions) is True, 'Not all data matched, expected to find key/pairs {} in {}'.format(
        updated_word_data, result[0])


def test_delete_word(api_client, word_data):
    """Test DELETE against blacklist-word endpoint."""
    post_response = api_client.create_blacklist_word(word_data)
    assert post_response.status_code == 201, \
        'Result of POST was {}, expected 201.'.format(post_response.status_code)

    delete_response = api_client.delete_blacklist_word(post_response.json()['id'])
    assert delete_response.status_code == 200, \
        'Result of DELETE was {}, expected 200.'.format(delete_response.status_code)

    get_word_response = api_client.get_blacklist_words()
    assert get_word_response.status_code == 200, \
        'Result of GET was {}, expected 200.'.format(get_word_response.status_code)
    result = [item for item in get_word_response.json()['items'] if item['word'] == word_data['word']]
    assert len(result) == 0, \
        'Length of result was greater than 0, ' \
        'filter data was "{}", ' \
        'get response was "{}"'.format(word_data['word'], get_word_response.json())


def test_validate_product_for_blacklisting(api_client, fixture_product_id):
    """Test GET against validate endpoint."""
    response = api_client.validate_product_for_blacklisting(fixture_product_id)
    assert response.status_code == 200