Revision 1c3231aa test/py/ganeti.rpc_unittest.py
| b/test/py/ganeti.rpc_unittest.py | ||
|---|---|---|
| 341 | 341 |
ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list) |
| 342 | 342 |
result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| 343 | 343 |
ssc=ssc, nslookup_fn=NotImplemented) |
| 344 |
self.assertEqual(result, zip(node_list, addr_list)) |
|
| 344 |
self.assertEqual(result, zip(node_list, addr_list, node_list))
|
|
| 345 | 345 |
|
| 346 | 346 |
def testNsLookup(self): |
| 347 | 347 |
addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| ... | ... | |
| 351 | 351 |
nslookup_fn = lambda name, family=None: node_addr_map.get(name) |
| 352 | 352 |
result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| 353 | 353 |
ssc=ssc, nslookup_fn=nslookup_fn) |
| 354 |
self.assertEqual(result, zip(node_list, addr_list)) |
|
| 354 |
self.assertEqual(result, zip(node_list, addr_list, node_list))
|
|
| 355 | 355 |
|
| 356 | 356 |
def testDisabledSsconfIp(self): |
| 357 | 357 |
addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| ... | ... | |
| 361 | 361 |
nslookup_fn = lambda name, family=None: node_addr_map.get(name) |
| 362 | 362 |
result = rpc._SsconfResolver(False, node_list, NotImplemented, |
| 363 | 363 |
ssc=ssc, nslookup_fn=nslookup_fn) |
| 364 |
self.assertEqual(result, zip(node_list, addr_list)) |
|
| 364 |
self.assertEqual(result, zip(node_list, addr_list, node_list))
|
|
| 365 | 365 |
|
| 366 | 366 |
def testBothLookups(self): |
| 367 | 367 |
addr_list = ["192.0.2.%d" % n for n in range(0, 255, 13)] |
| ... | ... | |
| 373 | 373 |
nslookup_fn = lambda name, family=None: node_addr_map.get(name) |
| 374 | 374 |
result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| 375 | 375 |
ssc=ssc, nslookup_fn=nslookup_fn) |
| 376 |
self.assertEqual(result, zip(node_list, addr_list)) |
|
| 376 |
self.assertEqual(result, zip(node_list, addr_list, node_list))
|
|
| 377 | 377 |
|
| 378 | 378 |
def testAddressLookupIPv6(self): |
| 379 | 379 |
addr_list = ["2001:db8::%d" % n for n in range(0, 255, 11)] |
| ... | ... | |
| 382 | 382 |
ssc = GetFakeSimpleStoreClass(lambda _: node_addr_list) |
| 383 | 383 |
result = rpc._SsconfResolver(True, node_list, NotImplemented, |
| 384 | 384 |
ssc=ssc, nslookup_fn=NotImplemented) |
| 385 |
self.assertEqual(result, zip(node_list, addr_list)) |
|
| 385 |
self.assertEqual(result, zip(node_list, addr_list, node_list))
|
|
| 386 | 386 |
|
| 387 | 387 |
|
| 388 | 388 |
class TestStaticResolver(unittest.TestCase): |
| ... | ... | |
| 390 | 390 |
addresses = ["192.0.2.%d" % n for n in range(0, 123, 7)] |
| 391 | 391 |
nodes = ["node%s.example.com" % n for n in range(0, 123, 7)] |
| 392 | 392 |
res = rpc._StaticResolver(addresses) |
| 393 |
self.assertEqual(res(nodes, NotImplemented), zip(nodes, addresses)) |
|
| 393 |
self.assertEqual(res(nodes, NotImplemented), zip(nodes, addresses, nodes))
|
|
| 394 | 394 |
|
| 395 | 395 |
def testWrongLength(self): |
| 396 | 396 |
res = rpc._StaticResolver([]) |
| ... | ... | |
| 399 | 399 |
|
| 400 | 400 |
class TestNodeConfigResolver(unittest.TestCase): |
| 401 | 401 |
@staticmethod |
| 402 |
def _GetSingleOnlineNode(name): |
|
| 403 |
assert name == "node90.example.com" |
|
| 404 |
return objects.Node(name=name, offline=False, primary_ip="192.0.2.90") |
|
| 402 |
def _GetSingleOnlineNode(uuid): |
|
| 403 |
assert uuid == "node90-uuid" |
|
| 404 |
return objects.Node(name="node90.example.com", |
|
| 405 |
uuid=uuid, |
|
| 406 |
offline=False, |
|
| 407 |
primary_ip="192.0.2.90") |
|
| 405 | 408 |
|
| 406 | 409 |
@staticmethod |
| 407 |
def _GetSingleOfflineNode(name): |
|
| 408 |
assert name == "node100.example.com" |
|
| 409 |
return objects.Node(name=name, offline=True, primary_ip="192.0.2.100") |
|
| 410 |
def _GetSingleOfflineNode(uuid): |
|
| 411 |
assert uuid == "node100-uuid" |
|
| 412 |
return objects.Node(name="node100.example.com", |
|
| 413 |
uuid=uuid, |
|
| 414 |
offline=True, |
|
| 415 |
primary_ip="192.0.2.100") |
|
| 410 | 416 |
|
| 411 | 417 |
def testSingleOnline(self): |
| 412 | 418 |
self.assertEqual(rpc._NodeConfigResolver(self._GetSingleOnlineNode, |
| 413 | 419 |
NotImplemented, |
| 414 |
["node90.example.com"], None),
|
|
| 415 |
[("node90.example.com", "192.0.2.90")])
|
|
| 420 |
["node90-uuid"], None),
|
|
| 421 |
[("node90.example.com", "192.0.2.90", "node90-uuid")])
|
|
| 416 | 422 |
|
| 417 | 423 |
def testSingleOffline(self): |
| 418 | 424 |
self.assertEqual(rpc._NodeConfigResolver(self._GetSingleOfflineNode, |
| 419 | 425 |
NotImplemented, |
| 420 |
["node100.example.com"], None),
|
|
| 421 |
[("node100.example.com", rpc._OFFLINE)])
|
|
| 426 |
["node100-uuid"], None),
|
|
| 427 |
[("node100.example.com", rpc._OFFLINE, "node100-uuid")])
|
|
| 422 | 428 |
|
| 423 | 429 |
def testSingleOfflineWithAcceptOffline(self): |
| 424 | 430 |
fn = self._GetSingleOfflineNode |
| 425 |
assert fn("node100.example.com").offline
|
|
| 431 |
assert fn("node100-uuid").offline
|
|
| 426 | 432 |
self.assertEqual(rpc._NodeConfigResolver(fn, NotImplemented, |
| 427 |
["node100.example.com"],
|
|
| 433 |
["node100-uuid"],
|
|
| 428 | 434 |
rpc_defs.ACCEPT_OFFLINE_NODE), |
| 429 |
[("node100.example.com", "192.0.2.100")])
|
|
| 435 |
[("node100.example.com", "192.0.2.100", "node100-uuid")])
|
|
| 430 | 436 |
for i in [False, True, "", "Hello", 0, 1]: |
| 431 | 437 |
self.assertRaises(AssertionError, rpc._NodeConfigResolver, |
| 432 | 438 |
fn, NotImplemented, ["node100.example.com"], i) |
| ... | ... | |
| 434 | 440 |
def testUnknownSingleNode(self): |
| 435 | 441 |
self.assertEqual(rpc._NodeConfigResolver(lambda _: None, NotImplemented, |
| 436 | 442 |
["node110.example.com"], None), |
| 437 |
[("node110.example.com", "node110.example.com")])
|
|
| 443 |
[("node110.example.com", "node110.example.com",
|
|
| 444 |
"node110.example.com")]) |
|
| 438 | 445 |
|
| 439 | 446 |
def testMultiEmpty(self): |
| 440 | 447 |
self.assertEqual(rpc._NodeConfigResolver(NotImplemented, |
| ... | ... | |
| 443 | 450 |
[]) |
| 444 | 451 |
|
| 445 | 452 |
def testMultiSomeOffline(self): |
| 446 |
nodes = dict(("node%s.example.com" % i,
|
|
| 453 |
nodes = dict(("node%s-uuid" % i,
|
|
| 447 | 454 |
objects.Node(name="node%s.example.com" % i, |
| 448 | 455 |
offline=((i % 3) == 0), |
| 449 |
primary_ip="192.0.2.%s" % i)) |
|
| 456 |
primary_ip="192.0.2.%s" % i, |
|
| 457 |
uuid="node%s-uuid" % i)) |
|
| 450 | 458 |
for i in range(1, 255)) |
| 451 | 459 |
|
| 452 | 460 |
# Resolve no names |
| ... | ... | |
| 458 | 466 |
# Offline, online and unknown hosts |
| 459 | 467 |
self.assertEqual(rpc._NodeConfigResolver(NotImplemented, |
| 460 | 468 |
lambda: nodes, |
| 461 |
["node3.example.com",
|
|
| 462 |
"node92.example.com",
|
|
| 463 |
"node54.example.com",
|
|
| 469 |
["node3-uuid",
|
|
| 470 |
"node92-uuid",
|
|
| 471 |
"node54-uuid",
|
|
| 464 | 472 |
"unknown.example.com",], |
| 465 | 473 |
None), [ |
| 466 |
("node3.example.com", rpc._OFFLINE),
|
|
| 467 |
("node92.example.com", "192.0.2.92"),
|
|
| 468 |
("node54.example.com", rpc._OFFLINE),
|
|
| 469 |
("unknown.example.com", "unknown.example.com"),
|
|
| 474 |
("node3.example.com", rpc._OFFLINE, "node3-uuid"),
|
|
| 475 |
("node92.example.com", "192.0.2.92", "node92-uuid"),
|
|
| 476 |
("node54.example.com", rpc._OFFLINE, "node54-uuid"),
|
|
| 477 |
("unknown.example.com", "unknown.example.com", "unknown.example.com"),
|
|
| 470 | 478 |
]) |
| 471 | 479 |
|
| 472 | 480 |
|
| ... | ... | |
| 672 | 680 |
def _Resolver(expected, hosts, options): |
| 673 | 681 |
self.assertEqual(hosts, nodes) |
| 674 | 682 |
self.assertEqual(options, expected) |
| 675 |
return zip(hosts, nodes) |
|
| 683 |
return zip(hosts, nodes, hosts)
|
|
| 676 | 684 |
|
| 677 | 685 |
def _DynamicResolverOptions((arg0, )): |
| 678 | 686 |
return sum(arg0) |
Also available in: Unified diff