Coverage for tests/store/test_store_logic.py: 100%

1from unittest import TestCase 

2from webapp.store.logic import ( 

3 convert_channel_maps, 

4 extract_series, 

5 extract_bases, 

6 format_slug, 

7 get_banner_url, 

8 get_library, 

9 process_libraries, 

10 add_store_front_data, 

11 process_revision, 

12 add_overlay_data, 

13 get_revisions, 

14) 

15from mock_data.mock_store_logic import ( 

16 sample_channel_map, 

17 converted_sample_channel_map, 

18 sample_libraries, 

19 sample_processed_libraries, 

20 sample_charm, 

21) 

22 

23 

24class TestConvertChannelMaps(TestCase): 

25 def test_convert_channel_map(self): 

26 result = convert_channel_maps(sample_channel_map) 

27 self.assertDictEqual(result, converted_sample_channel_map) 

28 

29 

30class TestAddStoreFront(TestCase): 

31 def test_add_store_front_data(self): 

32 result = add_store_front_data(sample_charm) 

33 

34 self.assertIn("store_front", result) 

35 

36 self.assertIn("icons", result["store_front"]) 

37 self.assertIn("deployable-on", result["store_front"]) 

38 self.assertIn("categories", result["store_front"]) 

39 self.assertIn("display-name", result["store_front"]) 

40 

41 

42class TestGetBannerUrl(TestCase): 

43 def test_banner_url_in_media(self): 

44 media = [ 

45 {"type": "image", "url": "https://example.com/image1.jpg"}, 

46 {"type": "banner", "url": "https://example.com/banner.jpg"}, 

47 {"type": "video", "url": "https://example.com/video.mp4"}, 

48 ] 

49 

50 result = get_banner_url(media) 

51 

52 self.assertEqual(result, "https://example.com/banner.jpg") 

53 

54 def test_banner_url_not_in_media(self): 

55 media = [ 

56 {"type": "image", "url": "https://example.com/image1.jpg"}, 

57 {"type": "video", "url": "https://example.com/video.mp4"}, 

58 ] 

59 

60 result = get_banner_url(media) 

61 

62 self.assertIsNone(result) 

63 

64 def test_empty_media_list(self): 

65 media = [] 

66 

67 result = get_banner_url(media) 

68 

69 self.assertIsNone(result) 

70 

71 

72class TestExtractSeries(TestCase): 

73 def test_extract_series_short_name(self): 

74 result = extract_series(sample_channel_map[0], long_name=False) 

75 expected_result = ["14.04", "12.04"] 

76 self.assertListEqual(result, expected_result) 

77 

78 def test_extract_series_long_name(self): 

79 result = extract_series(sample_channel_map[1], long_name=True) 

80 expected_result = ["Ubuntu 20.04", "Ubuntu 18.04"] 

81 self.assertListEqual(result, expected_result) 

82 

83 def test_extract_series_duplicate_bases(self): 

84 result = extract_series(sample_channel_map[1], long_name=False) 

85 expected_result = ["20.04", "18.04"] 

86 self.assertListEqual(result, expected_result) 

87 

88 

89class TestExtractBases(TestCase): 

90 def test_extract_bases(self): 

91 result = extract_bases(sample_channel_map[0]) 

92 expected_result = [{"channels": ["14.04", "12.04"], "name": "ubuntu"}] 

93 self.assertEqual(result, expected_result) 

94 

95 def test_extract_bases_empty_bases(self): 

96 channel = {"revision": {"bases": []}} 

97 result = extract_bases(channel) 

98 self.assertEqual(result, []) 

99 

100 def test_extract_bases_duplicate_bases(self): 

101 result = extract_bases(sample_channel_map[1]) 

102 expected_result = [{"channels": ["20.04", "18.04"], "name": "ubuntu"}] 

103 self.assertEqual(result, expected_result) 

104 

105 

106class TestLibraries(TestCase): 

107 def test_process_libraries(self): 

108 self.assertListEqual( 

109 process_libraries(sample_libraries), sample_processed_libraries 

110 ) 

111 

112 def test_get_library(self): 

113 libraries = [ 

114 {"name": "library1", "id": "lb1"}, 

115 {"name": "library2", "id": "lb2"}, 

116 {"name": "library3", "id": "lb3"}, 

117 {"name": "library4", "id": "lb4"}, 

118 {"name": "library5", "id": "lb5"}, 

119 ] 

120 

121 self.assertEqual(get_library("library1", libraries), "lb1") 

122 self.assertIsNone(get_library("library6", libraries)) 

123 

124 

125class TestFormatslug(TestCase): 

126 def test_format_slug(self): 

127 sample_slug1 = "sample-slug1" 

128 sample_slug2 = "sample_slug2" 

129 sample_slug3 = "sample And slug3" 

130 sample_slug4 = "sample Iot slug4" 

131 

132 self.assertEqual(format_slug(sample_slug1), "Sample Slug1") 

133 self.assertEqual(format_slug(sample_slug2), "Sample Slug2") 

134 self.assertEqual(format_slug(sample_slug3), "Sample and Slug3") 

135 self.assertEqual(format_slug(sample_slug4), "Sample IoT Slug4") 

136 

137 

138class TestProcessRevision(TestCase): 

139 def test_process_revision(self): 

140 revision = { 

141 "bases": [ 

142 {"architecture": "all", "channel": "12.04", "name": "ubuntu"}, 

143 {"architecture": "xyz", "channel": "14.04", "name": "ubuntu"}, 

144 ], 

145 "created-at": "2024-06-7", 

146 "download": { 

147 "hash-sha-256": "qwerty", 

148 "url": "some-random-url", 

149 "size": 1024, 

150 }, 

151 } 

152 

153 processed_revision = { 

154 "bases": [ 

155 { 

156 "architecture": "amd64", 

157 "channel": "12.04", 

158 "name": "ubuntu", 

159 }, 

160 { 

161 "architecture": "arm64", 

162 "channel": "12.04", 

163 "name": "ubuntu", 

164 }, 

165 { 

166 "architecture": "ppc64el", 

167 "channel": "12.04", 

168 "name": "ubuntu", 

169 }, 

170 { 

171 "architecture": "riscv64", 

172 "channel": "12.04", 

173 "name": "ubuntu", 

174 }, 

175 { 

176 "architecture": "s390x", 

177 "channel": "12.04", 

178 "name": "ubuntu", 

179 }, 

180 {"architecture": "xyz", "channel": "14.04", "name": "ubuntu"}, 

181 ], 

182 "created-at": "2024-06-7", 

183 "download": { 

184 "hash-sha-256": "qwerty", 

185 "url": "some-random-url", 

186 "size": 1024, 

187 }, 

188 } 

189 

190 self.assertEqual(process_revision(revision), processed_revision) 

191 

192 

193class TestAddOverlayData(TestCase): 

194 def test_add_overlay_data(self): 

195 package = {"name": "postgresql-k8s", "other": "test data"} 

196 result = add_overlay_data(package) 

197 self.assertEqual( 

198 {"juju_cmd_extra_flags": "--trust"}, result["overlay_data"] 

199 ) 

200 

201 def test_overlay_data_not_needed(self): 

202 package = {"name": "no-data", "other": "test data"} 

203 result = add_overlay_data(package) 

204 self.assertEqual(package, result) 

205 

206 

207class TestGetRevisions(TestCase): 

208 def test_get_revisions_sorted_unique(self): 

209 """Test that get_revisions returns sorted unique revisions""" 

210 channel_maps = [ 

211 {"revision": {"revision": 5}, "channel": {"name": "stable"}}, 

212 {"revision": {"revision": 3}, "channel": {"name": "edge"}}, 

213 {"revision": {"revision": 8}, "channel": {"name": "candidate"}}, 

214 { 

215 "revision": {"revision": 3}, # Duplicate revision 

216 "channel": {"name": "beta"}, 

217 }, 

218 ] 

219 

220 result = get_revisions(channel_maps) 

221 expected = [8, 5, 3] # Sorted in descending order, unique 

222 

223 self.assertEqual(result, expected) 

224 

225 def test_get_revisions_single_revision(self): 

226 """Test with a single revision""" 

227 channel_maps = [ 

228 {"revision": {"revision": 42}, "channel": {"name": "stable"}} 

229 ] 

230 

231 result = get_revisions(channel_maps) 

232 expected = [42] 

233 

234 self.assertEqual(result, expected) 

235 

236 def test_get_revisions_empty_list(self): 

237 """Test with empty channel maps list""" 

238 channel_maps = [] 

239 

240 result = get_revisions(channel_maps) 

241 expected = [] 

242 

243 self.assertEqual(result, expected) 

244 

245 def test_get_revisions_all_same_revision(self): 

246 """Test with all channel maps having the same revision""" 

247 channel_maps = [ 

248 {"revision": {"revision": 7}, "channel": {"name": "stable"}}, 

249 {"revision": {"revision": 7}, "channel": {"name": "candidate"}}, 

250 {"revision": {"revision": 7}, "channel": {"name": "edge"}}, 

251 ] 

252 

253 result = get_revisions(channel_maps) 

254 expected = [7] # Only one unique revision 

255 

256 self.assertEqual(result, expected) 

257 

258 def test_get_revisions_with_sample_data(self): 

259 """Test with existing sample channel map data""" 

260 result = get_revisions(sample_channel_map) 

261 expected = [2, 1] # Based on sample_channel_map revisions 

262 

263 self.assertEqual(result, expected)