Coverage for tests/endpoints/publisher/tests_settings.py: 100%

1from unittest.mock import patch, Mock 

2from tests.endpoints.endpoint_testing import TestEndpoints 

3 

4 

5class TestGetSettingsData(TestEndpoints): 

6 @patch("webapp.helpers.launchpad.get_snap_by_store_name") 

7 @patch("canonicalwebteam.store_api.dashboard.Dashboard.get_snap_info") 

8 def test_get_settings_data_success( 

9 self, mock_get_snap_info, mock_get_snap_by_store_name 

10 ): 

11 # Mock the snap details returned by the dashboard 

12 mock_snap_details = { 

13 "snap_name": "test-snap", 

14 "title": "Test Snap", 

15 "snap_id": "test-snap-id-123", 

16 "publisher": {"display-name": "Test Publisher"}, 

17 "license": "MIT", 

18 "private": False, 

19 "unlisted": False, 

20 "store": "ubuntu", 

21 "keywords": ["test", "snap"], 

22 "status": "Published", 

23 "update_metadata_on_release": True, 

24 "visibility_locked": False, 

25 "whitelist_country_codes": ["US", "GB"], 

26 "blacklist_country_codes": ["XX"], 

27 } 

28 mock_get_snap_info.return_value = mock_snap_details 

29 

30 # Mock launchpad response 

31 mock_lp_snap = Mock() 

32 mock_get_snap_by_store_name.return_value = mock_lp_snap 

33 

34 # Make the request 

35 response = self.client.get("/api/test-snap/settings") 

36 data = response.json 

37 

38 # Assert response structure 

39 self.assertEqual(response.status_code, 200) 

40 self.assertTrue(data["success"]) 

41 self.assertIn("data", data) 

42 

43 # Assert data content 

44 response_data = data["data"] 

45 self.assertEqual(response_data["snap_name"], "test-snap") 

46 self.assertEqual(response_data["snap_title"], "Test Snap") 

47 self.assertEqual(response_data["snap_id"], "test-snap-id-123") 

48 self.assertEqual(response_data["publisher_name"], "Test Publisher") 

49 self.assertEqual(response_data["license"], "MIT") 

50 self.assertFalse(response_data["private"]) 

51 self.assertFalse(response_data["unlisted"]) 

52 self.assertEqual(response_data["store"], "ubuntu") 

53 self.assertEqual(response_data["keywords"], ["test", "snap"]) 

54 self.assertEqual(response_data["status"], "Published") 

55 self.assertTrue(response_data["update_metadata_on_release"]) 

56 self.assertFalse(response_data["visibility_locked"]) 

57 self.assertTrue(response_data["is_on_lp"]) 

58 

59 # Assert country codes 

60 self.assertEqual(response_data["whitelist_countries"], ["US", "GB"]) 

61 self.assertEqual(response_data["blacklist_countries"], ["XX"]) 

62 

63 # Assert countries list is populated 

64 self.assertIn("countries", response_data) 

65 self.assertIsInstance(response_data["countries"], list) 

66 self.assertTrue(len(response_data["countries"]) > 0) 

67 

68 # Check that each country has the expected structure 

69 country = response_data["countries"][0] 

70 self.assertIn("key", country) 

71 self.assertIn("name", country) 

72 

73 @patch("webapp.helpers.launchpad.get_snap_by_store_name") 

74 @patch("canonicalwebteam.store_api.dashboard.Dashboard.get_snap_info") 

75 def test_get_settings_data_no_country_codes( 

76 self, mock_get_snap_info, mock_get_snap_by_store_name 

77 ): 

78 # Mock snap details without country codes 

79 mock_snap_details = { 

80 "snap_name": "test-snap", 

81 "title": "Test Snap", 

82 "snap_id": "test-snap-id-123", 

83 "publisher": {"display-name": "Test Publisher"}, 

84 "license": "MIT", 

85 "private": False, 

86 "unlisted": False, 

87 "store": "ubuntu", 

88 "keywords": ["test", "snap"], 

89 "status": "Published", 

90 "update_metadata_on_release": True, 

91 "visibility_locked": False, 

92 } 

93 mock_get_snap_info.return_value = mock_snap_details 

94 

95 # Mock launchpad response - no snap found 

96 mock_get_snap_by_store_name.return_value = None 

97 

98 # Make the request 

99 response = self.client.get("/api/test-snap/settings") 

100 data = response.json 

101 

102 # Assert response 

103 self.assertEqual(response.status_code, 200) 

104 self.assertTrue(data["success"]) 

105 

106 response_data = data["data"] 

107 self.assertEqual(response_data["whitelist_countries"], []) 

108 self.assertEqual(response_data["blacklist_countries"], []) 

109 self.assertFalse(response_data["is_on_lp"]) 

110 

111 @patch("webapp.helpers.launchpad.get_snap_by_store_name") 

112 @patch("canonicalwebteam.store_api.dashboard.Dashboard.get_snap_info") 

113 def test_get_settings_data_empty_country_codes( 

114 self, mock_get_snap_info, mock_get_snap_by_store_name 

115 ): 

116 # Mock snap details with empty country codes 

117 mock_snap_details = { 

118 "snap_name": "test-snap", 

119 "title": "Test Snap", 

120 "snap_id": "test-snap-id-123", 

121 "publisher": {"display-name": "Test Publisher"}, 

122 "license": "MIT", 

123 "private": False, 

124 "unlisted": False, 

125 "store": "ubuntu", 

126 "keywords": ["test", "snap"], 

127 "status": "Published", 

128 "update_metadata_on_release": True, 

129 "visibility_locked": False, 

130 "whitelist_country_codes": [], 

131 "blacklist_country_codes": [], 

132 } 

133 mock_get_snap_info.return_value = mock_snap_details 

134 

135 # Mock launchpad response 

136 mock_get_snap_by_store_name.return_value = None 

137 

138 # Make the request 

139 response = self.client.get("/api/test-snap/settings") 

140 data = response.json 

141 

142 # Assert response 

143 self.assertEqual(response.status_code, 200) 

144 self.assertTrue(data["success"]) 

145 

146 response_data = data["data"] 

147 self.assertEqual(response_data["whitelist_countries"], []) 

148 self.assertEqual(response_data["blacklist_countries"], []) 

149 

150 @patch("webapp.helpers.launchpad.get_snap_by_store_name") 

151 @patch("canonicalwebteam.store_api.dashboard.Dashboard.get_snap_info") 

152 def test_get_settings_data_visibility_locked_true( 

153 self, mock_get_snap_info, mock_get_snap_by_store_name 

154 ): 

155 # Mock snap details with visibility_locked as True 

156 mock_snap_details = { 

157 "snap_name": "test-snap", 

158 "title": "Test Snap", 

159 "snap_id": "test-snap-id-123", 

160 "publisher": {"display-name": "Test Publisher"}, 

161 "license": "MIT", 

162 "private": False, 

163 "unlisted": False, 

164 "store": "ubuntu", 

165 "keywords": ["test", "snap"], 

166 "status": "Published", 

167 "update_metadata_on_release": True, 

168 "visibility_locked": True, 

169 } 

170 mock_get_snap_info.return_value = mock_snap_details 

171 mock_get_snap_by_store_name.return_value = None 

172 

173 # Make the request 

174 response = self.client.get("/api/test-snap/settings") 

175 data = response.json 

176 

177 # Assert response 

178 self.assertEqual(response.status_code, 200) 

179 self.assertTrue(data["success"]) 

180 

181 response_data = data["data"] 

182 self.assertTrue(response_data["visibility_locked"]) 

183 

184 

185class TestPostSettingsData(TestEndpoints): 

186 @patch("webapp.publisher.snaps.logic.filter_changes_data") 

187 @patch("canonicalwebteam.store_api.dashboard.Dashboard.snap_metadata") 

188 def test_post_settings_data_success( 

189 self, mock_snap_metadata, mock_filter_changes 

190 ): 

191 # Mock the filtered data 

192 mock_filter_changes.return_value = {"title": "Updated Title"} 

193 

194 # Mock successful API response 

195 mock_response = {"success": True} 

196 mock_snap_metadata.return_value = mock_response 

197 

198 # Make the request with form data 

199 response = self.client.post( 

200 "/api/test-snap/settings", 

201 data={ 

202 "snap_id": "test-snap-id-123", 

203 "changes": '{"title": "Updated Title"}', 

204 }, 

205 ) 

206 

207 # Assert response 

208 self.assertEqual(response.status_code, 200) 

209 data = response.json 

210 self.assertEqual(data, mock_response)