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

1from unittest.mock import patch 

2from canonicalwebteam.exceptions import StoreApiError 

3from tests.endpoints.endpoint_testing import TestEndpoints 

4 

5 

6class TestGetPubliciseData(TestEndpoints): 

7 @patch("webapp.endpoints.publisher.publicise.device_gateway") 

8 @patch("webapp.endpoints.publisher.publicise.dashboard") 

9 def test_get_publicise_data_success_with_trending( 

10 self, mock_dashboard, mock_device_gateway 

11 ): 

12 # Mock the snap details returned by the dashboard 

13 mock_snap_details = { 

14 "snap_name": "test-snap", 

15 "private": False, 

16 "channel_maps_list": [ 

17 { 

18 "channel": { 

19 "name": "stable", 

20 "track": "latest", 

21 "risk": "stable", 

22 } 

23 } 

24 ], 

25 } 

26 mock_dashboard.get_snap_info.return_value = mock_snap_details 

27 

28 # Mock device gateway response with trending 

29 mock_public_details = {"snap": {"trending": True}} 

30 mock_device_gateway.get_item_details.return_value = mock_public_details 

31 

32 # Make the request 

33 response = self.client.get("/api/test-snap/publicise") 

34 data = response.json 

35 

36 # Assert response structure 

37 self.assertEqual(response.status_code, 200) 

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

39 self.assertIn("data", data) 

40 

41 # Assert data content 

42 response_data = data["data"] 

43 self.assertTrue(response_data["is_released"]) 

44 self.assertTrue(response_data["trending"]) 

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

46 

47 # Verify mocks were called correctly 

48 mock_dashboard.get_snap_info.assert_called_once() 

49 mock_device_gateway.get_item_details.assert_called_once_with( 

50 "test-snap", api_version=2, fields=["trending", "private"] 

51 ) 

52 

53 @patch("webapp.endpoints.publisher.publicise.device_gateway") 

54 @patch("webapp.endpoints.publisher.publicise.dashboard") 

55 def test_get_publicise_data_success_without_trending( 

56 self, mock_dashboard, mock_device_gateway 

57 ): 

58 # Mock the snap details returned by the dashboard 

59 mock_snap_details = { 

60 "snap_name": "test-snap", 

61 "private": True, 

62 "channel_maps_list": [], # Empty list means not released 

63 } 

64 mock_dashboard.get_snap_info.return_value = mock_snap_details 

65 

66 # Mock device gateway to raise StoreApiError 

67 mock_device_gateway.get_item_details.side_effect = StoreApiError( 

68 "API Error", 500 

69 ) 

70 

71 # Make the request 

72 response = self.client.get("/api/test-snap/publicise") 

73 data = response.json 

74 

75 # Assert response structure 

76 self.assertEqual(response.status_code, 200) 

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

78 self.assertIn("data", data) 

79 

80 # Assert data content 

81 response_data = data["data"] 

82 # Empty channel_maps_list means not released 

83 self.assertFalse(response_data["is_released"]) 

84 self.assertFalse(response_data["trending"]) # Default when API fails 

85 self.assertTrue(response_data["private"]) 

86 

87 # Verify mocks were called correctly 

88 mock_dashboard.get_snap_info.assert_called_once() 

89 mock_device_gateway.get_item_details.assert_called_once_with( 

90 "test-snap", api_version=2, fields=["trending", "private"] 

91 ) 

92 

93 @patch("webapp.endpoints.publisher.publicise.device_gateway") 

94 @patch("webapp.endpoints.publisher.publicise.dashboard") 

95 def test_get_publicise_data_released_snap( 

96 self, mock_dashboard, mock_device_gateway 

97 ): 

98 # Mock the snap details with multiple channels 

99 mock_snap_details = { 

100 "snap_name": "test-snap", 

101 "private": False, 

102 "channel_maps_list": [ 

103 {"channel": {"name": "stable"}}, 

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

105 {"channel": {"name": "edge"}}, 

106 ], 

107 } 

108 mock_dashboard.get_snap_info.return_value = mock_snap_details 

109 

110 # Mock device gateway response 

111 mock_public_details = {"snap": {"trending": False}} 

112 mock_device_gateway.get_item_details.return_value = mock_public_details 

113 

114 # Make the request 

115 response = self.client.get("/api/test-snap/publicise") 

116 data = response.json 

117 

118 # Assert response 

119 self.assertEqual(response.status_code, 200) 

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

121 

122 response_data = data["data"] 

123 self.assertTrue(response_data["is_released"]) # Has channels 

124 self.assertFalse(response_data["trending"]) 

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

126 

127 @patch("webapp.endpoints.publisher.publicise.device_gateway") 

128 @patch("webapp.endpoints.publisher.publicise.dashboard") 

129 def test_get_publicise_data_private_snap( 

130 self, mock_dashboard, mock_device_gateway 

131 ): 

132 # Mock private snap details 

133 mock_snap_details = { 

134 "snap_name": "private-snap", 

135 "private": True, 

136 "channel_maps_list": [{"channel": {"name": "stable"}}], 

137 } 

138 mock_dashboard.get_snap_info.return_value = mock_snap_details 

139 

140 # Mock device gateway response 

141 mock_public_details = {"snap": {"trending": True}} 

142 mock_device_gateway.get_item_details.return_value = mock_public_details 

143 

144 # Make the request 

145 response = self.client.get("/api/private-snap/publicise") 

146 data = response.json 

147 

148 # Assert response 

149 self.assertEqual(response.status_code, 200) 

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

151 

152 response_data = data["data"] 

153 self.assertTrue(response_data["is_released"]) 

154 self.assertTrue(response_data["trending"]) 

155 self.assertTrue(response_data["private"])