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)
