"""Tests for dashboard_tools."""

from unittest.mock import patch

import config
import dashboard_tools
from tests import helpers


@patch('dashboard_tools.requests')
def test_get_dashboard_json(
        requests, get_mock_dashboard_json):
    """Return dict."""
    requests.get.return_value = get_mock_dashboard_json
    result = dashboard_tools.get_dashboard_json(7)
    assert result == helpers.dashboard_json


@patch('dashboard_tools.requests')
def test_post_dashboard(
        requests, get_mock_dashboard_json):
    """Return dict."""
    requests.post.return_value = get_mock_dashboard_json
    result = dashboard_tools.post_dashboard({})
    assert result == helpers.dashboard_json


@patch('dashboard_tools.requests')
def test_update_client_dashboard(
        requests, get_mock_dashboard_json):
    """Return dict."""
    requests.patch.return_value = get_mock_dashboard_json
    result = dashboard_tools.update_client_dashboard({}, 7)
    assert result == helpers.dashboard_json


def test_change_dashboard_space_id():
    """Return dict."""
    result = dashboard_tools.change_dashboard_space_id({
        'space_id': 990009900})
    assert result == {'space_id': config.CLIENT_LOOKER_SPACE_ID}


def test_change_dashboard_folder_id():
    """Return dict."""
    result = dashboard_tools.change_dashboard_folder_id({
        'folder_id': 990009900})
    assert result == {'folder_id': config.CLIENT_LOOKER_FOLDER_ID}


def test_change_dashboard_user_id():
    """Return dict."""
    result = dashboard_tools.change_dashboard_user_id({
        'user_id': 990009900})
    assert result == {'user_id': config.CLIENT_LOOKER_USER_ID}


def test_adjust_dashboard_json():
    """Return dict."""
    result = dashboard_tools.adjust_dashboard_json({
        'folder_id': 993090, 'space_id': 993090, 'user_id': 993090})
    assert result == {
        'user_id': config.CLIENT_LOOKER_USER_ID,
        'folder_id': config.CLIENT_LOOKER_FOLDER_ID,
        'space_id': config.CLIENT_LOOKER_SPACE_ID
    }


@patch('dashboard_tools.requests')
def test_get_all_dashboards(
        requests, get_mock_dashboard_list):
    """Return list."""
    requests.get.return_value = get_mock_dashboard_list
    result = dashboard_tools.get_all_dashboards('instance')
    assert result == helpers.list_of_dashboards


@patch('dashboard_tools.requests')
def test_check_dashboard_on_client_instance_positive(
        requests, get_mock_dashboard_list):
    """Return int."""
    requests.get.return_value = get_mock_dashboard_list
    result = dashboard_tools.check_dashboard_on_client_instance('awesome')
    assert result == 7


@patch('dashboard_tools.requests')
def test_check_dashboard_on_client_instance_negative(
        requests, get_mock_dashboard_list):
    """Return False."""
    requests.get.return_value = get_mock_dashboard_list
    result = dashboard_tools.check_dashboard_on_client_instance('wrong')
    assert result is False


@patch('dashboard_tools.requests')
def test_get_list_of_dashboard_filters(requests, get_mock_filter_list):
    """Return list."""
    requests.get.return_value = get_mock_filter_list
    result = dashboard_tools.get_list_of_dashboard_filters(7)
    assert result == helpers.list_of_dashboard_filters


@patch('dashboard_tools.requests')
def test_post_filter_to_client_instance(requests, get_mock_filter_json):
    """Return dict."""
    requests.post.return_value = get_mock_filter_json
    result = dashboard_tools.post_filter_to_client_instance({})
    assert result == helpers.dashboard_filter


@patch('dashboard_tools.requests')
def test_update_dashboard_filter(requests, get_mock_filter_json):
    """Return dict."""
    requests.patch.return_value = get_mock_filter_json
    result = dashboard_tools.update_dashboard_filter({}, 27)
    assert result == helpers.dashboard_filter


@patch('dashboard_tools.post_filter_to_client_instance')
def test_sync_dashboard_filters_no_list(post_filter_to_client_instance):
    """Assert post_filter_to_client_instance called."""
    dashboard_tools.sync_dashboard_filters(
        helpers.list_of_dashboard_filters, 66)
    post_filter_to_client_instance.assert_called()


@patch('dashboard_tools.post_filter_to_client_instance')
def test_sync_dashboard_filters_list_post(post_filter_to_client_instance):
    """Assert post called."""
    dashboard_tools.sync_dashboard_filters(
        helpers.list_of_dashboard_filters, 66, [{'title': 'low'}])
    post_filter_to_client_instance.assert_called()


@patch('dashboard_tools.update_dashboard_filter')
def test_sync_dashboard_filters_list_update(update_dashboard_filter):
    """Assert update_dashboard_filter called."""
    dashboard_tools.sync_dashboard_filters(
        helpers.list_of_dashboard_filters, 66,
        helpers.list_of_dashboard_filters)
    update_dashboard_filter.assert_called()


@patch('dashboard_tools.update_dashboard_filter')
@patch('dashboard_tools.post_filter_to_client_instance')
def test_sync_dashboard_filters_list_post_update(
        post_filter_to_client_instance, update_dashboard_filter):
    """Assert both post and update are called."""
    dashboard_tools.sync_dashboard_filters(
        helpers.list_of_dashboard_filters, 66,
        [helpers.dashboard_filter, {'title': 'low'}])
    post_filter_to_client_instance.assert_called()
    update_dashboard_filter.assert_called()


@patch('dashboard_tools.requests')
def test_get_dashboard_element_json(requests, get_mock_element_json):
    """Return dict."""
    requests.get.return_value = get_mock_element_json
    result = dashboard_tools.get_dashboard_element_json(64)
    assert result == helpers.dashboard_element


def test_adjust_dashboard_element_json():
    """Return dict."""
    result = dashboard_tools.adjust_dashboard_element_json(
        helpers.dashboard_element, 77, 88, None)
    assert result == {
        'id': 64, 'query_id': 88, 'look_id': None,
        'dashboard_id': 77, 'title': 'sales'}


def test_check_element_in_dashboard_positive():
    """Return True."""
    result = dashboard_tools.check_element_in_dashboard(
        'sales', helpers.list_of_dashboard_elements)
    assert result is True


def test_check_element_in_dashboard_negative():
    """Return False."""
    result = dashboard_tools.check_element_in_dashboard(
        'not_there', helpers.list_of_dashboard_elements)
    assert result is False


@patch('dashboard_tools.requests')
def test_post_dashboard_element(requests, get_mock_element_json):
    """Return int."""
    requests.post.return_value = get_mock_element_json
    result = dashboard_tools.post_dashboard_element(get_mock_element_json)
    assert result == 64


@patch('dashboard_tools.requests')
def test_update_dashboard_element(requests, get_mock_element_json):
    """Return int."""
    requests.patch.return_value = get_mock_element_json
    result = dashboard_tools.update_dashboard_element(get_mock_element_json)
    assert result == 64


@patch('dashboard_tools.requests')
def test_get_main_dashboard_layout(requests, get_mock_layout_json):
    """Return dict."""
    requests.get.return_value = get_mock_layout_json
    result = dashboard_tools.get_main_dashboard_layout(96)
    assert result == helpers.dashboard_layout


@patch('dashboard_tools.requests')
def test_post_dashboard_layout(requests, get_mock_layout_json):
    """Return int."""
    requests.post.return_value = get_mock_layout_json
    result = dashboard_tools.post_dashboard_layout({})
    assert result == 96


@patch('dashboard_tools.requests')
def test_update_dashboard_layout(requests, get_mock_layout_json):
    """Return dict."""
    requests.patch.return_value = get_mock_layout_json
    result = dashboard_tools.update_dashboard_layout(
        96, helpers.dashboard_layout)
    assert result == helpers.dashboard_layout


@patch('dashboard_tools.requests')
def test_get_all_dashboard_layout_components(
        requests, get_mock_list_of_layout_components):
    """Return list."""
    requests.get.return_value = get_mock_list_of_layout_components
    result = dashboard_tools.get_all_dashboard_layout_components(96)
    assert result == helpers.list_of_layout_components


@patch('dashboard_tools.requests')
def test_update_layout_component(requests, get_mock_layout_component_json):
    """Return dict."""
    requests.patch.return_value = get_mock_layout_component_json
    result = dashboard_tools.update_layout_component({}, 420)
    assert result == helpers.dashboard_layout_component


@patch('dashboard_tools.requests')
def test_delete_dashboard_element_positive(requests):
    """Delete called."""
    requests.delete.return_value = True
    dashboard_tools.delete_dashboard_element(980)
    requests.delete.assert_called()