def test_simple_list(self):
"""
SubProcess for listing files
"""
# Set up our threaded process
sp = SubProcess(['ls', '-1', '/tmp'])
# Now run our process
sp.start()
# Wait for it to complete
sp.join()
assert sp.is_complete() is True
assert sp.response_code() is 0
assert sp.successful() is True
assert sp.elapsed() > 0.0
assert isinstance(sp.stdout(), list)
assert isinstance(sp.stderr(), list)
assert isinstance(sp.stdout(as_list=False), basestring)
assert isinstance(sp.stderr(as_list=False), basestring)
# Because under the hood stdout and stderr are stored into
# Stream objects, we need to be able to check that multple
# calls to the same object still return the same results
assert len(sp.stdout()) > 1
assert len(sp.stdout()) > 1
assert len(sp.stderr()) > 0
assert len(sp.stderr()) > 0
def test_simple_list(self):
"""
SubProcess for listing files
"""
# Set up our threaded process
sp = SubProcess(['ls', '-1', '/tmp'])
# Now run our process
sp.start()
# Wait for it to complete
sp.join()
assert sp.is_complete() is True
assert sp.response_code() is 0
assert sp.successful() is True
assert sp.elapsed() > 0.0
assert isinstance(sp.stdout(), list)
assert isinstance(sp.stderr(), list)
assert isinstance(sp.stdout(as_list=False), basestring)
assert isinstance(sp.stderr(as_list=False), basestring)
# Because under the hood stdout and stderr are stored into
# Stream objects, we need to be able to check that multple
# calls to the same object still return the same results
assert len(sp.stdout()) > 1
assert len(sp.stdout()) > 1
assert len(sp.stderr()) > 0
assert len(sp.stderr()) > 0
def test_process_dies_with_object(self):
"""
SubProcess for a process that will never stop
"""
# Set up our threaded process to sleep for 1 day
sp = SubProcess(['sleep', '1d'])
# Now run our process
sp.start()
# Wait half a second (give thread time to start and run)
sp.join(timeout=0.5)
# We'll get the pid number of our process
assert sp.pid() is not None
pid = sp.pid()
# Test that the process is indeed running
assert self.pid_exists(pid) is True
# now we'll flat out destroy the object (always abort it first)
sp.abort()
del sp
# Test that the process is now dead as a result of the previous action
assert self.pid_exists(pid) is False
def test_process_dies_with_object(self):
"""
SubProcess for a process that will never stop
"""
# Set up our threaded process to sleep for 1 day
sp = SubProcess(['sleep', '1d'])
# Now run our process
sp.start()
# Wait half a second (give thread time to start and run)
sp.join(timeout=0.5)
# We'll get the pid number of our process
assert sp.pid() is not None
pid = sp.pid()
# Test that the process is indeed running
assert self.pid_exists(pid) is True
# now we'll flat out destroy the object (always abort it first)
sp.abort()
del sp
# Test that the process is now dead as a result of the previous action
assert self.pid_exists(pid) is False
def test_program_that_will_not_die(self):
"""
SubProcess for a process that will never stop
"""
# Set up our threaded process to sleep for 1 day
sp = SubProcess(['sleep', '1d'])
# Now run our process
sp.start()
# Wait half a second (give thread time to start and run)
sp.join(timeout=0.5)
# PID is always None unless the process is still running
assert sp.pid() is not None
assert isinstance(sp.pid(), int)
# The process is still running
assert sp.is_complete() is False
# The process is not successful, but we shouldn't be relying on this
# value anyway because it's not even complete.
assert sp.successful() is False
# time should be elapsing
assert sp.elapsed() > 0.0
# No output to report at this time because one of the downsides of
# using subprocess is you can't retrieve the pipes content until the
# end. Thus these functions will simply return nothing.
assert len(sp.stdout()) > 0
assert len(sp.stderr()) > 0
# Currently the response code is still unknown
assert sp.response_code() is ReturnCode.Unknown
# We'll abort the process now
sp.abort()
# Wait for it to complete (because it will complete now)
sp.join()
# PID is always None when process is stopped
assert sp.pid() is None
# The response code should have change to Aborted
assert sp.response_code() is ReturnCode.Aborted
# The process is now complete
assert sp.is_complete() is True
# But we should not be successful at this point
assert sp.successful() is False
def test_program_that_will_not_die(self):
"""
SubProcess for a process that will never stop
"""
# Set up our threaded process to sleep for 1 day
sp = SubProcess(['sleep', '1d'])
# Now run our process
sp.start()
# Wait half a second (give thread time to start and run)
sp.join(timeout=0.5)
# PID is always None unless the process is still running
assert sp.pid() is not None
assert isinstance(sp.pid(), int)
# The process is still running
assert sp.is_complete() is False
# The process is not successful, but we shouldn't be relying on this
# value anyway because it's not even complete.
assert sp.successful() is False
# time should be elapsing
assert sp.elapsed() > 0.0
# No output to report at this time because one of the downsides of
# using subprocess is you can't retrieve the pipes content until the
# end. Thus these functions will simply return nothing.
assert len(sp.stdout()) > 0
assert len(sp.stderr()) > 0
# Currently the response code is still unknown
assert sp.response_code() is ReturnCode.Unknown
# We'll abort the process now
sp.abort()
# Wait for it to complete (because it will complete now)
sp.join()
# PID is always None when process is stopped
assert sp.pid() is None
# The response code should have change to Aborted
assert sp.response_code() is ReturnCode.Aborted
# The process is now complete
assert sp.is_complete() is True
# But we should not be successful at this point
assert sp.successful() is False
def test_bad_execution(self):
"""
SubProcess for listing files with bad arguments
"""
# Set up our threaded process
sp = SubProcess(['ls', '-wtf', '-not-a-valid-argument'])
# Now run our process
sp.start()
# Wait for it to complete
sp.join()
assert sp.is_complete() is True
assert sp.response_code() is not 0
assert sp.successful() is False
assert sp.elapsed() > 0.0
# Because under the hood stdout and stderr are stored into
# Stream objects, we need to be able to check that multple
# calls to the same object still return the same results
assert len(sp.stdout()) > 0
assert len(sp.stdout()) > 0
assert len(sp.stderr()) > 1
assert len(sp.stderr()) > 1
def test_bad_execution(self):
"""
SubProcess for listing files with bad arguments
"""
# Set up our threaded process
sp = SubProcess(['ls', '-wtf', '-not-a-valid-argument'])
# Now run our process
sp.start()
# Wait for it to complete
sp.join()
assert sp.is_complete() is True
assert sp.response_code() is not 0
assert sp.successful() is False
assert sp.elapsed() > 0.0
# Because under the hood stdout and stderr are stored into
# Stream objects, we need to be able to check that multple
# calls to the same object still return the same results
assert len(sp.stdout()) > 0
assert len(sp.stdout()) > 0
assert len(sp.stderr()) > 1
assert len(sp.stderr()) > 1
def test(self, content=None, password=None):
"""
content must be pointing to a directory containing rar files that can
be easily sorted on. Alternatively, path can be of type NNTPContent()
or a set/list of.
If no password is specified, then the password configuration loaded
into the class is used instead.
This function just tests an archive to see if it can be properly
extracted using the known password.
"""
if content is not None:
paths = self.get_paths(content)
elif len(self.archive):
# Get first item in archive
paths = iter(self.archive)
else:
raise AttributeError("CodecRar: No rar file detected.")
if not self.can_exe(self._unrar):
return None
if not password:
password = self.password
# Initialize our command
execute = [
# Our Executable RAR Application
self._unrar,
# Use Test Flag
't',
# Assume Yes
'-y',
]
# Password Protection
if password is not None:
execute.append('-p%s' % password)
else:
# Do not prompt for password
execute.append('-p-')
if self.keep_broken:
# Keep Broken Flag
execute.append('-kb')
# Stop Switch Parsing
execute.append('--')
for _path in paths:
# Create our SubProcess Instance
sp = SubProcess(list(execute) + [_path])
# Start our execution now
sp.start()
sp.join()
# Let the caller know our status
if not sp.successful():
return False
return True
def test(self, content=None, password=None):
"""
content must be pointing to a directory containing rar files that can
be easily sorted on. Alternatively, path can be of type NNTPContent()
or a set/list of.
If no password is specified, then the password configuration loaded
into the class is used instead.
This function just tests an archive to see if it can be properly
extracted using the known password.
"""
if content is not None:
paths = self.get_paths(content)
elif len(self.archive):
# Get first item in archive
paths = iter(self.archive)
else:
raise AttributeError("Codec7Zip: No 7-Zip file detected.")
if not self.can_exe(self._bin):
return None
if not password:
password = self.password
# Initialize our command
execute = [
# Our Executable 7-Zip Application
self._bin,
# Use Test Flag
't',
# Assume Yes
'-y',
]
# Password Protection
if password is not None:
execute.append('-p%s' % password)
else:
# Do not prompt for password
execute.append('-p-')
# Stop Switch Parsing
execute.append('--')
for _path in paths:
# Create our SubProcess Instance
sp = SubProcess(list(execute) + [_path])
# Start our execution now
sp.start()
sp.join()
# Let the caller know our status
if not sp.successful():
return False
return True
def test(self, content=None):
"""
content must be pointing to a directory containing par files that can
be easily sorted on. Alternatively, path can be of type NNTPContent()
or a set/list of.
This function just tests an archive to see if it can be properly
prepared (it is effectively a wrapper to verify)
If anything but True is returned then there was a problem verifying
the results and a code identified in ParReturnCode() is returned
instead.
"""
if content is not None:
paths = self.get_paths(content)
elif len(self.archive):
# Get first item in archive
paths = iter(self.archive)
else:
raise AttributeError("CodecPar: No par file detected.")
if not self.can_exe(self._par):
return None
# filter our results by indexes
indexes = self.__filter_pars(paths, indexes=True, volumes=False)
if not len(indexes):
logger.warning('Archive contained no PAR files.')
return ParReturnCode.NoParFiles
# Initialize our command
execute = [
# Our Executable PAR Application
self._par,
# Use Test Flag
'verify',
]
if self.cpu_cores is not None and self.cpu_cores > 1:
# to checksum concurrently - uses multiple threads
execute.append('-t+')
# Stop Switch Parsing
execute.append('--')
for _path in indexes:
# Get the directory the par file resides in
par_path = dirname(_path)
with pushd(par_path):
# Create our SubProcess Instance
sp = SubProcess(list(execute) + [basename(_path)])
# Start our execution now
sp.start()
sp.join()
# Let the caller know our status
if sp.response_code() is not ParReturnCode.NoRepairRequired:
return sp.response_code()
return True