Python TaskModel.wait方法代码示例

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class VolumeGroupsTests(unittest.TestCase):
    def setUp(self):
        objstore_loc = config.get_object_store() + "_ginger"
        self._objstore = ObjectStore(objstore_loc)
        self.task_model = TaskModel(objstore=self._objstore)

    def test_get_vg_list(self):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        vgs_list = vgs.get_list()
        self.assertGreaterEqual(len(vgs_list), 0)

    def test_create_vg_missing_name(self):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        pvpaths = ["/dev/sdb1"]
        params = {"pv_paths": pvpaths}
        self.assertRaises(MissingParameter, vgs.create, params)

    def test_create_vg_missing_pvpaths(self):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        vgname = "testvg"
        params = {"vg_name": vgname}
        self.assertRaises(MissingParameter, vgs.create, params)

    @mock.patch("wok.plugins.ginger.models.utils._create_vg", autospec=True)
    def test_create_vg(self, mock_create_vg):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        vgname = "testvg"
        pvpaths = ["/dev/sdb1"]
        params = {"vg_name": vgname, "pv_paths": pvpaths}
        task_obj = vgs.create(params)
        self.task_model.wait(task_obj.get("id"))
        mock_create_vg.assert_called_with(vgname, pvpaths)

    @mock.patch("wok.plugins.ginger.models.utils._extend_vg", autospec=True)
    def test_extend_vg(self, mock_extend_vg):
        vg = vol_group.VolumeGroupModel(objstore=self._objstore)
        vgname = "testvg"
        pvpaths = ["/dev/sdb2"]
        vg.extend(vgname, pvpaths)
        mock_extend_vg.assert_called_with(vgname, pvpaths)

    @mock.patch("wok.plugins.ginger.models.utils._reduce_vg", autospec=True)
    def test_reduce_vg(self, mock_reduce_vg):
        vg = vol_group.VolumeGroupModel(objstore=self._objstore)
        vgname = "testvg"
        pvpaths = ["/dev/sdb2"]
        vg.reduce(vgname, pvpaths)
        mock_reduce_vg.assert_called_with(vgname, pvpaths)

    @mock.patch("wok.plugins.ginger.models.utils._remove_vg", autospec=True)
    def test_delete_vg(self, mock_delete_vg):
        vg = vol_group.VolumeGroupModel(objstore=self._objstore)
        vgname = "testvg"
        vg.delete(vgname)
        mock_delete_vg.assert_called_with(vgname)

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class FirmwareProgressTests(unittest.TestCase):
    def setUp(self):
        objstore_loc = config.get_object_store() + '_ginger'
        self._objstore = ObjectStore(objstore_loc)
        self.task = TaskModel(objstore=self._objstore)

    def test_fwprogress_without_update_flash(self):
        fwprogress = FirmwareProgressModel(objstore=self._objstore)
        task_info = fwprogress.lookup()
        self.task.wait(task_info['id'])
        task_info = self.task.lookup(task_info['id'])

        self.assertEquals('finished', task_info['status'])
        self.assertIn('Error', task_info['message'])
        self.assertEquals('/plugins/ginger/fwprogress',
                          task_info['target_uri'])

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class LogicalVolumesTests(unittest.TestCase):
    def setUp(self):
        objstore_loc = config.get_object_store() + '_ginger'
        self._objstore = ObjectStore(objstore_loc)
        self.task_model = TaskModel(objstore=self._objstore)

    def test_get_lv_list(self):
        lvs = log_volume.LogicalVolumesModel(objstore=self._objstore)
        lvs_list = lvs.get_list()
        self.assertGreaterEqual(len(lvs_list), 0)

    def test_create_lv_missing_vgname(self):
        lvs = log_volume.LogicalVolumesModel(objstore=self._objstore)
        size = ['10M']
        params = {'size': size}
        self.assertRaises(MissingParameter, lvs.create, params)

    def test_create_lv_missing_size(self):
        lvs = log_volume.LogicalVolumesModel(objstore=self._objstore)
        vgname = 'testvg'
        params = {'vg_name': vgname}
        self.assertRaises(MissingParameter, lvs.create, params)

    @mock.patch('wok.plugins.ginger.model.utils._create_lv', autospec=True)
    def test_create_lv(self, mock_create_lv):
        lvs = log_volume.LogicalVolumesModel(objstore=self._objstore)
        vgname = 'testvg'
        size = '10M'
        params = {'vg_name': vgname, 'size': size}
        task_obj = lvs.create(params)
        self.task_model.wait(task_obj.get('id'))
        mock_create_lv.assert_called_with(vgname, size)

    @mock.patch('wok.plugins.ginger.model.utils._remove_lv',
                autospec=True)
    def test_delete_lv(self, mock_delete_lv):
        lv = log_volume.LogicalVolumeModel(objstore=self._objstore)
        lvname = '/dev/testvg/lvol0'
        lv.delete(lvname)
        mock_delete_lv.assert_called_with(lvname)

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class VolumeGroupsTests(unittest.TestCase):

    def setUp(self):
        objstore_loc = config.get_object_store() + '_ginger'
        self._objstore = ObjectStore(objstore_loc)
        self.task_model = TaskModel(objstore=self._objstore)

    def test_get_vg_list(self):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        vgs_list = vgs.get_list()
        self.assertGreaterEqual(len(vgs_list), 0)

    def test_create_vg_missing_name(self):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        pvpaths = ['/dev/sdb1']
        params = {'pv_paths': pvpaths}
        self.assertRaises(MissingParameter, vgs.create, params)

    def test_create_vg_missing_pvpaths(self):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        vgname = 'testvg'
        params = {'vg_name': vgname}
        self.assertRaises(MissingParameter, vgs.create, params)

    @mock.patch('wok.plugins.ginger.model.utils._create_vg', autospec=True)
    def test_create_vg(self, mock_create_vg):
        vgs = vol_group.VolumeGroupsModel(objstore=self._objstore)
        vgname = 'testvg'
        pvpaths = ['/dev/sdb1']
        params = {'vg_name': vgname, 'pv_paths': pvpaths}
        task_obj = vgs.create(params)
        self.task_model.wait(task_obj.get('id'))
        mock_create_vg.assert_called_with(vgname, pvpaths)

    @mock.patch('wok.plugins.ginger.model.utils._extend_vg', autospec=True)
    def test_extend_vg(self, mock_extend_vg):
        vg = vol_group.VolumeGroupModel(objstore=self._objstore)
        vgname = 'testvg'
        pvpaths = ['/dev/sdb2']
        vg.extend(vgname, pvpaths)
        mock_extend_vg.assert_called_with(vgname, pvpaths)

    @mock.patch('wok.plugins.ginger.model.utils._reduce_vg', autospec=True)
    def test_reduce_vg(self, mock_reduce_vg):
        vg = vol_group.VolumeGroupModel(objstore=self._objstore)
        vgname = 'testvg'
        pvpaths = ['/dev/sdb2']
        vg.reduce(vgname, pvpaths)
        mock_reduce_vg.assert_called_with(vgname, pvpaths)

    @mock.patch('wok.plugins.ginger.model.utils._remove_vg',
                autospec=True)
    @mock.patch('wok.plugins.ginger.model.utils.get_lvm_version')
    @mock.patch('wok.plugins.ginger.model.vol_group.VolumeGroupModel.lookup')
    def test_delete_vg(self, mock_vg_lookup, mock_lvm_version, mock_delete_vg):
        mock_lvm_version.return_value = "2.02.98"
        mock_vg_lookup.return_value = {'vgName': 'testvg', 'Cur LV': 0}
        vg = vol_group.VolumeGroupModel(objstore=self._objstore)
        vgname = 'testvg'
        vg.delete(vgname)
        mock_delete_vg.assert_called_with(vgname)

    def test_parse_lvm_version(self):
        lvm_version_input = "     2.02.98(2) (2012-10-15)"
        lvm_version = utils._parse_lvm_version(lvm_version_input)
        if lvm_version != "2.02.98":
            self.fail()

    def test_parse_lvm_version_exception(self):
        lvm_version_input = "     wrong version string"
        self.assertRaises(
            OperationFailed,
            utils._parse_lvm_version,
            lvm_version_input)

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]

#.........这里部分代码省略.........
        mock_get_module.return_value = 'mlx5_core'

        expected_error_msg = "GINNET0079E"
        with self.assertRaisesRegexp(InvalidParameter, expected_error_msg):
            iface_model = InterfaceModel(objstore=self._objstore)
            iface_model.enable_sriov('any_iface_name', 'not_an_int')

    @mock.patch('wok.plugins.gingerbase.netinfo.get_interface_kernel_module')
    @mock.patch('os.path.isfile')
    @mock.patch('wok.plugins.ginger.model.interfaces.InterfaceModel.'
                '_mlx5_SRIOV_get_max_VF')
    def test_mlx5_sriov_no_system_files_failure(self, mock_get_max_VF,
                                                mock_isfile,
                                                mock_get_module):
        mock_get_max_VF.return_value = '8'
        mock_get_module.return_value = 'mlx5_core'

        call_file1_not_exist = \
            '/sys/class/net/%s/device/sriov_numvfs' % 'iface1'
        call_file2_not_exist = \
            '/sys/class/net/%s/device/mlx5_num_vfs' % 'iface1'

        mock_isfile.side_effect = [False, False]

        mock_isfile_calls = [
            call(call_file1_not_exist),
            call(call_file2_not_exist)
        ]

        expected_error_msg = "GINNET0078E"
        with self.assertRaisesRegexp(OperationFailed, expected_error_msg):
            iface_model = InterfaceModel(objstore=self._objstore)
            task_obj = iface_model.enable_sriov('iface1', 4)
            self.task.wait(task_obj['id'])

            mock_isfile.assert_has_calls(mock_isfile_calls)

    @mock.patch('wok.plugins.gingerbase.netinfo.get_interface_kernel_module')
    @mock.patch('os.path.isfile')
    def test_mlx5_sriov_not_enabled_in_FW(self, mock_isfile, mock_get_module):
        mock_get_module.return_value = 'mlx5_core'

        file1 = '/sys/class/net/%s/device/sriov_totalvfs' % 'iface1'
        mock_isfile.return_value = False

        with self.assertRaisesRegexp(OperationFailed, 'GINNET0082E'):
            iface_model = InterfaceModel(objstore=self._objstore)
            iface_model.enable_sriov('iface1', 4)
            mock_isfile.assert_called_once_with(file1)

    @mock.patch('os.path.isfile')
    def test_mlx5_sriov_get_maxVF_value(self, mock_isfile):
        file1 = '/sys/class/net/%s/device/sriov_totalvfs' % 'iface1'
        mock_isfile.return_value = True

        open_ = mock_open(read_data='8\n')

        with patch.object(builtins, 'open', open_):
            iface_model = InterfaceModel(objstore=self._objstore)
            max_vf_str = iface_model._mlx5_SRIOV_get_max_VF('iface1')
            mock_isfile.assert_called_once_with(file1)
            self.assertEqual(max_vf_str, '8')

        self.assertEqual(open_.call_args_list, [call(file1, 'r')])

    @mock.patch('os.path.isfile')

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class PartitionTests(unittest.TestCase):
    def setUp(self):
        objstore_loc = config.get_object_store() + '_ginger'
        self._objstore = ObjectStore(objstore_loc)
        self.task_model = TaskModel(objstore=self._objstore)

    def test_get_part_list(self):
        parts = diskparts.PartitionsModel()
        parts_list = parts.get_list()
        self.assertGreaterEqual(len(parts_list), 0)

    def test_create_part_missing_device(self):
        parts = diskparts.PartitionsModel()
        size = '10M'
        params = {'partsize': size}
        self.assertRaises(MissingParameter, parts.create, params)

    def test_create_part_missing_size(self):
        parts = diskparts.PartitionsModel()
        dev = '/dev/sdb'
        params = {'devname': dev}
        self.assertRaises(MissingParameter, parts.create, params)

    @mock.patch('wok.plugins.ginger.model.utils.create_disk_part',
                autospec=True)
    def test_create_part(self, mock_create_part):
        parts = diskparts.PartitionsModel()
        dev = '/dev/sdb'
        size = '10M'
        params = {'devname': dev, 'partsize': size}
        parts.create(params)
        mock_create_part.return_value = 'sdb1'
        mock_create_part.assert_called_with(dev, size)

    @mock.patch('wok.plugins.ginger.model.utils.change_part_type',
                autospec=True)
    def test_change_part_type(self, mock_change_type):
        part = diskparts.PartitionModel(objstore=self._objstore)
        part_name = 'sdb1'
        type = '82'
        mock_change_type.return_value = 'sdb1'
        part.change_type(part_name, type)
        mock_change_type.assert_called_with(part_name, type)

    @mock.patch('wok.plugins.ginger.model.utils.delete_part',
                autospec=True)
    def test_delete_part(self, mock_delete_part):
        part = diskparts.PartitionModel(objstore=self._objstore)
        part_name = 'sdb1'
        part.delete(part_name)
        mock_delete_part.assert_called_with(part_name)

    @mock.patch('wok.plugins.ginger.model.utils._makefs', autospec=True)
    @mock.patch('wok.plugins.ginger.model.utils._is_mntd', autospec=True)
    def test_format_part(self, mock_is_mntd, mock_makefs):
        mock_is_mntd.return_value = False
        part = diskparts.PartitionModel(objstore=self._objstore)
        name = 'a_partition_name'
        fstype = 'ext4'
        task_obj = part.format(name, fstype)
        self.task_model.wait(task_obj.get('id'))
        mock_makefs.assert_called_with(fstype, name)

    @mock.patch('wok.plugins.ginger.model.diskparts.get_partition_details',
                autospec=True)
    def test_lookup_invalid_part_returns_404(self, mock_get_part_details):
        mock_get_part_details.side_effect = [NotFoundError]

        part = diskparts.PartitionModel(objstore=self._objstore)

        with self.assertRaises(NotFoundError):
            part.lookup('/a/invalid/partition')

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class FirmwareTests(unittest.TestCase):
    def setUp(self):
        objstore_loc = config.get_object_store() + "_ginger"
        self._objstore = ObjectStore(objstore_loc)
        self.task = TaskModel(objstore=self._objstore)

    @mock.patch("wok.plugins.ginger.model.firmware.run_command")
    def test_model_lookup(self, mock_run_command):
        return_output = "0 1 2 3 4 5 6 7 8 9 10 11 12 13"
        mock_run_command.return_value = [return_output, "", 0]
        firmware_lookup = FirmwareModel(objstore=self._objstore).lookup()
        mock_run_command.assert_called_once_with("lsmcode")
        self.assertEquals(firmware_lookup, {"level": "5 6 7 8 9 10 11 12 13"})

    @mock.patch("wok.plugins.ginger.model.firmware.run_command")
    def test_model_lookup_with_product_in_output(self, mock_run_command):
        return_output = "0 1 2 3 4 Product 6 7 8 9 10 11 12 13"
        mock_run_command.return_value = [return_output, "", 0]
        firmware_lookup = FirmwareModel(objstore=self._objstore).lookup()
        mock_run_command.assert_called_once_with("lsmcode")
        self.assertEquals(firmware_lookup, {"level": "13"})

    @mock.patch("wok.plugins.ginger.model.firmware.detect_live_vm")
    def test_model_update_fails_with_running_vm(self, mock_detect_vm):
        mock_detect_vm.return_value = True
        with self.assertRaises(OperationFailed):
            FirmwareModel(objstore=self._objstore).upgrade(None, None)

    @mock.patch("wok.plugins.ginger.model.firmware.detect_live_vm")
    @mock.patch("wok.plugins.ginger.model.firmware.run_command")
    def test_model_upgrade(self, mock_run_command, mock_detect_vm):
        mock_detect_vm.return_value = False
        mock_run_command.return_value = ["", "", 0]

        temp = tempfile.NamedTemporaryFile()
        task = FirmwareModel(objstore=self._objstore).upgrade(None, temp.name)
        self.task.wait(task["id"])
        self.assertTrue(mock_run_command.called, msg="Expected call to run_command. Not called")

        task_info = self.task.lookup(task["id"])
        self.assertEquals("finished", task_info["status"])
        self.assertEquals("/plugins/ginger/firmware/upgrade", task_info["target_uri"])

    @mock.patch("wok.plugins.ginger.model.firmware.detect_live_vm")
    @mock.patch("wok.plugins.ginger.model.firmware.run_command")
    def test_model_upgrade_overwrite_perm_false(self, mock_run_command, mock_detect_vm):
        mock_detect_vm.return_value = False
        mock_run_command.return_value = ["", "", 0]

        temp = tempfile.NamedTemporaryFile()
        task = FirmwareModel(objstore=self._objstore).upgrade(None, temp.name, False)
        self.task.wait(task["id"])
        self.assertTrue(mock_run_command.called, msg="Expected call to run_command. Not called")

        task_info = self.task.lookup(task["id"])
        self.assertEquals("finished", task_info["status"])
        self.assertEquals("/plugins/ginger/firmware/upgrade", task_info["target_uri"])

    @mock.patch("wok.plugins.ginger.model.firmware.run_command")
    def test_model_commit(self, mock_run_command):
        mock_run_command.return_value = ["", "", 0]
        command = ["update_flash", "-c"]
        FirmwareModel(objstore=self._objstore).commit(None)
        mock_run_command.assert_called_once_with(command)

    @mock.patch("wok.plugins.ginger.model.firmware.run_command")
    def test_model_reject(self, mock_run_command):
        mock_run_command.return_value = ["", "", 0]
        command = ["update_flash", "-r"]
        FirmwareModel(objstore=self._objstore).reject(None)
        mock_run_command.assert_called_once_with(command)

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]

#.........这里部分代码省略.........
            cb('ready for upload')
        else:
            cb('OK', True)

    def _create_volume_with_url(self, cb, params):
        pool_name = params['pool']
        name = params['name']
        url = params['url']

        pool_model = StoragePoolModel(conn=self.conn, objstore=self.objstore)
        pool = pool_model.lookup(pool_name)

        if pool['type'] in ['dir', 'netfs']:
            file_path = os.path.join(pool['path'], name)
        else:
            file_path = tempfile.mkstemp(prefix=name)[1]

        with contextlib.closing(urllib.request.urlopen(url)) as response:
            with open(file_path, 'w') as volume_file:
                remote_size = response.getheader('Content-Length', '-')
                downloaded_size = 0

                try:
                    while True:
                        chunk_data = response.read(
                            READ_CHUNK_SIZE).decode('utf-8')
                        if not chunk_data:
                            break

                        volume_file.write(chunk_data)
                        downloaded_size += len(chunk_data)
                        cb(f'{downloaded_size}/{remote_size}')
                except (IOError, libvirt.libvirtError) as e:
                    if os.path.isfile(file_path):
                        os.remove(file_path)

                    raise OperationFailed(
                        'KCHVOL0007E', {'name': name,
                                        'pool': pool_name, 'err': str(e)}
                    )

        if pool['type'] in ['dir', 'netfs']:
            virt_pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
            virt_pool.refresh(0)
        else:

            def _stream_handler(stream, nbytes, fd):
                return fd.read(nbytes)

            virt_stream = virt_vol = None

            try:
                task = self.create(
                    pool_name,
                    {
                        'name': name,
                        'format': 'raw',
                        'capacity': downloaded_size,
                        'allocation': downloaded_size,
                    },
                )
                self.task.wait(task['id'])
                virt_vol = StorageVolumeModel.get_storagevolume(
                    pool_name, name, self.conn
                )

                virt_stream = self.conn.get().newStream(0)
                virt_vol.upload(virt_stream, 0, downloaded_size, 0)

                with open(file_path) as fd:
                    virt_stream.sendAll(_stream_handler, fd)

                virt_stream.finish()
            except (IOError, libvirt.libvirtError) as e:
                try:
                    if virt_stream:
                        virt_stream.abort()
                    if virt_vol:
                        virt_vol.delete(0)
                except libvirt.libvirtError as e:
                    wok_log.error(str(e))
                finally:
                    raise OperationFailed(
                        'KCHVOL0007E', {'name': name,
                                        'pool': pool_name, 'err': str(e)}
                    )
            finally:
                os.remove(file_path)

        cb('OK', True)

    def get_list(self, pool_name):
        pool = StoragePoolModel.get_storagepool(pool_name, self.conn)
        if not pool.isActive():
            raise InvalidOperation('KCHVOL0006E', {'pool': pool_name})
        try:
            pool.refresh(0)
        except Exception as e:
            wok_log.error(f'Pool refresh failed: {e}')
        return sorted(pool.listVolumes())

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class BackupArchiveTests(unittest.TestCase):

    def setUp(self):
        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
        objstore_loc = self.temp_file.name
        self._objstore = ObjectStore(objstore_loc)

        self.task = TaskModel(objstore=self._objstore)

        ArchivesModel._archive_dir = '/tmp'
        ArchivesModel._default_include = []
        ArchivesModel._default_exclude = []

    def tearDown(self):
        self.temp_file.close()
        os.remove(self.temp_file.name)

    @mock.patch('wok.plugins.ginger.model.backup.run_command')
    @mock.patch('wok.plugins.ginger.model.backup.get_tar_create_timeout')
    @mock.patch('wok.plugins.ginger.model.backup._sha256sum')
    def test_create_and_lookup_backup_file(self, mock_sha256sum,
                                           mock_timeout, mock_run_command):
        include = []
        exclude = []
        descr = 'test_create_lookup_bkp_file'
        mock_run_command.return_value = ["", "", 0]
        mock_timeout.return_value = 10
        mock_sha256sum.return_value = 'sha256sum'

        params = {'include': [], 'exclude': [], 'description': descr}
        task_obj = ArchivesModel(objstore=self._objstore).create(params)
        self.task.wait(task_obj['id'])

        archive_id = task_obj['target_uri'].split("/")[-1]
        archive_file = os.path.join('/tmp', archive_id + '.tar.gz')

        cmd = ['tar', '--create', '--gzip', '--absolute-names',
               '--file', archive_file, '--selinux', '--acl',
               '--xattrs'] + exclude + include

        mock_run_command.asert_called_once_with(cmd)
        mock_sha256sum.asert_called_once_with(archive_file)

        lookup = ArchiveModel(objstore=self._objstore).lookup(archive_id)

        self.assertEqual(lookup.get('identity'), archive_id)
        self.assertEqual(lookup.get('include'), [])
        self.assertEqual(lookup.get('exclude'), [])
        self.assertEqual(lookup.get('description'), descr)
        self.assertEqual(lookup.get('file'), archive_file)

    @mock.patch('wok.objectstore.ObjectStoreSession.delete')
    @mock.patch('wok.plugins.ginger.model.backup.ArchivesModel.'
                '_session_get_list')
    @mock.patch('os.listdir')
    def test_archive_list_removes_deleted_tar_entries(self, mock_listdir,
                                                      mock_get_list,
                                                      mock_session_delete):

        mock_listdir.return_value = ['file1.tar.gz', 'file3.tar.gz']
        mock_get_list.return_value = ['file1', 'file2', 'file3', 'file4']

        ArchivesModel(objstore=self._objstore).get_list()

        mock_listdir.assert_called_once_with(ArchivesModel._archive_dir)
        mock_session_delete.assert_has_calls(
            [
                call(ArchivesModel._objstore_type, 'file2'),
                call(ArchivesModel._objstore_type, 'file4')
            ]
        )

# 需要导入模块: from wok.model.tasks import TaskModel [as 别名]
# 或者: from wok.model.tasks.TaskModel import wait [as 别名]
class FirmwareTests(unittest.TestCase):

    def setUp(self):
        objstore_loc = config.get_object_store() + '_ginger'
        self._objstore = ObjectStore(objstore_loc)
        self.task = TaskModel(objstore=self._objstore)

    @mock.patch('wok.plugins.ginger.model.firmware.run_command')
    def test_model_lookup(self, mock_run_command):
        return_output = "0 1 2 3 4 5 6 7 8 9 10 11 12 13"
        mock_run_command.return_value = [return_output, "", 0]
        firmware_lookup = FirmwareModel(objstore=self._objstore).lookup()
        mock_run_command.assert_called_once_with('lsmcode')
        self.assertEquals(
            firmware_lookup,
            {'level': "5 6 7 8 9 10 11 12 13"}
        )

    @mock.patch('wok.plugins.ginger.model.firmware.run_command')
    def test_model_lookup_with_product_in_output(self, mock_run_command):
        return_output = "0 1 2 3 4 Product 6 7 8 9 10 11 12 13"
        mock_run_command.return_value = [return_output, "", 0]
        firmware_lookup = FirmwareModel(objstore=self._objstore).lookup()
        mock_run_command.assert_called_once_with('lsmcode')
        self.assertEquals(firmware_lookup, {'level': '13'})

    @mock.patch('wok.plugins.ginger.model.firmware.detect_live_vm')
    def test_model_update_fails_with_running_vm(self, mock_detect_vm):
        mock_detect_vm.return_value = True
        with self.assertRaises(OperationFailed):
            FirmwareModel(objstore=self._objstore).upgrade(None, None)

    @mock.patch('wok.plugins.ginger.model.firmware.detect_live_vm')
    @mock.patch('wok.plugins.ginger.model.firmware.run_command')
    def test_model_update(self, mock_run_command, mock_detect_vm):
        mock_detect_vm.return_value = False
        mock_run_command.return_value = ["", "", 0]

        temp = tempfile.NamedTemporaryFile()
        command = ['update_flash', '-f', temp.name]

        task = FirmwareModel(objstore=self._objstore).upgrade(temp.name)
        self.task.wait(task['id'])
        mock_run_command.assert_called_once_with(
            command,
            tee='/tmp/fw_tee_log.txt'
        )

    @mock.patch('wok.plugins.ginger.model.firmware.detect_live_vm')
    @mock.patch('wok.plugins.ginger.model.firmware.run_command')
    def test_model_update_overwrite_perm_false(
        self,
        mock_run_command,
        mock_detect_vm
    ):

        mock_detect_vm.return_value = False
        mock_run_command.return_value = ["", "", 0]

        temp = tempfile.NamedTemporaryFile()
        command = ['update_flash', '-n', '-f', temp.name]

        task = FirmwareModel(objstore=self._objstore).upgrade(temp.name,
                                                              False)
        self.task.wait(task['id'])
        mock_run_command.assert_called_once_with(
            command,
            tee='/tmp/fw_tee_log.txt'
        )

    @mock.patch('wok.plugins.ginger.model.firmware.run_command')
    def test_model_commit(self, mock_run_command):
        mock_run_command.return_value = ["", "", 0]
        command = ['update_flash', '-c']
        FirmwareModel(objstore=self._objstore).commit(None)
        mock_run_command.assert_called_once_with(command)

    @mock.patch('wok.plugins.ginger.model.firmware.run_command')
    def test_model_reject(self, mock_run_command):
        mock_run_command.return_value = ["", "", 0]
        command = ['update_flash', '-r']
        FirmwareModel(objstore=self._objstore).reject(None)
        mock_run_command.assert_called_once_with(command)