Coverage for osm_mon/tests/unit/collector/vnf_collectors/vmware/test_vrops_helper.py: 100%

1# -*- coding: utf-8 -*- 

2# # 

3# Copyright 2016-2019 VMware Inc. 

4# This file is part of ETSI OSM 

5# All Rights Reserved. 

6# 

7# Licensed under the Apache License, Version 2.0 (the "License"); you may 

8# not use this file except in compliance with the License. You may obtain 

9# a copy of the License at 

10# 

11# http://www.apache.org/licenses/LICENSE-2.0 

12# 

13# Unless required by applicable law or agreed to in writing, software 

14# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

15# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

16# License for the specific language governing permissions and limitations 

17# under the License. 

18# 

19# For those usages not covered by the Apache License, Version 2.0 please 

20# contact: osslegalrouting@vmware.com 

21# # 

22 

23from osm_mon.collector.vnf_collectors.vrops.vrops_helper import vROPS_Helper 

24from osm_mon.tests.unit.collector.vnf_collectors.vmware.mock_http import ( 

25 mock_http_response, 

26) 

27from unittest import TestCase 

28 

29import json 

30import os 

31import requests_mock 

32 

33 

34class vROPS_Helper_Resource_List_Test(TestCase): 

35 def setUp(self): 

36 super().setUp() 

37 self.vrops = vROPS_Helper() 

38 

39 def tearDown(self): 

40 super().tearDown() 

41 

42 def test_get_vm_resource_list_from_vrops(self): 

43 with requests_mock.Mocker() as mock_requests: 

44 mock_http_response( 

45 mock_requests, 

46 method="POST", 

47 url_pattern="/suite-api/api/auth/token/acquire", 

48 response_file="vrops_token.json", 

49 ) 

50 mock_http_response( 

51 mock_requests, 

52 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine", 

53 response_file="vrops_resources.json", 

54 ) 

55 resource_list = self.vrops.get_vm_resource_list_from_vrops() 

56 self.assertEqual( 

57 len(resource_list), 

58 3, 

59 "List of resources from canned vrops_resources.json", 

60 ) 

61 

62 def test_get_vm_resource_list_from_vrops_http_404(self): 

63 with requests_mock.Mocker() as mock_requests: 

64 mock_http_response( 

65 mock_requests, 

66 method="POST", 

67 url_pattern="/suite-api/api/auth/token/acquire", 

68 response_file="vrops_token.json", 

69 ) 

70 mock_http_response( 

71 mock_requests, 

72 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine", 

73 response_file="404.txt", 

74 status_code=404, 

75 ) 

76 resource_list = self.vrops.get_vm_resource_list_from_vrops() 

77 self.assertEqual(len(resource_list), 0, "Should return an empty list") 

78 

79 def test_get_vm_resource_list_from_vrops_bad_json(self): 

80 with requests_mock.Mocker() as mock_requests: 

81 mock_http_response( 

82 mock_requests, 

83 method="POST", 

84 url_pattern="/suite-api/api/auth/token/acquire", 

85 response_file="vrops_token.json", 

86 ) 

87 mock_http_response( 

88 mock_requests, 

89 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine", 

90 response_file="malformed.json", 

91 ) 

92 resource_list = self.vrops.get_vm_resource_list_from_vrops() 

93 self.assertEqual(len(resource_list), 0, "Should return an empty list") 

94 

95 

96class vROPS_Helper_Get_Metrics_Test(TestCase): 

97 def setUp(self): 

98 super().setUp() 

99 self.vrops = vROPS_Helper() 

100 with open( 

101 os.path.join(os.path.dirname(__file__), "osm_mocks", "VNFR.json"), "r" 

102 ) as f: 

103 self.vnfr = json.load(f) 

104 

105 def tearDown(self): 

106 super().tearDown() 

107 

108 def test_collect_one_metric_only(self): 

109 vdu_mappings = { 

110 "VMWARE-OID-VM-1": { 

111 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

112 "vrops_id": "VROPS-UUID-1", 

113 } 

114 } 

115 monitoring_params = [ 

116 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

117 ] 

118 

119 with requests_mock.Mocker() as mock_requests: 

120 mock_http_response( 

121 mock_requests, 

122 method="POST", 

123 url_pattern="/suite-api/api/auth/token/acquire", 

124 response_file="vrops_token.json", 

125 ) 

126 mock_http_response( 

127 mock_requests, 

128 url_pattern="/suite-api/api/resources/stats.*", 

129 response_file="vrops_multi.json", 

130 ) 

131 

132 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

133 self.assertEqual(len(metrics), 1, "Number of metrics returned") 

134 self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name") 

135 self.assertEqual(metrics[0].value, 100.0, "CPU metric value") 

136 

137 def test_collect_cpu_and_memory(self): 

138 vdu_mappings = { 

139 "VMWARE-OID-VM-1": { 

140 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

141 "vrops_id": "VROPS-UUID-1", 

142 } 

143 } 

144 monitoring_params = [ 

145 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

146 { 

147 "id": "ubuntu_vnf_average_memory_utilization", 

148 "performance-metric": "average_memory_utilization", 

149 }, 

150 ] 

151 

152 with requests_mock.Mocker() as mock_requests: 

153 mock_http_response( 

154 mock_requests, 

155 method="POST", 

156 url_pattern="/suite-api/api/auth/token/acquire", 

157 response_file="vrops_token.json", 

158 ) 

159 mock_http_response( 

160 mock_requests, 

161 url_pattern="/suite-api/api/resources/stats.*", 

162 response_file="vrops_multi.json", 

163 ) 

164 

165 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

166 

167 self.assertEqual(len(metrics), 2, "Number of metrics returned") 

168 self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name") 

169 self.assertEqual(metrics[0].value, 100.0, "CPU metric value") 

170 self.assertEqual( 

171 metrics[1].name, "average_memory_utilization", "Second metric name" 

172 ) 

173 self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value") 

174 

175 def test_collect_adjusted_metric(self): 

176 vdu_mappings = { 

177 "VMWARE-OID-VM-1": { 

178 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

179 "vrops_id": "VROPS-UUID-1", 

180 } 

181 } 

182 monitoring_params = [ 

183 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "disk_read_bytes"} 

184 ] 

185 

186 with requests_mock.Mocker() as mock_requests: 

187 mock_http_response( 

188 mock_requests, 

189 method="POST", 

190 url_pattern="/suite-api/api/auth/token/acquire", 

191 response_file="vrops_token.json", 

192 ) 

193 mock_http_response( 

194 mock_requests, 

195 url_pattern="/suite-api/api/resources/stats.*", 

196 response_file="vrops_multi.json", 

197 ) 

198 

199 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

200 

201 self.assertEqual(len(metrics), 1, "Number of metrics returned") 

202 self.assertEqual(metrics[0].name, "disk_read_bytes", "First metric name") 

203 self.assertEqual(metrics[0].value, 10240.0, "Disk read bytes (not KB/s)") 

204 

205 def test_collect_not_provided_metric(self): 

206 vdu_mappings = { 

207 "VMWARE-OID-VM-1": { 

208 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

209 "vrops_id": "VROPS-UUID-1", 

210 } 

211 } 

212 monitoring_params = [ 

213 { 

214 "id": "cirros_vnf_packets_sent", 

215 "performance-metric": "packets_in_dropped", 

216 }, 

217 ] 

218 

219 with requests_mock.Mocker() as mock_requests: 

220 mock_http_response( 

221 mock_requests, 

222 method="POST", 

223 url_pattern="/suite-api/api/auth/token/acquire", 

224 response_file="vrops_token.json", 

225 ) 

226 mock_http_response( 

227 mock_requests, 

228 url_pattern="/suite-api/api/resources/stats.*", 

229 response_file="vrops_multi.json", 

230 ) 

231 

232 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

233 

234 self.assertEqual(len(metrics), 0, "Number of metrics returned") 

235 

236 def test_collect_unkown_metric(self): 

237 vdu_mappings = { 

238 "VMWARE-OID-VM-1": { 

239 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

240 "vrops_id": "VROPS-UUID-1", 

241 } 

242 } 

243 monitoring_params = [ 

244 {"id": "cirros_vnf-Unknown_Metric", "performance-metric": "unknown"}, 

245 ] 

246 

247 with requests_mock.Mocker() as mock_requests: 

248 mock_http_response( 

249 mock_requests, 

250 method="POST", 

251 url_pattern="/suite-api/api/auth/token/acquire", 

252 response_file="vrops_token.json", 

253 ) 

254 mock_http_response( 

255 mock_requests, 

256 url_pattern="/suite-api/api/resources/stats.*", 

257 response_file="vrops_multi.json", 

258 ) 

259 

260 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

261 

262 self.assertEqual(len(metrics), 0, "Number of metrics returned") 

263 

264 def test_collect_vrops_no_data(self): 

265 vdu_mappings = { 

266 "VMWARE-OID-VM-1": { 

267 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

268 "vrops_id": "VROPS-UUID-1", 

269 } 

270 } 

271 monitoring_params = [ 

272 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

273 ] 

274 

275 with requests_mock.Mocker() as mock_requests: 

276 mock_http_response( 

277 mock_requests, 

278 method="POST", 

279 url_pattern="/suite-api/api/auth/token/acquire", 

280 response_file="vrops_token.json", 

281 ) 

282 mock_http_response( 

283 mock_requests, 

284 url_pattern="/suite-api/api/resources/stats.*", 

285 response_file="OK.json", 

286 ) 

287 

288 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

289 

290 self.assertEqual(len(metrics), 0, "Number of metrics returned") 

291 

292 def test_collect_vrops_unknown_vim_id(self): 

293 vdu_mappings = { 

294 "VMWARE-OID-VM-1": {"name": "vmware-scaling-1-ubuntu_vnfd-VM-2"} 

295 } 

296 monitoring_params = [ 

297 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

298 ] 

299 

300 with requests_mock.Mocker() as mock_requests: 

301 mock_http_response( 

302 mock_requests, 

303 method="POST", 

304 url_pattern="/suite-api/api/auth/token/acquire", 

305 response_file="vrops_token.json", 

306 ) 

307 mock_http_response( 

308 mock_requests, 

309 url_pattern="/suite-api/api/resources/stats.*", 

310 response_file="vrops_multi.json", 

311 ) 

312 

313 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

314 

315 self.assertEqual(len(metrics), 0, "Number of metrics returned") 

316 

317 def test_collect_vrops_http_error(self): 

318 vdu_mappings = { 

319 "VMWARE-OID-VM-1": { 

320 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

321 "vrops_id": "VROPS-UUID-1", 

322 } 

323 } 

324 monitoring_params = [ 

325 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

326 ] 

327 

328 with requests_mock.Mocker() as mock_requests: 

329 mock_http_response( 

330 mock_requests, 

331 method="POST", 

332 url_pattern="/suite-api/api/auth/token/acquire", 

333 response_file="vrops_token.json", 

334 ) 

335 mock_http_response( 

336 mock_requests, 

337 url_pattern="/suite-api/api/resources/stats.*", 

338 response_file="404.txt", 

339 status_code=404, 

340 ) 

341 

342 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

343 

344 self.assertEqual(len(metrics), 0, "Number of metrics returned") 

345 

346 def test_collect_vrops_json_parse_error(self): 

347 vdu_mappings = { 

348 "VMWARE-OID-VM-1": { 

349 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

350 "vrops_id": "VROPS-UUID-1", 

351 } 

352 } 

353 monitoring_params = [ 

354 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

355 ] 

356 

357 with requests_mock.Mocker() as mock_requests: 

358 mock_http_response( 

359 mock_requests, 

360 method="POST", 

361 url_pattern="/suite-api/api/auth/token/acquire", 

362 response_file="vrops_token.json", 

363 ) 

364 mock_http_response( 

365 mock_requests, 

366 url_pattern="/suite-api/api/resources/stats.*", 

367 response_file="404.txt", 

368 ) 

369 

370 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

371 

372 self.assertEqual(len(metrics), 0, "Number of metrics returned") 

373 

374 def test_collect_multi_vdu(self): 

375 vdu_mappings = { 

376 "VMWARE-UUID-VM-1": { 

377 "name": "vmware-scaling-1-ubuntu_vnfd-VM-1", 

378 "vrops_id": "VROPS-UUID-1", 

379 }, 

380 "VMWARE-UUID-VM-2": { 

381 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

382 "vrops_id": "VROPS-UUID-2", 

383 }, 

384 "VMWARE-UUID-VM-3": { 

385 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2", 

386 "vrops_id": "VROPS-UUID-3", 

387 }, 

388 } 

389 monitoring_params = [ 

390 {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"}, 

391 { 

392 "id": "ubuntu_vnf_average_memory_utilization", 

393 "performance-metric": "average_memory_utilization", 

394 }, 

395 {"id": "ubuntu_vnf_disk_read_ops", "performance-metric": "disk_read_ops"}, 

396 {"id": "ubuntu_vnf_disk_write_ops", "performance-metric": "disk_write_ops"}, 

397 { 

398 "id": "ubuntu_vnf_disk_read_bytes", 

399 "performance-metric": "disk_read_bytes", 

400 }, 

401 { 

402 "id": "ubuntu_vnf_disk_write_bytes", 

403 "performance-metric": "disk_write_bytes", 

404 }, 

405 { 

406 "id": "ubuntu_vnf_packets_out_dropped", 

407 "performance-metric": "packets_out_dropped", 

408 }, 

409 { 

410 "id": "ubuntu_vnf_packets_received", 

411 "performance-metric": "packets_received", 

412 }, 

413 {"id": "ubuntu_vnf_packets_sent", "performance-metric": "packets_sent"}, 

414 ] 

415 

416 with requests_mock.Mocker() as mock_requests: 

417 mock_http_response( 

418 mock_requests, 

419 method="POST", 

420 url_pattern="/suite-api/api/auth/token/acquire", 

421 response_file="vrops_token.json", 

422 ) 

423 mock_http_response( 

424 mock_requests, 

425 url_pattern="/suite-api/api/resources/stats.*", 

426 response_file="vrops_multi.json", 

427 ) 

428 metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr) 

429 

430 self.assertEqual( 

431 len(metrics), 

432 len(monitoring_params) * len(vdu_mappings), 

433 "Number of metrics returned", 

434 )