예제 #1
0
    def test__parse_driver_info(self):
        # make sure we get back the expected things
        self.assertIsNotNone(self.info.get('address'))
        self.assertIsNotNone(self.info.get('username'))
        self.assertIsNotNone(self.info.get('password'))
        self.assertIsNotNone(self.info.get('uuid'))

        info = dict(INFO_DICT)

        # test the default value for 'priv_level'
        node = db_utils.get_test_node(driver_info=info)
        ret = ipmi._parse_driver_info(node)
        self.assertEqual('ADMINISTRATOR', ret['priv_level'])

        # ipmi_username / ipmi_password are not mandatory
        del info['ipmi_username']
        node = db_utils.get_test_node(driver_info=info)
        ipmi._parse_driver_info(node)
        del info['ipmi_password']
        node = db_utils.get_test_node(driver_info=info)
        ipmi._parse_driver_info(node)

        # make sure error is raised when ipmi_address is missing
        del info['ipmi_address']
        node = db_utils.get_test_node(driver_info=info)
        self.assertRaises(exception.InvalidParameterValue,
                          ipmi._parse_driver_info,
                          node)

        # test the invalid priv_level value
        self.info['priv_level'] = 'ABCD'
        node = db_utils.get_test_node(driver_info=info)
        self.assertRaises(exception.InvalidParameterValue,
                          ipmi._parse_driver_info,
                          node)
예제 #2
0
    def test_get_nodeinfo_list_provision(self, mock_utcnow):
        past = datetime.datetime(2000, 1, 1, 0, 0)
        next = past + datetime.timedelta(minutes=8)
        present = past + datetime.timedelta(minutes=10)
        mock_utcnow.return_value = past

        # node with provision_updated timeout
        n1 = utils.get_test_node(id=1, uuid=ironic_utils.generate_uuid(),
                                 provision_updated_at=past)
        # node with None in provision_updated_at
        n2 = utils.get_test_node(id=2, uuid=ironic_utils.generate_uuid(),
                                 provision_state=states.DEPLOYWAIT)
        # node without timeout
        n3 = utils.get_test_node(id=3, uuid=ironic_utils.generate_uuid(),
                                 provision_updated_at=next)
        self.dbapi.create_node(n1)
        self.dbapi.create_node(n2)
        self.dbapi.create_node(n3)

        mock_utcnow.return_value = present
        res = self.dbapi.get_nodeinfo_list(filters={'provisioned_before': 300})
        self.assertEqual([1], [r[0] for r in res])

        res = self.dbapi.get_nodeinfo_list(filters={'provision_state':
                                                    states.DEPLOYWAIT})
        self.assertEqual([2], [r[0] for r in res])
예제 #3
0
    def test_get_nodeinfo_list_with_filters(self):
        n1 = utils.get_test_node(id=1, driver='driver-one',
                                 instance_uuid=ironic_utils.generate_uuid(),
                                 reservation='fake-host',
                                 uuid=ironic_utils.generate_uuid())
        n2 = utils.get_test_node(id=2, driver='driver-two',
                                 uuid=ironic_utils.generate_uuid(),
                                 maintenance=True)
        self.dbapi.create_node(n1)
        self.dbapi.create_node(n2)

        res = self.dbapi.get_nodeinfo_list(filters={'driver': 'driver-one'})
        self.assertEqual([1], [r[0] for r in res])

        res = self.dbapi.get_nodeinfo_list(filters={'driver': 'bad-driver'})
        self.assertEqual([], [r[0] for r in res])

        res = self.dbapi.get_nodeinfo_list(filters={'associated': True})
        self.assertEqual([1], [r[0] for r in res])

        res = self.dbapi.get_nodeinfo_list(filters={'associated': False})
        self.assertEqual([2], [r[0] for r in res])

        res = self.dbapi.get_nodeinfo_list(filters={'reserved': True})
        self.assertEqual([1], [r[0] for r in res])

        res = self.dbapi.get_nodeinfo_list(filters={'reserved': False})
        self.assertEqual([2], [r[0] for r in res])

        res = self.dbapi.get_node_list(filters={'maintenance': True})
        self.assertEqual([2], [r.id for r in res])

        res = self.dbapi.get_node_list(filters={'maintenance': False})
        self.assertEqual([1], [r.id for r in res])
예제 #4
0
 def test_create_node_instance_already_associated(self):
     instance = ironic_utils.generate_uuid()
     n1 = utils.get_test_node(id=1, uuid=ironic_utils.generate_uuid(),
                              instance_uuid=instance)
     self.dbapi.create_node(n1)
     n2 = utils.get_test_node(id=2, uuid=ironic_utils.generate_uuid(),
                              instance_uuid=instance)
     self.assertRaises(exception.InstanceAssociated,
                       self.dbapi.create_node, n2)
예제 #5
0
    def test__sync_power_state_node_no_power_state(self):
        self.service.start()
        self.config(force_power_state_during_sync=False, group='conductor')

        # create three nodes
        nodes = []
        for i in range(0, 3):
            n = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid(),
                    driver='fake', power_state=states.POWER_OFF)
            self.dbapi.create_node(n)
            nodes.append(n['uuid'])

        # cannot get power state of node 2; only nodes 1 & 3 have
        # their power states changed.
        with mock.patch.object(self.driver.power,
                               'get_power_state') as get_power_mock:
            returns = [states.POWER_ON,
                       exception.InvalidParameterValue("invalid"),
                       states.POWER_ON]

            def side_effect(*args):
                result = returns.pop(0)
                if isinstance(result, Exception):
                    raise result
                return result

            get_power_mock.side_effect = side_effect
            self.service._sync_power_states(self.context)
            self.assertThat(returns, HasLength(0))

        final = [states.POWER_ON, states.POWER_OFF, states.POWER_ON]
        for i in range(0, 3):
            n = self.dbapi.get_node(nodes[i])
            self.assertEqual(n.power_state, final[i])
예제 #6
0
파일: test_acl.py 프로젝트: hongbin/ironic
    def setUp(self):
        super(TestACL, self).setUp()

        self.environ = {"fake.cache": utils.FakeMemcache()}
        self.fake_db_node = db_utils.get_test_node(chassis_id=None)
        self.dbapi = db_api.get_instance()
        self.node_path = "/nodes/%s" % self.fake_db_node["uuid"]
예제 #7
0
 def test__parse_driver_info_missing_creds(self):
     # make sure error is raised when info is missing
     info = db_utils.get_test_ssh_info('no-creds')
     node = db_utils.get_test_node(driver_info=info)
     self.assertRaises(exception.InvalidParameterValue,
             ssh._parse_driver_info,
             node)
예제 #8
0
파일: test_ssh.py 프로젝트: krast/ironic
 def setUp(self):
     super(SSHDriverTestCase, self).setUp()
     self.driver = mgr_utils.get_mocked_node_manager(driver="fake_ssh")
     self.node = db_utils.get_test_node(driver="fake_ssh", driver_info=db_utils.ssh_info)
     self.dbapi = dbapi.get_instance()
     self.dbapi.create_node(self.node)
     self.sshclient = paramiko.SSHClient()
예제 #9
0
    def test_change_node_power_state_node_already_locked(self,
                                                         pwr_act_mock):
        # Test change_node_power_state with mocked
        # conductor.utils.node_power_action.
        fake_reservation = 'fake-reserv'
        pwr_state = states.POWER_ON
        n = utils.get_test_node(driver='fake',
                                power_state=pwr_state,
                                reservation=fake_reservation)
        db_node = self.dbapi.create_node(n)
        self.service.start()

        self.assertRaises(exception.NodeLocked,
                          self.service.change_node_power_state,
                          self.context,
                          db_node.uuid,
                          states.POWER_ON)
        # In this test worker should not be spawned, but waiting to make sure
        # the below perform_mock assertion is valid.
        self.service._worker_pool.waitall()
        self.assertFalse(pwr_act_mock.called, 'node_power_action has been '
                                              'unexpectedly called.')
        # Verify existing reservation wasn't broken.
        db_node.refresh(self.context)
        self.assertEqual(fake_reservation, db_node.reservation)
예제 #10
0
    def setUp(self):
        super(SSHDriverTestCase, self).setUp()
        self.context = context.get_admin_context()
        mgr_utils.mock_the_extension_manager(driver="fake_ssh")
        self.driver = driver_factory.get_driver("fake_ssh")
        n = db_utils.get_test_node(
                driver='fake_ssh',
                driver_info=INFO_DICT)
        self.dbapi = dbapi.get_instance()
        self.node = self.dbapi.create_node(n)
        self.port = self.dbapi.create_port(db_utils.get_test_port(
                                                         node_id=self.node.id))
        self.sshclient = paramiko.SSHClient()

        #setup these mocks because most tests use them
        self.parse_drv_info_patcher = mock.patch.object(ssh,
                                                        '_parse_driver_info')
        self.parse_drv_info_mock = None
        self.get_mac_addr_patcher = mock.patch.object(
                ssh,
                '_get_nodes_mac_addresses')
        self.get_mac_addr_mock = self.get_mac_addr_patcher.start()
        self.get_conn_patcher = mock.patch.object(ssh, '_get_connection')
        self.get_conn_mock = self.get_conn_patcher.start()

        def stop_patchers():
            if self.parse_drv_info_mock:
                self.parse_drv_info_patcher.stop()
            if self.get_mac_addr_mock:
                self.get_mac_addr_patcher.stop()
            if self.get_conn_mock:
                self.get_conn_patcher.stop()

        self.addCleanup(stop_patchers)
예제 #11
0
 def test_maintenance_mode_on(self):
     ndict = utils.get_test_node(driver='fake')
     node = self.dbapi.create_node(ndict)
     self.service.change_node_maintenance_mode(self.context, node.uuid,
                                               True)
     node.refresh(self.context)
     self.assertTrue(node.maintenance)
예제 #12
0
    def test_change_node_power_state_worker_pool_full(self):
        # Test change_node_power_state including integration with
        # conductor.utils.node_power_action and lower.
        initial_state = states.POWER_OFF
        n = utils.get_test_node(driver='fake',
                                power_state=initial_state)
        db_node = self.dbapi.create_node(n)
        self.service.start()

        with mock.patch.object(self.service, '_spawn_worker') \
                as spawn_mock:
            spawn_mock.side_effect = exception.NoFreeConductorWorker()

            self.assertRaises(exception.NoFreeConductorWorker,
                              self.service.change_node_power_state,
                              self.context,
                              db_node.uuid,
                              states.POWER_ON)

            spawn_mock.assert_called_once_with(mock.ANY, mock.ANY,
                                               mock.ANY, mock.ANY)
            db_node.refresh(self.context)
            self.assertEqual(initial_state, db_node.power_state)
            self.assertIsNone(db_node.target_power_state)
            self.assertIsNone(db_node.last_error)
            # Verify the picked reservation has been cleared due to full pool.
            self.assertIsNone(db_node.reservation)
예제 #13
0
    def test_change_node_power_state_set_power_failure(self):
        """Test if an exception is thrown when the set_power call
        fails.
        """
        ndict = utils.get_test_node(driver='fake',
                                    power_state=states.POWER_OFF)
        node = self.dbapi.create_node(ndict)

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            with mock.patch.object(self.driver.power, 'set_power_state') \
                    as set_power_mock:
                get_power_mock.return_value = states.POWER_OFF
                set_power_mock.side_effect = exception.IronicException()

                self.assertRaises(exception.IronicException,
                                  self.service.change_node_power_state,
                                  self.context,
                                  node['uuid'],
                                  states.POWER_ON)
                node.refresh(self.context)
                get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
                set_power_mock.assert_called_once_with(mock.ANY, mock.ANY,
                                                       states.POWER_ON)
                self.assertEqual(node['power_state'], states.POWER_OFF)
                self.assertEqual(node['target_power_state'], None)
                self.assertNotEqual(node['last_error'], None)
예제 #14
0
 def test_disable_console_already_disabled(self):
     ndict = utils.get_test_node(driver='fake', console_enabled=False)
     node = self.dbapi.create_node(ndict)
     with mock.patch.object(self.driver.console, 'stop_console') \
             as mock_sc:
         self.service.set_console_mode(self.context, node.uuid, False)
         self.assertFalse(mock_sc.called)
예제 #15
0
    def test_change_node_power_state_invalid_state(self):
        """Test if an exception is thrown when changing to an invalid
        power state.
        """
        ndict = utils.get_test_node(driver='fake',
                                    power_state=states.POWER_ON)
        node = self.dbapi.create_node(ndict)

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            get_power_mock.return_value = states.POWER_ON

            self.assertRaises(exception.InvalidParameterValue,
                              self.service.change_node_power_state,
                              self.context,
                              node['uuid'],
                              "POWER")
            node.refresh(self.context)
            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
            self.assertEqual(node['power_state'], states.POWER_ON)
            self.assertEqual(node['target_power_state'], None)
            self.assertNotEqual(node['last_error'], None)

            # last_error is cleared when a new transaction happens
            self.service.change_node_power_state(self.context, node['uuid'],
                                                 states.POWER_OFF)
            node.refresh(self.context)
            self.assertEqual(node['power_state'], states.POWER_OFF)
            self.assertEqual(node['target_power_state'], None)
            self.assertEqual(node['last_error'], None)
예제 #16
0
    def setUp(self):
        super(TestACL, self).setUp()

        self.environ = {'fake.cache': utils.FakeMemcache()}
        self.fake_node = db_utils.get_test_node(chassis_id=None)
        self.dbapi = db_api.get_instance()
        self.node_path = '/nodes/%s' % self.fake_node['uuid']
예제 #17
0
 def test_post_ports_subresource(self):
     ndict = dbutils.get_test_node()
     self.post_json('/nodes', ndict)
     pdict = dbutils.get_test_port()
     response = self.post_json('/nodes/ports', pdict,
                               expect_errors=True)
     self.assertEqual(response.status_int, 403)
예제 #18
0
 def setUp(self):
     super(ManagerRpcAPITestCase, self).setUp()
     self.context = context.get_admin_context()
     self.dbapi = dbapi.get_instance()
     self.fake_node = json.to_primitive(dbutils.get_test_node(
                                         control_driver='fake',
                                         deploy_driver='fake'))
예제 #19
0
    def test_destroy_node(self):
        n = utils.get_test_node()
        self.dbapi.create_node(n)

        self.dbapi.destroy_node(n['id'])
        self.assertRaises(exception.NodeNotFound,
                          self.dbapi.destroy_node, n['id'])
예제 #20
0
    def test_change_node_power_state_in_same_state(self):
        """Test that we don't try to set the power state if the requested
        state is the same as the current state.
        """
        ndict = utils.get_test_node(driver='fake',
                                    last_error='anything but None',
                                    power_state=states.POWER_ON)
        node = self.dbapi.create_node(ndict)

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            get_power_mock.return_value = states.POWER_ON
            with mock.patch.object(self.driver.power, 'set_power_state') \
                    as set_power_mock:
                set_power_mock.side_effect = exception.IronicException()

                self.service.change_node_power_state(self.context,
                                                     node['uuid'],
                                                     states.POWER_ON)
            node.refresh(self.context)
            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
            self.assertFalse(set_power_mock.called)
            self.assertEqual(node['power_state'], states.POWER_ON)
            self.assertEqual(node['target_power_state'], None)
            self.assertEqual(node['last_error'], None)
예제 #21
0
    def test_node_power_action_invalid_state(self):
        """Test if an exception is thrown when changing to an invalid
        power state.
        """
        ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
                                    driver='fake',
                                    power_state=states.POWER_ON)
        node = self.dbapi.create_node(ndict)
        task = task_manager.TaskManager(self.context, node.uuid)

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            get_power_mock.return_value = states.POWER_ON

            self.assertRaises(exception.InvalidParameterValue,
                              conductor_utils.node_power_action,
                              task,
                              task.node,
                              "INVALID_POWER_STATE")

            node.refresh(self.context)
            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
            self.assertEqual(node['power_state'], states.POWER_ON)
            self.assertIsNone(node['target_power_state'])
            self.assertIsNotNone(node['last_error'])

            # last_error is cleared when a new transaction happens
            conductor_utils.node_power_action(task, task.node,
                                              states.POWER_OFF)
            node.refresh(self.context)
            self.assertEqual(node['power_state'], states.POWER_OFF)
            self.assertIsNone(node['target_power_state'])
            self.assertIsNone(node['last_error'])
예제 #22
0
파일: test_ssh.py 프로젝트: seamicro/ironic
    def setUp(self):
        super(SSHDriverTestCase, self).setUp()
        self.driver = mgr_utils.get_mocked_node_manager(driver='fake_ssh')
        self.node = db_utils.get_test_node(
                        driver='fake_ssh',
                        driver_info=INFO_DICT)
        self.dbapi = dbapi.get_instance()
        self.dbapi.create_node(self.node)
        self.sshclient = paramiko.SSHClient()

        #setup these mocks because most tests use them
        self.parse_drv_info_patcher = mock.patch.object(ssh,
                                                        '_parse_driver_info')
        self.parse_drv_info_mock = None
        self.get_mac_addr_patcher = mock.patch.object(
                ssh,
                '_get_nodes_mac_addresses')
        self.get_mac_addr_mock = self.get_mac_addr_patcher.start()
        self.get_conn_patcher = mock.patch.object(ssh, '_get_connection')
        self.get_conn_mock = self.get_conn_patcher.start()

        def stop_patchers():
            if self.parse_drv_info_mock:
                self.parse_drv_info_patcher.stop()
            if self.get_mac_addr_mock:
                self.get_mac_addr_patcher.stop()
            if self.get_conn_mock:
                self.get_conn_patcher.stop()

        self.addCleanup(stop_patchers)
예제 #23
0
 def test_create_port_using_node_name(self, mock_utcnow, mock_anln):
     mock_anln.return_value = True
     pdict = apiutils.port_post_data()
     ndict = dbutils.get_test_node()
     del pdict['node_id']
     ndict['name'] = 'nodenaaame'
     ndict['created_at'] = datetime.datetime(2000, 1, 1, 0, 0)
     ndict['uuid'] = '1ab23c4d-03f2-4d2e-ae87-c02d7f33c126'
     node = obj_utils.create_test_node(self.context, **ndict)
     pdict['node'] = node.name
     test_time = datetime.datetime(2000, 1, 1, 0, 0)
     mock_utcnow.return_value = test_time
     response = self.post_json('/ports', pdict)
     self.assertEqual(201, response.status_int)
     result = self.get_json('/ports/%s' % pdict['uuid'])
     self.assertEqual(pdict['uuid'], result['uuid'])
     self.assertFalse(result['updated_at'])
     return_created_at = timeutils.parse_isotime(
         result['created_at']).replace(tzinfo=None)
     self.assertEqual(test_time, return_created_at)
     # Check location header
     self.assertIsNotNone(response.location)
     expected_location = '/v1/ports/%s' % pdict['uuid']
     self.assertEqual(urlparse.urlparse(response.location).path,
                      expected_location)
     data = self.get_json("/ports?node=%s" % pdict['node'],
                          headers={api_controller.Version.string: '1.5'})
     data = self.get_json('/ports/%s' % pdict['uuid'])
     self.assertEqual(pdict['uuid'], data['uuid'])
     self.assertIn('extra', data)
     self.assertIn('node', data)
예제 #24
0
    def test_node_power_action_invalid_driver_info(self):
        """Test if an exception is thrown when the driver validation
        fails.
        """
        ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
                                    driver='fake',
                                    power_state=states.POWER_ON)
        node = self.dbapi.create_node(ndict)
        task = task_manager.TaskManager(self.context, node.uuid)

        with mock.patch.object(self.driver.power, 'validate') \
                as validate_mock:
            validate_mock.side_effect = exception.InvalidParameterValue(
                'wrong power driver info')

            self.assertRaises(exception.InvalidParameterValue,
                              conductor_utils.node_power_action,
                              task,
                              task.node,
                              states.POWER_ON)

            node.refresh(self.context)
            validate_mock.assert_called_once_with(mock.ANY, mock.ANY)
            self.assertEqual(node['power_state'], states.POWER_ON)
            self.assertIsNone(node['target_power_state'])
            self.assertIsNotNone(node['last_error'])
예제 #25
0
    def test__sync_power_state_multiple_nodes(self):
        self.service.start()

        # create three nodes
        nodes = []
        for i in range(0, 3):
            n = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid(),
                    driver='fake', power_state=states.POWER_OFF)
            self.dbapi.create_node(n)
            nodes.append(n['uuid'])

        # lock the first node
        self.dbapi.reserve_nodes('fake-reserve', [nodes[0]])

        with mock.patch.object(self.driver.power,
                               'get_power_state') as get_power_mock:
            get_power_mock.return_value = states.POWER_ON
            with mock.patch.object(self.dbapi,
                                   'get_nodeinfo_list') as get_fnl_mock:
                # delete the second node
                self.dbapi.destroy_node(nodes[1])
                get_fnl_mock.return_value = [[n] for n in nodes]
                self.service._sync_power_states(self.context)
            # check that get_power only called once, which updated third node
            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
        n1 = self.dbapi.get_node(nodes[0])
        n3 = self.dbapi.get_node(nodes[2])
        self.assertEqual(n1['power_state'], states.POWER_OFF)
        self.assertEqual(n3['power_state'], states.POWER_ON)
예제 #26
0
 def test_validate_vendor_action_no_parameter(self):
     n = utils.get_test_node(driver='fake')
     self.dbapi.create_node(n)
     info = {'fake': 'baz'}
     self.assertRaises(exception.InvalidParameterValue,
                       self.service.validate_vendor_action,
                       self.context, n['uuid'], 'foo', info)
예제 #27
0
 def setUp(self):
     super(RPCAPITestCase, self).setUp()
     self.dbapi = dbapi.get_instance()
     self.fake_node = dbutils.get_test_node(driver='fake-driver')
     self.fake_node_obj = objects.Node._from_db_object(
                                                 objects.Node(self.context),
                                                 self.fake_node)
예제 #28
0
    def test_node_power_action_set_power_failure(self):
        """Test if an exception is thrown when the set_power call
        fails.
        """
        ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
                                    driver='fake',
                                    power_state=states.POWER_OFF)
        node = self.dbapi.create_node(ndict)
        task = task_manager.TaskManager(self.context, node.uuid)

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            with mock.patch.object(self.driver.power, 'set_power_state') \
                    as set_power_mock:
                get_power_mock.return_value = states.POWER_OFF
                set_power_mock.side_effect = exception.IronicException()

                self.assertRaises(
                    exception.IronicException,
                    conductor_utils.node_power_action,
                    task,
                    task.node,
                    states.POWER_ON)

                node.refresh(self.context)
                get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
                set_power_mock.assert_called_once_with(mock.ANY, mock.ANY,
                                                       states.POWER_ON)
                self.assertEqual(node['power_state'], states.POWER_OFF)
                self.assertIsNone(node['target_power_state'])
                self.assertIsNotNone(node['last_error'])
예제 #29
0
    def test_change_node_power_state_power_on(self):
        # Test change_node_power_state including integration with
        # conductor.utils.node_power_action and lower.
        n = utils.get_test_node(driver='fake',
                                power_state=states.POWER_OFF)
        db_node = self.dbapi.create_node(n)
        self.service.start()

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            get_power_mock.return_value = states.POWER_OFF

            self.service.change_node_power_state(self.context,
                                                 db_node.uuid,
                                                 states.POWER_ON)
            self.service._worker_pool.waitall()

            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
            db_node.refresh(self.context)
            self.assertEqual(states.POWER_ON, db_node.power_state)
            self.assertIsNone(db_node.target_power_state)
            self.assertIsNone(db_node.last_error)
            # Verify the reservation has been cleared by
            # background task's link callback.
            self.assertIsNone(db_node.reservation)
예제 #30
0
    def test_node_power_action_in_same_state(self):
        """Test that we don't try to set the power state if the requested
        state is the same as the current state.
        """
        ndict = utils.get_test_node(uuid=cmn_utils.generate_uuid(),
                                    driver='fake',
                                    last_error='anything but None',
                                    power_state=states.POWER_ON)
        node = self.dbapi.create_node(ndict)
        task = task_manager.TaskManager(self.context, node.uuid)

        with mock.patch.object(self.driver.power, 'get_power_state') \
                as get_power_mock:
            get_power_mock.return_value = states.POWER_ON

            with mock.patch.object(self.driver.power, 'set_power_state') \
                    as set_power_mock:
                conductor_utils.node_power_action(task, task.node,
                                                  states.POWER_ON)

                node.refresh(self.context)
                get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
                self.assertFalse(set_power_mock.called,
                                 "set_power_state unexpectedly called")
                self.assertEqual(node['power_state'], states.POWER_ON)
                self.assertIsNone(node['target_power_state'])
                self.assertIsNone(node['last_error'])
예제 #31
0
 def _create_test_node(self, **kwargs):
     n = db_utils.get_test_node(**kwargs)
     return self.dbapi.create_node(n)
예제 #32
0
파일: test_ssh.py 프로젝트: mydaisy2/ironic
 def setUp(self):
     super(SSHPrivateMethodsTestCase, self).setUp()
     self.node = db_utils.get_test_node(
                     driver='fake_ssh',
                     driver_info=db_utils.ssh_info)
     self.sshclient = paramiko.SSHClient()
예제 #33
0
def post_get_test_port(**kw):
    port = apiutils.port_post_data(**kw)
    node = dbutils.get_test_node()
    del port['node_id']
    port['node_uuid'] = kw.get('node_uuid', node['uuid'])
    return port
예제 #34
0
 def setUp(self):
     super(BareMetalIPMITestCase, self).setUp()
     self.node = db_utils.get_test_node()
     self.ipmi = ipmi.IPMIPowerDriver(self.node)
예제 #35
0
 def setUp(self):
     super(IPMIToolPrivateMethodTestCase, self).setUp()
     self.node = db_utils.get_test_node(driver='fake_ipmitool',
                                        driver_info=INFO_DICT)
     self.info = ipmi._parse_driver_info(self.node)
예제 #36
0
 def setUp(self):
     super(RPCAPITestCase, self).setUp()
     self.fake_node = dbutils.get_test_node(driver='fake-driver')
     self.fake_node_obj = objects.Node._from_db_object(
         objects.Node(self.context), self.fake_node)
예제 #37
0
 def setUp(self):
     super(TestDelete, self).setUp()
     ndict = dbutils.get_test_node()
     self.node = self.dbapi.create_node(ndict)
     pdict = dbutils.get_test_port()
     self.dbapi.create_port(pdict)
예제 #38
0
 def setUp(self):
     super(TestListPorts, self).setUp()
     ndict = dbutils.get_test_node()
     self.node = self.dbapi.create_node(ndict)
예제 #39
0
 def setUp(self):
     super(TestPatch, self).setUp()
     ndict = dbutils.get_test_node()
     self.node = self.dbapi.create_node(ndict)
     self.pdict = dbutils.get_test_port(id=None)
     self.dbapi.create_port(self.pdict)
예제 #40
0
 def test__parse_driver_info_too_many(self):
     info = db_utils.get_test_ssh_info('too_many')
     node = db_utils.get_test_node(driver='fake_ssh', driver_info=info)
     self.assertRaises(exception.InvalidParameterValue,
                       ssh._parse_driver_info, node)
예제 #41
0
 def test_get_nodeinfo_list_defaults(self):
     for i in range(1, 6):
         n = utils.get_test_node(id=i, uuid=ironic_utils.generate_uuid())
         self.dbapi.create_node(n)
     res = [i[0] for i in self.dbapi.get_nodeinfo_list()]
     self.assertEqual(sorted(res), sorted(range(1, 6)))
예제 #42
0
 def test__parse_driver_info_missing_creds(self):
     # make sure error is raised when info is missing
     info = db_utils.get_test_ssh_info('no-creds')
     node = db_utils.get_test_node(driver_info=info)
     self.assertRaises(exception.InvalidParameterValue,
                       ssh._parse_driver_info, node)
예제 #43
0
파일: test_acl.py 프로젝트: johalee/Ironic
    def setUp(self):
        super(TestACL, self).setUp()

        self.environ = {'fake.cache': utils.FakeMemcache()}
        self.fake_db_node = db_utils.get_test_node(chassis_id=None)
        self.node_path = '/nodes/%s' % self.fake_db_node['uuid']
예제 #44
0
 def test__parse_driver_info_bad_file(self):
     # A filename that doesn't exist errors.
     info = db_utils.get_test_ssh_info('file')
     node = db_utils.get_test_node(driver='fake_ssh', driver_info=info)
     self.assertRaises(exception.InvalidParameterValue,
                       ssh._parse_driver_info, node)
예제 #45
0
 def test_create_node_nullable_chassis_id(self):
     n = utils.get_test_node()
     del n['chassis_id']
     self.dbapi.create_node(n)
예제 #46
0
 def setUp(self):
     super(TestNodeObject, self).setUp()
     self.fake_node = utils.get_test_node()
     self.dbapi = db_api.get_instance()
예제 #47
0
파일: test_nodes.py 프로젝트: schatt/ironic
 def test_create_node(self):
     n = utils.get_test_node()
     self.dbapi.create_node(n)
예제 #48
0
 def setUp(self):
     super(IPMIPrivateMethodTestCase, self).setUp()
     self.node = db_utils.get_test_node(driver='fake_ipmi',
                                        driver_info=db_utils.ipmi_info)
     self.info = ipmi._parse_driver_info(self.node)
예제 #49
0
 def setUp(self):
     super(TestNodeObject, self).setUp()
     self.fake_node = utils.get_test_node()
예제 #50
0
 def test_delete_ports_subresource(self):
     ndict = dbutils.get_test_node()
     self.dbapi.create_node(ndict)
     response = self.delete('/nodes/%s/ports' % ndict['uuid'],
                            expect_errors=True)
     self.assertEqual(403, response.status_int)
예제 #51
0
def node_post_data(**kw):
    node = utils.get_test_node(**kw)
    node.pop('conductor_affinity')
    internal = node_controller.NodePatchType.internal_attrs()
    return remove_internal(node, internal)
예제 #52
0
    def test_ports_subresource_link(self):
        ndict = dbutils.get_test_node()
        self.dbapi.create_node(ndict)

        data = self.get_json('/nodes/%s' % ndict['uuid'])
        self.assertIn('ports', data.keys())
예제 #53
0
 def test_create_node_already_exists(self):
     n = utils.get_test_node()
     del n['id']
     self.dbapi.create_node(n)
     self.assertRaises(exception.NodeAlreadyExists, self.dbapi.create_node,
                       n)
예제 #54
0
 def test_detail_against_single(self):
     ndict = dbutils.get_test_node()
     node = self.dbapi.create_node(ndict)
     response = self.get_json('/nodes/%s/detail' % node['uuid'],
                              expect_errors=True)
     self.assertEqual(404, response.status_int)
예제 #55
0
 def test_delete_node(self, mock_dn):
     ndict = dbutils.get_test_node()
     self.dbapi.create_node(ndict)
     self.delete('/nodes/%s' % ndict['uuid'])
     mock_dn.assert_called_once_with(mock.ANY, ndict['uuid'], 'test-topic')
예제 #56
0
 def setUp(self):
     super(FakeDriverTestCase, self).setUp()
     self.driver = fake.FakeDriver()
     self.node = db_utils.get_test_node()
예제 #57
0
def create_fake_node(i):
    dbh = dbapi.get_instance()
    node = utils.get_test_node(id=i,
                               uuid=ironic_utils.generate_uuid())
    dbh.create_node(node)
    return node['uuid']