Coverage for tests/test_param_redirect.py: 98%

1import unittest 

2from unittest.mock import MagicMock 

3import json 

4from datetime import datetime, timedelta 

5 

6from webapp.helpers import param_redirect_capture, param_redirect_exec 

7 

8 

9class MockCookies: 

10 def __init__(self, cookie={}): 

11 self.cookie = cookie 

12 

13 def set_cookie(self, name, data, expires, secure=False, httponly=True): 

14 self.cookie[name] = { 

15 "data": data, 

16 "expires": expires, 

17 "secure": secure, 

18 "httponly": httponly, 

19 } 

20 

21 def get(self, name): 

22 return self.cookie[name] 

23 

24 

25class MockRequest: 

26 def __init__(self, path, args, cookies: MockCookies): 

27 self.path = path 

28 self.args = args 

29 self.cookies = cookies if cookies else MockCookies() 

30 

31 

32class TestParamRedirect(unittest.TestCase): 

33 def setUp(self): 

34 self.cookies = MockCookies() 

35 

36 def test_param_redirect_capture_matches(self): 

37 """ 

38 Test param capture works when the signature is exactly the same 

39 """ 

40 req = MockRequest( 

41 path="/accept-invite", 

42 args={"package": "test", "token": "test"}, 

43 cookies=self.cookies, 

44 ) 

45 

46 resp = req.cookies 

47 

48 param_redirect_capture(req, resp) 

49 

50 self.assertEqual( 

51 self.cookies.get("param_redirect")["data"], 

52 json.dumps( 

53 { 

54 "endpoint": "/accept-invite", 

55 "params": {"package": "test", "token": "test"}, 

56 } 

57 ), 

58 ) 

59 

60 self.assertLess( 

61 self.cookies.get("param_redirect")["expires"], 

62 datetime.now() + timedelta(days=10), 

63 ) 

64 

65 def test_param_redirect_capture_matches_order(self): 

66 """ 

67 Test param capture works when args are in a different order 

68 """ 

69 req = MockRequest( 

70 path="/accept-invite", 

71 args={"token": "test", "package": "test"}, 

72 cookies=self.cookies, 

73 ) 

74 

75 resp = req.cookies 

76 

77 param_redirect_capture(req, resp) 

78 

79 self.assertEqual( 

80 self.cookies.get("param_redirect")["data"], 

81 json.dumps( 

82 { 

83 "endpoint": "/accept-invite", 

84 "params": {"package": "test", "token": "test"}, 

85 } 

86 ), 

87 ) 

88 

89 self.assertLess( 

90 self.cookies.get("param_redirect")["expires"], 

91 datetime.now() + timedelta(days=10), 

92 ) 

93 

94 def test_param_redirect_capture_matches_args(self): 

95 """ 

96 Test param capture works when there are more arguments defined 

97 """ 

98 req = MockRequest( 

99 path="/accept-invite", 

100 args={"package": "test", "token": "test", "test": "test"}, 

101 cookies=self.cookies, 

102 ) 

103 

104 resp = req.cookies 

105 

106 param_redirect_capture(req, resp) 

107 

108 self.assertEqual( 

109 self.cookies.get("param_redirect")["data"], 

110 json.dumps( 

111 { 

112 "endpoint": "/accept-invite", 

113 "params": {"package": "test", "token": "test"}, 

114 } 

115 ), 

116 ) 

117 

118 self.assertLess( 

119 self.cookies.get("param_redirect")["expires"], 

120 datetime.now() + timedelta(days=10), 

121 ) 

122 

123 def test_param_redirect_capture_does_not_match(self): 

124 """ 

125 Test param capture doesn't capture a signature that doesn't match 

126 """ 

127 req = MockRequest( 

128 path="/accept-invite/test", 

129 args={"package": "test", "token": "test"}, 

130 cookies=self.cookies, 

131 ) 

132 

133 resp = req.cookies 

134 

135 param_redirect_capture(req, resp) 

136 

137 self.assertNotIn("param_redirect", self.cookies.cookie) 

138 

139 def test_param_redirect_exec(self): 

140 """ 

141 Tests successfuly retrieval of cookie and redirect 

142 """ 

143 req = MockRequest( 

144 path="/accept-invite", 

145 args={"package": "test", "token": "test"}, 

146 cookies=MockCookies( 

147 { 

148 "param_redirect": json.dumps( 

149 { 

150 "endpoint": "/accept-invite", 

151 "params": {"package": "test", "token": "test"}, 

152 } 

153 ) 

154 } 

155 ), 

156 ) 

157 make_response = MagicMock() 

158 redirect = MagicMock() 

159 param_redirect_exec( 

160 req=req, make_response=make_response, redirect=redirect 

161 ) 

162 

163 redirect.assert_called_with("/accept-invite?package=test&token=test") 

164 

165 def test_param_redirect_exec_no_match_path(self): 

166 """ 

167 Tests successful continuation if the path doesn't match. 

168 """ 

169 req = MockRequest( 

170 path="/accept-invite/test", 

171 args={"package": "test", "token": "test"}, 

172 cookies=MockCookies( 

173 { 

174 "param_redirect": json.dumps( 

175 { 

176 "endpoint": "/accept-invite", 

177 "params": {"package": "test", "token": "test"}, 

178 } 

179 ) 

180 } 

181 ), 

182 ) 

183 make_response = MagicMock() 

184 redirect = MagicMock() 

185 resp = param_redirect_exec( 

186 req=req, make_response=make_response, redirect=redirect 

187 ) 

188 

189 self.assertIsNone(resp) 

190 

191 redirect.assert_not_called() 

192 

193 def test_param_redirect_exec_no_cookie(self): 

194 """ 

195 Tests successful continuation if there is no cookie. 

196 """ 

197 req = MockRequest( 

198 path="/accept-invite", 

199 args={"package": "test", "token": "test"}, 

200 cookies=MockCookies({"param_redirect": None}), 

201 ) 

202 make_response = MagicMock() 

203 redirect = MagicMock() 

204 resp = param_redirect_exec( 

205 req=req, make_response=make_response, redirect=redirect 

206 ) 

207 

208 self.assertIsNone(resp) 

209 

210 redirect.assert_not_called() 

211 

212 

213if __name__ == "__main__": 

214 unittest.main()