Coverage for tests/test_schemas.py: 100%
66 statements
« prev ^ index » next coverage.py v7.15.3, created at 2026-08-04 18:15 +0000
« prev ^ index » next coverage.py v7.15.3, created at 2026-08-04 18:15 +0000
1from pephubclient import PEPHubClient
2from pephubclient.constants import CachedToken
3from unittest.mock import Mock
5example_schema = {
6 "a": "b",
7 "c": 1,
8}
9versions_example = {
10 "pagination": {"page": 0, "page_size": 100, "total": 1},
11 "results": [
12 {
13 "namespace": "databio",
14 "schema_name": "test_test",
15 "version": "bbb",
16 "contributors": None,
17 "release_notes": None,
18 "tags": {},
19 "release_date": "2025-04-02T18:27:22.829003Z",
20 "last_update_date": "2025-04-02T18:27:22.829009Z",
21 }
22 ],
23}
26# @pytest.mark.skip("Tests are not implemented yet")
27class TestSchemas:
28 def test_get_schema(self, mocker, test_jwt):
29 jwt_mock = mocker.patch(
30 "pephubclient.files_manager.FilesManager.load_token_data",
31 return_value=CachedToken(token=test_jwt),
32 )
33 requests_mock = mocker.patch(
34 "requests.request",
35 return_value=Mock(content="some return", status_code=200),
36 )
37 mocker.patch(
38 "pephubclient.helpers.RequestManager.decode_response",
39 return_value=example_schema,
40 )
42 phc = PEPHubClient()
43 schema_value = phc.schema.get(namespace="databio", schema_name="pep")
45 assert jwt_mock.called
46 assert requests_mock.called
47 assert schema_value == example_schema
49 def test_get_schema_versions(self, mocker, test_jwt):
50 jwt_mock = mocker.patch(
51 "pephubclient.files_manager.FilesManager.load_token_data",
52 return_value=CachedToken(token=test_jwt),
53 )
54 requests_mock = mocker.patch(
55 "requests.request",
56 return_value=Mock(content="some return", status_code=200),
57 )
58 mocker.patch(
59 "pephubclient.helpers.RequestManager.decode_response",
60 return_value=versions_example,
61 )
63 phc = PEPHubClient()
65 schema_versions = phc.schema.get_versions(
66 namespace="databio", schema_name="test_test"
67 )
69 assert jwt_mock.called
70 assert requests_mock.called
71 assert schema_versions
73 def test_create_schema(self, mocker, test_jwt):
74 jwt_mock = mocker.patch(
75 "pephubclient.files_manager.FilesManager.load_token_data",
76 return_value=CachedToken(token=test_jwt),
77 )
78 requests_mock = mocker.patch(
79 "requests.request",
80 return_value=Mock(content="some return", status_code=202),
81 )
83 phc = PEPHubClient()
85 phc.schema.create_schema(
86 namespace="tessttt",
87 schema_name="test_test1",
88 version="bbb",
89 schema_value={"b2": "v"},
90 contributors="Na",
91 )
93 assert jwt_mock.called
94 assert requests_mock.called
96 def test_update_schema(self, mocker, test_jwt):
97 jwt_mock = mocker.patch(
98 "pephubclient.files_manager.FilesManager.load_token_data",
99 return_value=CachedToken(token=test_jwt),
100 )
101 requests_mock = mocker.patch(
102 "requests.request",
103 return_value=Mock(content="some return", status_code=202),
104 )
106 phc = PEPHubClient()
108 phc.schema.update_record(
109 namespace="test_test",
110 schema_name="test_test",
111 update_fields={
112 "maintainers": "new_maintainer",
113 "private": True,
114 "lifecycle_stage": "development",
115 },
116 )
118 assert jwt_mock.called
119 assert requests_mock.called
121 def test_delete_schema(self, mocker, test_jwt):
122 jwt_mock = mocker.patch(
123 "pephubclient.files_manager.FilesManager.load_token_data",
124 return_value=CachedToken(token=test_jwt),
125 )
126 requests_mock = mocker.patch(
127 "requests.request",
128 return_value=Mock(content="some return", status_code=202),
129 )
131 phc = PEPHubClient()
133 phc.schema.delete_schema(
134 namespace="test_test",
135 schema_name="testttt",
136 )
138 assert jwt_mock.called
139 assert requests_mock.called
141 def test_add_version(self, mocker, test_jwt):
142 jwt_mock = mocker.patch(
143 "pephubclient.files_manager.FilesManager.load_token_data",
144 return_value=CachedToken(token=test_jwt),
145 )
146 requests_mock = mocker.patch(
147 "requests.request",
148 return_value=Mock(content="some return", status_code=202),
149 )
151 phc = PEPHubClient()
153 phc.schema.add_version(
154 namespace="test_test",
155 schema_name="test2",
156 version="1.2.5",
157 schema_value={"b": "v2"},
158 contributors="Na",
159 )
161 assert jwt_mock.called
162 assert requests_mock.called
164 def test_update_version(self, mocker, test_jwt):
165 jwt_mock = mocker.patch(
166 "pephubclient.files_manager.FilesManager.load_token_data",
167 return_value=CachedToken(token=test_jwt),
168 )
169 requests_mock = mocker.patch(
170 "requests.request",
171 return_value=Mock(content="some return", status_code=202),
172 )
174 phc = PEPHubClient()
176 phc.schema.update_version(
177 namespace="test_test",
178 schema_name="test2",
179 version="1.2.4",
180 update_fields={
181 "contributors": "new cont",
182 "release_notes": "note new",
183 },
184 )
186 assert jwt_mock.called
187 assert requests_mock.called
189 def test_delete_version(self, mocker, test_jwt):
190 jwt_mock = mocker.patch(
191 "pephubclient.files_manager.FilesManager.load_token_data",
192 return_value=CachedToken(token=test_jwt),
193 )
194 requests_mock = mocker.patch(
195 "requests.request",
196 return_value=Mock(content="some return", status_code=202),
197 )
199 phc = PEPHubClient()
201 phc.schema.delete_version(
202 namespace="test2",
203 schema_name="test_test",
204 version="1.2.5",
205 )
207 assert jwt_mock.called
208 assert requests_mock.called