Coverage for test_mqtt_networking.py: 99%

303 statements  

« prev     ^ index     » next       coverage.py v7.2.7, created at 2024-02-27 14:21 +0000

1#----------------------------------------------------------------------------------- 

2# System tests for the schematic editor functions 

3#----------------------------------------------------------------------------------- 

4 

5from system_test_harness import * 

6import test_object_edit_windows 

7 

8#----------------------------------------------------------------------------------- 

9# This function tests the basic network tx/rx of signals, sections and instruments 

10#----------------------------------------------------------------------------------- 

11 

12def run_basic_networking_tests(delay:float=0.0): 

13 print("Basic MQTT networking tests") 

14 # As we are using networking, we need to introduce an additional delay for messages 

15 # to be sent to and received from the MQTT message broker - as we are using a 

16 # local broker, a short delay of 100ms should suffice 

17 network_delay = 0.1 

18 # basic section mirroring Tests 

19 reset_layout() 

20 sleep(network_delay) 

21 sleep(delay) 

22 assert_sections_clear(1,2,3,4) 

23 set_sections_occupied(1) 

24 sleep(network_delay) 

25 sleep(delay) 

26 assert_sections_occupied(1,2,3,4) 

27 set_sections_clear(1) 

28 sleep(network_delay) 

29 sleep(delay) 

30 assert_sections_clear(1,2,3,4) 

31 set_sections_occupied(2) 

32 sleep(network_delay) 

33 sleep(delay) 

34 assert_sections_occupied(1,2,3,4) 

35 set_sections_clear(2) 

36 sleep(network_delay) 

37 sleep(delay) 

38 assert_sections_clear(1,2,3,4) 

39 # Basic block_instrument tests 

40 reset_layout() 

41 sleep(network_delay) 

42 sleep(delay) 

43 assert_block_section_ahead_not_clear(1,2) 

44 set_instrument_clear(1) 

45 sleep(network_delay) 

46 sleep(delay) 

47 assert_block_section_ahead_clear(2) 

48 assert_block_section_ahead_not_clear(1) 

49 set_instrument_occupied(1) 

50 sleep(network_delay) 

51 sleep(delay) 

52 assert_block_section_ahead_not_clear(1,2) 

53 set_instrument_blocked(1) 

54 sleep(network_delay) 

55 sleep(delay) 

56 assert_block_section_ahead_not_clear(1,2) 

57 set_instrument_clear(2) 

58 sleep(network_delay) 

59 sleep(delay) 

60 assert_block_section_ahead_clear(1) 

61 assert_block_section_ahead_not_clear(2) 

62 set_instrument_occupied(2) 

63 sleep(network_delay) 

64 sleep(delay) 

65 assert_block_section_ahead_not_clear(1,2) 

66 set_instrument_blocked(2) 

67 sleep(network_delay) 

68 sleep(delay) 

69 assert_block_section_ahead_not_clear(1,2) 

70 for ring in range(5): 

71 sleep(0.1) 

72 click_telegraph_key(1) 

73 sleep(delay) 

74 for ring in range(5): 

75 sleep(0.1) 

76 click_telegraph_key(2) 

77 # basic set aspect on signal ahead tests 

78 assert_signals_PROCEED(6,16) 

79 trigger_signals_passed(16) 

80 sleep(network_delay) 

81 assert_signals_DANGER(16) 

82 assert_signals_CAUTION(6) 

83 sleep(1.0) 

84 sleep(network_delay) 

85 assert_signals_CAUTION(16) 

86 assert_signals_PRELIM_CAUTION(6) 

87 sleep(1.0) 

88 sleep(network_delay) 

89 assert_signals_PRELIM_CAUTION(16) 

90 assert_signals_PROCEED(6) 

91 sleep(1.0) 

92 sleep(network_delay) 

93 assert_signals_PROCEED(16) 

94 assert_signals_PROCEED(6) 

95 return() 

96 

97#----------------------------------------------------------------------------------- 

98# This tests the more complex functions still "work" with networking: 

99# Interlock distant with home signals ahead 

100# Override distant on all local home signals ahead 

101# Override distant on distant signal ahead 

102# Approach control (approach on red if any local home signals ahead are at danger) 

103#----------------------------------------------------------------------------------- 

104 

105def run_specific_signal_ahead_tests(delay:float=0.0): 

106 print("MQTT interlocking and override on signals ahead tests") 

107 # As we are using networking, we need to introduce an additional delay for messages 

108 # to be sent to and received from the MQTT message broker - as we are using a 

109 # local broker, a short delay of 100ms should suffice 

110 network_delay = 0.1 

111 reset_layout() 

112 sleep(delay) 

113 sleep(network_delay) 

114 # Test interlocking of distant signals against all home signal ahead 

115 # Signals are only interlocked against LOCAL home signals as the first signal on 

116 # the next section should always be a distant signal (and we always assume that) 

117 # Scenario 1 

118 assert_signals_locked(2) 

119 set_signals_off(3) 

120 sleep(delay) 

121 sleep(network_delay) 

122 assert_signals_unlocked(2) 

123 set_signals_off(13) 

124 sleep(delay) 

125 sleep(network_delay) 

126 assert_signals_unlocked(2) 

127 set_signals_on(3) 

128 sleep(delay) 

129 sleep(network_delay) 

130 assert_signals_locked(2) 

131 set_signals_on(13) 

132 sleep(delay) 

133 sleep(network_delay) 

134 assert_signals_locked(2) 

135 # Scenario 2 

136 assert_signals_unlocked(4) 

137 set_signals_off(14) 

138 sleep(delay) 

139 sleep(network_delay) 

140 assert_signals_unlocked(4) 

141 set_signals_on(14) 

142 sleep(delay) 

143 sleep(network_delay) 

144 assert_signals_unlocked(4) 

145 # Test approach control of home signals (release on red) against home signals ahead 

146 # Signals are only subject to approach control against LOCAL home signals as the first 

147 # signal on the next section should always be a distant signal (and we always assume that) 

148 assert_signals_DANGER(3,13) 

149 set_signals_off(13) 

150 sleep(delay) 

151 sleep(network_delay) 

152 assert_signals_PROCEED(13) 

153 assert_signals_DANGER(3) 

154 set_signals_off(3) 

155 sleep(delay) 

156 sleep(network_delay) 

157 assert_signals_PROCEED(3,13) 

158 set_signals_on(3,13) 

159 sleep(delay) 

160 sleep(network_delay) 

161 assert_signals_DANGER(3,13) 

162 # Test override of distant signals (to caution) against home signals ahead 

163 # Distant signals are only subject to override control against LOCAL home signals as the first 

164 # signal on the next section should always be a distant signal (and we always assume that) 

165 assert_signals_CAUTION(2) 

166 assert_signals_DANGER(13,3) 

167 set_signals_off(3,13) 

168 sleep(delay) 

169 sleep(network_delay) 

170 set_signals_off(2) 

171 sleep(delay) 

172 sleep(network_delay) 

173 assert_signals_PROCEED(2,3,13) 

174 set_signals_on(13) 

175 sleep(delay) 

176 sleep(network_delay) 

177 assert_signals_PROCEED(2,3) 

178 assert_signals_DANGER(13) 

179 set_signals_on(3) 

180 sleep(delay) 

181 sleep(network_delay) 

182 assert_signals_CAUTION(2) 

183 assert_signals_DANGER(13,3) 

184 set_signals_off(3) 

185 sleep(delay) 

186 sleep(network_delay) 

187 assert_signals_PROCEED(2,3) 

188 assert_signals_DANGER(13) 

189 set_signals_off(13) 

190 sleep(delay) 

191 sleep(network_delay) 

192 assert_signals_PROCEED(2,3,13) 

193 set_signals_on(2) 

194 sleep(delay) 

195 sleep(network_delay) 

196 set_signals_on(3,13) 

197 sleep(delay) 

198 sleep(network_delay) 

199 assert_signals_CAUTION(2) 

200 assert_signals_DANGER(13,3) 

201 # Test override of secondary distant arms (to caution) against distant signals ahead 

202 # This is the case where a signal controlled by a remote signal box may be mounted on 

203 # the post of a home signal controlled by the local signal box. In this case we still 

204 # want it to appear on the local schematic (effectively mirroring the distant signal 

205 # on the remote signal box's schematic 

206 assert_signals_route_MAIN(1) 

207 assert_signals_DANGER(1) 

208 set_signals_off(1) 

209 sleep(delay) 

210 sleep(network_delay) 

211 assert_signals_PROCEED(1) ################################################################################## 

212 set_signals_on(1) 

213 sleep(delay) 

214 sleep(network_delay) 

215 assert_signals_DANGER(1) 

216 set_points_switched(1) 

217 sleep(delay) 

218 sleep(network_delay) 

219 set_signals_off(1) 

220 sleep(delay) 

221 sleep(network_delay) 

222 assert_signals_CAUTION(1) 

223 set_signals_off(11) 

224 sleep(delay) 

225 sleep(network_delay) 

226 assert_signals_PROCEED(1) 

227 set_signals_on(11) 

228 sleep(delay) 

229 sleep(network_delay) 

230 assert_signals_CAUTION(1) 

231 set_signals_on(1) 

232 sleep(delay) 

233 sleep(network_delay) 

234 assert_signals_DANGER(1) 

235 set_points_normal(1) 

236 sleep(delay) 

237 sleep(network_delay) 

238 return() 

239 

240#----------------------------------------------------------------------------------- 

241# Test Publish and subscribe to remote track sensors 

242#----------------------------------------------------------------------------------- 

243 

244def run_remote_track_sensor_tests(delay:float=0.0): 

245 print("MQTT remote track sensor tests") 

246 # As we are using networking, we need to introduce an additional delay for messages 

247 # to be sent to and received from the MQTT message broker - as we are using a 

248 # local broker, a short 'network_delay' of 100ms should suffice 

249 # We also need to introduce a delay for triggering of the remote GPIO sensors 

250 # as these are configured with a timeout period of 0.1 seconds (this means that 

251 # any additional triggers received within the 0.1 seconds will be ignored 

252 gpio_trigger_delay = 0.2 

253 network_delay = 0.1 

254 reset_layout() 

255 sleep(delay+network_delay) 

256 set_signals_off(5,7,8,9) 

257 sleep(delay+network_delay) 

258 assert_sections_clear(5,6,7,8,9) 

259 set_sections_occupied(5) 

260 sleep(delay+network_delay) 

261 simulate_gpio_triggered(4) 

262 sleep(delay+network_delay+gpio_trigger_delay) 

263 assert_sections_occupied(6) 

264 assert_sections_clear(5,7,8,9) 

265 simulate_gpio_triggered(5) 

266 sleep(delay+network_delay+gpio_trigger_delay) 

267 assert_sections_occupied(7) 

268 assert_sections_clear(5,6,8,9) 

269 simulate_gpio_triggered(6) 

270 sleep(delay+network_delay+gpio_trigger_delay) 

271 assert_sections_occupied(8) 

272 assert_sections_clear(5,6,7,9) 

273 simulate_gpio_triggered(7) 

274 sleep(delay+network_delay+gpio_trigger_delay) 

275 assert_sections_occupied(9) 

276 assert_sections_clear(5,6,7,8) 

277 set_signals_on(5) 

278 sleep(delay) 

279 set_signals_on(7,8,9) 

280 return() 

281 

282#----------------------------------------------------------------------------------- 

283# This tests that received events that we are no longer interested in 

284# are safely ignored (i.e. no exceptions generated) 

285#----------------------------------------------------------------------------------- 

286 

287def run_object_deletion_tests(delay:float=0.0): 

288 print("MQTT object deletion tests") 

289 # As we are using networking, we need to introduce an additional delay for messages 

290 # to be sent to and received from the MQTT message broker - as we are using a 

291 # local broker, a short delay of 100ms should suffice 

292 network_delay = 0.1 

293 # Delete stuff 

294 i1 = get_object_id("instrument",1) 

295 s1 = get_object_id("section",1) 

296 p6 = get_object_id("signal",6) 

297 set_edit_mode() 

298 sleep(delay) 

299 sleep(network_delay) 

300 select_or_deselect_objects(i1,s1,p6) 

301 sleep(delay) 

302 sleep(network_delay) 

303 delete_selected_objects() 

304 sleep(delay) 

305 sleep(network_delay) 

306 set_run_mode() 

307 sleep(delay) 

308 sleep(network_delay) 

309 # Check the received events have no adverse effects for sections 

310 assert_sections_clear(2,3,4) 

311 set_sections_occupied(2) 

312 sleep(delay) 

313 sleep(network_delay) 

314 assert_sections_occupied(2,4) 

315 assert_sections_clear(3) 

316 set_sections_clear(2) 

317 sleep(delay) 

318 sleep(network_delay) 

319 assert_sections_clear(2,3,4) 

320 # Check the received events have no adverse effects for instruments 

321 set_instrument_clear(2) 

322 sleep(delay) 

323 sleep(network_delay) 

324 assert_block_section_ahead_not_clear(2) 

325 set_instrument_occupied(2) 

326 sleep(delay) 

327 sleep(network_delay) 

328 assert_block_section_ahead_not_clear(2) 

329 set_instrument_blocked(2) 

330 sleep(delay) 

331 sleep(network_delay) 

332 assert_block_section_ahead_not_clear(2) 

333 for ring in range(5): 

334 sleep(0.1) 

335 click_telegraph_key(2) 

336 # Check the received events have no adverse effects for signals 

337 assert_signals_PROCEED(16) 

338 trigger_signals_passed(16) 

339 sleep(delay) 

340 sleep(network_delay) 

341 assert_signals_DANGER(16) 

342 sleep(network_delay) 

343 sleep(1.0) 

344 assert_signals_CAUTION(16) 

345 sleep(network_delay) 

346 sleep(1.0) 

347 assert_signals_PRELIM_CAUTION(16) 

348 sleep(network_delay) 

349 sleep(1.0) 

350 assert_signals_PROCEED(16) 

351 # Get everyhing back to normal  

352 set_edit_mode() 

353 sleep(delay) 

354 sleep(network_delay) 

355 undo() 

356 sleep(delay) 

357 sleep(network_delay) 

358 set_run_mode() 

359 return() 

360 

361###################################################################################################### 

362 

363def run_all_mqtt_networking_tests(delay:float=0.0, shutdown:bool=False): 

364 initialise_test_harness(filename="./test_mqtt_networking.sig") 

365 # Edit/save all schematic objects to give confidence that editing doesn't break the layout configuration 

366 set_edit_mode() 

367 test_object_edit_windows.test_all_object_edit_windows(delay) 

368 set_run_mode() 

369 run_basic_networking_tests(delay) 

370 run_remote_track_sensor_tests(delay) 

371 run_specific_signal_ahead_tests(delay) 

372 run_object_deletion_tests(delay) 

373 if shutdown: report_results() 

374 

375if __name__ == "__main__": 375 ↛ 376line 375 didn't jump to line 376, because the condition on line 375 was never true

376 start_application(lambda:run_all_mqtt_networking_tests(delay=0.0, shutdown=True)) 

377 

378############################################################################################################################### 

379