def execute(self, **kwargs): """ Computes the percent complete, number missing items, and the pass/fail status """ # Extract configuration parameters specs = self.specs or 'tests' # Get complete directory paths root_dir = mooseutils.git_root_dir() directories = [mooseutils.eval_path(d) for d in (self.directories or [root_dir])] for i, d in enumerate(directories): if not os.path.isdir(d): directories[i] = os.path.join(root_dir, d) if not os.path.isdir(directories[i]): raise NotADirectoryError("Supplied directory does not exist: {}".format(d)) # Build Requirement objects and remove directory based dict req_dict = get_requirements_from_tests(directories, specs.split(), self.include_non_testable) requirements = [] for values in req_dict.values(): requirements += values # Populate the lists of tests for SQARequirementDiffReport self.test_names = set() for req in requirements: self.test_names.add((req.filename, req.name, req.line)) # Get list of files to search if self.working_dirs is None: self.working_dirs = [mooseutils.git_root_dir()] file_list = SQAReport._getFiles(self.working_dirs) # Check the requirements logger = check_requirements(requirements, color_text=self.color_text, file_list=file_list, **kwargs) return logger
def __init__(self, **kwargs): super().__init__(**kwargs) # Default attributes self.exe_directory = self.exe_directory or mooseutils.git_root_dir() self.exe_name = self.exe_name or os.path.basename(self.exe_directory) self.working_dir = self.working_dir or mooseutils.git_root_dir() self.content_directory = self.content_directory or os.path.join(self.exe_directory, 'doc', 'content') self.object_prefix = self.object_prefix or os.path.join(self.content_directory, 'source') self.syntax_prefix = self.syntax_prefix or os.path.join(self.content_directory, 'syntax')
def get_options(): """Return the command-line options""" parser = argparse.ArgumentParser( description='Tool for listing author line counts.', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('locations', nargs='*', type=str, default=[mooseutils.git_root_dir()], help='The repository directory to consider.') parser.add_argument( '-j', '--num-threads', type=int, default=os.cpu_count(), help="The number of threads to use for computing the counts.") parser.add_argument('--exclude', nargs=1, type=str, default='contrib', help="Exclude pattern passed to git ls-files call.") parser.add_argument('-l', '--languages', nargs='+', type=str, choices=list(LANGUAGES.keys()), default=list(LANGUAGES.keys()), help="Limit the analysis the the listed languages.") return parser.parse_args()
def testNoneError(self): fname = 'markers/box_marker/wrong' root_dir = mooseutils.git_root_dir(os.path.dirname(__file__)) with self.assertRaises(NameError) as e: filename = _find_file(root_dir, fname) self.assertIn('Unable to locate a test specification', str(e.exception))
def testLanguage(self): locations = [ os.path.join(mooseutils.git_root_dir(), 'python', 'mooseutils') ] out = mooseutils.check_output( ['./authors.py', *locations, '-j', '1', '-l', 'Python'], cwd=os.path.join(mooseutils.git_root_dir(), 'scripts')) self.assertIn('Andrew', out) self.assertNotIn('C++', out) self.assertIn('Python', out) self.assertNotIn('Input', out) self.assertNotIn('Markdown', out) self.assertNotIn('Make', out) self.assertNotIn('YAML', out) self.assertIn('Total', out) self.assertIn('TOTAL', out)
def get_options(): """Command-line options.""" parser = argparse.ArgumentParser( description='SQA Requirement checking tool.') parser.add_argument('-d', '--directory', type=str, default=mooseutils.git_root_dir(), help="The directory to search.") parser.add_argument('-r', '--remote', type=str, default='origin', help="The name of the git remote to compare against.") parser.add_argument('-b', '--branch', type=str, default='devel', help="The name of the branch to compare against.") parser.add_argument( '--specs', type=list, default=['tests'], help="The name of the specification files to consider.") parser.add_argument('--skip', nargs='+', default=[], help="Partial directory paths to ignore.") return parser.parse_args()
def sqa_check(working_dir=os.getcwd(), remote='origin', branch='devel', specs=['tests'], skip=[]): """Check that test specifications that were modified include requirements.""" # Fetch cmd = ['git', 'fetch', remote] subprocess.call(cmd) # Root directory of repository root = git_root_dir(working_dir) # Check requirements on changed tests specs count = 0 cmd = ['git', 'merge-base', '{}/{}'.format(remote, branch), 'HEAD'] sha = subprocess.check_output(cmd).strip() cmd = ['git', 'diff', sha, '--name-only'] for filename in subprocess.check_output(cmd).split('\n'): if os.path.isfile(filename) and (os.path.basename(filename) in specs) and \ not any(s in filename for s in skip): count += check_requirement(os.path.join(root, filename)) return count
def testGitInitSubmodule(self, status_func, call_func): status_func.return_value = {'test':'-'} root = mooseutils.git_root_dir() mooseutils.git_init_submodule('test', root) status_func.assert_called_with(root) call_func.assert_called_with(['git', 'submodule', 'update', '--init', 'test'], cwd=root)
def doc_tree(items): """ Create a tree of files for processing. Inputs: inputs: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. """ # Error checking if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error( 'The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None # Define a dict for storing nodes by path nodes = dict() # Create the root node nodes[()] = page.DirectoryNode(source='') # Create the file tree for value in items: if 'root_dir' not in value: LOG.error( 'The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') root = mooseutils.eval_path(value['root_dir']) if not os.path.isabs(root): root = os.path.join(MooseDocs.ROOT_DIR, root) # Update the project files MooseDocs.PROJECT_FILES.update( mooseutils.git_ls_files(mooseutils.git_root_dir(root))) files = doc_import(root, content=value.get('content', None)) for filename in files: key = tuple(filename.replace(root, '').strip('/').split('/')) # Create directory nodes if they don't exist for i in range(1, len(key)): dir_key = key[:i] if dir_key not in nodes: nodes[dir_key] = page.DirectoryNode(nodes[key[:i - 1]], name=key[i - 1], source=os.path.join( root, *dir_key)) # Create the file node, if it doesn't already exist. This enforces that the first # item in the supplied content lists is the page that is rendered. if key not in nodes: nodes[key] = create_file_node(nodes[key[:-1]], key[-1], filename) return nodes[()]
def testEndswith(self): fname = 'markers/box_marker/tests' root_dir = mooseutils.git_root_dir(os.path.dirname(__file__)) filename = _find_file(root_dir, fname) self.assertEqual( filename, os.path.join(root_dir, 'test', 'tests', 'markers', 'box_marker', 'tests'))
def testGitSubmoduleInfo(self): root = mooseutils.git_root_dir() status = mooseutils.git_submodule_info(root) self.assertIn('large_media', status) self.assertIn('libmesh', status) self.assertIn('petsc', status) self.assertEqual(len(status['large_media']), 3) self.assertEqual(len(status['libmesh']), 3) self.assertEqual(len(status['petsc']), 3)
def __init__(self, **kwargs): self._documents = dict() kwargs.setdefault('required_documents', INL_DOCUMENTS) self._documents = { name: kwargs.pop(name, None) for name in kwargs.get('required_documents') } super().__init__(**kwargs) self.working_dir = self.working_dir or mooseutils.git_root_dir()
def setUpClass(cls): cls.ROOT_DIR = mooseutils.git_root_dir(os.path.dirname(__file__)) cls.TEMPLATE_DIR = os.path.join(cls.ROOT_DIR, 'framework', 'doc', 'content', 'templates', 'sqa') cls.TEMPLATE_NAMES =['far.md.template', 'rtm.md.template', 'sdd.md.template', 'srs.md.template', 'stp.md.template', 'vvr.md.template', 'cci.md.template', 'scs.md.template', 'sll.md.template', 'app_index.md.template', 'app_far.md.template', 'app_rtm.md.template', 'app_sdd.md.template', 'app_srs.md.template', 'app_stp.md.template', 'app_vvr.md.template', 'app_cci.md.template', 'app_scs.md.template', 'app_sll.md.template'] cls.DOC_FILE = os.path.join(cls.ROOT_DIR, 'modules', 'doc', 'content', 'python', 'MooseDocs', 'extensions', 'sqa.md') cls.COLLECTIONS = {'FUNCTIONAL', 'USABILITY', 'PERFORMANCE', 'SYSTEM', 'FAILURE_ANALYSIS'}
def __init__(self, **kwargs): self.app_syntax = kwargs.pop('app_syntax', None) self.app_types = kwargs.pop('app_types', None) self.working_dir = kwargs.pop('working_dir', mooseutils.git_root_dir()) self.exe_directory = kwargs.pop('exe_directory', mooseutils.git_root_dir()) self.exe_name = kwargs.pop('exe_name', os.path.basename(self.exe_directory)) self.content_directory = kwargs.pop( 'content_directory', os.path.join(self.exe_directory, 'doc', 'content')) self.object_prefix = kwargs.pop( 'object_prefix', os.path.join(self.content_directory, 'source')) self.syntax_prefix = kwargs.pop( 'syntax_prefix', os.path.join(self.content_directory, 'syntax')) self.remove = kwargs.pop('remove', None) self.alias = kwargs.pop('alias', None) self.unregister = kwargs.pop('unregister', None) self.allow_test_objects = kwargs.pop('allow_test_objects', False) super().__init__(**kwargs)
def __init__(self, **kwargs): self._documents = dict() kwargs.setdefault('required_documents', INL_DOCUMENTS) for name in kwargs.get('required_documents'): doc = kwargs.pop(name, None) if doc is not None: doc = mooseutils.eval_path(doc) self._documents[name] = doc super().__init__(**kwargs) if self.working_dirs is None: self.working_dirs = [mooseutils.git_root_dir()]
def compute_requirement_stats(location, specs=['tests'], working_dir=None, show=True, list_missing=False): """ Report requirement statistics for the test spec files with the supplied location. Inputs: location: Path to directory contain test specifications, the supplied path should be relative to the cwd input. specs: The filename(s) to consider working_dir: The working directory, if not supplied the root directory of the repository is used """ from .hit_load import hit_load tests_with_missing_requirements = set() working_dir = git_root_dir( os.getcwd()) if working_dir is None else working_dir data = SQAStats(location) location = os.path.join(working_dir, location) for filename in git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: root = hit_load(filename) has_requirement = False for child in root.children[0]: data.tests += 1 deprecated = root.children[0].get( 'deprecated', False) or child.get('deprecated', False) if deprecated: data.tests_deprecated += 1 if child.get('requirement', None): has_requirement = True data.tests_with_requirement += 1 elif not deprecated: tests_with_missing_requirements.add((filename, child.name)) data.files += 1 if show: print(data) if list_missing and tests_with_missing_requirements: print('\nMissing Requirements:') for filename, test in tests_with_missing_requirements: print('{}:{}'.format(filename, test)) return data
def doc_tree(items): """ Create a tree of files for processing. Inputs: inputs: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. """ # Error checking if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error('The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None # Define a dict for storing nodes by path nodes = dict() # Create the root node nodes[()] = page.DirectoryNode(source='') # Create the file tree for value in items: if 'root_dir' not in value: LOG.error('The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') root = mooseutils.eval_path(value['root_dir']) if not os.path.isabs(root): root = os.path.join(MooseDocs.ROOT_DIR, root) # Update the project files MooseDocs.PROJECT_FILES.update(mooseutils.git_ls_files(mooseutils.git_root_dir(root))) files = doc_import(root, content=value.get('content', None)) for filename in files: key = tuple(filename.replace(root, '').strip('/').split('/')) # Create directory nodes if they don't exist for i in range(1, len(key)): dir_key = key[:i] if dir_key not in nodes: nodes[dir_key] = page.DirectoryNode(nodes[key[:i-1]], name=key[i-1], source=os.path.join(root, *dir_key)) # Create the file node nodes[key] = create_file_node(nodes[key[:-1]], key[-1], filename) return nodes[()]
def get_content(items, in_ext): """ Create a tree of files for processing. Inputs: items: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. in_ext[tuple]: Set of extensions to be converted (e.g., ('.md', )). out_ext[str]: The extension of rendered result (e.g., '.html'). """ if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error( 'The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None roots = set() nodes = dict() for root, filename, external in get_files(items, in_ext): roots.add(root) key = filename.replace(root, '').strip('/') parts = key.split('/') # Create directory nodes if they don't exist for i in range(1, len(parts)): dir_key = os.path.join(*parts[:i]) if dir_key not in nodes: nodes[dir_key] = pages.Directory(dir_key, external=external, source=os.path.join( root, dir_key)) # Create the file node, if it doesn't already exist. This enforces that the first # item in the supplied content lists is the page that is rendered. if key not in nodes: nodes[key] = create_file_page(key, filename, in_ext) nodes[key].external = external # Update the project files for root in roots: if mooseutils.is_git_repo(root): MooseDocs.PROJECT_FILES.update( mooseutils.git_ls_files(mooseutils.git_root_dir(root))) else: MooseDocs.PROJECT_FILES.update(mooseutils.list_files(root)) return list(nodes.values())
def get_options(): """Command-line options.""" parser = argparse.ArgumentParser(description='SQA Requirement checking tool.') parser.add_argument('-d', '--directory', type=str, default=mooseutils.git_root_dir(), help="The directory to search.") parser.add_argument('-r', '--remote', type=str, default='origin', help="The name of the git remote to compare against.") parser.add_argument('-b', '--branch', type=str, default='devel', help="The name of the branch to compare against.") parser.add_argument('--specs', type=list, default=['tests'], help="The name of the specification files to consider.") parser.add_argument('--skip', nargs='+', default=[], help="Partial directory paths to ignore.") return parser.parse_args()
def execute(self, **kwargs): """ Computes the percent complete, number missing items, and the pass/fail status """ # Extract configuration parameters working_dir = self.working_dir or mooseutils.git_root_dir() local_dirs = self.directories specs = self.specs or 'tests' # Get complete directory paths if local_dirs: directories = list() for local_dir in local_dirs: d = mooseutils.eval_path(local_dir) if not os.path.isdir(d): d = os.path.join(working_dir, d) directories.append(d) else: directories = [working_dir] # Check that directories exist for d in directories: if not os.path.isdir(d): raise NotADirectoryError( "Supplied directory does not exist: {}".format(d)) # Build Requirement objects and remove directory based dict req_dict = get_requirements(directories, specs.split()) requirements = [] for values in req_dict.values(): requirements += values # Populate the lists of tests for SQARequirementDiffReport self.test_names = set() for req in requirements: self.test_names.add((req.filename, req.name, req.line)) # Check the requirements logger = check_requirements(requirements, color_text=self.color_text, **kwargs) return logger
def get_content(items, in_ext): """ Create a tree of files for processing. Inputs: items: [list[dict(),...] A list of dict items, each dict entry must contain the 'root_dir' and 'content' fields that are passed to the doc_import function. in_ext[tuple]: Set of extensions to be converted (e.g., ('.md', )). out_ext[str]: The extension of rendered result (e.g., '.html'). """ if not isinstance(items, list) or any(not isinstance(x, dict) for x in items): LOG.error('The supplied items must be a list of dict items, each with a "root_dir" and ' 'optionally a "content" entry.') return None roots = set() nodes = dict() for root, filename in get_files(items, in_ext): roots.add(root) key = filename.replace(root, '').strip('/') parts = key.split('/') # Create directory nodes if they don't exist for i in range(1, len(parts)): dir_key = os.path.join(*parts[:i]) if dir_key not in nodes: nodes[dir_key] = MooseDocs.tree.pages.Directory(dir_key, source=os.path.join(root, dir_key)) # Create the file node, if it doesn't already exist. This enforces that the first # item in the supplied content lists is the page that is rendered. if key not in nodes: nodes[key] = create_file_page(key, filename, in_ext) # Update the project files for root in roots: if mooseutils.is_git_repo(root): MooseDocs.PROJECT_FILES.update(mooseutils.git_ls_files(mooseutils.git_root_dir(root))) else: MooseDocs.PROJECT_FILES.update(mooseutils.list_files(root)) return nodes.values()
def get_requirements_from_tests(directories, specs, include_non_testable=False): """ Build requirements dictionary from the provided directories. Input: directories[list]: A list of directories to consider specs[list]: A list of test specification names (e.g., ['tests']) """ out = collections.defaultdict(list) for location in directories: root_dir = mooseutils.git_root_dir(location) for filename in sorted(mooseutils.git_ls_files(location)): if os.path.isfile(filename) and (os.path.basename(filename) in specs): local = os.path.relpath(filename, location) group = local.split('/')[0] out[group] += get_requirements_from_file(filename, os.path.dirname(local), include_non_testable, root_dir) return out
def get_test_specification(filename, block): """ Create a TestSpecification object from the HIT file and block name. Input: filename[str]: Complete filename of a HIT file containing test specification(s) block[str]: The name of the block to use for creating the TestSpecification object This function exists to allow for requirements to be defined outside of the test specifications, but still reference tests for the purpose of SQA traceability. Support for this was added to allow for non-functional requirements to be defined outside of the test specifications. """ root = pyhit.load(filename) # Locate the desired block node = moosetree.find(root, lambda n: n.fullpath.endswith(block)) if node is None: raise KeyError("Unable to locate '{}' in {}".format(block, filename)) # Build/return TestSpecification object name = node.name if node.parent.parent.is_root else '{}/{}'.format(node.parent.name, node.name) return _create_specification(node, name, filename, mooseutils.git_root_dir(os.path.dirname(filename)))
def compute_requirement_stats(location, specs=['tests'], working_dir=None, show=True): """ Report requirement statistics for the test spec files with the supplied location. Inputs: location: Path to directory contain test specifications, the supplied path should be relative to the cwd input. specs: The filename(s) to consider working_dir: The working directory, if not supplied the root directory of the repository is used """ working_dir = git_root_dir( os.getcwd()) if working_dir is None else working_dir data = SQAStats(location) location = os.path.join(working_dir, location) for filename in git_ls_files(location): if not os.path.isfile(filename): continue fname = os.path.basename(filename) if fname in specs: root = hit_load(filename) has_requirement = False for child in root.children[0]: data.tests += 1 if child.get('requirement', None): has_requirement = True data.tests_with_requirement += 1 data.files += 1 if has_requirement: data.files_with_requirement += 1 if show: print(data) return data
def check_documents(documents, file_list=None, **kwargs): """ Tool for checking SQA document deficiencies """ # Setup logger, assume the names of the documents with a "log_" prefix are the logging flags (see get_documents) for doc in documents: kwargs.setdefault("log_" + doc.name, logging.ERROR) logger = LogHelper(__name__, **kwargs) # Setup file_list, if not provided if (file_list is None) and (not mooseutils.is_git_repo()): msg = "If the 'file_list' is not provided then the working directory must be a git repository." raise ValueError(msg) elif file_list is None: root = mooseutils.git_root_dir() file_list = mooseutils.git_ls_files(root, recurse_submodules=False) # Perform document checks for doc in documents: _check_document(doc.name, doc.filename, file_list, logger) return logger
import os import sys import subprocess import mooseutils moose_dir = mooseutils.git_root_dir(os.path.dirname(__file__)) status = mooseutils.git_submodule_status(moose_dir) # Use framework/contrib/hit because moosetools submodule is not available if status['moosetools'] == '-': hit_dir = os.path.join(moose_dir, 'framework', 'contrib', 'hit') sys.path.append(hit_dir) try: import hit except: moose_test_dir = os.path.abspath(os.path.join(moose_dir, 'test')) subprocess.run(['make', 'hit'], cwd=moose_test_dir) import hit # Use hit in moosetools submodule else: hit_dir = os.path.join(moose_dir, 'moosetools', 'contrib', 'hit') sys.path.append(hit_dir) try: import hit except: subprocess.run(['make', 'hit.so'], cwd=hit_dir) import hit from hit import TokenType, Token from .pyhit import Node, load, write, parse, tokenize
import logging if sys.version_info < (3, 6): print('"MOOSEDocs" requires python version 3.6 or greater, version {}.{} is being used.' \ .format(sys.version_info[0], sys.version_info[1])) sys.exit(1) import mooseutils # Current logging level, used to allow for debug only type checking, etc. LOG_LEVEL = logging.NOTSET # The repository root location is_git_repo = mooseutils.git_is_repo() if is_git_repo: os.environ.setdefault('ROOT_DIR', mooseutils.git_root_dir()) elif 'ROOT_DIR' not in os.environ: print('MooseDocs requires the ROOT_DIR environment variable to set when operating outside of a git repository.') sys.exit(1) ROOT_DIR = os.environ['ROOT_DIR'] # Setup MOOSE_DIR/ROOT_DIR MOOSE_DIR = os.getenv('MOOSE_DIR', None) if MOOSE_DIR is None: print("The MOOSE_DIR environment must be set, this should be set within moosedocs.py.") sys.exit(1) # Initialize submodule(s) mooseutils.git_init_submodule('large_media', MOOSE_DIR)
#!/usr/bin/env python import os import sys import unittest import mooseutils ROOT_DIR = mooseutils.git_root_dir() sys.path.insert(0, os.path.join(ROOT_DIR, 'scripts')) from sqa_check import check_requirement class Test(unittest.TestCase): def testScript(self): """Test the SQA checker.""" check_requirement('[Tests][foo][][]') output = sys.stdout.getvalue() self.assertIn('requirement', output) self.assertIn('design', output) self.assertIn('issues', output) if __name__ == '__main__': unittest.main(verbosity=2, buffer=True)
if messages: print 'ERROR in {}'.format(filename) print '\n'.join(messages) + '\n' return 1 return 0 if __name__ == '__main__': opt = get_options() # Fetch cmd = ['git', 'fetch', opt.remote] subprocess.call(cmd) # Root git directory root = mooseutils.git_root_dir() # Check requirements on changed tests specs count = 0 cmd = [ 'git', 'diff', '{}/{}'.format(opt.remote, opt.branch), '--name-only' ] for filename in subprocess.check_output(cmd).split('\n'): if os.path.isfile(filename) and (os.path.basename(filename) in opt.specs): count += check_requirement(os.path.join(root, filename)) sys.exit(count)
#!/usr/bin/env python3 #* This file is part of the MOOSE framework #* https://www.mooseframework.org #* #* All rights reserved, see COPYRIGHT for full restrictions #* https://github.com/idaholab/moose/blob/master/COPYRIGHT #* #* Licensed under LGPL 2.1, please see LICENSE for details #* https://www.gnu.org/licenses/lgpl-2.1.html import os import sys import unittest import mooseutils ROOT_DIR = mooseutils.git_root_dir() sys.path.insert(0, os.path.join(ROOT_DIR, 'scripts')) from git_news import main class Test(unittest.TestCase): def testScript(self): """Test the get_news.py script""" proc = main() self.assertFalse(proc.returncode) if __name__ == '__main__': unittest.main(verbosity=2, buffer=True)
if child.get('issues', issues) is None: messages.append(" 'issues' parameter is missing in '{}' block.".format(child.name)) if messages: print 'ERROR in {}'.format(filename) print '\n'.join(messages) + '\n' return 1 return 0 if __name__ == '__main__': opt = get_options() # Fetch cmd = ['git', 'fetch', opt.remote] subprocess.call(cmd) # Root git directory root = mooseutils.git_root_dir() # Check requirements on changed tests specs count = 0 cmd = ['git', 'merge-base', '{}/{}'.format(opt.remote, opt.branch), 'HEAD'] sha = subprocess.check_output(cmd).strip() cmd = ['git', 'diff', sha, '--name-only'] for filename in subprocess.check_output(cmd).split('\n'): if os.path.isfile(filename) and (os.path.basename(filename) in opt.specs): count += check_requirement(os.path.join(root, filename)) sys.exit(count)
def check_requirements(requirements, file_list=None, color_text=True, allowed_collections=None, allowed_classifications=None, **kwargs): """ Tool for checking Requirement for deficiencies """ # Create key values for the logging messages log_default = kwargs.get('log_default', logging.ERROR) kwargs.setdefault('log_deprecated_requirement', log_default) kwargs.setdefault('log_deprecated_design', log_default) kwargs.setdefault('log_deprecated_issues', log_default) kwargs.setdefault('log_deprecated_detail', log_default) kwargs.setdefault('log_deprecated_verification', log_default) kwargs.setdefault('log_deprecated_validation', log_default) kwargs.setdefault('log_deprecated_with_details', log_default) kwargs.setdefault('log_missing', log_default) kwargs.setdefault('log_missing_requirement', log_default) kwargs.setdefault('log_missing_design', log_default) kwargs.setdefault('log_missing_issues', log_default) kwargs.setdefault('log_empty_requirement', log_default) kwargs.setdefault('log_empty_design', log_default) kwargs.setdefault('log_empty_issues', log_default) kwargs.setdefault('log_empty_verification', log_default) kwargs.setdefault('log_empty_validation', log_default) kwargs.setdefault('log_top_level_detail', log_default) kwargs.setdefault('log_missing_detail', log_default) kwargs.setdefault('log_empty_detail', log_default) kwargs.setdefault('log_extra_requirement', log_default) kwargs.setdefault('log_extra_design', log_default) kwargs.setdefault('log_extra_issues', log_default) kwargs.setdefault('log_extra_collections', log_default) kwargs.setdefault('log_invalid_collection', log_default) kwargs.setdefault('log_issue_format', log_default) kwargs.setdefault('log_design_files', log_default) kwargs.setdefault('log_validation_files', log_default) kwargs.setdefault('log_verification_files', log_default) kwargs.setdefault('log_testable', log_default) kwargs.setdefault('log_duplicate_requirement', log_default) kwargs.setdefault('log_duplicate_detail', log_default) logger = RequirementLogHelper(__name__, **kwargs) RequirementLogHelper.COLOR_TEXT = color_text # Setup file_list, if not provided if (file_list is None) and (not mooseutils.git_is_repo()): msg = "If the 'file_list' is not provided then the working directory must be a git repository." raise ValueError(msg) elif file_list is None: root = mooseutils.git_root_dir() ver = mooseutils.git_version() file_list = mooseutils.git_ls_files(root, recurse_submodules=True) # Setup allowed collections if allowed_collections is None: allowed_collections = set(moosesqa.MOOSESQA_COLLECTIONS) # Storage container for duplicate detection requirement_dict = collections.defaultdict(set) # Check each Requirement object for deficiencies for req in requirements: _check_requirement(req, logger, file_list, allowed_collections) if req.requirement is not None: key = [req.requirement] for detail in req.details: if detail.detail is not None: key.append(detail.detail) requirement_dict['\n'.join(key)].add(req) # Duplicate checking for txt, value in requirement_dict.items(): if len(value) > 1: msg = 'Duplicate requirements found:' msg += '\n{}\n'.format( mooseutils.colorText(txt, 'GREY', colored=color_text)) for r in value: r.duplicate = True msg += RequirementLogHelper._colorTestInfo(r, None, None, None) LogHelper.log(logger, 'log_duplicate_requirement', msg.strip('\n')) return logger
def testGitSubmoduleStatus(self): root = mooseutils.git_root_dir() status = mooseutils.git_submodule_status(root) self.assertIn('large_media', status) self.assertIn('libmesh', status) self.assertIn('petsc', status)
def testGitRootDir(self): root = mooseutils.git_root_dir() self.assertEqual( root, os.path.abspath( os.path.join(os.path.dirname(__file__), '..', '..', '..')))
def testToManyError(self): fname = 'box_marker/tests' root_dir = mooseutils.git_root_dir(os.path.dirname(__file__)) with self.assertRaises(NameError) as e: filename = _find_file(root_dir, fname) self.assertIn('Located multiple test specifications', str(e.exception))