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) 

14from mock_data.mock_store_logic import ( 

15 sample_channel_map, 

16 converted_sample_channel_map, 

17 sample_libraries, 

18 sample_processed_libraries, 

19 sample_charm, 

20) 

21 

22 

23class TestConvertChannelMaps(TestCase): 

24 def test_convert_channel_map(self): 

25 result = convert_channel_maps(sample_channel_map) 

26 self.assertDictEqual(result, converted_sample_channel_map) 

27 

28 

29class TestAddStoreFront(TestCase): 

30 def test_add_store_front_data(self): 

31 result = add_store_front_data(sample_charm) 

32 

33 self.assertIn("store_front", result) 

34 

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

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

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

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

39 

40 

41class TestGetBannerUrl(TestCase): 

42 def test_banner_url_in_media(self): 

43 media = [ 

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

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

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

47 ] 

48 

49 result = get_banner_url(media) 

50 

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

52 

53 def test_banner_url_not_in_media(self): 

54 media = [ 

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

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

57 ] 

58 

59 result = get_banner_url(media) 

60 

61 self.assertIsNone(result) 

62 

63 def test_empty_media_list(self): 

64 media = [] 

65 

66 result = get_banner_url(media) 

67 

68 self.assertIsNone(result) 

69 

70 

71class TestExtractSeries(TestCase): 

72 def test_extract_series_short_name(self): 

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

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

75 self.assertListEqual(result, expected_result) 

76 

77 def test_extract_series_long_name(self): 

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

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

80 self.assertListEqual(result, expected_result) 

81 

82 def test_extract_series_duplicate_bases(self): 

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

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

85 self.assertListEqual(result, expected_result) 

86 

87 

88class TestExtractBases(TestCase): 

89 def test_extract_bases(self): 

90 result = extract_bases(sample_channel_map[0]) 

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

92 self.assertEqual(result, expected_result) 

93 

94 def test_extract_bases_empty_bases(self): 

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

96 result = extract_bases(channel) 

97 self.assertEqual(result, []) 

98 

99 def test_extract_bases_duplicate_bases(self): 

100 result = extract_bases(sample_channel_map[1]) 

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

102 self.assertEqual(result, expected_result) 

103 

104 

105class TestLibraries(TestCase): 

106 def test_process_libraries(self): 

107 self.assertListEqual( 

108 process_libraries(sample_libraries), sample_processed_libraries 

109 ) 

110 

111 def test_get_library(self): 

112 libraries = [ 

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

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

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

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

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

118 ] 

119 

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

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

122 

123 

124class TestFormatslug(TestCase): 

125 def test_format_slug(self): 

126 sample_slug1 = "sample-slug1" 

127 sample_slug2 = "sample_slug2" 

128 sample_slug3 = "sample And slug3" 

129 sample_slug4 = "sample Iot slug4" 

130 

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

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

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

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

135 

136 

137class TestProcessRevision(TestCase): 

138 def test_process_revision(self): 

139 revision = { 

140 "bases": [ 

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

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

143 ], 

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

145 "download": { 

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

147 "url": "some-random-url", 

148 "size": 1024, 

149 }, 

150 } 

151 

152 processed_revision = { 

153 "bases": [ 

154 { 

155 "architecture": "amd64", 

156 "channel": "12.04", 

157 "name": "ubuntu", 

158 }, 

159 { 

160 "architecture": "arm64", 

161 "channel": "12.04", 

162 "name": "ubuntu", 

163 }, 

164 { 

165 "architecture": "ppc64el", 

166 "channel": "12.04", 

167 "name": "ubuntu", 

168 }, 

169 { 

170 "architecture": "riscv64", 

171 "channel": "12.04", 

172 "name": "ubuntu", 

173 }, 

174 { 

175 "architecture": "s390x", 

176 "channel": "12.04", 

177 "name": "ubuntu", 

178 }, 

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

180 ], 

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

182 "download": { 

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

184 "url": "some-random-url", 

185 "size": 1024, 

186 }, 

187 } 

188 

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

190 

191 

192class TestAddOverlayData(TestCase): 

193 def test_add_overlay_data(self): 

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

195 result = add_overlay_data(package) 

196 self.assertEqual( 

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

198 ) 

199 

200 def test_overlay_data_not_needed(self): 

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

202 result = add_overlay_data(package) 

203 self.assertEqual(package, result)