summaryrefslogtreecommitdiff
path: root/tests/unit/base/test_rest_object.py
blob: 13a44c554ac2845f13bbcb63179f924c0c4695e7 (plain)
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
import pickle

import pytest

import gitlab
from gitlab import base
from tests.unit import helpers
from tests.unit.helpers import FakeManager  # noqa: F401, needed for _create_managers


def test_instantiate(gl, fake_manager):
    attrs = {"foo": "bar"}
    obj = helpers.FakeObject(fake_manager, attrs.copy())

    assert attrs == obj._attrs
    assert {} == obj._updated_attrs
    assert obj._create_managers() is None
    assert fake_manager == obj.manager
    assert gl == obj.manager.gitlab
    assert str(obj) == f"{type(obj)} => {attrs}"


def test_instantiate_non_dict(gl, fake_manager):
    with pytest.raises(gitlab.exceptions.GitlabParsingError):
        helpers.FakeObject(fake_manager, ["a", "list", "fails"])


def test_missing_attribute_does_not_raise_custom(gl, fake_manager):
    """Ensure a missing attribute does not raise our custom error message
    if the RESTObject was not created from a list"""
    obj = helpers.FakeObject(manager=fake_manager, attrs={"foo": "bar"})
    with pytest.raises(AttributeError) as excinfo:
        obj.missing_attribute
    exc_str = str(excinfo.value)
    assert "missing_attribute" in exc_str
    assert "was created via a list()" not in exc_str
    assert base._URL_ATTRIBUTE_ERROR not in exc_str


def test_missing_attribute_from_list_raises_custom(gl, fake_manager):
    """Ensure a missing attribute raises our custom error message if the
    RESTObject was created from a list"""
    obj = helpers.FakeObject(
        manager=fake_manager, attrs={"foo": "bar"}, created_from_list=True
    )
    with pytest.raises(AttributeError) as excinfo:
        obj.missing_attribute
    exc_str = str(excinfo.value)
    assert "missing_attribute" in exc_str
    assert "was created via a list()" in exc_str
    assert base._URL_ATTRIBUTE_ERROR in exc_str


def test_picklability(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"foo": "bar"})
    original_obj_module = obj._module
    pickled = pickle.dumps(obj)
    unpickled = pickle.loads(pickled)
    assert isinstance(unpickled, helpers.FakeObject)
    assert hasattr(unpickled, "_module")
    assert unpickled._module == original_obj_module
    pickle.dumps(unpickled)


def test_attrs(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"foo": "bar"})

    assert "bar" == obj.foo
    with pytest.raises(AttributeError):
        getattr(obj, "bar")

    obj.bar = "baz"
    assert "baz" == obj.bar
    assert {"foo": "bar"} == obj._attrs
    assert {"bar": "baz"} == obj._updated_attrs


def test_get_id(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"foo": "bar"})
    obj.id = 42
    assert 42 == obj.get_id()

    obj.id = None
    assert obj.get_id() is None


def test_encoded_id(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"foo": "bar"})
    obj.id = 42
    assert 42 == obj.encoded_id

    obj.id = None
    assert obj.encoded_id is None

    obj.id = "plain"
    assert "plain" == obj.encoded_id

    obj.id = "a/path"
    assert "a%2Fpath" == obj.encoded_id

    # If you assign it again it does not double URL-encode
    obj.id = obj.encoded_id
    assert "a%2Fpath" == obj.encoded_id


def test_custom_id_attr(fake_manager):
    obj = helpers.OtherFakeObject(fake_manager, {"foo": "bar"})
    assert "bar" == obj.get_id()


def test_update_attrs(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"foo": "bar"})
    obj.bar = "baz"
    obj._update_attrs({"foo": "foo", "bar": "bar"})
    assert {"foo": "foo", "bar": "bar"} == obj._attrs
    assert {} == obj._updated_attrs


def test_update_attrs_deleted(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"foo": "foo", "bar": "bar"})
    obj.bar = "baz"
    obj._update_attrs({"foo": "foo"})
    assert {"foo": "foo"} == obj._attrs
    assert {} == obj._updated_attrs


def test_dir_unique(fake_manager):
    obj = helpers.FakeObject(fake_manager, {"manager": "foo"})
    assert len(dir(obj)) == len(set(dir(obj)))


def test_create_managers(gl, fake_manager):
    class ObjectWithManager(helpers.FakeObject):
        fakes: "FakeManager"

    obj = ObjectWithManager(fake_manager, {"foo": "bar"})
    obj.id = 42
    assert isinstance(obj.fakes, helpers.FakeManager)
    assert obj.fakes.gitlab == gl
    assert obj.fakes._parent == obj


def test_equality(fake_manager):
    obj1 = helpers.FakeObject(fake_manager, {"id": "foo"})
    obj2 = helpers.FakeObject(fake_manager, {"id": "foo", "other_attr": "bar"})
    assert obj1 == obj2
    assert len(set((obj1, obj2))) == 1


def test_equality_custom_id(fake_manager):
    obj1 = helpers.OtherFakeObject(fake_manager, {"foo": "bar"})
    obj2 = helpers.OtherFakeObject(fake_manager, {"foo": "bar", "other_attr": "baz"})
    assert obj1 == obj2


def test_equality_no_id(fake_manager):
    obj1 = helpers.FakeObject(fake_manager, {"attr1": "foo"})
    obj2 = helpers.FakeObject(fake_manager, {"attr1": "bar"})
    assert not obj1 == obj2


def test_inequality(fake_manager):
    obj1 = helpers.FakeObject(fake_manager, {"id": "foo"})
    obj2 = helpers.FakeObject(fake_manager, {"id": "bar"})
    assert obj1 != obj2


def test_inequality_no_id(fake_manager):
    obj1 = helpers.FakeObject(fake_manager, {"attr1": "foo"})
    obj2 = helpers.FakeObject(fake_manager, {"attr1": "bar"})
    assert obj1 != obj2
    assert len(set((obj1, obj2))) == 2


def test_equality_with_other_objects(fake_manager):
    obj1 = helpers.FakeObject(fake_manager, {"id": "foo"})
    obj2 = None
    assert not obj1 == obj2


def test_dunder_str(fake_manager):
    fake_object = helpers.FakeObject(fake_manager, {"attr1": "foo"})
    assert str(fake_object) == (
        "<class 'tests.unit.helpers.FakeObject'> => {'attr1': 'foo'}"
    )


@pytest.mark.parametrize(
    "id_attr,repr_attr, attrs, expected_repr",
    [
        ("id", None, {"id": 1}, "<ReprObject id:1>"),
        (
            "id",
            "name",
            {"id": 1, "name": "fake"},
            "<ReprObject id:1 name:fake>",
        ),
        ("name", "name", {"name": "fake"}, "<ReprObject name:fake>"),
        ("id", "name", {"id": 1}, "<ReprObject id:1>"),
        (None, None, {}, "<ReprObject>"),
        (None, "name", {"name": "fake"}, "<ReprObject name:fake>"),
        (None, "name", {}, "<ReprObject>"),
    ],
    ids=[
        "GetMixin with id",
        "GetMixin with id and _repr_attr",
        "GetMixin with _repr_attr matching _id_attr",
        "GetMixin with _repr_attr without _repr_attr value defined",
        "GetWithoutIDMixin",
        "GetWithoutIDMixin with _repr_attr",
        "GetWithoutIDMixin with _repr_attr without _repr_attr value defined",
    ],
)
def test_dunder_repr(fake_manager, id_attr, repr_attr, attrs, expected_repr):
    class ReprObject(helpers.FakeObject):
        _id_attr = id_attr
        _repr_attr = repr_attr

    fake_object = ReprObject(fake_manager, attrs)

    assert repr(fake_object) == expected_repr


def test_pformat(fake_manager):
    fake_object = helpers.FakeObject(
        fake_manager, {"attr1": "foo" * 10, "ham": "eggs" * 15}
    )
    assert fake_object.pformat() == (
        "<class 'tests.unit.helpers.FakeObject'> => "
        "\n{'attr1': 'foofoofoofoofoofoofoofoofoofoo',\n"
        " 'ham': 'eggseggseggseggseggseggseggseggseggseggseggseggseggseggseggs'}"
    )


def test_pprint(capfd, fake_manager):
    fake_object = helpers.FakeObject(
        fake_manager, {"attr1": "foo" * 10, "ham": "eggs" * 15}
    )
    result = fake_object.pprint()
    assert result is None
    stdout, stderr = capfd.readouterr()
    assert stdout == (
        "<class 'tests.unit.helpers.FakeObject'> => "
        "\n{'attr1': 'foofoofoofoofoofoofoofoofoofoo',\n"
        " 'ham': 'eggseggseggseggseggseggseggseggseggseggseggseggseggseggseggs'}\n"
    )
    assert stderr == ""


def test_repr(fake_manager):
    attrs = {"attr1": "foo"}
    obj = helpers.FakeObject(fake_manager, attrs)
    assert repr(obj) == "<FakeObject id:None>"

    helpers.FakeObject._id_attr = None
    assert repr(obj) == "<FakeObject>"


def test_attributes_get(fake_object):
    assert fake_object.attr1 == "foo"
    result = fake_object.attributes
    assert result == {"attr1": "foo", "alist": [1, 2, 3]}


def test_attributes_shows_updates(fake_object):
    # Updated attribute value is reflected in `attributes`
    fake_object.attr1 = "hello"
    assert fake_object.attributes == {"attr1": "hello", "alist": [1, 2, 3]}
    assert fake_object.attr1 == "hello"
    # New attribute is in `attributes`
    fake_object.new_attrib = "spam"
    assert fake_object.attributes == {
        "attr1": "hello",
        "new_attrib": "spam",
        "alist": [1, 2, 3],
    }


def test_attributes_is_copy(fake_object):
    # Modifying the dictionary does not cause modifications to the object
    result = fake_object.attributes
    result["alist"].append(10)
    assert result == {"attr1": "foo", "alist": [1, 2, 3, 10]}
    assert fake_object.attributes == {"attr1": "foo", "alist": [1, 2, 3]}


def test_attributes_has_parent_attrs(fake_object_with_parent):
    assert fake_object_with_parent.attr1 == "foo"
    result = fake_object_with_parent.attributes
    assert result == {"attr1": "foo", "alist": [1, 2, 3], "test_id": "42"}


def test_asdict(fake_object):
    assert fake_object.attr1 == "foo"
    result = fake_object.asdict()
    assert result == {"attr1": "foo", "alist": [1, 2, 3]}


def test_asdict_no_parent_attrs(fake_object_with_parent):
    assert fake_object_with_parent.attr1 == "foo"
    result = fake_object_with_parent.asdict()
    assert result == {"attr1": "foo", "alist": [1, 2, 3]}
    assert "test_id" not in fake_object_with_parent.asdict()
    assert "test_id" not in fake_object_with_parent.asdict(with_parent_attrs=False)
    assert "test_id" in fake_object_with_parent.asdict(with_parent_attrs=True)


def test_asdict_modify_dict_does_not_change_object(fake_object):
    result = fake_object.asdict()
    # Demonstrate modifying the dictionary does not modify the object
    result["attr1"] = "testing"
    result["alist"].append(4)
    assert result == {"attr1": "testing", "alist": [1, 2, 3, 4]}
    assert fake_object.attr1 == "foo"
    assert fake_object.alist == [1, 2, 3]


def test_asdict_modify_dict_does_not_change_object2(fake_object):
    # Modify attribute and then ensure modifying a list in the returned dict won't
    # modify the list in the object.
    fake_object.attr1 = [9, 7, 8]
    assert fake_object.asdict() == {
        "attr1": [9, 7, 8],
        "alist": [1, 2, 3],
    }
    result = fake_object.asdict()
    result["attr1"].append(1)
    assert fake_object.asdict() == {
        "attr1": [9, 7, 8],
        "alist": [1, 2, 3],
    }


def test_asdict_modify_object(fake_object):
    # asdict() returns the updated value
    fake_object.attr1 = "spam"
    assert fake_object.asdict() == {"attr1": "spam", "alist": [1, 2, 3]}