Coverage for tests/routers/test_device_router.py: 99%

1import json 

2import pytest 

3import warnings 

4from zenossapi.apiclient import ZenossAPIClientError 

5from zenossapi.routers.device import DeviceRouter, ZenossDeviceClass, ZenossDevice, ZenossComponent 

6from zenossapi.routers.properties import ZenossProperty, ZenossCustomProperty 

7from zenossapi.routers.template import ZenossTemplate 

8import resp_json 

9import properties_resp 

10 

11pytest_plugins = "pytest-responses" 

12url = 'https://zenoss/zport/dmd' 

13headers = dict( 

14 ContentType='application/json' 

15) 

16resp_body_template = dict( 

17 result=dict( 

18 success=True, 

19 data=[], 

20 ) 

21) 

22 

23 

24def request_callback(request): 

25 rdata = json.loads(request.body) 

26 resp_headers = dict(ContentType='application/json') 

27 

28 def getProductionStates(rdata): 

29 resp_body_template['result']['data'].extend([ 

30 dict(name='Production', value=1000), 

31 dict(name='Maintenance', value=300), 

32 ]) 

33 return resp_body_template 

34 

35 def getPriorities(rdata): 

36 resp_body_template['result']['data'].append(dict(name='Normal', value=3)) 

37 return resp_body_template 

38 

39 def getInfo(rdata): 

40 if rdata['uid'] == "Devices/Server/TEST": 

41 return resp_json.dc_info 

42 elif rdata['uid'] == "Devices/Server/TEST/devices/test.example.com": 

43 return resp_json.dev_info 

44 elif rdata['uid'] == "Devices/Server/TEST/devices/test.example.com/hw/cpus/0": 

45 return resp_json.component_info 

46 elif rdata['uid'] == "Devices/Server/TEST/devices/test.example.com/DnsMonitor": 

47 return resp_json.local_template 

48 elif rdata['uid'] == "Devices/Server/TEST/rrdTemplates/Device": 

49 return resp_json.device_template 

50 elif rdata['uid'] == "Devices/rrdTemplates/DnsMonitor": 

51 return resp_json.dns_template 

52 elif rdata['uid'] == "Devices/Server/rrdTemplates/Apache": 

53 return resp_json.apache_template 

54 elif rdata['uid'] == "Devices/Server/rrdTemplates/DigMonitor": 

55 return resp_json.dig_template 

56 else: 

57 return resp_json.not_found 

58 

59 def getCollectors(rdata): 

60 return resp_json.collectors 

61 

62 def getDeviceClasses(rdata): 

63 return resp_json.dev_classes 

64 

65 def getGroups(rdata): 

66 return resp_json.groups 

67 

68 def getSystems(rdata): 

69 return resp_json.systems 

70 

71 def getDevices(rdata): 

72 return resp_json.devices 

73 

74 def addDeviceClassNode(rdata): 

75 return resp_json.add_dc 

76 

77 def addDevice(rdata): 

78 return resp_json.add_dev 

79 

80 def getComponents(rdata): 

81 return resp_json.components 

82 

83 def getUserCommands(rdata): 

84 return resp_json.uc 

85 

86 def getLocalTemplates(rdata): 

87 return resp_json.local_templates 

88 

89 def getTemplates(rdata): 

90 return resp_json.templates 

91 

92 def getUnboundTemplates(rdata): 

93 return resp_json.ub_templates 

94 

95 def getBoundTemplates(rdata): 

96 return resp_json.bound_templates 

97 

98 def getOverridableTemplates(rdata): 

99 return resp_json.or_templates 

100 

101 def moveDevices(rdata): 

102 return resp_json.move_dev 

103 

104 def lockDevices(rdata): 

105 return resp_json.lock 

106 

107 def resetIp(rdata): 

108 return resp_json.resetip 

109 

110 def setProductionState(rdata): 

111 return resp_json.prod_state 

112 

113 def setPriority(rdata): 

114 return resp_json.priority 

115 

116 def setCollector(rdata): 

117 return resp_json.set_collector 

118 

119 def remodel(rdata): 

120 return resp_json.remodel 

121 

122 def setComponentsMonitored(rdata): 

123 return resp_json.monitored 

124 

125 def lockComponents(rdata): 

126 return resp_json.lock_c 

127 

128 def deleteComponents(rdata): 

129 return resp_json.delete_c 

130 

131 def getZenProperties(rdata): 

132 if rdata['params']: 

133 if 'id' in rdata['params']: 

134 if 'islocal' in rdata['params']: 

135 return properties_resp.get_local_prop 

136 else: 

137 return properties_resp.get_prop 

138 elif 'islocal' in rdata['params']: 

139 return properties_resp.local_props 

140 

141 return properties_resp.props 

142 

143 def getCustomProperties(rdata): 

144 if rdata['params'] and 'id' in rdata['params']: 

145 if 'islocal' in rdata['params']: 

146 return properties_resp.custom_local_props 

147 

148 return properties_resp.custom_props 

149 

150 def setZenProperty(rdata): 

151 if rdata['zProperty'] == "zWinTrustedRealm": 

152 return properties_resp.set_prop 

153 elif rdata['zProperty'] == "cDateTest": 

154 return properties_resp.set_custom_prop 

155 

156 def deleteZenProperty(rdata): 

157 return properties_resp.delete_prop 

158 

159 def update(rdata): 

160 return { 

161 "uuid": "ba2f41f8-3c48-40a6-ab45-3c5e84252c3c", 

162 "action": "PropertiesRouter", 

163 "result": { 

164 "success": True 

165 }, 

166 "tid": 1, 

167 "type": "rpc", 

168 "method": "update" 

169 } 

170 

171 if rdata['method'] in ['setBoundTemplates', 'bindOrUnbindTemplate', 

172 'resetBoundTemplates', 'renameDevice', 

173 'removeDevices']: 

174 resp_body = resp_json.success 

175 else: 

176 method = locals()[rdata['method']] 

177 resp_body = method(rdata['data'][0]) 

178 

179 return (200, resp_headers, json.dumps(resp_body)) 

180 

181 

182def responses_callback(responses): 

183 responses.add_callback( 

184 responses.POST, 

185 '{0}/device_router'.format(url), 

186 callback=request_callback, 

187 content_type='application/json', 

188 ) 

189 

190 

191class TestDeviceRouter(object): 

192 

193 def test_device_router_init(self, responses): 

194 responses_callback(responses) 

195 

196 dr = DeviceRouter(url, headers, True) 

197 assert dr.uid is None 

198 assert dr.properties is None 

199 assert dr.prod_states_by_value[1000] == "Production" 

200 assert dr.prod_states_by_name['Production'] == 1000 

201 assert dr.priorities_by_value[3] == "Normal" 

202 assert dr.priorities_by_name['Normal'] == 3 

203 

204 def test_device_router_get_info_by_uid(self, responses): 

205 responses_callback(responses) 

206 

207 dr = DeviceRouter(url, headers, True) 

208 resp = dr.get_info_by_uid('Devices/Server/TEST') 

209 assert resp['data']['name'] == "TEST" 

210 

211 def test_device_router_get_info_by_uid_not_found(self, responses): 

212 responses_callback(responses) 

213 

214 dr = DeviceRouter(url, headers, True) 

215 with pytest.raises(ZenossAPIClientError, match="Request failed: ObjectNotFoundException: Cannot find \"Devices/Server/TEST\". KeyError: 'TEST'"): 

216 resp = dr.get_info_by_uid('Devices/Server/NOTFOUND') 

217 

218 def test_device_router_list_collectors(self, responses): 

219 responses_callback(responses) 

220 

221 dr = DeviceRouter(url, headers, True) 

222 resp = dr.list_collectors() 

223 assert resp[0] == "localhost" 

224 

225 def test_device_router_list_device_classes(self, responses): 

226 responses_callback(responses) 

227 

228 dr = DeviceRouter(url, headers, True) 

229 resp = dr.list_device_classes() 

230 assert len(resp) == 7 

231 assert resp[-1] == "Devices/Server/SSH/Linux" 

232 

233 def test_device_router_list_groups(self, responses): 

234 responses_callback(responses) 

235 

236 dr = DeviceRouter(url, headers, True) 

237 resp = dr.list_groups() 

238 assert len(resp) == 1 

239 assert resp[0] == "/TestGroup" 

240 

241 def test_device_router_list_systems(self, responses): 

242 responses_callback(responses) 

243 

244 dr = DeviceRouter(url, headers, True) 

245 resp = dr.list_systems() 

246 assert len(resp) == 1 

247 assert resp[0] == "/TestSystem" 

248 

249 def test_device_router_get_device_class(self, responses): 

250 responses_callback(responses) 

251 

252 dr = DeviceRouter(url, headers, True) 

253 resp = dr.get_device_class('Server/TEST') 

254 assert isinstance(resp, ZenossDeviceClass) 

255 

256 def test_device_router_zenossdeviceclass_list_devices(self, responses): 

257 responses_callback(responses) 

258 

259 dr = DeviceRouter(url, headers, True) 

260 dc = dr.get_device_class('Server/TEST') 

261 resp = dc.get_devices() 

262 assert resp['total'] == 1 

263 assert resp['devices'][0].name == "test.example.com" 

264 assert resp['devices'][0].uid == "Devices/Server/TEST/devices/test.example.com" 

265 

266 def test_device_router_zenossdeviceclass_get_devices(self, responses): 

267 responses_callback(responses) 

268 

269 dr = DeviceRouter(url, headers, True) 

270 dc = dr.get_device_class('Server/TEST') 

271 resp = dc.get_devices() 

272 assert len(resp['devices']) == 1 

273 assert isinstance(resp['devices'][0], ZenossDevice) 

274 

275 def test_device_router_zenossdeviceclass_get_device(self, responses): 

276 responses_callback(responses) 

277 

278 dr = DeviceRouter(url, headers, True) 

279 dc = dr.get_device_class('Server/TEST') 

280 resp = dc.get_device('test.example.com') 

281 assert isinstance(resp, ZenossDevice) 

282 assert resp.uid == "Devices/Server/TEST/devices/test.example.com" 

283 

284 def test_device_router_zenossdeviceclass_add_subclass(self, responses): 

285 responses_callback(responses) 

286 

287 dr = DeviceRouter(url, headers, True) 

288 dc = dr.get_device_class('Server/TEST') 

289 resp = dc.add_subclass('Foo') 

290 assert isinstance(resp, ZenossDeviceClass) 

291 

292 def test_device_router_zenossdeviceclass_add_device(self, responses): 

293 responses_callback(responses) 

294 

295 dr = DeviceRouter(url, headers, True) 

296 dc = dr.get_device_class('Server/TEST') 

297 resp = dc.add_device('test2.example.com') 

298 assert resp == "721739ae-2b1d-4613-91e9-681f134a2c49" 

299 

300 def test_device_router_zenossdeviceclass_list_properties(self, responses): 

301 responses.add_callback( 

302 responses.POST, 

303 '{0}/properties_router'.format(url), 

304 callback=request_callback, 

305 content_type='application/json', 

306 ) 

307 responses.add_callback( 

308 responses.POST, 

309 '{0}/device_router'.format(url), 

310 callback=request_callback, 

311 content_type='application/json', 

312 ) 

313 

314 dr = DeviceRouter(url, headers, True) 

315 dc = dr.get_device_class('Server/TEST') 

316 props = dc.list_properties() 

317 assert props['total'] == 4 

318 assert len(props['properties']) == 4 

319 assert props['properties'][0]['id'] == "zAggregatorCollectionInterval" 

320 

321 def test_device_router_zenossdeviceclass_list_local_properties(self, responses): 

322 responses.add_callback( 

323 responses.POST, 

324 '{0}/properties_router'.format(url), 

325 callback=request_callback, 

326 content_type='application/json', 

327 ) 

328 responses.add_callback( 

329 responses.POST, 

330 '{0}/device_router'.format(url), 

331 callback=request_callback, 

332 content_type='application/json', 

333 ) 

334 

335 dr = DeviceRouter(url, headers, True) 

336 dc = dr.get_device_class('Server/TEST') 

337 props = dc.list_local_properties() 

338 assert props['total'] == 2 

339 assert len(props['properties']) == 2 

340 assert props['properties'][0]['id'] == "zMySQLConnectionString" 

341 

342 def test_device_router_zenossdeviceclass_list_custom_properites(self, responses): 

343 responses.add_callback( 

344 responses.POST, 

345 '{0}/properties_router'.format(url), 

346 callback=request_callback, 

347 content_type='application/json', 

348 ) 

349 responses.add_callback( 

350 responses.POST, 

351 '{0}/device_router'.format(url), 

352 callback=request_callback, 

353 content_type='application/json', 

354 ) 

355 

356 dr = DeviceRouter(url, headers, True) 

357 dc = dr.get_device_class('Server/TEST') 

358 props = dc.list_custom_properties() 

359 assert props['total'] == 1 

360 assert len(props['properties']) == 1 

361 assert props['properties'][0]['id'] == "cDateTest" 

362 assert props['properties'][0]['path'] == "/" 

363 

364 def test_device_router_zenossdeviceclass_get_properties(self, responses): 

365 responses.add_callback( 

366 responses.POST, 

367 '{0}/properties_router'.format(url), 

368 callback=request_callback, 

369 content_type='application/json', 

370 ) 

371 responses.add_callback( 

372 responses.POST, 

373 '{0}/device_router'.format(url), 

374 callback=request_callback, 

375 content_type='application/json', 

376 ) 

377 

378 dr = DeviceRouter(url, headers, True) 

379 dc = dr.get_device_class('Server/TEST') 

380 props = dc.get_properties() 

381 assert props['total'] == 4 

382 assert len(props['properties']) == 4 

383 assert isinstance(props['properties'][0], ZenossProperty) 

384 assert props['properties'][0].id == "zAggregatorCollectionInterval" 

385 

386 def test_device_router_zenossdeviceclass_get_property(self, responses): 

387 responses.add_callback( 

388 responses.POST, 

389 '{0}/properties_router'.format(url), 

390 callback=request_callback, 

391 content_type='application/json', 

392 ) 

393 responses.add_callback( 

394 responses.POST, 

395 '{0}/device_router'.format(url), 

396 callback=request_callback, 

397 content_type='application/json', 

398 ) 

399 

400 dr = DeviceRouter(url, headers, True) 

401 dc = dr.get_device_class('Server/TEST') 

402 prop = dc.get_property('zWinTrustedRealm') 

403 assert isinstance(prop, ZenossProperty) 

404 assert prop.id == 'zWinTrustedRealm' 

405 

406 def test_device_router_zenossdeviceclass_get_custom_properties(self, responses): 

407 responses.add_callback( 

408 responses.POST, 

409 '{0}/properties_router'.format(url), 

410 callback=request_callback, 

411 content_type='application/json', 

412 ) 

413 responses.add_callback( 

414 responses.POST, 

415 '{0}/device_router'.format(url), 

416 callback=request_callback, 

417 content_type='application/json', 

418 ) 

419 

420 dr = DeviceRouter(url, headers, True) 

421 dc = dr.get_device_class('Server/TEST') 

422 props = dc.get_custom_properties() 

423 assert props['total'] == 1 

424 assert len(props['properties']) == 1 

425 assert isinstance(props['properties'][0], ZenossCustomProperty) 

426 assert props['properties'][0].id == "cDateTest" 

427 

428 def test_device_router_zenossdeviceclass_get_custom_property(self, responses): 

429 responses.add_callback( 

430 responses.POST, 

431 '{0}/properties_router'.format(url), 

432 callback=request_callback, 

433 content_type='application/json', 

434 ) 

435 responses.add_callback( 

436 responses.POST, 

437 '{0}/device_router'.format(url), 

438 callback=request_callback, 

439 content_type='application/json', 

440 ) 

441 

442 dr = DeviceRouter(url, headers, True) 

443 dc = dr.get_device_class('Server/TEST') 

444 prop = dc.get_custom_property('zWinTrustedRealm') 

445 assert isinstance(prop, ZenossCustomProperty) 

446 assert prop.id == "cDateTest" 

447 assert prop.path == "Devices/" 

448 

449 def test_device_router_zenossdeviceclass_set_property(self, responses): 

450 responses.add_callback( 

451 responses.POST, 

452 '{0}/properties_router'.format(url), 

453 callback=request_callback, 

454 content_type='application/json', 

455 ) 

456 responses.add_callback( 

457 responses.POST, 

458 '{0}/device_router'.format(url), 

459 callback=request_callback, 

460 content_type='application/json', 

461 ) 

462 

463 dr = DeviceRouter(url, headers, True) 

464 dc = dr.get_device_class('Server/TEST') 

465 prop = dc.set_property('zWinTrustedRealm', value='Westeros') 

466 assert prop is True 

467 

468 def test_device_router_zenossdeviceclass_delete_property(self, responses): 

469 responses.add_callback( 

470 responses.POST, 

471 '{0}/properties_router'.format(url), 

472 callback=request_callback, 

473 content_type='application/json', 

474 ) 

475 responses.add_callback( 

476 responses.POST, 

477 '{0}/device_router'.format(url), 

478 callback=request_callback, 

479 content_type='application/json', 

480 ) 

481 

482 dr = DeviceRouter(url, headers, True) 

483 dc = dr.get_device_class('Server/TEST') 

484 assert dc.delete_property('zWinTrustedRealm') 

485 

486 def test_device_router_zenossdevice_list_components(self, responses): 

487 responses_callback(responses) 

488 

489 dr = DeviceRouter(url, headers, True) 

490 dc = dr.get_device_class('Server/TEST') 

491 d = dc.get_device('test.example.com') 

492 resp = d.list_components() 

493 assert resp['total'] == 1 

494 assert resp['components'][0] == "hw/cpus/0" 

495 

496 def test_device_router_zenossdevice_list_components_bad_filter(self, responses): 

497 responses_callback(responses) 

498 

499 dr = DeviceRouter(url, headers, True) 

500 dc = dr.get_device_class('Server/TEST') 

501 d = dc.get_device('test.example.com') 

502 with pytest.warns(UserWarning): 

503 resp = d.list_components(name='foo') 

504 

505 def test_device_router_zenossdevice_get_components(self, responses): 

506 responses_callback(responses) 

507 

508 dr = DeviceRouter(url, headers, True) 

509 dc = dr.get_device_class('Server/TEST') 

510 d = dc.get_device('test.example.com') 

511 resp = d.get_components() 

512 assert len(resp) == 1 

513 assert isinstance(resp[0], ZenossComponent) 

514 

515 def test_device_router_zenossdevice_get_component(self, responses): 

516 responses_callback(responses) 

517 

518 dr = DeviceRouter(url, headers, True) 

519 dc = dr.get_device_class('Server/TEST') 

520 d = dc.get_device('test.example.com') 

521 resp = d.get_component('hw/cpus/0') 

522 assert resp.uid == "Devices/Server/TEST/devices/test.example.com/hw/cpus/0" 

523 assert resp.meta_type == "CPU" 

524 assert resp.name == "0" 

525 

526 def test_device_router_zenossdevice_list_user_commands(self, responses): 

527 responses_callback(responses) 

528 

529 dr = DeviceRouter(url, headers, True) 

530 dc = dr.get_device_class('Server/TEST') 

531 d = dc.get_device('test.example.com') 

532 resp = d.list_user_commands() 

533 assert len(resp) == 6 

534 assert resp[2]['name'] == "ping" 

535 

536 def test_device_router_zenossdevice_list_local_templates(self, responses): 

537 responses_callback(responses) 

538 

539 dr = DeviceRouter(url, headers, True) 

540 dc = dr.get_device_class('Server/TEST') 

541 d = dc.get_device('test.example.com') 

542 resp = d.list_local_templates() 

543 assert resp[0] == "DnsMonitor" 

544 

545 def test_device_router_zenossdevice_get_local_templates(self, responses): 

546 responses.assert_all_requests_are_fired = False 

547 responses.add( 

548 responses.POST, 

549 '{0}/template_router'.format(url), 

550 json=resp_json.local_template, 

551 status=200, 

552 ) 

553 responses.add_callback( 

554 responses.POST, 

555 '{0}/device_router'.format(url), 

556 callback=request_callback, 

557 content_type='application/json', 

558 ) 

559 dr = DeviceRouter(url, headers, True) 

560 dc = dr.get_device_class('Server/TEST') 

561 d = dc.get_device('test.example.com') 

562 resp = d.get_local_templates() 

563 assert isinstance(resp[0], ZenossTemplate) 

564 assert resp[0].uid == "Devices/Server/TEST/devices/test.example.com/DnsMonitor" 

565 

566 def test_device_router_zenossdevice_list_active_templates(self, responses): 

567 responses_callback(responses) 

568 

569 dr = DeviceRouter(url, headers, True) 

570 dc = dr.get_device_class('Server/TEST') 

571 d = dc.get_device('test.example.com') 

572 resp = d.list_active_templates() 

573 assert resp[0]['name'] == "Device" 

574 

575 def test_device_router_zenossdevice_get_active_templates(self, responses): 

576 responses.assert_all_requests_are_fired = False 

577 responses.add_callback( 

578 responses.POST, 

579 '{0}/template_router'.format(url), 

580 callback=request_callback, 

581 content_type='application/json', 

582 ) 

583 responses.add_callback( 

584 responses.POST, 

585 '{0}/device_router'.format(url), 

586 callback=request_callback, 

587 content_type='application/json', 

588 ) 

589 dr = DeviceRouter(url, headers, True) 

590 dc = dr.get_device_class('Server/TEST') 

591 d = dc.get_device('test.example.com') 

592 resp = d.get_active_templates() 

593 assert len(resp) == 2 

594 assert isinstance(resp[0], ZenossTemplate) 

595 assert resp[0].uid == "Devices/Server/TEST/rrdTemplates/Device" 

596 

597 def test_device_router_zenossdevice_list_unbound_templates(self, responses): 

598 responses_callback(responses) 

599 

600 dr = DeviceRouter(url, headers, True) 

601 dc = dr.get_device_class('Server/TEST') 

602 d = dc.get_device('test.example.com') 

603 resp = d.list_unbound_templates() 

604 assert resp[0]['name'] == "Apache" 

605 

606 def test_device_router_zenossdevice_get_unbound_templates(self, responses): 

607 responses.assert_all_requests_are_fired = False 

608 responses.add_callback( 

609 responses.POST, 

610 '{0}/template_router'.format(url), 

611 callback=request_callback, 

612 content_type='application/json', 

613 ) 

614 responses.add_callback( 

615 responses.POST, 

616 '{0}/device_router'.format(url), 

617 callback=request_callback, 

618 content_type='application/json', 

619 ) 

620 dr = DeviceRouter(url, headers, True) 

621 dc = dr.get_device_class('Server/TEST') 

622 d = dc.get_device('test.example.com') 

623 resp = d.get_unbound_templates() 

624 assert len(resp) == 2 

625 assert isinstance(resp[0], ZenossTemplate) 

626 assert resp[0].uid == "Devices/Server/rrdTemplates/Apache" 

627 assert resp[1].name == "DigMonitor" 

628 

629 def test_device_router_zenossdevice_list_bound_templates(self, responses): 

630 responses_callback(responses) 

631 

632 dr = DeviceRouter(url, headers, True) 

633 dc = dr.get_device_class('Server/TEST') 

634 d = dc.get_device('test.example.com') 

635 resp = d.list_bound_templates() 

636 assert resp[0]['name'] == "Device" 

637 

638 def test_device_router_zenossdevice_get_bound_templates(self, responses): 

639 responses.assert_all_requests_are_fired = False 

640 responses.add_callback( 

641 responses.POST, 

642 '{0}/template_router'.format(url), 

643 callback=request_callback, 

644 content_type='application/json', 

645 ) 

646 responses.add_callback( 

647 responses.POST, 

648 '{0}/device_router'.format(url), 

649 callback=request_callback, 

650 content_type='application/json', 

651 ) 

652 dr = DeviceRouter(url, headers, True) 

653 dc = dr.get_device_class('Server/TEST') 

654 d = dc.get_device('test.example.com') 

655 resp = d.get_bound_templates() 

656 assert len(resp) == 2 

657 assert isinstance(resp[0], ZenossTemplate) 

658 

659 def test_device_router_zenossdevice_list_overridable_templates(self, responses): 

660 responses_callback(responses) 

661 

662 dr = DeviceRouter(url, headers, True) 

663 dc = dr.get_device_class('Server/TEST') 

664 d = dc.get_device('test.example.com') 

665 resp = d.list_overridable_templates() 

666 assert resp[0]['name'] == "Device" 

667 

668 def test_device_router_zenossdevice_get_overridable_templates(self, responses): 

669 responses.assert_all_requests_are_fired = False 

670 responses.add_callback( 

671 responses.POST, 

672 '{0}/template_router'.format(url), 

673 callback=request_callback, 

674 content_type='application/json', 

675 ) 

676 responses.add_callback( 

677 responses.POST, 

678 '{0}/device_router'.format(url), 

679 callback=request_callback, 

680 content_type='application/json', 

681 ) 

682 dr = DeviceRouter(url, headers, True) 

683 dc = dr.get_device_class('Server/TEST') 

684 d = dc.get_device('test.example.com') 

685 resp = d.get_overridable_templates() 

686 assert len(resp) == 1 

687 assert isinstance(resp[0], ZenossTemplate) 

688 

689 def test_device_router_zenossdevice_set_bound_templates(self, responses): 

690 responses_callback(responses) 

691 

692 dr = DeviceRouter(url, headers, True) 

693 dc = dr.get_device_class('Server/TEST') 

694 d = dc.get_device('test.example.com') 

695 resp = d.set_bound_templates(['Device']) 

696 

697 def test_device_router_zenossdevice_bind_or_unbind_template(self, responses): 

698 responses_callback(responses) 

699 

700 dr = DeviceRouter(url, headers, True) 

701 dc = dr.get_device_class('Server/TEST') 

702 d = dc.get_device('test.example.com') 

703 resp = d.bind_or_unbind_template('Devices', 'DnsMonitor') 

704 

705 def test_device_router_zenossdevice_reset_bound_templates(self, responses): 

706 responses_callback(responses) 

707 

708 dr = DeviceRouter(url, headers, True) 

709 dc = dr.get_device_class('Server/TEST') 

710 d = dc.get_device('test.example.com') 

711 resp = d.reset_bound_templates() 

712 

713 def test_device_router_zenossdevice_move(self, responses): 

714 responses_callback(responses) 

715 

716 dr = DeviceRouter(url, headers, True) 

717 dc = dr.get_device_class('Server/TEST') 

718 d = dc.get_device('test.example.com') 

719 resp = d.move('Server/TEST') 

720 

721 def test_device_router_zenossdevice_reidentify(self, responses): 

722 responses_callback(responses) 

723 

724 dr = DeviceRouter(url, headers, True) 

725 dc = dr.get_device_class('Server/TEST') 

726 d = dc.get_device('test.example.com') 

727 resp = d.reidentify('test2.example.com') 

728 

729 def test_device_router_zenossdevice_lock(self, responses): 

730 responses_callback(responses) 

731 

732 dr = DeviceRouter(url, headers, True) 

733 dc = dr.get_device_class('Server/TEST') 

734 d = dc.get_device('test.example.com') 

735 resp = d.lock(updates=True, deletion=True) 

736 assert resp == "Locked 1 devices." 

737 

738 def test_device_router_zenossdevice_lock_for_updates(self, responses): 

739 responses_callback(responses) 

740 

741 dr = DeviceRouter(url, headers, True) 

742 dc = dr.get_device_class('Server/TEST') 

743 d = dc.get_device('test.example.com') 

744 resp = d.lock_for_updates() 

745 assert resp == "Locked 1 devices." 

746 

747 def test_device_router_zenossdevice_lock_for_deletion(self, responses): 

748 responses_callback(responses) 

749 

750 dr = DeviceRouter(url, headers, True) 

751 dc = dr.get_device_class('Server/TEST') 

752 d = dc.get_device('test.example.com') 

753 resp = d.lock_for_deletion() 

754 assert resp == "Locked 1 devices." 

755 

756 def test_device_router_zenossdevice_reset_ip_address(self, responses): 

757 responses_callback(responses) 

758 

759 dr = DeviceRouter(url, headers, True) 

760 dc = dr.get_device_class('Server/TEST') 

761 d = dc.get_device('test.example.com') 

762 resp = d.reset_ip_address() 

763 assert resp == "Reset 1 IP addresses." 

764 

765 def test_device_router_zenossdevice_set_production_state(self, responses): 

766 responses_callback(responses) 

767 

768 dr = DeviceRouter(url, headers, True) 

769 dc = dr.get_device_class('Server/TEST') 

770 d = dc.get_device('test.example.com') 

771 resp = d.set_production_state(300) 

772 assert resp == "Set 1 devices to Maintenance." 

773 

774 def test_device_router_zenossdevice_set_priority(self, responses): 

775 responses_callback(responses) 

776 

777 dr = DeviceRouter(url, headers, True) 

778 dc = dr.get_device_class('Server/TEST') 

779 d = dc.get_device('test.example.com') 

780 resp = d.set_priority(3) 

781 assert resp == "Set 1 devices to Normal priority." 

782 

783 def test_device_router_zenossdevice_set_collector(self, responses): 

784 responses_callback(responses)