def _config_cmd(self, pav_cfg, args): """Show the whole pavilion config or a config template.""" if args.template: config.PavilionConfigLoader().dump(self.outfile) else: config.PavilionConfigLoader().dump(self.outfile, values=pav_cfg)
def _config_cmd(pav_cfg, args, outfile=sys.stdout): if args.template: config.PavilionConfigLoader().dump(sys.stdout) else: config.PavilionConfigLoader().dump(outfile, values=pav_cfg)
def test_get(self): # Try to get a configuration from the testing pavilion.yaml file. try: pav_cfg = config.PavilionConfigLoader().load(open(self.PAV_CONFIG_PATH)) except FileNotFoundError: self._logger.error("Could not find pavilion config at '{}'. You'll probably need to " "setup the proxy information for this test." .format(self.PAV_CONFIG_PATH)) pav_cfg = config.PavilionConfigLoader().load_empty() info = wget.head(pav_cfg, self.GET_TARGET) # Make sure we can pull basic info using an HTTP HEAD. # The Etag can change pretty easily; and the content-encoding may muck with the length, # so we can't really verify these. self.assertIn('Content-Length', info) self.assertIn('ETag', info) # Note that there are race conditions with this, however, it is unlikely they will ever be # encountered in this context. dest_fn = tempfile.mktemp(dir='/tmp') # Raises an exception on failure. wget.get(pav_cfg, self.GET_TARGET, dest_fn) self.assertEqual(get_hash(self.LOCAL_TARGET), get_hash(dest_fn)) os.unlink(dest_fn)
def __init__(self, *args, **kwargs): """Setup the pav_cfg object, and do other initialization required by pavilion.""" # Open the default pav config file (found in # test/data/pav_config_dir/pavilion.yaml), modify it, and then # save the modified file to a temp location and read it instead. with self.PAV_CONFIG_PATH.open() as cfg_file: raw_pav_cfg = config.PavilionConfigLoader().load(cfg_file) raw_pav_cfg.config_dirs = [self.TEST_DATA_ROOT/'pav_config_dir', self.PAV_LIB_DIR] raw_pav_cfg.working_dir = self.PAV_ROOT_DIR/'test'/'working_dir' raw_pav_cfg.user_config = False raw_pav_cfg.result_log = raw_pav_cfg.working_dir/'results.log' if not raw_pav_cfg.working_dir.exists(): raw_pav_cfg.working_dir.mkdir() cfg_dir = raw_pav_cfg.working_dir/'pav_cfgs' if not cfg_dir.exists(): cfg_dir.mkdir() cfg_path = Path(tempfile.mktemp( suffix='.yaml', dir=str(cfg_dir))) with cfg_path.open('w') as pav_cfg_file: config.PavilionConfigLoader().dump(pav_cfg_file, raw_pav_cfg) with cfg_path.open() as cfg_file: self.pav_cfg = config.PavilionConfigLoader().load(cfg_file) self.pav_cfg.pav_cfg_file = cfg_path self.pav_cfg.pav_vars = pavilion_variables.PavVars() if not self.pav_cfg.working_dir.exists(): self.pav_cfg.working_dir.mkdir(parents=True) # Create the basic directories in the working directory for path in self.WORKING_DIRS: path = self.pav_cfg.working_dir/path if not path.exists(): path.mkdir() self.tmp_dir = tempfile.TemporaryDirectory() # We have to get this to set up the base argument parser before # plugins can add to it. _ = arguments.get_parser() super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Do a default pav config, which will load from # the pavilion lib path. self.pav_config = config.PavilionConfigLoader().load_empty()
def test_module_wrappers(self): """Make sure module wrapper loading is sane too.""" # Get an empty pavilion config and set some config dirs on it. pav_cfg = config.PavilionConfigLoader().load_empty() # We're loading multiple directories of plugins - AT THE SAME TIME! pav_cfg.config_dirs = [ os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir'), os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir2') ] plugins.initialize_plugins(pav_cfg) module_wrapper.get_module_wrapper('foo', '1.0') bar1 = module_wrapper.get_module_wrapper('bar', '1.3') bar2 = module_wrapper.get_module_wrapper('bar', '1.2.0') self.assertIsNot(bar1, bar2) self.assertEqual('1.3', bar1.get_version('1.3')) self.assertEqual('1.2.0', bar2.get_version('1.2.0')) self.assertRaises(module_wrapper.ModuleWrapperError, lambda: bar2.get_version('1.3.0')) bar1.load({}) plugins._reset_plugins()
def test_command_plugins(self): """Make sure command plugin loading is sane.""" # Get an empty pavilion config and set some config dirs on it. pav_cfg = config.PavilionConfigLoader().load_empty() # We're loading multiple directories of plugins - AT THE SAME TIME! pav_cfg.config_dirs = [ os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir'), os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir2') ] plugins.initialize_plugins(pav_cfg) commands.get_command('poof').run(pav_cfg, []) commands.get_command('blarg').run(pav_cfg, []) # Clean up our plugin initializations. plugins._reset_plugins() pav_cfg.config_dirs.append( os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir_conflicts')) self.assertRaises(plugins.PluginError, lambda: plugins.initialize_plugins(pav_cfg)) # Clean up our plugin initializations. plugins._reset_plugins()
def test_plugin_loading(self): """Check to make sure the plugin system initializes correctly. Separate tests will check the internal initialization of each plugin sub-system.""" # Get an empty pavilion config and set some config dirs on it. pav_cfg = config.PavilionConfigLoader().load_empty() # We're loading multiple directories of plugins - AT THE SAME TIME! pav_cfg.config_dirs = [ os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir'), os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir2') ] for path in pav_cfg.config_dirs: self.assertTrue(os.path.exists(path)) plugins.initialize_plugins(pav_cfg) created_manager = plugins._PLUGIN_MANAGER # Make sure this can run multiple times, plugins.initialize_plugins(pav_cfg) # Make sure only one of these is ever created. self.assertIs(created_manager, plugins._PLUGIN_MANAGER) # Clean up our plugin initializations. plugins._reset_plugins()
def __init__(self, *args, **kwargs): with open(self.PAV_CONFIG_PATH) as cfg_file: self.pav_cfg = config.PavilionConfigLoader().load(cfg_file) self.pav_cfg.config_dirs = [ os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir') ] self.tmp_dir = tempfile.TemporaryDirectory() #self.pav_cfg.working_dir = self.tmp_dir.name self.pav_cfg.working_dir = '/tmp/{}/pav_tests/'.format(os.getlogin()) # Create the basic directories in the working directory for path in [ self.pav_cfg.working_dir, os.path.join(self.pav_cfg.working_dir, 'builds'), os.path.join(self.pav_cfg.working_dir, 'tests'), os.path.join(self.pav_cfg.working_dir, 'suites'), os.path.join(self.pav_cfg.working_dir, 'downloads') ]: if not os.path.exists(path): os.makedirs(path, exist_ok=True) super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): with self.PAV_CONFIG_PATH.open() as cfg_file: raw_pav_cfg = config.PavilionConfigLoader().load(cfg_file) raw_pav_cfg.config_dirs = [ self.TEST_DATA_ROOT / 'pav_config_dir', self.PAV_LIB_DIR ] raw_pav_cfg.working_dir = Path('/tmp') / get_login() / 'pav_tests' raw_pav_cfg.result_log = raw_pav_cfg.working_dir / 'results.log' if not raw_pav_cfg.working_dir.exists(): raw_pav_cfg.working_dir.mkdir() cfg_dir = raw_pav_cfg.working_dir / 'pav_cfgs' if not cfg_dir.exists(): cfg_dir.mkdir() cfg_path = Path(tempfile.mktemp(suffix='.yaml', dir=str(cfg_dir))) with cfg_path.open('w') as pav_cfg_file: config.PavilionConfigLoader().dump(pav_cfg_file, raw_pav_cfg) with cfg_path.open() as cfg_file: self.pav_cfg = config.PavilionConfigLoader().load(cfg_file) self.pav_cfg.pav_cfg_file = cfg_path # Create the basic directories in the working directory for path in [ self.pav_cfg.working_dir, self.pav_cfg.working_dir / 'builds', self.pav_cfg.working_dir / 'tests', self.pav_cfg.working_dir / 'series', self.pav_cfg.working_dir / 'users', self.pav_cfg.working_dir / 'downloads' ]: if not path.exists(): os.makedirs(str(path), exist_ok=True) self.tmp_dir = tempfile.TemporaryDirectory() # We have to get this to set up the base argument parser before # plugins can add to it. _ = arguments.get_parser() super().__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Do a default pav config, which will load from # the pavilion lib path. self.pav_config = config.PavilionConfigLoader().load_empty() self.pav_config.config_dirs = [self.TEST_DATA_ROOT / 'pav_config_dir']
def test_blank_cycle(self): """Ensure we can both write and read the config template.""" loader = config.PavilionConfigLoader() file = io.StringIO() loader.dump(file) file.seek(0) loader.load(file)
def test_update(self): # Try to get a configuration from the testing pavilion.yaml file. try: pav_cfg = config.PavilionConfigLoader().load(open(self.PAV_CONFIG_PATH)) except FileNotFoundError: self._logger.error("Could not find pavilion config at '{}'. You'll probably need to " "setup the proxy information for this test." .format(self.PAV_CONFIG_PATH)) pav_cfg = config.PavilionConfigLoader().load_empty() dest_fn = tempfile.mktemp(dir='/tmp') info_fn = '{}.info'.format(dest_fn) self.assertFalse(os.path.exists(dest_fn)) self.assertFalse(os.path.exists(info_fn)) # Update should get the file if it doesn't exist. wget.update(pav_cfg, self.GET_TARGET, dest_fn) self.assertTrue(os.path.exists(dest_fn)) self.assertTrue(os.path.exists(info_fn)) # It should update the file if the info file isn't there and the sizes don't match. ctime = os.stat(dest_fn).st_ctime with open(dest_fn, 'ab') as dest_file: dest_file.write(b'a') os.unlink(info_fn) wget.update(pav_cfg, self.GET_TARGET, dest_fn) new_ctime = os.stat(dest_fn).st_ctime self.assertNotEqual(new_ctime, ctime) ctime = new_ctime # We'll muck up the info file data, to force an update. with dbm.open(info_fn, 'w') as db: db['ETag'] = 'nope' db['Content-Length'] = '-1' wget.update(pav_cfg, self.GET_TARGET, dest_fn) new_ctime = os.stat(dest_fn).st_ctime self.assertNotEqual(new_ctime, ctime) os.unlink(dest_fn) os.unlink(info_fn)
def test_cycle(self): """Make sure we can load the defaults, save them, and reload them.""" loader = config.PavilionConfigLoader() pav_cfg = loader.load_empty() file = io.StringIO() loader.dump(file, pav_cfg) file.seek(0) new_cfg = loader.load(file) self.assertEqual(pav_cfg, new_cfg)
def test_result_parser_plugins(self): """Check basic result parser structure.""" # Get an empty pavilion config and set some config dirs on it. pav_cfg = config.PavilionConfigLoader().load_empty() plugins.initialize_plugins(pav_cfg) # We're loading multiple directories of plugins - AT THE SAME TIME! pav_cfg.config_dirs = [ os.path.join(self.TEST_DATA_ROOT, 'pav_config_dir') ] # We should have exactly one test plugin. self.assertEqual(len(result_parsers.list_plugins()), 1) regex = result_parsers.get_plugin('regex') plugins._reset_plugins()
def test_system_plugins(self): """Make sure system values appear as expected. Also that deferred variables behave as expected.""" # Get an empty pavilion config and set some config dirs on it. pav_cfg = config.PavilionConfigLoader().load_empty() plugins.initialize_plugins(pav_cfg) self.assertFalse(system_variables._LOADED_PLUGINS is None) host_arch = subprocess.check_output(['uname', '-i']) host_arch = host_arch.strip().decode('UTF-8') host_name = subprocess.check_output(['hostname', '-s']) host_name = host_name.strip().decode('UTF-8') with open('/etc/os-release', 'r') as release: rlines = release.readlines() host_os = {} for line in rlines: if line[:3] == 'ID=': host_os['ID'] = line[3:].strip().strip('"') elif line[:11] == 'VERSION_ID=': host_os['Version'] = line[11:].strip().strip('"') sys_vars = system_variables.get_system_plugin_dict(defer=False) self.assertFalse('sys_arch' in sys_vars) self.assertEqual(host_arch, sys_vars['sys_arch']) self.assertTrue('sys_arch' in sys_vars) self.assertFalse('sys_name' in sys_vars) self.assertEqual(host_name, sys_vars['sys_name']) self.assertTrue('sys_name' in sys_vars) self.assertFalse('sys_os' in sys_vars) self.assertEqual(host_os['ID'], sys_vars['sys_os']['ID']) self.assertEqual(host_os['Version'], sys_vars['sys_os']['Version']) self.assertTrue('sys_os' in sys_vars) self.assertFalse('host_arch' in sys_vars) self.assertEqual(host_arch, sys_vars['host_arch']) self.assertTrue('host_arch' in sys_vars) self.assertFalse('host_name' in sys_vars) self.assertEqual(host_name, sys_vars['host_name']) self.assertTrue('host_name' in sys_vars) self.assertFalse('host_os' in sys_vars) self.assertEqual(host_os['ID'], sys_vars['host_os']['ID']) self.assertEqual(host_os['Version'], sys_vars['host_os']['Version']) self.assertTrue('host_os' in sys_vars) # Re-initialize the plugin system. plugins._reset_plugins() # Make sure these have been wiped self.assertIsNone(system_variables._LOADED_PLUGINS) # Make sure these have been wiped. self.assertIsNone(system_variables._SYS_VAR_DICT) plugins.initialize_plugins(pav_cfg) # but these are back self.assertIsNotNone(system_variables._LOADED_PLUGINS) sys_vars = system_variables.get_system_plugin_dict(defer=True) self.assertTrue(len(system_variables._SYS_VAR_DICT.items()) == 0) # Check that the deferred values are actually deferred. self.assertFalse('host_arch' in sys_vars) self.assertTrue( isinstance(sys_vars['host_arch'], variables.DeferredVariable)) self.assertFalse('host_name' in sys_vars) self.assertTrue( isinstance(sys_vars['host_name'], variables.DeferredVariable)) self.assertFalse('host_os' in sys_vars) self.assertTrue( isinstance(sys_vars['host_os'], variables.DeferredVariable)) plugins._reset_plugins()
def _config_cmd(self, pav_cfg, args): if args.template: config.PavilionConfigLoader().dump(self.outfile) else: config.PavilionConfigLoader().dump(self.outfile, values=pav_cfg)