tracker/clients/python/tests/test_get_domains.py at flux-sync · LearningAzure2020/tracker · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
"""Tests for functions that get domain lists"""
import json

from gql import Client

# Avoid confusion with gql Client
import tracker_client.domains as tc
import tracker_client.queries as queries

# pylint: disable=no-member


def test_get_all_domains_error(mocker, error_message):
    """Test that get_all_domains correctly handles error response"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=error_message,
    )

    client = Client()
    result = tc.get_all_domains(client)

    assert result == json.dumps(
        error_message,
        indent=4,
    )


def test_get_all_domains(mocker, all_domains_input, all_domains_output):
    """Test that get_all_domains produces correct output"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=all_domains_input,
    )

    client = Client()
    result = tc.get_all_domains(client)

    tc.execute_query.assert_called_once_with(client, queries.ALL_DOMAINS_QUERY)
    assert result == json.dumps(all_domains_output, indent=4)


def test_get_domains_by_acronym_error(mocker, error_message):
    """Test that get_domains_by_acronym correctly handles error response"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=error_message,
    )

    client = Client()
    result = tc.get_domains_by_acronym(client, "foo")

    assert result == json.dumps(
        {
            "error": {
                "message": "No organization with the provided slug could be found."
            }
        },
        indent=4,
    )


def test_get_domains_by_acronym_key_error(mocker, all_domains_input):
    """Test that get_domains_by_acronym correctly handles the given acronym not being in the response"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=all_domains_input,
    )

    client = Client()
    result = tc.get_domains_by_acronym(client, "foo")

    tc.execute_query.assert_called_once_with(client, queries.ALL_DOMAINS_QUERY)
    assert result == json.dumps(
        {
            "error": {
                "message": "No organization with the provided acronym could be found."
            }
        },
        indent=4,
    )


def test_get_domains_by_acronym(mocker, all_domains_input, org_domains_output):
    """Test that get_domains_by_acronym produces correct output"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=all_domains_input,
    )

    client = Client()
    result = tc.get_domains_by_acronym(client, "def")

    tc.execute_query.assert_called_once_with(client, queries.ALL_DOMAINS_QUERY)
    assert result == json.dumps(org_domains_output, indent=4)


def test_get_domains_by_name_error(mocker, error_message):
    """Test that get_domains_by_name correctly handles error response"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=error_message,
    )

    client = Client()
    result = tc.get_domains_by_name(client, "foo bar")

    assert result == json.dumps(
        error_message,
        indent=4,
    )


def test_get_domains_by_name(mocker, name_domain_input, org_domains_output):
    """Test that get_domains_by_name produces correct output"""
    mocker.patch(
        "tracker_client.domains.execute_query",
        auto_spec=True,
        return_value=name_domain_input,
    )

    expected_params = {"orgSlug": "foo-bar"}
    client = Client()
    result = tc.get_domains_by_name(client, "foo bar")

    tc.execute_query.assert_called_once_with(
        client, queries.DOMAINS_BY_SLUG, expected_params
    )
    assert result == json.dumps(org_domains_output, indent=4)