Coverage for tests/test_annotation.py: 100%
103 statements
« prev ^ index » next coverage.py v7.16.2, created at 2026-10-01 22:07 +0000
1import datetime
3import pytest
5from pepdbagent.exceptions import FilterError, ProjectNotFoundError
7from .utils import PEPDBAgentContextManager
10@pytest.mark.skipif(
11 not PEPDBAgentContextManager().db_setup(),
12 reason="DB is not setup",
13)
14class TestAnnotation:
15 """
16 Test function within annotation class
17 """
19 @pytest.mark.parametrize(
20 "namespace, name",
21 [
22 ["namespace1", "amendments1"],
23 ["namespace1", "amendments2"],
24 ["namespace2", "derive"],
25 ["namespace2", "imply"],
26 ["namespace3", "subtable1"],
27 ],
28 )
29 def test_annotation_of_one_project(self, namespace, name):
30 with PEPDBAgentContextManager(add_data=True) as agent:
31 result = agent.annotation.get(
32 namespace=namespace,
33 name=name,
34 tag="default",
35 )
36 assert result.results[0].namespace == namespace
38 @pytest.mark.parametrize(
39 "namespace, name",
40 [
41 ["namespace6", "amendments1"],
42 ],
43 )
44 def test_annotation_of_one_non_existing_project(self, namespace, name):
45 with PEPDBAgentContextManager(add_data=True) as agent:
46 with pytest.raises(ProjectNotFoundError):
47 agent.annotation.get(
48 namespace=namespace,
49 name=name,
50 tag="default",
51 )
53 @pytest.mark.parametrize(
54 "namespace, n_projects",
55 [
56 ["namespace1", 6],
57 ["namespace2", 8],
58 ["namespace3", 10],
59 ["private", 0],
60 ["private_test", 0],
61 ],
62 )
63 def test_annotation_all(self, namespace, n_projects):
64 with PEPDBAgentContextManager(add_data=True) as agent:
65 result = agent.annotation.get(
66 namespace=namespace,
67 )
68 assert result.count == n_projects
69 assert len(result.results) == n_projects
71 @pytest.mark.parametrize(
72 "namespace, n_projects",
73 [
74 ["namespace1", 6],
75 ["namespace2", 8],
76 ["namespace3", 10],
77 ["private", 0],
78 ["private_test", 6],
79 ],
80 )
81 @pytest.mark.parametrize("admin", ("private_test", ["private_test", "bbb"]))
82 def test_annotation_all_private(self, namespace, n_projects, admin):
83 with PEPDBAgentContextManager(add_data=True) as agent:
84 result = agent.annotation.get(namespace=namespace, admin=admin)
85 assert result.count == n_projects
86 assert len(result.results) == n_projects
88 @pytest.mark.parametrize(
89 "namespace, limit, n_projects",
90 [
91 ["namespace1", 3, 6],
92 ["namespace2", 2, 8],
93 ["namespace3", 8, 10],
94 ["private", 0, 0],
95 ["private_test", 5, 6],
96 ],
97 )
98 @pytest.mark.parametrize("admin", ("private_test", ["private_test", "bbb"]))
99 def test_annotation_limit(self, namespace, limit, admin, n_projects):
100 with PEPDBAgentContextManager(add_data=True) as agent:
101 result = agent.annotation.get(namespace=namespace, admin=admin, limit=limit)
102 assert result.count == n_projects
103 assert len(result.results) == limit
105 @pytest.mark.parametrize(
106 "namespace, order_by, first_name",
107 [
108 ["namespace1", "name", "amendments1"],
109 ["namespace2", "name", "biocproject_exceptions"],
110 ["namespace3", "name", "node_alias"],
111 ["private_test", "name", "amendments1"],
112 ],
113 )
114 @pytest.mark.parametrize("admin", ["private_test"])
115 def test_order_by(self, namespace, admin, order_by, first_name):
116 with PEPDBAgentContextManager(add_data=True) as agent:
117 result = agent.annotation.get(
118 namespace=namespace, admin=admin, order_by=order_by
119 )
120 assert result.results[0].name == first_name
122 @pytest.mark.parametrize(
123 "namespace, order_by, last_name",
124 [
125 ["namespace1", "name", "biocproject"],
126 ["namespace2", "name", "imports"],
127 ["namespace3", "name", "subtables"],
128 ["private_test", "name", "subtable3"],
129 ],
130 )
131 @pytest.mark.parametrize("admin", ["private_test"])
132 def test_order_by_desc(self, namespace, admin, order_by, last_name):
133 with PEPDBAgentContextManager(add_data=True) as agent:
134 result = agent.annotation.get(
135 namespace=namespace,
136 admin=admin,
137 order_by=order_by,
138 order_desc=True,
139 )
140 assert result.results[0].name == last_name
142 @pytest.mark.parametrize(
143 "namespace, query, found_number",
144 [
145 ["namespace1", "ame", 2],
146 ["namespace2", "proj", 2],
147 ["namespace3", "ABLE", 6],
148 ["private_test", "a", 0],
149 [None, "re", 2],
150 ],
151 )
152 def test_name_search(self, namespace, query, found_number):
153 with PEPDBAgentContextManager(add_data=True) as agent:
154 result = agent.annotation.get(namespace=namespace, query=query)
155 assert len(result.results) == found_number
157 @pytest.mark.parametrize(
158 "namespace, query, found_number",
159 [
160 ["namespace1", "ame", 2],
161 ["namespace2", "proj", 2],
162 ["namespace3", "ABLE", 6],
163 ["private_test", "b", 2],
164 [None, "re", 3],
165 ],
166 )
167 def test_name_search_private(self, namespace, query, found_number):
168 with PEPDBAgentContextManager(add_data=True) as agent:
169 result = agent.annotation.get(
170 namespace=namespace, query=query, admin="private_test"
171 )
172 assert len(result.results) == found_number
174 @pytest.mark.parametrize(
175 "namespace, name",
176 [
177 ["namespace1", "amendments1"],
178 ["namespace1", "amendments2"],
179 ["namespace2", "derive"],
180 ["namespace2", "imply"],
181 ["namespace3", "subtable1"],
182 ],
183 )
184 def test_all_annotations_are_returned(self, namespace, name):
185 with PEPDBAgentContextManager(add_data=True) as agent:
186 result = agent.annotation.get(
187 namespace=namespace,
188 name=name,
189 tag="default",
190 )
191 assert result.results[0].model_fields_set == {
192 "is_private",
193 "tag",
194 "namespace",
195 "digest",
196 "description",
197 "number_of_samples",
198 "name",
199 "last_update_date",
200 "submission_date",
201 "pep_schema",
202 "pop",
203 "stars_number",
204 "forked_from",
205 }
207 @pytest.mark.parametrize(
208 "namespace, query, found_number",
209 [
210 ["namespace1", "ame", 2],
211 [None, "re", 3],
212 ],
213 )
214 def test_search_filter_success(self, namespace, query, found_number):
215 with PEPDBAgentContextManager(add_data=True) as agent:
216 date_now = datetime.datetime.now() + datetime.timedelta(days=1)
217 date_old = datetime.datetime.now() - datetime.timedelta(days=5)
218 result = agent.annotation.get(
219 namespace=namespace,
220 query=query,
221 admin="private_test",
222 filter_by="submission_date",
223 filter_start_date=date_old.strftime("%Y/%m/%d"),
224 filter_end_date=date_now.strftime("%Y/%m/%d"),
225 )
226 assert len(result.results) == found_number
228 @pytest.mark.parametrize(
229 "namespace, query, found_number",
230 [
231 ["namespace1", "ame", 0],
232 [None, "re", 0],
233 ],
234 )
235 def test_search_filter_zero_prj(self, namespace, query, found_number):
236 with PEPDBAgentContextManager(add_data=True) as agent:
237 date_now = datetime.datetime.now() - datetime.timedelta(days=2)
238 date_old = date_now - datetime.timedelta(days=2)
239 result = agent.annotation.get(
240 namespace=namespace,
241 query=query,
242 admin="private_test",
243 filter_by="submission_date",
244 filter_start_date=date_old.strftime("%Y/%m/%d"),
245 filter_end_date=date_now.strftime("%Y/%m/%d"),
246 )
247 assert len(result.results) == found_number
249 @pytest.mark.parametrize(
250 "namespace, query, found_number",
251 [
252 ["namespace1", "ame", 2],
253 ],
254 )
255 def test_search_incorrect_filter_by_string(self, namespace, query, found_number):
256 with PEPDBAgentContextManager(add_data=True) as agent:
257 date_now = datetime.datetime.now() - datetime.timedelta(days=2)
258 date_old = date_now - datetime.timedelta(days=2)
259 with pytest.raises(FilterError):
260 agent.annotation.get(
261 namespace=namespace,
262 query=query,
263 admin="private_test",
264 filter_by="incorrect",
265 filter_start_date=date_old.strftime("%Y/%m/%d"),
266 filter_end_date=date_now.strftime("%Y/%m/%d"),
267 )
269 @pytest.mark.parametrize(
270 "rp_list, admin, found_number",
271 [
272 [
273 [
274 "namespace1/amendments1:default",
275 "namespace1/amendments2:default",
276 "namespace2/derive:default",
277 "private_test/amendments1:default",
278 ],
279 "namespace1",
280 4,
281 ],
282 [
283 [
284 "namespace1/amendments1:default",
285 "namespace1/amendments2:default",
286 "namespace2/derive:default",
287 "private_test/amendments1:default",
288 ],
289 "private_test",
290 4,
291 ],
292 ],
293 )
294 def test_get_annotation_by_rp_list(self, rp_list, admin, found_number):
295 with PEPDBAgentContextManager(add_data=True) as agent:
296 result = agent.annotation.get_by_rp_list(rp_list)
297 assert len(result.results) == found_number
299 def test_get_annotation_by_rp_enpty_list(self):
300 with PEPDBAgentContextManager(add_data=True) as agent:
301 result = agent.annotation.get_by_rp_list([])
302 assert len(result.results) == 0
304 @pytest.mark.parametrize(
305 "namespace, query, found_number",
306 [
307 ["namespace1", "ame", 2],
308 ],
309 )
310 def test_search_incorrect_incorrect_pep_type(self, namespace, query, found_number):
311 with PEPDBAgentContextManager(add_data=True) as agent:
312 with pytest.raises(ValueError):
313 agent.annotation.get(namespace=namespace, pep_type="incorrect")
315 @pytest.mark.parametrize(
316 "namespace, query, found_number",
317 [
318 ["namespace1", "ame", 2],
319 ],
320 )
321 def test_project_list_without_annotation(self, namespace, query, found_number):
322 with PEPDBAgentContextManager(add_data=True) as agent:
323 result = agent.annotation.get_projects_list(
324 namespace=namespace,
325 search_str=query,
326 )
327 assert len(result) == found_number