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) 

13from mock_data.mock_store_logic import ( 

14 sample_channel_map, 

15 converted_sample_channel_map, 

16 sample_libraries, 

17 sample_processed_libraries, 

18 sample_charm, 

19) 

20 

21 

22class TestConvertChannelMaps(TestCase): 

23 def test_convert_channel_map(self): 

24 result = convert_channel_maps(sample_channel_map) 

25 self.assertDictEqual(result, converted_sample_channel_map) 

26 

27 

28class TestAddStoreFront(TestCase): 

29 def test_add_store_front_data(self): 

30 result = add_store_front_data(sample_charm) 

31 

32 self.assertIn("store_front", result) 

33 

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

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

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

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

38 

39 

40class TestGetBannerUrl(TestCase): 

41 def test_banner_url_in_media(self): 

42 media = [ 

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

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

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

46 ] 

47 

48 result = get_banner_url(media) 

49 

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

51 

52 def test_banner_url_not_in_media(self): 

53 media = [ 

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

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

56 ] 

57 

58 result = get_banner_url(media) 

59 

60 self.assertIsNone(result) 

61 

62 def test_empty_media_list(self): 

63 media = [] 

64 

65 result = get_banner_url(media) 

66 

67 self.assertIsNone(result) 

68 

69 

70class TestExtractSeries(TestCase): 

71 def test_extract_series_short_name(self): 

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

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

74 self.assertListEqual(result, expected_result) 

75 

76 def test_extract_series_long_name(self): 

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

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

79 self.assertListEqual(result, expected_result) 

80 

81 def test_extract_series_duplicate_bases(self): 

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

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

84 self.assertListEqual(result, expected_result) 

85 

86 

87class TestExtractBases(TestCase): 

88 def test_extract_bases(self): 

89 result = extract_bases(sample_channel_map[0]) 

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

91 self.assertEqual(result, expected_result) 

92 

93 def test_extract_bases_empty_bases(self): 

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

95 result = extract_bases(channel) 

96 self.assertEqual(result, []) 

97 

98 def test_extract_bases_duplicate_bases(self): 

99 result = extract_bases(sample_channel_map[1]) 

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

101 self.assertEqual(result, expected_result) 

102 

103 

104class TestLibraries(TestCase): 

105 def test_process_libraries(self): 

106 self.assertListEqual( 

107 process_libraries(sample_libraries), sample_processed_libraries 

108 ) 

109 

110 def test_get_library(self): 

111 libraries = [ 

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

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

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

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

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

117 ] 

118 

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

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

121 

122 

123class TestFormatslug(TestCase): 

124 def test_format_slug(self): 

125 sample_slug1 = "sample-slug1" 

126 sample_slug2 = "sample_slug2" 

127 sample_slug3 = "sample And slug3" 

128 sample_slug4 = "sample Iot slug4" 

129 

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

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

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

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

134 

135 

136class TestProcessRevision(TestCase): 

137 def test_process_revision(self): 

138 revision = { 

139 "bases": [ 

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

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

142 ], 

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

144 "download": { 

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

146 "url": "some-random-url", 

147 "size": 1024, 

148 }, 

149 } 

150 

151 processed_revision = { 

152 "bases": [ 

153 { 

154 "architecture": "amd64", 

155 "channel": "12.04", 

156 "name": "ubuntu", 

157 }, 

158 { 

159 "architecture": "arm64", 

160 "channel": "12.04", 

161 "name": "ubuntu", 

162 }, 

163 { 

164 "architecture": "ppc64el", 

165 "channel": "12.04", 

166 "name": "ubuntu", 

167 }, 

168 { 

169 "architecture": "riscv64", 

170 "channel": "12.04", 

171 "name": "ubuntu", 

172 }, 

173 { 

174 "architecture": "s390x", 

175 "channel": "12.04", 

176 "name": "ubuntu", 

177 }, 

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

179 ], 

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

181 "download": { 

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

183 "url": "some-random-url", 

184 "size": 1024, 

185 }, 

186 } 

187 

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