class TestBrinkFilesystem(BrinkTestCase):
"""
Unit tests for `BrinkFilesystem`.
"""
def setUp(self):
super(TestBrinkFilesystem, self).setUp()
self.brink_fs = BrinkFilesystem()
self.brink_fs._isValidSystemPath = self.Mock(return_value=True)
def test_which_extra_paths_not_defined(self):
"""
Returns `None` if the command could not be found in system path or
in the `extra_paths` argument.
"""
command = mk.string()
extra_paths = [mk.string()]
self.brink_fs.listFolder = self.Mock(return_value=[])
result = self.brink_fs.which(command, extra_paths=extra_paths)
self.assertIsNone(result)
def test_which_extra_paths_file_found(self):
"""
Returns the full path to the specified command if found and the
executable file exists.
"""
folder = mk.string()
command = mk.string()
full_path_to_command = os.path.join(folder, command)
extra_paths = [mk.string(), folder]
def _folderListing(path):
result = []
if folder == path:
result.append(command)
return result
self.brink_fs.listFolder = _folderListing
result = self.brink_fs.which(command, extra_paths=extra_paths)
self.assertEqual(full_path_to_command, result)
def test_which_extra_paths_file_not_exists(self):
"""
Returns `None` if the specified command is defined in `extra_paths`
but the actual, executable, file does not exist.
"""
command = mk.string()
path_exe_file = "%s.exe" % command
self.brink_fs.listFolder = self.Mock(return_value=[])
extra_paths = [mk.string(), path_exe_file]
result = self.brink_fs.which(command, extra_paths=extra_paths)
self.assertIsNone(result)
def test_parseUnixPaths(self):
"""
It uses : to separate path entries.
"""
path1 = mk.string()
path2 = mk.string()
paths = u"%s:%s" % (path1, path2)
result = self.brink_fs._parseUnixPaths(paths)
self.assertEqual(2, len(result))
self.assertContains(path1, result)
self.assertContains(path2, result)
def test_parseWindowsPaths(self):
"""
It uses ; to separate path entries.
"""
path1 = mk.string()
path2 = mk.string()
paths = u"%s;%s" % (path1, path2)
result = self.brink_fs._parseWindowsPaths(paths)
self.assertEqual(2, len(result))
self.assertContains(path1, result)
self.assertContains(path2, result)
def test_findCommand_ok_posix(self):
"""
On Unix systems it does not validate Windows type executable files
as valid commands.
"""
if os.name == "nt":
raise self.skipTest("Unix specific test.")
command = mk.string()
path = mk.string()
full_path = "%s/%s" % (path, command)
exe_command = "%s.exe" % command
bat_command = "%s.bat" % command
cmd_command = "%s.cmd" % command
files = [exe_command, bat_command, cmd_command]
self.brink_fs.listFolder = self.Mock(return_value=files)
result = self.brink_fs._findCommand(command, path)
self.assertIsNone(result)
files.append(command)
result = self.brink_fs._findCommand(command, path)
self.assertEqual(full_path, result)
def test_findCommand_ok_windows(self):
"""
On Windows systems it validates files with .exe extension before
checking files without extension.
"""
if os.name != "nt":
raise self.skipTest("Windows specific test.")
command = mk.string()
path = mk.string()
exe_command = "%s.exe" % command
full_path = "%s\%s" % (path, exe_command)
files = [command, exe_command]
self.brink_fs.listFolder = self.Mock(return_value=files)
result = self.brink_fs._findCommand(command, path)
self.assertEqual(full_path, result)
def test_findCommand_ok_windows_with_extension(self):
"""
On Windows systems it validates files with .exe extension, even
when the command is specified with explicit .exe extension.
"""
if os.name != "nt":
raise self.skipTest("Windows specific test.")
command = mk.string()
path = mk.string()
exe_command = "%s.exe" % command
full_path = "%s\%s" % (path, exe_command)
files = [command, exe_command]
self.brink_fs.listFolder = self.Mock(return_value=files)
result = self.brink_fs._findCommand(exe_command, path)
self.assertEqual(full_path, result)
def test_findCommand_checks_folders_only(self):
"""
Returns `None` if the path argument is not a folder.
"""
command = mk.string()
path = mk.string()
self.brink_fs._isValidSystemPath = self.Mock(return_value=False)
result = self.brink_fs._findCommand(command, path)
self.assertIsNone(result)
def test_findCommand_no_result(self):
"""
Returns `None` if the command could not be found in the specified
path.
"""
command = mk.string()
path = mk.string()
files = [mk.string(), mk.string()]
self.brink_fs.listFolder = self.Mock(return_value=files)
result = self.brink_fs._findCommand(command, path)
self.assertIsNone(result)
def test_getSearchPaths_default(self):
"""
It returns a list of paths from operating system environment
variable.
"""
if os.name == "posix":
paths = self.brink_fs._parseUnixPaths(os.environ["PATH"])
else:
paths = self.brink_fs._parseWindowsPaths(os.environ["PATH"])
result = self.brink_fs._getSearchPaths()
self.assertEqual(paths, result)
def test_getSearchPaths_with_extra(self):
"""
If a list of extra paths if provided, it return a list with paths
defined in the operating system, but with the list of extra paths
prepended to the result.
"""
path1 = mk.string
path2 = mk.string
if os.name == "posix":
path3 = self.brink_fs._parseUnixPaths(os.environ["PATH"])[0]
else:
path3 = self.brink_fs._parseWindowsPaths(os.environ["PATH"])[0]
result = self.brink_fs._getSearchPaths(extra_paths=[path1, path2])
self.assertEqual(path1, result[0])
self.assertEqual(path2, result[1])
self.assertEqual(path3, result[2])
class TestBrinkFilesystem(BrinkTestCase):
"""
Unit tests for `BrinkFilesystem`.
"""
def setUp(self):
super(TestBrinkFilesystem, self).setUp()
self.sut = BrinkFilesystem()
self.sut._isValidSystemPath = self.Mock(return_value=True)
def test_which_extra_paths_not_defined(self):
"""
Returns `None` if the command could not be found in system path or
in the `extra_paths` argument.
"""
command = mk.string()
extra_paths = [mk.string()]
self.sut.listFolder = self.Mock(return_value=[])
result = self.sut.which(command, extra_paths=extra_paths)
self.assertIsNone(result)
def test_which_extra_paths_file_found(self):
"""
Returns the full path to the specified command if found and the
executable file exists.
"""
folder = mk.string()
command = mk.string()
full_path_to_command = os.path.join(folder, command)
extra_paths = [mk.string(), folder]
def _folderListing(path):
result = []
if folder == path:
result.append(command)
return result
self.sut.listFolder = _folderListing
result = self.sut.which(command, extra_paths=extra_paths)
self.assertEqual(full_path_to_command, result)
def test_which_extra_paths_file_not_exists(self):
"""
Returns `None` if the specified command is defined in `extra_paths`
but the actual, executable, file does not exist.
"""
command = mk.string()
path_exe_file = '%s.exe' % command
self.sut.listFolder = self.Mock(return_value=[])
extra_paths = [mk.string(), path_exe_file]
result = self.sut.which(command, extra_paths=extra_paths)
self.assertIsNone(result)
def test_parseUnixPaths(self):
"""
It uses : to separate path entries.
"""
path1 = mk.string()
path2 = mk.string()
paths = u'%s:%s' % (path1, path2)
result = self.sut._parseUnixPaths(paths)
self.assertEqual(2, len(result))
self.assertContains(path1, result)
self.assertContains(path2, result)
def test_parseWindowsPaths(self):
"""
It uses ; to separate path entries.
"""
path1 = mk.string()
path2 = mk.string()
paths = u'%s;%s' % (path1, path2)
result = self.sut._parseWindowsPaths(paths)
self.assertEqual(2, len(result))
self.assertContains(path1, result)
self.assertContains(path2, result)
def test_findCommand_ok_posix(self):
"""
On Unix systems it does not validate Windows type executable files
as valid commands.
"""
if os.name == 'nt':
raise self.skipTest("Unix specific test.")
command = mk.string()
path = mk.string()
full_path = '%s/%s' % (path, command)
exe_command = '%s.exe' % command
bat_command = '%s.bat' % command
cmd_command = '%s.cmd' % command
files = [
exe_command,
bat_command,
cmd_command,
]
self.sut.listFolder = self.Mock(return_value=files)
result = self.sut._findCommand(command, path)
self.assertIsNone(result)
files.append(command)
result = self.sut._findCommand(command, path)
self.assertEqual(full_path, result)
def test_findCommand_ok_windows(self):
"""
On Windows systems it validates files with .exe extension before
checking files without extension.
"""
if os.name != 'nt':
raise self.skipTest("Windows specific test.")
command = mk.string()
path = mk.string()
exe_command = '%s.exe' % command
full_path = '%s\%s' % (path, exe_command)
files = [
command,
exe_command,
]
self.sut.listFolder = self.Mock(return_value=files)
result = self.sut._findCommand(command, path)
self.assertEqual(full_path, result)
def test_findCommand_ok_windows_with_extension(self):
"""
On Windows systems it validates files with .exe extension, even
when the command is specified with explicit .exe extension.
"""
if os.name != 'nt':
raise self.skipTest("Windows specific test.")
command = mk.string()
path = mk.string()
exe_command = '%s.exe' % command
full_path = '%s\%s' % (path, exe_command)
files = [
command,
exe_command,
]
self.sut.listFolder = self.Mock(return_value=files)
result = self.sut._findCommand(exe_command, path)
self.assertEqual(full_path, result)
def test_findCommand_checks_folders_only(self):
"""
Returns `None` if the path argument is not a folder.
"""
command = mk.string()
path = mk.string()
self.sut._isValidSystemPath = self.Mock(return_value=False)
result = self.sut._findCommand(command, path)
self.assertIsNone(result)
def test_findCommand_no_result(self):
"""
Returns `None` if the command could not be found in the specified
path.
"""
command = mk.string()
path = mk.string()
files = [mk.string(), mk.string()]
self.sut.listFolder = self.Mock(return_value=files)
result = self.sut._findCommand(command, path)
self.assertIsNone(result)
def test_getSearchPaths_default(self):
"""
It returns a list of paths from operating system environment
variable.
"""
if os.name == 'posix':
paths = self.sut._parseUnixPaths(os.environ['PATH'])
else:
paths = self.sut._parseWindowsPaths(os.environ['PATH'])
result = self.sut._getSearchPaths()
self.assertEqual(paths, result)
def test_getSearchPaths_with_extra(self):
"""
If a list of extra paths if provided, it return a list with paths
defined in the operating system, but with the list of extra paths
prepended to the result.
"""
path1 = mk.string
path2 = mk.string
if os.name == 'posix':
path3 = self.sut._parseUnixPaths(os.environ['PATH'])[0]
else:
path3 = self.sut._parseWindowsPaths(os.environ['PATH'])[0]
result = self.sut._getSearchPaths(extra_paths=[path1, path2])
self.assertEqual(path1, result[0])
self.assertEqual(path2, result[1])
self.assertEqual(path3, result[2])
def test_copyFolder_no_overwrite(self):
"""
It can copy the folder without overwriting existing files.
"""
source_segments = mk.fs.createFolderInTemp(prefix=u'src-')
destination_segments = mk.fs.createFolderInTemp(prefix=u'dst-')
self.addCleanup(lambda: mk.fs.deleteFolder(source_segments))
self.addCleanup(lambda: mk.fs.deleteFolder(destination_segments))
existing_name = mk.makeFilename()
existing_source_segments = source_segments + [existing_name]
existing_destination_segments = destination_segments + [existing_name]
mk.fs.createFile(existing_source_segments, content=b'source-exist')
mk.fs.createFile(
existing_destination_segments, content=b'destination-exist')
mk.fs.createFile(source_segments + [u'other-file'], content=b'other')
self.sut.copyFolder(
source=[u'/'] + source_segments,
destination=[u'/'] + destination_segments,
overwrite=False,
)
self.assertTrue(
mk.fs.exists(destination_segments + [u'other-file']))
self.assertTrue(
mk.fs.exists(existing_destination_segments))
self.assertEqual(
b'destination-exist',
mk.fs.getFileContent(existing_destination_segments, utf8=False))
def test_join_rejoin_unicode(self):
"""
It can join and re-join the result from unicode path.
"""
first_join = self.sut.join([mk.makeFilename(), mk.makeFilename()])
second_join = self.sut.join([first_join, mk.makeFilename()])
if os.name == 'posix':
self.assertIsInstance(str, second_join)
else:
self.assertIsInstance(unicode, second_join)