Inheritance diagram for lsst.utils.tests.ExecutablesTestCase:

Public Member Functions
def	setUpClass (cls)

def	testSanity (self)

def	assertExecutable (self, executable, root_dir=None, args=None, msg=None)

def	create_executable_tests (cls, ref_file, executables=None)

Public Attributes
	TESTS_DISCOVERED

Static Public Attributes
int	TESTS_DISCOVERED = -1

Detailed Description

Test that executables can be run and return good status.

The test methods are dynamically created. Callers
must subclass this class in their own test file and invoke
the create_executable_tests() class method to register the tests.

Definition at line 148 of file tests.py.

Member Function Documentation

◆ assertExecutable()

def lsst.utils.tests.ExecutablesTestCase.assertExecutable	(	self,
		executable,
		root_dir = `None`,
		args = `None`,
		msg = `None`
	)

Check an executable runs and returns good status.

Prints output to standard out. On bad exit status the test
fails. If the executable can not be located the test is skipped.

Parameters
----------
executable : `str`
    Path to an executable. ``root_dir`` is not used if this is an
    absolute path.
root_dir : `str`, optional
    Directory containing executable. Ignored if `None`.
args : `list` or `tuple`, optional
    Arguments to be provided to the executable.
msg : `str`, optional
    Message to use when the test fails. Can be `None` for default
    message.

Raises
------
AssertionError
    The executable did not return 0 exit status.

Definition at line 171 of file tests.py.

     def assertExecutable(self, executable, root_dir=None, args=None, msg=None):
         """Check an executable runs and returns good status.
  
         Prints output to standard out. On bad exit status the test
         fails. If the executable can not be located the test is skipped.
  
         Parameters
         ----------
         executable : `str`
             Path to an executable. ``root_dir`` is not used if this is an
             absolute path.
         root_dir : `str`, optional
             Directory containing executable. Ignored if `None`.
         args : `list` or `tuple`, optional
             Arguments to be provided to the executable.
         msg : `str`, optional
             Message to use when the test fails. Can be `None` for default
             message.
  
         Raises
         ------
         AssertionError
             The executable did not return 0 exit status.
         """
  
         if root_dir is not None and not os.path.isabs(executable):
             executable = os.path.join(root_dir, executable)
  
         # Form the argument list for subprocess
         sp_args = [executable]
         argstr = "no arguments"
         if args is not None:
             sp_args.extend(args)
             argstr = 'arguments "' + " ".join(args) + '"'
  
         print("Running executable '{}' with {}...".format(executable, argstr))
         if not os.path.exists(executable):
             self.skipTest("Executable {} is unexpectedly missing".format(executable))
         failmsg = None
         try:
             output = subprocess.check_output(sp_args)
         except subprocess.CalledProcessError as e:
             output = e.output
             failmsg = "Bad exit status from '{}': {}".format(executable, e.returncode)
         print(output.decode('utf-8'))
         if failmsg:
             if msg is None:
                 msg = failmsg
             self.fail(msg)
  

◆ create_executable_tests()

def lsst.utils.tests.ExecutablesTestCase.create_executable_tests	(	cls,
		ref_file,
		executables = `None`
	)

Discover executables to test and create corresponding test methods.

Scans the directory containing the supplied reference file
(usually ``__file__`` supplied from the test class) to look for
executables. If executables are found a test method is created
for each one. That test method will run the executable and
check the returned value.

Executable scripts with a ``.py`` extension and shared libraries
are ignored by the scanner.

This class method must be called before test discovery.

Parameters
----------
ref_file : `str`
    Path to a file within the directory to be searched.
    If the files are in the same location as the test file, then
    ``__file__`` can be used.
executables : `list` or `tuple`, optional
    Sequence of executables that can override the automated
    detection. If an executable mentioned here is not found, a
    skipped test will be created for it, rather than a failed
    test.

Examples
--------
>>> cls.create_executable_tests(__file__)

Definition at line 254 of file tests.py.

     def create_executable_tests(cls, ref_file, executables=None):
         """Discover executables to test and create corresponding test methods.
  
         Scans the directory containing the supplied reference file
         (usually ``__file__`` supplied from the test class) to look for
         executables. If executables are found a test method is created
         for each one. That test method will run the executable and
         check the returned value.
  
         Executable scripts with a ``.py`` extension and shared libraries
         are ignored by the scanner.
  
         This class method must be called before test discovery.
  
         Parameters
         ----------
         ref_file : `str`
             Path to a file within the directory to be searched.
             If the files are in the same location as the test file, then
             ``__file__`` can be used.
         executables : `list` or `tuple`, optional
             Sequence of executables that can override the automated
             detection. If an executable mentioned here is not found, a
             skipped test will be created for it, rather than a failed
             test.
  
         Examples
         --------
         >>> cls.create_executable_tests(__file__)
         """
  
         # Get the search directory from the reference file
         ref_dir = os.path.abspath(os.path.dirname(ref_file))
  
         if executables is None:
             # Look for executables to test by walking the tree
             executables = []
             for root, dirs, files in os.walk(ref_dir):
                 for f in files:
                     # Skip Python files. Shared libraries are executable.
                     if not f.endswith(".py") and not f.endswith(".so"):
                         full_path = os.path.join(root, f)
                         if os.access(full_path, os.X_OK):
                             executables.append(full_path)
  
         # Store the number of tests found for later assessment.
         # Do not raise an exception if we have no executables as this would
         # cause the testing to abort before the test runner could properly
         # integrate it into the failure report.
         cls.TESTS_DISCOVERED = len(executables)
  
         # Create the test functions and attach them to the class
         for e in executables:
             cls._build_test_method(e, ref_dir)
  
  
 @contextlib.contextmanager

◆ setUpClass()

def lsst.utils.tests.ExecutablesTestCase.setUpClass ( cls )

Abort testing if automated test creation was enabled and
no tests were found.

Definition at line 158 of file tests.py.

     def setUpClass(cls):
         """Abort testing if automated test creation was enabled and
         no tests were found."""
  
         if cls.TESTS_DISCOVERED == 0:
             raise RuntimeError("No executables discovered.")
  

◆ testSanity()

def lsst.utils.tests.ExecutablesTestCase.testSanity ( self )

This test exists to ensure that there is at least one test to be
executed. This allows the test runner to trigger the class set up
machinery to test whether there are some executables to test.

Definition at line 165 of file tests.py.

     def testSanity(self):
         """This test exists to ensure that there is at least one test to be
         executed. This allows the test runner to trigger the class set up
         machinery to test whether there are some executables to test."""
         pass
  

Member Data Documentation

◆ TESTS_DISCOVERED [1/2]

int lsst.utils.tests.ExecutablesTestCase.TESTS_DISCOVERED = -1

static

Definition at line 155 of file tests.py.

◆ TESTS_DISCOVERED [2/2]

lsst.utils.tests.ExecutablesTestCase.TESTS_DISCOVERED

Definition at line 162 of file tests.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/utils/22.0.1-4-g5b7b756+c1283a92b8/python/lsst/utils/tests.py

Public Member Functions

Public Attributes

Static Public Attributes