Coverage for cc_modules/tests/cc_view_classes_tests.py: 19%

93 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2022-11-08 23:14 +0000

1#!/usr/bin/env python 

2 

3""" 

4camcops_server/cc_modules/tests/cc_view_classes_tests.py 

5 

6=============================================================================== 

7 

8 Copyright (C) 2012, University of Cambridge, Department of Psychiatry. 

9 Created by Rudolf Cardinal (rnc1001@cam.ac.uk). 

10 

11 This file is part of CamCOPS. 

12 

13 CamCOPS is free software: you can redistribute it and/or modify 

14 it under the terms of the GNU General Public License as published by 

15 the Free Software Foundation, either version 3 of the License, or 

16 (at your option) any later version. 

17 

18 CamCOPS is distributed in the hope that it will be useful, 

19 but WITHOUT ANY WARRANTY; without even the implied warranty of 

20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

21 GNU General Public License for more details. 

22 

23 You should have received a copy of the GNU General Public License 

24 along with CamCOPS. If not, see <https://www.gnu.org/licenses/>. 

25 

26=============================================================================== 

27 

28""" 

29 

30from cardinal_pythonlib.typing_helpers import with_typehint 

31from camcops_server.cc_modules.cc_session import CamcopsSession 

32from camcops_server.cc_modules.cc_unittest import BasicDatabaseTestCase 

33from camcops_server.cc_modules.cc_view_classes import FormWizardMixin, View 

34 

35 

36class TestView(FormWizardMixin, View): 

37 pass 

38 

39 

40class TestStateMixin(with_typehint(BasicDatabaseTestCase)): 

41 """ 

42 For testing FormWizardMixin state. 

43 """ 

44 

45 def assert_state_is_finished(self) -> None: 

46 """ 

47 Asserts that the state has been marked as "finished", i.e. with the 

48 finish flag set to true and only selected other parameters present. 

49 """ 

50 state = self.req.camcops_session.form_state 

51 self.assertIsNotNone(state, msg="state is None (incorrect)") 

52 self.assertTrue( 

53 state[FormWizardMixin.PARAM_FINISHED], 

54 msg=f"PARAM_FINISHED is " 

55 f"{state[FormWizardMixin.PARAM_FINISHED]!r} (should be True)", 

56 ) 

57 expected_finished_params = { 

58 FormWizardMixin.PARAM_FINISHED, 

59 FormWizardMixin.PARAM_ROUTE_NAME, 

60 FormWizardMixin.PARAM_STEP, 

61 } 

62 state_params = set(state.keys()) 

63 wrong_params = state_params - expected_finished_params 

64 missing_params = expected_finished_params - state_params 

65 self.assertFalse( 

66 bool(wrong_params), 

67 msg=f"Inappropriate parameters: {wrong_params!r}", 

68 ) 

69 self.assertFalse( 

70 bool(missing_params), msg=f"Missing parameters: {missing_params!r}" 

71 ) 

72 

73 def assert_state_is_clean(self) -> None: 

74 """ 

75 Asserts that the state is None or contains only certain permitted 

76 parameters. 

77 """ 

78 state = self.req.camcops_session.form_state 

79 permissible_params = { 

80 FormWizardMixin.PARAM_FINISHED, 

81 FormWizardMixin.PARAM_ROUTE_NAME, 

82 FormWizardMixin.PARAM_STEP, 

83 } 

84 state_is_none = bool(state is None) 

85 state_params = set(state.keys()) 

86 wrong_params = state_params - permissible_params 

87 state_contains_only_permissible_params = not wrong_params 

88 self.assertTrue( 

89 state_is_none or state_contains_only_permissible_params, 

90 msg=f"State contains inappropriate parameters {wrong_params!r}", 

91 ) 

92 

93 

94class FormWizardMixinTests(TestStateMixin, BasicDatabaseTestCase): 

95 def setUp(self) -> None: 

96 super().setUp() 

97 

98 self.req.matched_route.name = "test_route" 

99 

100 def test_route_name_is_saved_in_existing_session(self) -> None: 

101 self.req.camcops_session.form_state = { 

102 FormWizardMixin.PARAM_STEP: "some-previous-step", 

103 FormWizardMixin.PARAM_ROUTE_NAME: "some_previous_route_name", 

104 } 

105 self.req.dbsession.add(self.req.camcops_session) 

106 self.req.dbsession.commit() 

107 

108 TestView(self.req) 

109 

110 self.assertEqual( 

111 self.req.camcops_session.form_state[ 

112 FormWizardMixin.PARAM_ROUTE_NAME 

113 ], # noqa 

114 "test_route", 

115 ) 

116 

117 self.req.dbsession.flush() 

118 session_id = self.req.camcops_session.id 

119 self.assertIsNotNone(session_id) 

120 

121 self.req.dbsession.commit() 

122 

123 session = ( 

124 self.req.dbsession.query(CamcopsSession) 

125 .filter(CamcopsSession.id == session_id) 

126 .one() 

127 ) 

128 

129 self.assertEqual( 

130 session.form_state[FormWizardMixin.PARAM_ROUTE_NAME], "test_route" 

131 ) 

132 

133 def test_step_is_saved_in_new_session(self) -> None: 

134 view = TestView(self.req) 

135 view.step = "test" 

136 self.assertEqual( 

137 self.req.camcops_session.form_state[FormWizardMixin.PARAM_STEP], 

138 "test", 

139 ) 

140 

141 self.req.dbsession.flush() 

142 session_id = self.req.camcops_session.id 

143 self.assertIsNotNone(session_id) 

144 

145 self.req.dbsession.commit() 

146 

147 session = ( 

148 self.req.dbsession.query(CamcopsSession) 

149 .filter(CamcopsSession.id == session_id) 

150 .one() 

151 ) 

152 

153 self.assertEqual( 

154 session.form_state[FormWizardMixin.PARAM_STEP], "test" 

155 ) 

156 

157 def test_route_name_is_saved_in_new_session(self) -> None: 

158 TestView(self.req) 

159 

160 self.assertEqual( 

161 self.req.camcops_session.form_state[ 

162 FormWizardMixin.PARAM_ROUTE_NAME 

163 ], # noqa 

164 "test_route", 

165 ) 

166 

167 self.req.dbsession.flush() 

168 session_id = self.req.camcops_session.id 

169 self.assertIsNotNone(session_id) 

170 

171 self.req.dbsession.commit() 

172 

173 session = ( 

174 self.req.dbsession.query(CamcopsSession) 

175 .filter(CamcopsSession.id == session_id) 

176 .one() 

177 ) 

178 

179 self.assertEqual( 

180 session.form_state[FormWizardMixin.PARAM_ROUTE_NAME], "test_route" 

181 ) 

182 

183 def test_step_is_updated_for_same_route(self) -> None: 

184 self.req.camcops_session.form_state = { 

185 FormWizardMixin.PARAM_STEP: "previous_step", 

186 FormWizardMixin.PARAM_ROUTE_NAME: "test_route", 

187 } 

188 self.req.dbsession.add(self.req.camcops_session) 

189 self.req.dbsession.commit() 

190 

191 view = TestView(self.req) 

192 view.step = "next_step" 

193 self.assertEqual( 

194 self.req.camcops_session.form_state[FormWizardMixin.PARAM_STEP], 

195 "next_step", 

196 ) 

197 

198 self.req.dbsession.flush() 

199 session_id = self.req.camcops_session.id 

200 self.assertIsNotNone(session_id) 

201 

202 self.req.dbsession.commit() 

203 

204 session = ( 

205 self.req.dbsession.query(CamcopsSession) 

206 .filter(CamcopsSession.id == session_id) 

207 .one() 

208 ) 

209 

210 self.assertEqual( 

211 session.form_state[FormWizardMixin.PARAM_STEP], "next_step" 

212 ) 

213 

214 def test_arbitrary_field_is_saved_in_new_session(self) -> None: 

215 view = TestView(self.req) 

216 view.state["test_field"] = "test_value" 

217 

218 self.assertEqual( 

219 self.req.camcops_session.form_state["test_field"], "test_value" 

220 ) 

221 

222 self.req.dbsession.flush() 

223 session_id = self.req.camcops_session.id 

224 self.assertIsNotNone(session_id) 

225 

226 self.req.dbsession.commit() 

227 

228 session = ( 

229 self.req.dbsession.query(CamcopsSession) 

230 .filter(CamcopsSession.id == session_id) 

231 .one() 

232 ) 

233 

234 self.assertEqual(session.form_state["test_field"], "test_value") 

235 

236 def test_finish_and_finished(self) -> None: 

237 self.req.camcops_session.form_state = { 

238 FormWizardMixin.PARAM_STEP: "previous_step", 

239 FormWizardMixin.PARAM_ROUTE_NAME: "test_route", 

240 } 

241 self.req.dbsession.add(self.req.camcops_session) 

242 self.req.dbsession.commit() 

243 

244 view = TestView(self.req) 

245 self.assertFalse(view.finished()) 

246 

247 view.finish() 

248 

249 self.assertTrue(view.finished()) 

250 self.assert_state_is_finished()