def setUp(self): super(ResourcesTest, self).setUp() self.fs = fake_filesystem.FakeFilesystem() resources.os = fake_filesystem.FakeOsModule(self.fs) self.fs.CreateFile('/test/file.txt') self.fs.CreateFile('/test2/resources/file.txt')
def stat(self): fake_os = ffs.FakeOsModule(self._fs) return fake_os.stat(self._path)
def test_run_snappy_itransfer_ngs_mapping_smoke_test(mocker, germline_trio_sheet_tsv, minimal_config): fake_base_path = "/base/path" dest_path = "/irods/dest" sodar_uuid = "466ab946-ce6a-4c78-9981-19b79e7bbe86" argv = [ "--verbose", "snappy", "itransfer-step", "--step", "ngs_mapping", "--base-path", fake_base_path, "--sodar-api-token", "XXXX", sodar_uuid, "--tool", "bwa", ] parser, subparsers = setup_argparse() args = parser.parse_args(argv) # Setup fake file system but only patch selected modules. We cannot use the Patcher approach here as this would # break both biomedsheets and multiprocessing. fs = fake_filesystem.FakeFilesystem() fake_file_paths = [] for member in ("index", "father", "mother"): for ext in ("", ".md5"): fake_file_paths.append( "%s/ngs_mapping/output/bwa.%s-N1-DNA1-WES1/out/%s-N1-DNA1-WES1.bam%s" % (fake_base_path, member, member, ext)) fs.create_file(fake_file_paths[-1]) fake_file_paths.append( "%s/ngs_mapping/output/bwa.%s-N1-DNA1-WES1/log/bwa.%s-N1-DNA1-WES1.log%s" % (fake_base_path, member, member, ext)) fs.create_file(fake_file_paths[-1]) # Create sample sheet in fake file system sample_sheet_path = fake_base_path + "/.snappy_pipeline/sheet.tsv" fs.create_file(sample_sheet_path, contents=germline_trio_sheet_tsv, create_missing_dirs=True) # Create config in fake file system config_path = fake_base_path + "/.snappy_pipeline/config.yaml" fs.create_file(config_path, contents=minimal_config, create_missing_dirs=True) # Print path to all created files print("\n".join(fake_file_paths + [sample_sheet_path, config_path])) # Remove index's log MD5 file again so it is recreated. fs.remove(fake_file_paths[3]) # Set Mocker mocker.patch("pathlib.Path.exists", my_exists) mocker.patch( "cubi_tk.snappy.itransfer_common.SnappyItransferCommandBase.get_sodar_info", my_get_sodar_info, ) fake_os = fake_filesystem.FakeOsModule(fs) mocker.patch("glob.os", fake_os) mocker.patch("cubi_tk.snappy.itransfer_common.os", fake_os) mocker.patch("cubi_tk.snappy.itransfer_step.os", fake_os) mock_check_output = mock.mock_open() mocker.patch("cubi_tk.snappy.itransfer_common.check_output", mock_check_output) fake_open = fake_filesystem.FakeFileOpen(fs) mocker.patch("cubi_tk.snappy.itransfer_common.open", fake_open) mocker.patch("cubi_tk.snappy.common.open", fake_open) mock_check_call = mock.mock_open() mocker.patch("cubi_tk.snappy.itransfer_common.check_call", mock_check_call) # Actually exercise code and perform test. res = main(argv) assert not res # We do not care about call order but simply test call count and then assert that all files are there which would # be equivalent of comparing sets of files. assert fs.exists(fake_file_paths[3]) assert mock_check_call.call_count == 1 mock_check_call.assert_called_once_with( ["md5sum", "bwa.index-N1-DNA1-WES1.log"], cwd=os.path.dirname(fake_file_paths[3]), stdout=ANY, ) assert mock_check_output.call_count == len(fake_file_paths) * 3 for path in fake_file_paths: mapper_index, rel_path = os.path.relpath( path, os.path.join(fake_base_path, "ngs_mapping/output")).split("/", 1) _mapper, index = mapper_index.rsplit(".", 1) remote_path = os.path.join(dest_path, index, "ngs_mapping", args.remote_dir_date, rel_path) expected_mkdir_argv = ["imkdir", "-p", os.path.dirname(remote_path)] expected_irsync_argv = [ "irsync", "-a", "-K", path, "i:%s" % remote_path ] expected_ils_argv = ["ils", os.path.dirname(remote_path)] mock_check_output.assert_any_call(expected_mkdir_argv) mock_check_output.assert_any_call(expected_irsync_argv) mock_check_output.assert_any_call(expected_ils_argv, stderr=-2)
'headers': ['name', 'ward', 'party', 'other'], 'row-count': 79, 'source': '/data/resources/31f/d4c/1e-9c82-424b-b78b-48cd08db6e64', 'time': 0.007, 'valid': True }], 'time': 0.009, 'valid': True, 'warnings': [] } real_open = open _fs = fake_filesystem.FakeFilesystem() _mock_os = fake_filesystem.FakeOsModule(_fs) _mock_file_open = fake_filesystem.FakeFileOpen(_fs) def _mock_open_if_open_fails(*args, **kwargs): try: return real_open(*args, **kwargs) except (OSError, IOError): return _mock_file_open(*args, **kwargs) def mock_uploads(func): @change_config('ckan.storage_path', '/doesnt_exist') @mock.patch.object(ckan.lib.uploader, 'os', _mock_os) @mock.patch.object(builtins, 'open', side_effect=_mock_open_if_open_fails) @mock.patch.object(ckan.lib.uploader, '_storage_path', new='/doesnt_exist')
class FakeFsMixin(object): fs = fake_filesystem.FakeFilesystem() f_open = fake_filesystem.FakeFileOpen(fs) f_os = fake_filesystem.FakeOsModule(fs) builtins_open = 'builtins.open'
def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem(path_separator='/') self.pathlib = fake_pathlib.FakePathlibModule(self.filesystem) self.os = fake_filesystem.FakeOsModule(self.filesystem)
def setUp(self): super(FileUtilTest, self).setUp() self.filesystem = fake_filesystem.FakeFilesystem() file_util.os = fake_filesystem.FakeOsModule(self.filesystem) file_util.open = fake_filesystem.FakeFileOpen(self.filesystem)
class TestOSDInstanceMethods(): ''' This class contains a set of functions that test srv.salt._modules.osd ''' fs = fake_fs.FakeFilesystem() dev_dir = '/dev' devices = [ 'sda', 'sdaa', 'sda1', 'sda10', 'sdaa1', 'sdaa10', 'sdax', 'sdax10', 'nvme0n1', 'nvme1n1', 'nvme100n1', 'nvme0n1p1', 'nvme0n1p100', 'nvme0n100', 'nvme1n1p1', 'nvme100n1p1' ] for dev in devices: fs.CreateFile('{}/{}'.format(dev_dir, dev)) f_glob = fake_glob.FakeGlobModule(fs) f_os = fake_fs.FakeOsModule(fs) f_open = fake_fs.FakeFileOpen(fs) @mock.patch('srv.salt._modules.osd.glob') def test_paths(self, glob): glob.return_value.glob = [] ret = osd.paths() glob.glob.assert_called_once() glob.glob.assert_called_with('/var/lib/ceph/osd/*') assert type(ret) is list @mock.patch('srv.salt._modules.osd.glob') def test_devices(self, glob): glob.return_value.glob = [] ret = osd.devices() glob.glob.assert_called_once() glob.glob.assert_called_with('/var/lib/ceph/osd/*') assert type(ret) is list @mock.patch('srv.salt._modules.osd.glob') def test_pairs(self, glob): glob.return_value.glob = [] ret = osd.pairs() glob.glob.assert_called_once() glob.glob.assert_called_with('/var/lib/ceph/osd/*') assert type(ret) is list @pytest.mark.skip(reason="Postponed to later") def test_filter_devices(self): pass @pytest.mark.skip(reason="about to be refactored") def test_configured(self): pass @mock.patch('srv.salt._modules.osd.glob') def test_list_(self, glob): glob.return_value.glob = [] osd.__grains__ = {'ceph': {'foo': 'mocked_grain'}} ret = osd.list_() glob.glob.assert_called_once() glob.glob.assert_called_with('/var/lib/ceph/osd/*/fsid') assert 'foo' in ret assert type(ret) is list osd.__grains__ = {} @mock.patch('srv.salt._modules.osd.glob') def test_list_no_grains(self, glob): glob.return_value.glob = [] ret = osd.list_() glob.glob.assert_called_once() glob.glob.assert_called_with('/var/lib/ceph/osd/*/fsid') assert type(ret) is list @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_default(self): ret = osd._find_paths('/dev/sda') assert sorted(ret) == sorted(['/dev/sda10', '/dev/sda1']) @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_none(self): ret = osd._find_paths('/dev/sdx') assert ret == [] @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_long(self): ret = osd._find_paths('/dev/sdaa') assert sorted(ret) == sorted(['/dev/sdaa10', '/dev/sdaa1']) @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_one_high(self): ret = osd._find_paths('/dev/sdax') assert sorted(ret) == sorted(['/dev/sdax10']) @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_nvme_1(self): ret = osd._find_paths('/dev/nvme0n1') assert sorted(ret) == sorted(['/dev/nvme0n1p1', '/dev/nvme0n1p100']) @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_nvme_2(self): ret = osd._find_paths('/dev/nvme0n1') assert sorted(ret) == sorted(['/dev/nvme0n1p1', '/dev/nvme0n1p100']) @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_nvme_3(self): ret = osd._find_paths('/dev/nvme1n1') assert ret == ['/dev/nvme1n1p1'] @mock.patch('glob.glob', new=f_glob.glob) def test__find_paths_nvme_4(self): ret = osd._find_paths('/dev/nvme100n1') assert ret == ['/dev/nvme100n1p1'] @mock.patch('srv.salt._modules.osd.time') def test_readlink_shortname(self, mock_time): osd.__salt__ = {} osd.__salt__['helper.run'] = mock.Mock() osd.__salt__['helper.run'].return_value = ('', '/dev/vdb', '') result = osd.readlink("/dev/vdb") assert result == "/dev/vdb" @mock.patch('srv.salt._modules.osd.time') def test_readlink_longname(self, mock_time): osd.__salt__ = {} osd.__salt__['helper.run'] = mock.Mock() osd.__salt__['helper.run'].return_value = ('', '/dev/sdb1', '') result = osd.readlink("/dev/disk/by-id/wwn-0x12345-part1") assert result == "/dev/sdb1" @mock.patch('srv.salt._modules.osd.time') def test_readlink_samename(self, mock_time): osd.__salt__ = {} osd.__salt__['helper.run'] = mock.Mock() osd.__salt__['helper.run'].return_value = ( '', '/dev/disk/by-id/wwn-0x12345-part1', '') result = osd.readlink("/dev/disk/by-id/wwn-0x12345-part1") assert result == "/dev/disk/by-id/wwn-0x12345-part1"
class StorageDeviceTestCase(unittest.TestCase): fs = fake_filesystem.FakeFilesystem() f_open = fake_filesystem.FakeFileOpen(fs) f_os = fake_filesystem.FakeOsModule(fs) @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_model(self): self.fs.reset() self.fs.create_file('/sys/block/sda/device/model', contents='''FooBar\n''') sd = openmediavault.device.StorageDevice('/dev/sda') self.assertIsInstance(sd.model, str) self.assertEqual(sd.model, 'FooBar') @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SSD': '0'}) sd = openmediavault.device.StorageDevice('/dev/sda') is_rotational = sd.is_rotational() self.assertIsInstance(is_rotational, bool) self.assertTrue(is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SSD': '1'}) sd = openmediavault.device.StorageDevice('/dev/sda') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_3(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_ROTATION_RATE_RPM': '0'}) sd = openmediavault.device.StorageDevice('/dev/sda') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_4(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_ROTATION_RATE_RPM': '1000'}) sd = openmediavault.device.StorageDevice('/dev/sda') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_5(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_FEATURE_SET_AAM': '0'}) sd = openmediavault.device.StorageDevice('/dev/sda') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_6(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_FEATURE_SET_AAM': '1'}) sd = openmediavault.device.StorageDevice('/dev/sda') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sda') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_7(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.reset() self.fs.create_file('/sys/block/sda/queue/rotational', contents='''1\n''') sd = openmediavault.device.StorageDevice('/dev/sda') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sda') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_8(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.reset() self.fs.create_file('/sys/block/sda/queue/rotational', contents='''0\n''') sd = openmediavault.device.StorageDevice('/dev/sda') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sda') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_9(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.reset() self.fs.create_file('/sys/block/sda/device/model', contents='''I am a SSD\n''') sd = openmediavault.device.StorageDevice('/dev/sda') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sda') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_10(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.reset() self.fs.create_file('/sys/block/sda/device/model', contents='''Foo Bar\n''') sd = openmediavault.device.StorageDevice('/dev/sda') self.assertFalse(sd.is_rotational())
def size(self): fake_os = ffs.FakeOsModule(self._fs) return fake_os.path.getsize(self._path)
def testLaunchGooGet(self, sleep, branch, call): # pylint: disable=unused-argument path = r'C:\ProgramData\GooGet\googet.exe' pkg = 'test_package_v1' retries = 5 sleep_dur = 30 branch.return_value = 'example' # Filesystem self.filesystem = fake_filesystem.FakeFilesystem() googet.os = fake_filesystem.FakeOsModule(self.filesystem) self.filesystem.CreateFile(path) call.return_value = 0 # Command called successfully self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path=path, flags=[ 'http://example.com/team-unstable, ' 'http://example.co.uk/secure-unstable, ' 'https://example.jp/unstable/', '-reinstall', 'whatever' ]) cmd_string = ( ' -noconfirm --root=C:\\ProgramData\\GooGet install -sources ' 'http://example.com/team-unstable, ' 'http://example.co.uk/secure-unstable, ' 'https://example.jp/unstable/ -reinstall whatever ') cmd = path + cmd_string + pkg call.assert_called_with(cmd) # String replacement of sources flag was successful self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path=path, flags=self.flags) cmd_string = ( ' -noconfirm --root=C:\\ProgramData\\GooGet install -sources ' 'http://example.com/team-example, ' 'http://example.co.uk/secure-example%, ' 'http://example.jp/example% whatever -reinstall ') cmd = path + cmd_string + pkg call.assert_called_with(cmd) # Only pkg self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path=None, flags=None) cmd_string = ' -noconfirm --root=C:\\ProgramData\\GooGet install ' cmd = path + cmd_string + pkg call.assert_called_with(cmd) # No Path self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path=None, flags=self.flags) cmd_string = ( ' -noconfirm --root=C:\\ProgramData\\GooGet install -sources ' 'http://example.com/team-example, ' 'http://example.co.uk/secure-example%, ' 'http://example.jp/example% whatever -reinstall ') cmd = path + cmd_string + pkg call.assert_called_with(cmd) # No flags self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path=path, flags=None) cmd = path + ' -noconfirm --root=C:\\ProgramData\\GooGet install ' + pkg call.assert_called_with(cmd) # Path does not exist with self.assertRaisesRegex(googet.Error, 'Cannot find path of GooGet binary*'): self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path='C:\\abc\\def\\ghi', flags=self.flags) # Empty Package Name with self.assertRaisesRegex( googet.Error, 'Missing package name for GooGet install.'): self.install.LaunchGooGet('', retries, sleep_dur, self.buildinfo, path=path, flags=self.flags) # Non zero return value call.return_value = 2 with self.assertRaisesRegex( googet.Error, 'GooGet command failed after ' + str(retries) + ' attempts'): self.install.LaunchGooGet(pkg, retries, sleep_dur, self.buildinfo, path=path, flags=self.flags)
def is_folder(self): fake_os = ffs.FakeOsModule(self._fs) return fake_os.path.isdir(self._path)
def unlink(self): fake_os = ffs.FakeOsModule(self._fs) return fake_os.unlink(self._path)
def is_file(self): fake_os = ffs.FakeOsModule(self._fs) return fake_os.path.isfile(self._path)
def setUp(self, logs): super(AutobuildTest, self).setUp() self.autobuild = autobuild.AutoBuild() autobuild.logging = logs.logging self.filesystem = fake_filesystem.FakeFilesystem() autobuild.os = fake_filesystem.FakeOsModule(self.filesystem)
def setUp(self): self.fs = fake_filesystem.FakeFilesystem() resources.os = fake_filesystem.FakeOsModule(self.fs) self.fs.CreateFile('/test/file.txt')
class StorageDeviceTestCase(unittest.TestCase): fs = fake_filesystem.FakeFilesystem() f_open = fake_filesystem.FakeFileOpen(fs) f_os = fake_filesystem.FakeOsModule(fs) def setUp(self): self.fs.reset() @mock.patch('pyudev.Devices.from_device_file') def test_get_model_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_MODEL_ENC': 'Foo\\x20Bar'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.get_model(), str) self.assertEqual(sd.get_model(), 'Foo Bar') @mock.patch('pyudev.Devices.from_device_file') def test_get_model_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.get_model(), str) self.assertEqual(sd.get_model(), '') @mock.patch('pyudev.Devices.from_device_file') def test_get_vendor_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_VENDOR_ENC': 'Foo\\x20Bar\\x20\\x20'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.get_vendor(), str) self.assertEqual(sd.get_vendor(), 'Foo Bar ') @mock.patch('pyudev.Devices.from_device_file') def test_get_vendor_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.get_vendor(), str) self.assertEqual(sd.get_vendor(), '') @mock.patch('pyudev.Devices.from_device_file') def test_get_serial_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SERIAL_SHORT': 'Foo_Bar'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.get_serial(), str) self.assertEqual(sd.get_serial(), 'Foo Bar') @mock.patch('pyudev.Devices.from_device_file') def test_get_serial_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.get_serial(), str) self.assertEqual(sd.get_serial(), '') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_removable_1(self): self.fs.create_file('/sys/block/sdx/removable', contents='''1\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_removable()) @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_removable_2(self): self.fs.create_file('/sys/block/sdx/removable', contents='''FooBar\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_removable()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SSD': '0'}) sd = openmediavault.device.StorageDevice('/dev/sdx') is_rotational = sd.is_rotational() self.assertIsInstance(is_rotational, bool) self.assertTrue(is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SSD': '1'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_3(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_ROTATION_RATE_RPM': '0'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_4(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_ROTATION_RATE_RPM': '1000'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_5(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_FEATURE_SET_AAM': '0'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_6(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_FEATURE_SET_AAM': '1'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sdx') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_7(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.create_file('/sys/block/sdx/queue/rotational', contents='''1\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sdx') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_8(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.create_file('/sys/block/sdx/queue/rotational', contents='''0\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_9(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_MODEL_ENC': 'I\\x20am\\x20a\\x20SSD'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational()) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_10(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_MODEL_ENC': 'Foo\\x20Bar'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational())
def setUp(self): self.filesystem = fake_filesystem.FakeFilesystem() file_util.os = fake_filesystem.FakeOsModule(self.filesystem) file_util.open = fake_filesystem.FakeFileOpen(self.filesystem)
def test_get_students_missing_file(fs): os_module = fake_filesystem.FakeOsModule(fs) assert os_module.path.exists('./students.txt') == False assert get_students() == {'my': []}
def test_run_seasnap_itransfer_results_smoke_test(mocker): # --- setup arguments dest_path = "/irods/dest" fake_base_path = "/base/path" blueprint_path = os.path.join(os.path.dirname(__file__), "data", "test_blueprint.txt") argv = [ "--verbose", "sea-snap", "itransfer-results", blueprint_path, dest_path, "--num-parallel-transfers", "0", ] parser, subparsers = setup_argparse() # Setup fake file system but only patch selected modules. We cannot use the Patcher approach here as this would # break biomedsheets. fs = fake_filesystem.FakeFilesystem() fake_os = fake_filesystem.FakeOsModule(fs) fake_pl = fake_pathlib.FakePathlibModule(fs) # --- add test files fake_file_paths = [] for member in ("sample1", "sample2", "sample3"): for ext in ("", ".md5"): fake_file_paths.append( "%s/mapping/star/%s/out/star.%s-N1-RNA1-RNA-Seq1.bam%s" % (fake_base_path, member, member, ext)) fs.create_file(fake_file_paths[-1]) fake_file_paths.append( "%s/mapping/star/%s/report/star.%s-N1-RNA1-RNA-Seq1.log%s" % (fake_base_path, member, member, ext)) fs.create_file(fake_file_paths[-1]) fs.add_real_file(blueprint_path) fake_pl.Path(blueprint_path).touch() # Remove index's log MD5 file again so it is recreated. fs.remove(fake_file_paths[3]) # --- mock modules mocker.patch("glob.os", fake_os) mocker.patch("cubi_tk.sea_snap.itransfer_results.pathlib", fake_pl) mocker.patch("cubi_tk.sea_snap.itransfer_results.os", fake_os) mocker.patch("cubi_tk.snappy.itransfer_common.os", fake_os) mock_check_output = mock.mock_open() mocker.patch("cubi_tk.sea_snap.itransfer_results.check_output", mock_check_output) mocker.patch("cubi_tk.snappy.itransfer_common.check_output", mock_check_output) mock_check_call = mock.mock_open() mocker.patch("cubi_tk.snappy.itransfer_common.check_call", mock_check_call) fake_open = fake_filesystem.FakeFileOpen(fs) mocker.patch("cubi_tk.snappy.itransfer_common.open", fake_open) # necessary because independent test fail mock_value = mock.MagicMock() mocker.patch("cubi_tk.sea_snap.itransfer_results.Value", mock_value) mocker.patch("cubi_tk.snappy.itransfer_common.Value", mock_value) # --- run tests res = main(argv) print(mock_check_output.call_args_list) assert not res assert fs.exists(fake_file_paths[3]) assert mock_check_call.call_count == 1 assert mock_check_call.call_args[0] == ([ "md5sum", "star.sample1-N1-RNA1-RNA-Seq1.log" ], ) assert mock_check_output.call_count == len(fake_file_paths) * 2 remote_path = os.path.join(dest_path, "fakedest") for path in fake_file_paths: expected_mkdir_argv = f"imkdir -p $(dirname {remote_path} )" ext = ".md5" if path.split(".")[-1] == "md5" else "" expected_irsync_argv = f"irsync -a -K {path} {('i:%s' + ext) % remote_path}" assert ((expected_mkdir_argv, ), { "shell": True }) in mock_check_output.call_args_list assert ((expected_irsync_argv, ), { "shell": True }) in mock_check_output.call_args_list
def setUp(self): self.fs = fake_filesystem.FakeFilesystem() self.fake_os = fake_filesystem.FakeOsModule(self.fs)
def setUp(self): self.setUpPyfakefs() self.os = fake_filesystem.FakeOsModule(self.fs) self.hook = FileHook()
class StorageDeviceTestCase(unittest.TestCase): fs = fake_filesystem.FakeFilesystem() f_open = fake_filesystem.FakeFileOpen(fs) f_os = fake_filesystem.FakeOsModule(fs) def setUp(self): self.fs.reset() @mock.patch('pyudev.Devices.from_device_file') def test_get_model_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_MODEL_ENC': 'Foo\\x20Bar'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.model, str) self.assertEqual(sd.model, 'Foo Bar') @mock.patch('pyudev.Devices.from_device_file') def test_get_model_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.model, str) self.assertEqual(sd.model, '') @mock.patch('pyudev.Devices.from_device_file') def test_get_vendor_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_VENDOR_ENC': 'Foo\\x20Bar\\x20\\x20'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.vendor, str) self.assertEqual(sd.vendor, 'Foo Bar ') @mock.patch('pyudev.Devices.from_device_file') def test_get_vendor_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.vendor, str) self.assertEqual(sd.vendor, '') @mock.patch('pyudev.Devices.from_device_file') def test_get_serial_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SERIAL_SHORT': 'Foo_Bar'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.serial, str) self.assertEqual(sd.serial, 'Foo Bar') @mock.patch('pyudev.Devices.from_device_file') def test_get_serial_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertIsInstance(sd.serial, str) self.assertEqual(sd.serial, '') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_removable_1(self): self.fs.create_file('/sys/block/sdx/removable', contents='''1\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_removable) @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_removable_2(self): self.fs.create_file('/sys/block/sdx/removable', contents='''FooBar\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_removable) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_1(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SSD': '0'}) sd = openmediavault.device.StorageDevice('/dev/sdx') is_rotational = sd.is_rotational self.assertIsInstance(is_rotational, bool) self.assertTrue(is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_2(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_SSD': '1'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_3(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_ROTATION_RATE_RPM': '0'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_4(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_ROTATION_RATE_RPM': '1000'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_5(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_FEATURE_SET_AAM': '0'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_6(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_ATA_FEATURE_SET_AAM': '1'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sdx') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_7(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.create_file('/sys/block/sdx/queue/rotational', contents='''1\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') @mock.patch('os.path.realpath', return_value='/dev/sdx') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_is_rotational_8(self, _, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice({}) self.fs.create_file('/sys/block/sdx/queue/rotational', contents='''0\n''') sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_9(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_MODEL_ENC': 'I\\x20am\\x20a\\x20SSD'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertFalse(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_is_rotational_10(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_MODEL_ENC': 'Foo\\x20Bar'}) sd = openmediavault.device.StorageDevice('/dev/sdx') self.assertTrue(sd.is_rotational) def test_from_device_file_bcache(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/bcache1') self.assertIsInstance( sd, openmediavault.device.plugins.bcache.StorageDevice) def test_from_device_file_cciss_1(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/cciss/c0d0p2') self.assertIsInstance( sd, openmediavault.device.plugins.cciss.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/cciss/c0d0') self.assertTrue(sd.is_raid) self.assertEqual(sd.device_name(False), 'cciss!c0d0p2') self.assertEqual(sd.smart_device_type, '') def test_from_device_file_cciss_2(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/cciss/c0d0') self.assertIsInstance( sd, openmediavault.device.plugins.cciss.StorageDevice) self.assertEqual(sd.device_name(False), 'cciss!c0d0') self.assertEqual(sd.smart_device_type, 'cciss,0') @mock.patch('pyudev.Devices.from_device_file') def test_from_device_file_cdrom(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_CDROM_MEDIA': '0'}) sd = openmediavault.device.StorageDevice.from_device_file('/dev/sr2') self.assertIsInstance( sd, openmediavault.device.plugins.cdrom.StorageDevice) self.assertTrue(sd.is_read_only) self.assertFalse(sd.is_media_available) self.assertEqual(sd.size(), 0) @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) @mock.patch('os.path.realpath', new=f_os.path.realpath) def test_from_device_file_dm_1(self): self.fs.create_symlink('/dev/mapper/test', '/dev/dm-1') self.fs.create_file('/sys/block/dm-1/dm/name', contents='''foo\n''') sd = openmediavault.device.StorageDevice.from_device_file( '/dev/mapper/test') self.assertIsInstance(sd, openmediavault.device.plugins.dm.StorageDevice) self.assertEqual(sd.canonical_device_file, '/dev/dm-1') self.assertEqual(sd.device_name(True), 'dm-1') self.assertEqual(sd.name, 'foo') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_from_device_file_dm_2(self): self.fs.create_file('/sys/block/dm-2/dm/uuid', contents='''CRYPT-gyhi31UL0XD8\n''') sd = openmediavault.device.StorageDevice.from_device_file('/dev/dm-2') self.assertIsInstance(sd, openmediavault.device.plugins.dm.StorageDevice) self.assertEqual(sd.canonical_device_file, '/dev/dm-2') self.assertEqual(sd.device_name(False), 'dm-2') self.assertEqual(sd.uuid, 'CRYPT-gyhi31UL0XD8') @mock.patch('builtins.open', new=f_open) @mock.patch('os.path.exists', new=f_os.path.exists) def test_from_device_file_dm_3(self): self.fs.create_file('/sys/block/dm-3/dm/uuid', contents='''LVM-EOVOgvd6Wfgpb\n''') sd = openmediavault.device.StorageDevice.from_device_file('/dev/dm-3') self.assertIsInstance( sd, openmediavault.device.plugins.dm.StorageDeviceLVM) def test_from_device_file_fio(self): sd = openmediavault.device.StorageDevice.from_device_file('/dev/fioa1') self.assertIsInstance(sd, openmediavault.device.plugins.fio.StorageDevice) self.assertFalse(sd.is_rotational) self.assertFalse(sd.has_smart_support) def test_from_device_file_hd(self): sd = openmediavault.device.StorageDevice.from_device_file('/dev/hdc3') self.assertIsInstance(sd, openmediavault.device.plugins.hd.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/hdc') self.assertEqual(sd.smart_device_type, 'ata') def test_from_device_file_i2o(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/i2o/hdb1') self.assertIsInstance(sd, openmediavault.device.plugins.i2o.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/i2o/hdb') self.assertTrue(sd.is_raid) def test_from_device_file_loop(self): sd = openmediavault.device.StorageDevice.from_device_file('/dev/loop2') self.assertIsInstance(sd, openmediavault.device.plugins.loop.StorageDevice) def test_from_device_file_md(self): sd = openmediavault.device.StorageDevice.from_device_file('/dev/md0p1') self.assertIsInstance(sd, openmediavault.device.plugins.md.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/md0') self.assertTrue(sd.is_raid) def test_from_device_file_mmc(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/mmcblk0p1') self.assertIsInstance(sd, openmediavault.device.plugins.mmc.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/mmcblk0') self.assertFalse(sd.is_rotational) def test_from_device_file_nvm(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/nvme0n1p1') self.assertIsInstance(sd, openmediavault.device.plugins.nvm.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/nvme0n1') self.assertFalse(sd.is_rotational) self.assertEqual(sd.smart_device_type, 'nvme') def test_from_device_file_rbd(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/rbd1p1') self.assertIsInstance(sd, openmediavault.device.plugins.rbd.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/rbd1') self.assertFalse(sd.is_rotational) @mock.patch('pyudev.Devices.from_device_file') def test_from_device_file_sd(self, mock_from_device_file): mock_from_device_file.return_value = MockedPyUdevDevice( {'ID_BUS': 'usb'}) sd = openmediavault.device.StorageDevice.from_device_file('/dev/sda1') self.assertIsInstance(sd, openmediavault.device.plugins.sd.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/sda') self.assertTrue(sd.is_usb) self.assertEqual(sd.smart_device_type, 'sat') def test_from_device_file_sg(self): sd = openmediavault.device.StorageDevice.from_device_file('/dev/sg17') self.assertIsInstance(sd, openmediavault.device.plugins.sg.StorageDevice) self.assertEqual(sd.smart_device_type, 'scsi') def test_from_device_file_virtio(self): sd = openmediavault.device.StorageDevice.from_device_file('/dev/vda1') self.assertIsInstance( sd, openmediavault.device.plugins.virtio.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/vda') self.assertEqual(sd.smart_device_type, 'sat') def test_from_device_file_xen(self): sd = openmediavault.device.StorageDevice.from_device_file( '/dev/xvdtq37') self.assertIsInstance(sd, openmediavault.device.plugins.xen.StorageDevice) self.assertEqual(sd.parent.device_file, '/dev/xvdtq')
contents=('# a line comment\n' 'cluster-ceph/cluster/*.sls \t# with a comment')) fs.CreateFile('policy.cfg_leading_whitespace', contents=(' cluster-ceph/cluster/*.sls')) fs.CreateFile('policy.cfg_trailing_whitespace', contents=('cluster-ceph/cluster/*.sls ')) fs.CreateFile('policy.cfg_trailing_and_leading_whitespace', contents=(' cluster-ceph/cluster/*.sls ')) fs.CreateFile('policy.cfg_trailing_and_leading_whitespace_and_leading_comment', contents=(' #cluster-ceph/cluster/*.sls ')) fs.CreateFile( 'policy.cfg_trailing_and_leading_whitespace_and_trailing_comment', contents=(' cluster-ceph/cluster/*.sls #')) f_glob = fake_glob.FakeGlobModule(fs) f_os = fake_fs.FakeOsModule(fs) f_open = fake_fs.FakeFileOpen(fs) class TestPush(): @patch('glob.glob', new=f_glob.glob) def test_parse(self): parsed = push._parse('{}/*.sls'.format(proposal_dir)) assert len(parsed) == len(nodes) parsed = push._parse('{}/mon*.sls'.format(proposal_dir)) assert len(parsed) == len([n for n in nodes if n.startswith('mon')]) parsed = push._parse('{}/mon[1,2].sls'.format(proposal_dir)) assert len(parsed) == 2
import pytest import salt.client import os from pyfakefs import fake_filesystem, fake_filesystem_glob from mock import patch, MagicMock from srv.modules.runners import ui_iscsi fs = fake_filesystem.FakeFilesystem() f_glob = fake_filesystem_glob.FakeGlobModule(fs) f_os = fake_filesystem.FakeOsModule(fs) f_open = fake_filesystem.FakeFileOpen(fs) class TestIscsi(): @patch('salt.client.LocalClient', autospec=True) @patch('srv.modules.runners.ui_iscsi.Iscsi.config', autospec=True) @patch('srv.modules.runners.ui_iscsi.Iscsi.interfaces', autospec=True) @patch('srv.modules.runners.ui_iscsi.Iscsi.images', autospec=True) def test_populate(self, localclient, config, interfaces, images): iscsi = ui_iscsi.Iscsi() result = iscsi.populate() assert (config.call_count == 1 and 'config' in result and interfaces.call_count == 1 and 'interfaces' in result and images.call_count == 1 and 'images' in result) @patch('salt.client.LocalClient', autospec=True) def test_interfaces(self, localclient): expected = [{ 'node': 'igw1.ceph', 'addr': '172.16.11.16'
def iterdir(self): fake_os = ffs.FakeOsModule(self._fs) for child in fake_os.listdir(self._path): yield PathMock(self._fs, self._path, child)