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
|
# SPDX-FileCopyrightText: 2022-2023 Greenbone AG
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
# pylint: disable=no-member, disallowed-name
import unittest
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta, timezone
from typing import Dict, List, Optional, Union
from pontos.models import Model, ModelAttribute, ModelError, dotted_attributes
class DottedAttributesTestCase(unittest.TestCase):
def test_with_new_class(self):
class Foo:
pass
foo = Foo()
attrs = {"bar": 123, "hello": "World", "baz": [1, 2, 3]}
foo = dotted_attributes(foo, attrs)
self.assertEqual(foo.bar, 123)
self.assertEqual(foo.baz, [1, 2, 3])
self.assertEqual(foo.hello, "World")
def test_with_github_model_attribute(self):
foo = ModelAttribute()
attrs = {"bar": 123, "hello": "World", "baz": [1, 2, 3]}
foo = dotted_attributes(foo, attrs)
self.assertEqual(foo.bar, 123)
self.assertEqual(foo.baz, [1, 2, 3])
self.assertEqual(foo.hello, "World")
class ModelTestCase(unittest.TestCase):
def test_from_dict(self):
model = Model.from_dict(
{
"x": 1,
"y": 2,
"hello": "World",
"baz": [1, 2, 3],
"bar": {"a": "b"},
}
)
self.assertEqual(model.x, 1)
self.assertEqual(model.y, 2)
self.assertEqual(model.hello, "World")
self.assertEqual(model.baz, [1, 2, 3])
self.assertEqual(model.bar.a, "b")
def test_from_dict_failure(self):
with self.assertRaisesRegex(
ValueError, "Invalid data for creating an instance of.*"
):
Model.from_dict("foo")
class ExampleModelTestCase(unittest.TestCase):
def test_optional(self):
@dataclass
class OtherModel(Model):
something: str
@dataclass
class ExampleModel(Model):
foo: str
bar: Optional[OtherModel] = None
model = ExampleModel.from_dict({"foo": "abc"})
self.assertIsNone(model.bar)
def test_list(self):
@dataclass
class ExampleModel(Model):
foo: List[str]
model = ExampleModel.from_dict({"foo": ["a", "b", "c"]})
self.assertEqual(model.foo, ["a", "b", "c"])
def test_list_with_default(self):
@dataclass
class ExampleModel(Model):
foo: List[str] = field(default_factory=list)
model = ExampleModel.from_dict({})
self.assertEqual(model.foo, [])
def test_datetime(self):
@dataclass
class ExampleModel(Model):
foo: datetime
model = ExampleModel.from_dict({"foo": "1988-10-01T04:00:00.000"})
self.assertEqual(
model.foo, datetime(1988, 10, 1, 4, tzinfo=timezone.utc)
)
model = ExampleModel.from_dict({"foo": "1988-10-01T04:00:00Z"})
self.assertEqual(
model.foo, datetime(1988, 10, 1, 4, tzinfo=timezone.utc)
)
model = ExampleModel.from_dict({"foo": "1988-10-01T04:00:00+00:00"})
self.assertEqual(
model.foo, datetime(1988, 10, 1, 4, tzinfo=timezone.utc)
)
model = ExampleModel.from_dict({"foo": "1988-10-01T04:00:00+01:00"})
self.assertEqual(
model.foo,
datetime(1988, 10, 1, 4, tzinfo=timezone(timedelta(hours=1))),
)
model = ExampleModel.from_dict({"foo": "2021-06-06T11:15:10.213"})
self.assertEqual(
model.foo,
datetime(2021, 6, 6, 11, 15, 10, 213000, tzinfo=timezone.utc),
)
def test_date(self):
@dataclass
class ExampleModel(Model):
foo: date
model = ExampleModel.from_dict({"foo": "1988-10-01"})
self.assertEqual(model.foo, date(1988, 10, 1))
def test_union(self):
@dataclass
class ExampleModel(Model):
foo: Union[str, int]
model = ExampleModel.from_dict({"foo": "123"})
self.assertEqual(model.foo, "123")
model = ExampleModel.from_dict({"foo": 123})
self.assertEqual(model.foo, 123)
def test_other_model(self):
@dataclass
class OtherModel(Model):
bar: str
@dataclass
class ExampleModel(Model):
foo: Optional[OtherModel] = None
model = ExampleModel.from_dict({"foo": {"bar": "baz"}})
self.assertEqual(model.foo.bar, "baz")
def test_all(self):
@dataclass
class OtherModel(Model):
something: str
@dataclass
class ExampleModel(Model):
foo: str
bar: datetime
id: Union[str, int]
baz: List[str] = field(default_factory=list)
ipsum: Optional[OtherModel] = None
model = ExampleModel.from_dict(
{
"foo": "abc",
"bar": "1988-10-01T04:00:00.000",
"id": 123,
"baz": ["a", "b", "c"],
"ipsum": {"something": "def"},
}
)
self.assertEqual(model.foo, "abc")
self.assertEqual(
model.bar, datetime(1988, 10, 1, 4, tzinfo=timezone.utc)
)
self.assertEqual(model.id, 123)
self.assertEqual(model.baz, ["a", "b", "c"])
self.assertIsNotNone(model.ipsum)
self.assertEqual(model.ipsum.something, "def")
def test_list_with_dict(self):
@dataclass
class ExampleModel(Model):
foo: List[Dict]
model = ExampleModel.from_dict({"foo": [{"a": 1}, {"b": 2}, {"c": 3}]})
self.assertEqual(model.foo, [{"a": 1}, {"b": 2}, {"c": 3}])
def test_model_error(self):
@dataclass
class ExampleModel(Model):
foo: Optional[str] = None
with self.assertRaisesRegex(
ModelError,
"Error while creating ExampleModel model. Could not set value for "
"property 'foo' from '{'bar': 'baz'}'.",
):
ExampleModel.from_dict({"foo": {"bar": "baz"}})
def test_model_error_2(self):
@dataclass
class OtherModel(Model):
something: str
@dataclass
class ExampleModel(Model):
foo: Optional[OtherModel]
with self.assertRaisesRegex(
ModelError,
"Error while creating ExampleModel model. Could not set value for "
"property 'foo' from 'abc'.",
):
ExampleModel.from_dict(
{
"foo": "abc",
}
)
|
