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

1from pephubclient import PEPHubClient 

2from pephubclient.constants import CachedToken 

3from unittest.mock import Mock 

4 

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} 

24 

25 

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 ) 

41 

42 phc = PEPHubClient() 

43 schema_value = phc.schema.get(namespace="databio", schema_name="pep") 

44 

45 assert jwt_mock.called 

46 assert requests_mock.called 

47 assert schema_value == example_schema 

48 

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 ) 

62 

63 phc = PEPHubClient() 

64 

65 schema_versions = phc.schema.get_versions( 

66 namespace="databio", schema_name="test_test" 

67 ) 

68 

69 assert jwt_mock.called 

70 assert requests_mock.called 

71 assert schema_versions 

72 

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 ) 

82 

83 phc = PEPHubClient() 

84 

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 ) 

92 

93 assert jwt_mock.called 

94 assert requests_mock.called 

95 

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 ) 

105 

106 phc = PEPHubClient() 

107 

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 ) 

117 

118 assert jwt_mock.called 

119 assert requests_mock.called 

120 

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 ) 

130 

131 phc = PEPHubClient() 

132 

133 phc.schema.delete_schema( 

134 namespace="test_test", 

135 schema_name="testttt", 

136 ) 

137 

138 assert jwt_mock.called 

139 assert requests_mock.called 

140 

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 ) 

150 

151 phc = PEPHubClient() 

152 

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 ) 

160 

161 assert jwt_mock.called 

162 assert requests_mock.called 

163 

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 ) 

173 

174 phc = PEPHubClient() 

175 

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 ) 

185 

186 assert jwt_mock.called 

187 assert requests_mock.called 

188 

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 ) 

198 

199 phc = PEPHubClient() 

200 

201 phc.schema.delete_version( 

202 namespace="test2", 

203 schema_name="test_test", 

204 version="1.2.5", 

205 ) 

206 

207 assert jwt_mock.called 

208 assert requests_mock.called