← Back to branch summary

~mpontillo/maas/dns-api-ui-consistency--bug-1686864

« back to all changes in this revision

Viewing changes to src/provisioningserver/drivers/pod/tests/test_rsd.py

  • Committer: Mike Pontillo
  • Date: 2017-04-27 22:41:56 UTC
  • mfrom: (6016.2.13 maas)
  • Revision ID: mike.pontillo@canonical.com-20170427224156-ko031qa7rsn2mw0s
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/provisioningserver/drivers/pod/tests/test_rsd.py
1013
1013
            b"redfish/v1/Services/1/Targets/3": SAMPLE_JSON_TARGET,
1014
1014
        }
1015
1015
        remote_drives = set(
1016
 
            "redfish/v1/Services/1/Targets/1")
 
1016
            b"/redfish/v1/Services/1/Targets/1")
1017
1017
 
1018
1018
        remote_storage = driver.calculate_remote_storage(
1019
1019
            remote_drives, logical_drives, targets)
1313
1313
        context = make_context()
1314
1314
        url = driver.get_url(context)
1315
1315
        headers = driver.make_auth_headers(**context)
1316
 
        node_data = SAMPLE_JSON_NODE
1317
1316
        discovered_machine = make_discovered_machine(block_devices=[])
1318
 
        TARGET_CHANGED = deepcopy(SAMPLE_JSON_TARGET)
1319
 
        TARGET_CHANGED['Addresses'][0]['iSCSI']['TargetLUN'].append({'LUN': 3})
 
1317
        node_data = deepcopy(SAMPLE_JSON_NODE)
 
1318
        node_data['Links']['RemoteDrives'].append({
 
1319
            "@odata.id": "/redfish/v1/Services/1/Targets/3"})
 
1320
        LV_CHANGED = deepcopy(SAMPLE_JSON_LV)
 
1321
        LV_CHANGED['Links']['Targets'].append({
 
1322
            "@odata.id": "/redfish/v1/Services/1/Targets/3"})
 
1323
        TARGET_CHANGED_1 = deepcopy(SAMPLE_JSON_TARGET)
 
1324
        TARGET_CHANGED_2 = deepcopy(SAMPLE_JSON_TARGET)
 
1325
        TARGET_CHANGED_1['Addresses'][0]['iSCSI']['TargetLUN'].append(
 
1326
            {'LUN': 3})
 
1327
        TARGET_CHANGED_2['Initiator'][0]['iSCSI']['InitiatorIQN'] = "ALL"
 
1328
        remote_drives = set([
 
1329
            "/redfish/v1/Services/1/Targets/1",
 
1330
            "/redfish/v1/Services/1/Targets/2",
 
1331
            "/redfish/v1/Services/1/Targets/3",
 
1332
        ])
1320
1333
        logical_drives = {
1321
1334
            b"redfish/v1/Services/1/LogicalDrives/1": SAMPLE_JSON_LV,
1322
1335
            b"redfish/v1/Services/1/LogicalDrives/2": SAMPLE_JSON_LVG,
1323
 
            b"redfish/v1/Services/1/LogicalDrives/3": SAMPLE_JSON_LV
 
1336
            b"redfish/v1/Services/1/LogicalDrives/3": LV_CHANGED,
1324
1337
        }
1325
1338
        targets = {
1326
1339
            b"redfish/v1/Services/1/Targets/1": SAMPLE_JSON_TARGET,
1327
 
            b"redfish/v1/Services/1/Targets/2": TARGET_CHANGED,
 
1340
            b"redfish/v1/Services/1/Targets/2": TARGET_CHANGED_1,
 
1341
            b"redfish/v1/Services/1/Targets/3": TARGET_CHANGED_2,
1328
1342
        }
1329
1343
 
1330
1344
        driver.get_pod_machine_remote_storages(
1331
 
            node_data, url, headers, logical_drives,
 
1345
            node_data, url, headers, remote_drives, logical_drives,
1332
1346
            targets, discovered_machine)
 
1347
        self.assertEquals(
 
1348
            set([
 
1349
                "/redfish/v1/Services/1/Targets/1",
 
1350
                "/redfish/v1/Services/1/Targets/2"]), remote_drives)
 
1351
        self.assertEquals(
 
1352
            {
 
1353
                b"redfish/v1/Services/1/LogicalDrives/1": SAMPLE_JSON_LV,
 
1354
                b"redfish/v1/Services/1/LogicalDrives/2": SAMPLE_JSON_LVG
 
1355
            }, logical_drives)
 
1356
        self.assertEquals(
 
1357
            {
 
1358
                b"redfish/v1/Services/1/Targets/1": SAMPLE_JSON_TARGET,
 
1359
                b"redfish/v1/Services/1/Targets/2": TARGET_CHANGED_1
 
1360
            }, targets)
1333
1361
        self.assertThat(
1334
1362
            discovered_machine.block_devices, MatchesListwise([
1335
1363
                MatchesStructure(
1368
1396
        discovered_machine = make_discovered_machine(block_devices=[])
1369
1397
        TARGET_CHANGED = deepcopy(SAMPLE_JSON_TARGET)
1370
1398
        TARGET_CHANGED['Addresses'][0]['iSCSI']['TargetLUN'].append({'LUN': 3})
 
1399
        remote_drives = set(
 
1400
            b"/redfish/v1/Services/1/Targets/1")
1371
1401
        logical_drives = {
1372
1402
            b"redfish/v1/Services/1/LogicalDrives/1": SAMPLE_JSON_LV,
1373
1403
            b"redfish/v1/Services/1/LogicalDrives/2": SAMPLE_JSON_LVG,
1379
1409
        }
1380
1410
 
1381
1411
        driver.get_pod_machine_remote_storages(
1382
 
            node_data, url, headers, logical_drives,
 
1412
            node_data, url, headers, remote_drives, logical_drives,
1383
1413
            targets, discovered_machine, request)
1384
1414
        self.assertThat(
1385
1415
            discovered_machine.block_devices, MatchesListwise([
1481
1511
        node_data = SAMPLE_JSON_NODE
1482
1512
        TARGET_CHANGED = deepcopy(SAMPLE_JSON_TARGET)
1483
1513
        TARGET_CHANGED['Addresses'][0]['iSCSI']['TargetLUN'].append({'LUN': 3})
 
1514
        remote_drives = set(
 
1515
            b"/redfish/v1/Services/1/Targets/1")
1484
1516
        logical_drives = {
1485
1517
            b"redfish/v1/Services/1/LogicalDrives/1": SAMPLE_JSON_LV,
1486
1518
            b"redfish/v1/Services/1/LogicalDrives/2": SAMPLE_JSON_LVG,
1506
1538
            driver, 'get_pod_machine_interfaces')
1507
1539
 
1508
1540
        machine = yield driver.get_pod_machine(
1509
 
            b"redfish/v1/Nodes/1", url, headers,
 
1541
            b"redfish/v1/Nodes/1", url, headers, remote_drives,
1510
1542
            logical_drives, targets, request)
1511
1543
        self.assertEquals(node_data['Name'], machine.hostname)
1512
1544
        self.assertEquals(
1523
1555
            MockCalledOnceWith(node_data, url, headers, machine, request))
1524
1556
        self.assertThat(
1525
1557
            mock_get_pod_machine_remote_storages,
1526
 
            MockCalledOnceWith(node_data, url, headers, logical_drives,
1527
 
                               targets, machine, request))
 
1558
            MockCalledOnceWith(node_data, url, headers, remote_drives,
 
1559
                               logical_drives, targets, machine, request))
1528
1560
        self.assertThat(
1529
1561
            mock_get_pod_machine_interfaces,
1530
1562
            MockCalledOnceWith(node_data, url, headers, machine))
1535
1567
        context = make_context()
1536
1568
        url = driver.get_url(context)
1537
1569
        headers = driver.make_auth_headers(**context)
 
1570
        remote_drives = set(
 
1571
            b"redfish/v1/Services/1/Targets/1")
1538
1572
        logical_drives = {
1539
1573
            factory.make_name('lv_path'): factory.make_name('lv_data')
1540
1574
            for _ in range(3)
1557
1591
        mock_get_pod_machine.return_value = expected_machines
1558
1592
 
1559
1593
        discovered_machines = yield driver.get_pod_machines(
1560
 
            url, headers, logical_drives, targets)
 
1594
            url, headers, remote_drives, logical_drives, targets)
1561
1595
        self.assertEquals(1, len(discovered_machines))
1562
1596
        self.assertThat(mock_get_pod_machine, MockCalledOnceWith(
1563
1597
            b"redfish/v1/Nodes/1", url, headers,
1564
 
            logical_drives, targets, None))
 
1598
            remote_drives, logical_drives, targets, None))
1565
1599
 
1566
1600
    def test__get_pod_hints(self):
1567
1601
        driver = RSDPodDriver()
1638
1672
            mock_get_pod_resources, MockCalledOnceWith(url, headers))
1639
1673
        self.assertThat(
1640
1674
            mock_get_pod_machines, MockCalledOnceWith(
1641
 
                url, headers, logical_drives, targets))
 
1675
                url, headers, remote_drives, logical_drives, targets))
1642
1676
        self.assertThat(mock_get_pod_hints, MockCalledOnceWith(
1643
1677
            mock_get_pod_resources.return_value))
1644
1678
 
1815
1849
            for _ in range(3)
1816
1850
        }
1817
1851
        remote_drives = set([
1818
 
            factory.make_name('target_path')
 
1852
            factory.make_name('target_path').encode('utf-8')
1819
1853
            for _ in range(3)
1820
1854
        ])
1821
1855
        mock_scrape_logical_drives_and_targets = self.patch(
2197
2231
        mock_get_composed_node_state = self.patch(
2198
2232
            driver, 'get_composed_node_state')
2199
2233
        mock_get_composed_node_state.return_value = power_change
 
2234
        mock_redfish_request = self.patch(driver, 'redfish_request')
 
2235
        NODE_POWERED_ON = deepcopy(SAMPLE_JSON_NODE)
 
2236
        NODE_POWERED_ON['PowerState'] = "On"
 
2237
        mock_redfish_request.return_value = (NODE_POWERED_ON, None)
2200
2238
 
2201
2239
        power_state = yield driver.power_query(system_id, context)
2202
2240
        self.assertThat(
2220
2258
        mock_get_composed_node_state = self.patch(
2221
2259
            driver, 'get_composed_node_state')
2222
2260
        mock_get_composed_node_state.return_value = power_change
 
2261
        mock_redfish_request = self.patch(driver, 'redfish_request')
 
2262
        mock_redfish_request.return_value = (SAMPLE_JSON_NODE, None)
2223
2263
 
2224
2264
        power_state = yield driver.power_query(system_id, context)
2225
2265
        self.assertThat(