def test_custom_rpm_version_py_command(self): """Test custom rpm_version command.""" stdout, stderr, return_code = self.run_setup('rpm_version') self.addDetail('stdout', content.text_content(stdout)) self.addDetail('stderr', content.text_content(stderr)) self.assertIn('Extracting rpm version', stdout) self.assertEqual(return_code, 0)
def _run_core(self): # Add an observer to trap all logged errors. self.case.reactor = self._reactor error_observer = _log_observer full_log = StringIO() full_observer = log.FileLogObserver(full_log) spinner = self._make_spinner() successful, unhandled = run_with_log_observers( [error_observer.gotEvent, full_observer.emit], self._blocking_run_deferred, spinner ) self.case.addDetail("twisted-log", text_content(full_log.getvalue())) logged_errors = error_observer.flushErrors() for logged_error in logged_errors: successful = False self._got_user_failure(logged_error, tb_label="logged-error") if unhandled: successful = False for debug_info in unhandled: f = debug_info.failResult info = debug_info._getDebugTracebacks() if info: self.case.addDetail("unhandled-error-in-deferred-debug", text_content(info)) self._got_user_failure(f, "unhandled-error-in-deferred") junk = spinner.clear_junk() if junk: successful = False self._log_user_exception(UncleanReactorError(junk)) if successful: self.result.addSuccess(self.case, details=self.case.getDetails())
def _setUp(self): super(NeutronNetworkFixture, self)._setUp() self.neutron = get_neutron_client( project_name=self.project_fixture.name, user_name=self.project_fixture.admin_user.name, password=self.project_fixture.admin_user_fixture.password) self.subnet_id = self.get_subnet_id() cidr = CONF.network['cidr'].format(subnet=self.subnet_id) # TODO: handle clashes and retry. self.net_name = factory.make_obj_name("network") self.sub_name = factory.make_obj_name("subnet") self.network = self.neutron.create_network( {"network": dict(name=self.net_name)}) network_id = self.network["network"]["id"] self.subnet = self.neutron.create_subnet( {"subnet": dict( name=self.sub_name, network_id=network_id, cidr=cidr, ip_version=4)}) self.addCleanup(self.delete_network) self.addDetail( 'NeutronNetworkFixture-network', text_content('Network %s created' % self.net_name)) self.addDetail( 'NeutronNetworkFixture-subnet', text_content('Subnet %s created (cidr=%s)' % ( self.sub_name, cidr)))
def test_bug_import_script_in_testing_mode(self): # Test that the bug import script works with --testing. script = os.path.join(config.root, 'scripts', 'bug-import.py') cache_filename = os.path.join(self.tmpdir, 'bug-map.pickle') stdout, stderr, returncode = run_process( (script, '--testing', '--cache', cache_filename, self.write_example_xml())) self.addDetail("stdout", text_content(stdout)) self.addDetail("stderr", text_content(stderr)) self.assertEqual(0, returncode) # Find the product that was created: match = re.search(r'Product ([^ ]+) created', stderr) self.assertIsNotNone(match) product_name = match.group(1) # Find the imported bug number: match = re.search(r'Creating Launchpad bug #(\d+)', stderr) self.assertIsNotNone(match) bug_id = int(match.group(1)) # Abort transaction so we can see the result: transaction.abort() bug = getUtility(IBugSet).get(bug_id) self.assertEqual('A test bug', bug.title) self.assertEqual(product_name, bug.bugtasks[0].product.name)
def test_show_redundancy_summary(self): ret, session = self.login() prompt = accelerated_upgrade.get_prompt(session) search_window = len(prompt) + 1 self.addDetail('prompt', text_content(prompt)) session.sendline() status = session.expect_exact( [prompt], timeout=3, searchwindowsize=search_window) self.assertEqual(0, status) self.addDetail('received-prompt', text_content(session.after)) cmd = 'show redundancy summary' session.sendline(cmd) status = session.expect_exact( [prompt, INVALID_INPUT, MORE, EOF], timeout=5, searchwindowsize=search_window ) #check if get prompt after the command self.assertEqual(0, status) # replace LF with CR/LF (maybe different on Windows) output = asr_9k.commands[cmd][0].replace('\n', '\r\n') found = session.before.find(output) self.addDetail('found', text_content(str(found))) self.addDetail('received', text_content(session.before)) self.addDetail('expected', text_content(output)) self.assertNotEqual(-1, found)
def run_apt_autoremove(self): if sys.platform == "win32": return deb_env = os.environ.copy() deb_env.update( {"DEBIAN_FRONTEND": "noninteractive", "DEBCONF_NONINTERACTIVE_SEEN": "true"} ) try: autoremove_output = subprocess.check_output( "sudo apt-get autoremove -y".split(), stderr=subprocess.STDOUT, env=deb_env, ) self.addDetail( "apt-get autoremove output", content.text_content(autoremove_output.decode("utf-8")), ) except FileNotFoundError as e: self.addDetail("apt-get autoremove error", content.text_content(str(e))) except subprocess.CalledProcessError as e: self.addDetail("apt-get autoremove error", content.text_content(str(e))) self.addDetail( "apt-get autoremove output", content.text_content(e.output.decode("utf-8")), ) if os.getenv("SNAPCRAFT_APT_AUTOREMOVE_CHECK_FAIL", False): raise
def test_pep8(self): # NOTE(jecarey): Add tests marked as off_by_default to enable testing turn_on = set(['H106']) if self.options.select: turn_on.update(self.options.select) self.options.select = tuple(turn_on) report = pep8.BaseReport(self.options) checker = pep8.Checker(filename=self.filename, lines=self.lines, options=self.options, report=report) checker.check_all() self.addDetail('doctest', content.text_content(self.raw)) if self.code == 'Okay': self.assertThat( len(report.counters), matchers.Not(matchers.GreaterThan( len(self.options.benchmark_keys))), "incorrectly found %s" % ', '.join( [key for key in report.counters if key not in self.options.benchmark_keys])) else: self.addDetail('reason', content.text_content("Failed to trigger rule %s" % self.code)) self.assertIn(self.code, report.counters)
def test_recordsets_with_zone_id(self): '''Test DNS recordsets functionality''' sub = ''.join(random.choice(string.ascii_lowercase) for _ in range(6)) zone = '%s.example2.net.' % sub email = '*****@*****.**' name = 'www.%s' % zone type_ = 'a' description = 'Test recordset' ttl = 3600 records = ['192.168.1.1'] self.addDetail('zone', content.text_content(zone)) self.addDetail('recordset', content.text_content(name)) # Create a zone to hold the tested recordset zone_obj = self.user_cloud.create_zone(name=zone, email=email) # Test we can create a recordset and we get it returned created_recordset = self.user_cloud.create_recordset(zone_obj['id'], name, type_, records, description, ttl) self.addCleanup(self.cleanup, zone, created_recordset['id']) self.assertEqual(created_recordset['zone_id'], zone_obj['id']) self.assertEqual(created_recordset['name'], name) self.assertEqual(created_recordset['type'], type_.upper()) self.assertEqual(created_recordset['records'], records) self.assertEqual(created_recordset['description'], description) self.assertEqual(created_recordset['ttl'], ttl) # Test that we can list recordsets recordsets = self.user_cloud.list_recordsets(zone_obj['id'],) self.assertIsNotNone(recordsets) # Test we get the same recordset with the get_recordset method get_recordset = self.user_cloud.get_recordset(zone_obj['id'], created_recordset['id']) self.assertEqual(get_recordset['id'], created_recordset['id']) # Test we can update a field on the recordset and only that field # is updated updated_recordset = self.user_cloud.update_recordset( zone_obj['id'], created_recordset['id'], ttl=7200) self.assertEqual(updated_recordset['id'], created_recordset['id']) self.assertEqual(updated_recordset['name'], name) self.assertEqual(updated_recordset['type'], type_.upper()) self.assertEqual(updated_recordset['records'], records) self.assertEqual(updated_recordset['description'], description) self.assertEqual(updated_recordset['ttl'], 7200) # Test we can delete and get True returned deleted_recordset = self.user_cloud.delete_recordset( zone, created_recordset['id']) self.assertTrue(deleted_recordset)
def test_logfile_contains_finish(self): """Confirm that logger calls in 'finish' phase recorded Repository layout being checked B---C local/master / A---D---E upstream/master """ tree = [ ('A', []), ('B', ['A']), ('C', ['B']), ('D', ['A']), ('E', ['D']), ] branches = { 'head': ('master', 'C'), 'upstream': ('upstream/master', 'E'), } self.gittree = base.BuildTree(self.testrepo, tree, branches.values()) cmdline = self.parser.get_default('script_cmdline') tfile = None try: tfile = tempfile.NamedTemporaryFile(delete=False) # need to close to allow reopen to write tfile.close() cmdline.extend(['-v', '--log-file', tfile.name, '--log-level', 'debug', 'import', '--into', 'master', 'upstream/master']) try: output = subprocess.check_output(cmdline, stderr=subprocess.STDOUT) except subprocess.CalledProcessError as cpe: self.addDetail( 'subprocess-output', content.text_content(cpe.output.decode('utf-8'))) raise self.addDetail( 'subprocess-output', content.text_content(output.decode('utf-8'))) logfile_contents = open(tfile.name, 'r').read() finally: if tfile and os.path.exists(tfile.name): os.remove(tfile.name) self.assertThat( logfile_contents, matchers.Contains("Merging by inverting the 'ours' strategy")) self.assertThat( logfile_contents, matchers.Contains("Replacing tree contents with those from"))
def refcounts(self, rc, prev): """Report a change in reference counts.""" details = { 'sys-refcounts': text_content(str(rc)), 'changes': text_content(str(rc - prev)), } # XXX: Emit the details dict as JSON? self._emit_fake_test(self.TAG_REFCOUNTS, self.TAG_REFCOUNTS, details)
def detailed_refcounts(self, track, rc, prev): """Report a change in reference counts, with extra detail.""" details = { 'sys-refcounts': text_content(str(rc)), 'changes': text_content(str(rc - prev)), 'track': text_content(str(track.delta)), } self._emit_fake_test(self.TAG_REFCOUNTS, self.TAG_REFCOUNTS, details)
def test_update_cluster(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": "cirros-0.4.0-x86_64-disk", "networks": [ { "network": "private" } ], "security_groups": [ "default" ] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) cluster_name = 'example_cluster' desired_capacity = 0 self.addDetail('cluster', content.text_content(cluster_name)) # Test that we can create a cluster and we get it returned cluster = self.user_cloud.create_cluster( name=cluster_name, profile=profile, desired_capacity=desired_capacity) self.addCleanup(self.cleanup_cluster, cluster['cluster']['id']) # Test that we can update a field on the cluster and only that field # is updated self.user_cloud.update_cluster(cluster['cluster']['id'], new_name='new_cluster_name') wait = wait_for_status( self.user_cloud.get_cluster_by_id, {'name_or_id': cluster['cluster']['id']}, 'status', 'ACTIVE') self.assertTrue(wait) cluster_update = self.user_cloud.get_cluster_by_id( cluster['cluster']['id']) self.assertEqual(cluster_update['id'], cluster['cluster']['id']) self.assertEqual(cluster_update['name'], 'new_cluster_name') self.assertEqual(cluster_update['profile_id'], cluster['cluster']['profile_id']) self.assertEqual(cluster_update['desired_capacity'], cluster['cluster']['desired_capacity'])
def test_yaml_snippet(self): if not self.in_filename: return if self.conf_filename is not None: config = configparser.ConfigParser() config.readfp(open(self.conf_filename)) else: config = {} expected_xml = self._read_utf8_content() yaml_content = self._read_yaml_content(self.in_filename) if isinstance(yaml_content, list): yaml_content = yaml_content[0] project = None if ('project-type' in yaml_content): yaml_content['project-type'] if (yaml_content['project-type'] == "maven"): project = project_maven.Maven(None) elif (yaml_content['project-type'] == "matrix"): project = project_matrix.Matrix(None) elif (yaml_content['project-type'] == "flow"): project = project_flow.Flow(None) elif (yaml_content['project-type'] == "multijob"): project = project_multijob.MultiJob(None) elif (yaml_content['project-type'] == "folder"): project = folders.Folder(None) if project: xml_project = project.root_xml(yaml_content) else: xml_project = XML.Element('project') print yaml_content plugins_info = None if self.plugins_info_filename is not None: plugins_info = self._read_yaml_content(self.plugins_info_filename) self.addDetail("plugins-info-filename", text_content(self.plugins_info_filename)) self.addDetail("plugins-info", text_content(str(plugins_info))) parser = YamlParser(config, plugins_info) pub = self.klass(parser.registry) # Generate the XML tree directly with modules/general pub.gen_xml(parser, xml_project, yaml_content) # Prettify generated XML pretty_xml = XmlJob(xml_project, 'fixturejob').output().decode('utf-8') self.assertThat( pretty_xml, testtools.matchers.DocTestMatches(expected_xml, doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF) )
def test_get_cluster_receiver_by_id(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": "cirros-0.4.0-x86_64-disk", "networks": [ { "network": "private" } ], "security_groups": [ "default" ] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) cluster_name = 'example_cluster' desired_capacity = 0 self.addDetail('cluster', content.text_content(cluster_name)) # Test that we can create a cluster and we get it returned cluster = self.user_cloud.create_cluster( name=cluster_name, profile=profile, desired_capacity=desired_capacity) self.addCleanup(self.cleanup_cluster, cluster['cluster']['id']) receiver_name = "example_receiver" receiver_type = "webhook" self.addDetail('receiver', content.text_content(receiver_name)) # Test that we can create a receiver and we get it returned receiver = self.user_cloud.create_cluster_receiver( name=receiver_name, receiver_type=receiver_type, cluster_name_or_id=cluster['cluster']['id'], action='CLUSTER_SCALE_OUT') self.addCleanup(self.cleanup_receiver, receiver['id']) # Test that we get the same receiver with the get_receiver method receiver_get = self.user_cloud.get_cluster_receiver_by_id( receiver['id']) self.assertEqual(receiver_get['id'], receiver["id"])
def test_recordsets(self): '''Test DNS recordsets functionality''' zone = 'example2.net.' email = '*****@*****.**' name = 'www' type_ = 'a' description = 'Test recordset' ttl = 3600 records = ['192.168.1.1'] self.addDetail('zone', content.text_content(zone)) self.addDetail('recordset', content.text_content(name)) self.addCleanup(self.cleanup, zone, name) # Create a zone to hold the tested recordset zone_obj = self.user_cloud.create_zone(name=zone, email=email) # Test we can create a recordset and we get it returned created_recordset = self.user_cloud.create_recordset(zone, name, type_, records, description, ttl) self.assertEqual(created_recordset['zone_id'], zone_obj['id']) self.assertEqual(created_recordset['name'], name + '.' + zone) self.assertEqual(created_recordset['type'], type_.upper()) self.assertEqual(created_recordset['records'], records) self.assertEqual(created_recordset['description'], description) self.assertEqual(created_recordset['ttl'], ttl) # Test that we can list recordsets recordsets = self.user_cloud.list_recordsets(zone) self.assertIsNotNone(recordsets) # Test we get the same recordset with the get_recordset method get_recordset = self.user_cloud.get_recordset(zone, created_recordset['id']) self.assertEqual(get_recordset['id'], created_recordset['id']) # Test the get method also works by name get_recordset = self.user_cloud.get_recordset(zone, name + '.' + zone) self.assertEqual(get_recordset['id'], created_recordset['id']) # Test we can update a field on the recordset and only that field # is updated updated_recordset = self.user_cloud.update_recordset(zone_obj['id'], name + '.' + zone, ttl=7200) self.assertEqual(updated_recordset['id'], created_recordset['id']) self.assertEqual(updated_recordset['name'], name + '.' + zone) self.assertEqual(updated_recordset['type'], type_.upper()) self.assertEqual(updated_recordset['records'], records) self.assertEqual(updated_recordset['description'], description) self.assertEqual(updated_recordset['ttl'], 7200) # Test we can delete and get True returned deleted_recordset = self.user_cloud.delete_recordset( zone, name + '.' + zone) self.assertTrue(deleted_recordset)
def addSkip(self, test, reason=None, details=None): super(TestByTestResult, self).addSkip(test, reason, details) self._status = 'skip' if details is None: details = {'reason': text_content(reason)} elif reason: # XXX: What if details already has 'reason' key? details['reason'] = text_content(reason) self._details = details
def test_yaml_snippet(self): if not self.in_filename: return jjb_config = self._get_config() expected_xml = self._read_utf8_content() yaml_content = self._read_yaml_content(self.in_filename) plugins_info = None if self.plugins_info_filename is not None: plugins_info = self._read_yaml_content(self.plugins_info_filename) self.addDetail("plugins-info-filename", text_content(self.plugins_info_filename)) self.addDetail("plugins-info", text_content(str(plugins_info))) parser = YamlParser(jjb_config) registry = ModuleRegistry(jjb_config, plugins_info) registry.set_parser_data(parser.data) pub = self.klass(registry) project = None if "project-type" in yaml_content: if yaml_content["project-type"] == "maven": project = project_maven.Maven(registry) elif yaml_content["project-type"] == "matrix": project = project_matrix.Matrix(registry) elif yaml_content["project-type"] == "flow": project = project_flow.Flow(registry) elif yaml_content["project-type"] == "multijob": project = project_multijob.MultiJob(registry) elif yaml_content["project-type"] == "externaljob": project = project_externaljob.ExternalJob(registry) if "view-type" in yaml_content: if yaml_content["view-type"] == "list": project = view_list.List(None) elif yaml_content["view-type"] == "pipeline": project = view_pipeline.Pipeline(None) else: raise InvalidAttributeError("view-type", yaml_content["view-type"]) if project: xml_project = project.root_xml(yaml_content) else: xml_project = XML.Element("project") # Generate the XML tree directly with modules/general pub.gen_xml(xml_project, yaml_content) # Prettify generated XML pretty_xml = XmlJob(xml_project, "fixturejob").output().decode("utf-8") self.assertThat( pretty_xml, testtools.matchers.DocTestMatches(expected_xml, doctest.ELLIPSIS | doctest.REPORT_NDIFF) )
def test_yaml_snippet(self): config = self._get_config() expected_xml = self._read_utf8_content().strip() \ .replace('<BLANKLINE>', '').replace('\n\n', '\n') parser = YamlParser(config) parser.parse(self.in_filename) plugins_info = None if self.plugins_info_filename: plugins_info = self._read_yaml_content(self.plugins_info_filename) self.addDetail("plugins-info-filename", text_content(self.plugins_info_filename)) self.addDetail("plugins-info", text_content(str(plugins_info))) registry = ModuleRegistry(config, plugins_info) registry.set_parser_data(parser.data) job_data_list, view_data_list = parser.expandYaml(registry) # Generate the XML tree xml_generator = XmlJobGenerator(registry) xml_jobs = xml_generator.generateXML(job_data_list) xml_jobs.sort(key=AlphanumSort) # check reference files are under correct path for folders prefix = os.path.dirname(self.in_filename) # split using '/' since fullname uses URL path separator expected_folders = list(set([ os.path.normpath( os.path.join(prefix, '/'.join(job_data['name'].split('/')[:-1]))) for job_data in job_data_list ])) actual_folders = [os.path.dirname(f) for f in self.out_filenames] six.assertCountEqual( self, expected_folders, actual_folders, "Output file under wrong path, was '%s', should be '%s'" % (self.out_filenames[0], os.path.join(expected_folders[0], os.path.basename(self.out_filenames[0])))) # Prettify generated XML pretty_xml = u"\n".join(job.output().decode('utf-8') for job in xml_jobs) \ .strip().replace('\n\n', '\n') self.assertThat( pretty_xml, testtools.matchers.DocTestMatches(expected_xml, doctest.ELLIPSIS | doctest.REPORT_NDIFF))
def test_json_renderer(self): context = json.loads(TEST_JSON) x = renderers.JsonRenderer() result = x.render('{{a.b}}', context) self.addDetail('result', content.text_content(result)) result_structure = json.loads(result) desire_structure = json.loads('[1,2,3,"foo"]') self.assertEqual(desire_structure, result_structure) result = x.render('{{a.c}}', context) self.addDetail('result', content.text_content(result)) self.assertEqual(u'the quick brown fox', result)
def __init__(self, popen_command, code, expected, stdout, stderr): """Initialize this mismatch detail object.""" super(SubprocessExitWithMismatch, self).__init__() command = " ".join(popen_command) self._msg = "{0} exited with {1}, but expected {2}".format(command, code, expected) self._details = { "Output": text_content(stdout), "Errors": text_content(stderr) }
def _end_test(self, detail_description): end_time = time.time() self.test_time = end_time - self.start_time content = test_content.text_content( detail_description + " time: " + str(self.test_time) + "s") self.addDetail("Current", content) reference_time = self._get_benchmark_result() if reference_time is not None: content = test_content.text_content( "Min time: " + str(reference_time[0]) + "s, " + "Max time: " + str(reference_time[1]) + "s") self.addDetail("AWS", content)
def test_custom_build_py_command(self): """Test custom build_py command. Test that a custom subclass of the build_py command runs when listed in the commands [global] option, rather than the normal build command. """ stdout, stderr, return_code = self.run_setup('build_py') self.addDetail('stdout', content.text_content(stdout)) self.addDetail('stderr', content.text_content(stderr)) self.assertIn('Running custom build_py command.', stdout) self.assertEqual(return_code, 0)
def setUp(self): # add description in case parent setup fails. self.addDetail('description', text_content(self.desc)) # builds the tree to be tested super(TestUpstreamMergeBaseSearcher, self).setUp() # need the tree built at this point self.addDetail('expected-changes', text_content(pformat( list((c, self.gittree.graph[c].hexsha) for c in self.expected_changes))))
def test_smoke(self): diff = create_proper_job(self.factory) transaction.commit() out, err, exit_code = run_script( "LP_DEBUG_SQL=1 cronscripts/process-job-source.py -vv %s" % (IPackageDiffJobSource.getName()) ) self.addDetail("stdout", text_content(out)) self.addDetail("stderr", text_content(err)) self.assertEqual(0, exit_code) self.assertEqual(PackageDiffStatus.COMPLETED, diff.status) self.assertIsNot(None, diff.diff_content)
def execute(self, cmd, stdin=None): proc = subprocess.Popen( self.cmd + cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) out, err = proc.communicate(stdin) self.addDetail('stdout', content.text_content(out.decode('utf-8', 'replace'))) self.addDetail('stderr', content.text_content(err.decode('utf-8', 'replace'))) return proc.returncode, out, err
def test_yaml_snippet(self): if not self.in_filename: return config = self._get_config() expected_xml = self._read_utf8_content() yaml_content = self._read_yaml_content(self.in_filename) plugins_info = None if self.plugins_info_filename is not None: plugins_info = self._read_yaml_content(self.plugins_info_filename) self.addDetail("plugins-info-filename", text_content(self.plugins_info_filename)) self.addDetail("plugins-info", text_content(str(plugins_info))) parser = YamlParser(config, plugins_info) pub = self.klass(parser.registry) project = None if ('project-type' in yaml_content): if (yaml_content['project-type'] == "maven"): project = project_maven.Maven(parser.registry) elif (yaml_content['project-type'] == "matrix"): project = project_matrix.Matrix(parser.registry) elif (yaml_content['project-type'] == "flow"): project = project_flow.Flow(parser.registry) elif (yaml_content['project-type'] == "multijob"): project = project_multijob.MultiJob(parser.registry) elif (yaml_content['project-type'] == "externaljob"): project = project_externaljob.ExternalJob(parser.registry) if project: xml_project = project.root_xml(yaml_content) else: xml_project = XML.Element('project') # Generate the XML tree directly with modules/general pub.gen_xml(parser, xml_project, yaml_content) # Prettify generated XML pretty_xml = XmlJob(xml_project, 'fixturejob').output().decode('utf-8') self.assertThat( pretty_xml, testtools.matchers.DocTestMatches(expected_xml, doctest.ELLIPSIS | doctest.REPORT_NDIFF) )
def setUp(self): super(CapturedSubprocess, self).setUp() proc = subprocess.Popen(*self.args, **self.kwargs) out, err = proc.communicate() self.out = out.decode('utf-8', 'replace') self.err = err.decode('utf-8', 'replace') self.addDetail(self.label + '-stdout', content.text_content(self.out)) self.addDetail(self.label + '-stderr', content.text_content(self.err)) self.returncode = proc.returncode if proc.returncode: raise AssertionError('Failed process %s' % proc.returncode) self.addCleanup(delattr, self, 'out') self.addCleanup(delattr, self, 'err') self.addCleanup(delattr, self, 'returncode')
def test_pep8(self): report = pep8.BaseReport(self.options) checker = pep8.Checker(lines=self.lines, options=self.options, report=report) checker.check_all() self.addDetail("doctest", content.text_content(self.raw)) if self.code == "Okay": self.assertThat( len(report.counters), matchers.Not(matchers.GreaterThan(len(self.options.benchmark_keys))), "incorrectly found %s" % ", ".join([key for key in report.counters if key not in self.options.benchmark_keys]), ) else: self.addDetail("reason", content.text_content("Failed to trigger rule %s" % self.code)) self.assertIn(self.code, report.counters)
def test_script(self): product = self.factory.makeProduct() self.factory.makeBug(target=product) self.assertEqual(0, get_bugsummary_rows(product).count()) self.assertEqual(1, get_bugsummaryjournal_rows(product).count()) transaction.commit() exit_code, out, err = run_script('scripts/bugsummary-rebuild.py') self.addDetail("stdout", text_content(out)) self.addDetail("stderr", text_content(err)) self.assertEqual(0, exit_code) transaction.commit() self.assertEqual(1, get_bugsummary_rows(product).count()) self.assertEqual(0, get_bugsummaryjournal_rows(product).count())
def install_snap(self, snap_content_dir, snap_name, version): if not config.get('skip-install', False): snap_file_name = '{}_{}_amd64.snap'.format( snap_name, version) snap_local_path = os.path.join( self.src_dir, snap_content_dir, snap_file_name) self.snappy_testbed.copy_file(snap_local_path, '/home/ubuntu') snap_path_in_testbed = os.path.join( '/home/ubuntu/', snap_file_name) # Remove the snap file from the testbed. self.addCleanup( self.snappy_testbed.run_command, ['rm', snap_path_in_testbed]) try: self.snappy_testbed.run_command([ 'sudo', 'snap', 'install', snap_path_in_testbed]) except subprocess.CalledProcessError as e: self.addDetail( 'ssh output', content.text_content(str(e.output))) raise # Uninstall the snap from the testbed. snap_name = snap_file_name[:snap_file_name.index('_')] self.addCleanup( self.snappy_testbed.run_command, ['sudo', 'snap', 'remove', snap_name]) list_output = self.snappy_testbed.run_command( ['snap', 'list']) expected = '.*{}.*'.format(snap_name) self.assertThat( list_output, MatchesRegex(expected, flags=re.DOTALL))
def test_list_cluster_policies(self): policy_name = 'example_policy' spec = { "properties": { "adjustment": { "min_step": 1, "number": 1, "type": "CHANGE_IN_CAPACITY" }, "event": "CLUSTER_SCALE_IN" }, "type": "senlin.policy.scaling", "version": "1.0" } self.addDetail('policy', content.text_content(policy_name)) # Test that we can create a policy and we get it returned policy = self.user_cloud.create_cluster_policy(name=policy_name, spec=spec) self.addCleanup(self.cleanup_policy, policy['id']) policy_get = self.user_cloud.get_cluster_policy_by_id(policy['id']) # Test that we can list policies policies = self.user_cloud.list_cluster_policies() # Format of the created_at variable differs between policy create # and policy get so if we don't ignore this variable, comparison will # always fail policies[0]['created_at'] = 'ignore' policy_get['created_at'] = 'ignore' self.assertEqual(policies, [policy_get])
def install_snap(self, snap_local_path, snap_name, version, devmode=False, classic=False): if not config.get("skip-install", False): tmp_in_testbed = self.snappy_testbed.run_command( "mktemp -d").strip() self.addCleanup(self.snappy_testbed.run_command, ["rm", "-rf", tmp_in_testbed]) self.snappy_testbed.copy_file(snap_local_path, tmp_in_testbed) snap_file_name = os.path.basename(snap_local_path) snap_path_in_testbed = os.path.join(tmp_in_testbed, snap_file_name) cmd = [ "sudo", "snap", "install", "--force-dangerous", snap_path_in_testbed ] if devmode: cmd.append("--devmode") if classic: cmd.append("--classic") try: self.snappy_testbed.run_command(cmd) except subprocess.CalledProcessError as e: self.addDetail("ssh output", content.text_content(str(e.output))) raise # Uninstall the snap from the testbed. snap_name = snap_file_name[:snap_file_name.index("_")] self.addCleanup(self.snappy_testbed.run_command, ["sudo", "snap", "remove", snap_name]) list_output = self.snappy_testbed.run_command(["snap", "list"]) expected = ".*{}.*".format(snap_name) self.assertThat(list_output, MatchesRegex(expected, flags=re.DOTALL))
def test_get_cluster_profile_by_id(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": base.IMAGE_NAME, "networks": [ { "network": "private" } ], "security_groups": [ "default" ] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) profile_get = self.user_cloud.get_cluster_profile_by_id(profile['id']) # Test that we get the same profile with the get_profile method # Format of the created_at variable differs between policy create # and policy get so if we don't ignore this variable, comparison will # always fail profile['created_at'] = 'ignore' profile_get['created_at'] = 'ignore' self.assertEqual(profile_get, profile)
def test__command_high_verbosity(self): verbosity, set_verbosity = self._get_log_levels(3) name = factory.make_name("log.name") logged = log_something( name, verbosity=verbosity, set_verbosity=set_verbosity, mode=LoggingMode.COMMAND, ) self.addDetail("logged", text_content(logged)) observed = find_log_lines(logged) expected = [ (name, "debug", "From `twisted.logger`."), (name, "info", "From `twisted.logger`."), (name, "warn", "From `twisted.logger`."), (name, "error", "From `twisted.logger`."), (name, "info", "From `twisted.python.log`."), ("logsomething", "info", "From `twisted.python.log.logfile`."), (name, "debug", "From `logging`."), (name, "info", "From `logging`."), (name, "warn", "From `logging`."), (name, "error", "From `logging`."), ("maas." + name, "debug", "From `get_maas_logger`."), ("maas." + name, "info", "From `get_maas_logger`."), ("maas." + name, "warn", "From `get_maas_logger`."), ("maas." + name, "error", "From `get_maas_logger`."), ] self.assertSequenceEqual(expected, observed) self.assertThat( logged, DocTestMatches("""\ ... Printing to stdout. Printing to stderr. This is a warning! """), )
def test_list_cluster_profiles(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": base.IMAGE_NAME, "networks": [ { "network": "private" } ], "security_groups": [ "default" ] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) # Test that we can list profiles wait = wait_for_create(self.user_cloud.get_cluster_profile_by_id, {'name_or_id': profile['id']}) get_profile = self.user_cloud.get_cluster_profile_by_id(profile['id']) profiles = self.user_cloud.list_cluster_profiles() self.assertEqual(profiles, [get_profile]) self.assertTrue(wait)
def install_snap(self, snap_local_path, snap_name, version, devmode=False, classic=False): if not config.get('skip-install', False): tmp_in_testbed = self.snappy_testbed.run_command( 'mktemp -d').strip() self.addCleanup(self.snappy_testbed.run_command, ['rm', '-rf', tmp_in_testbed]) self.snappy_testbed.copy_file(snap_local_path, tmp_in_testbed) snap_file_name = os.path.basename(snap_local_path) snap_path_in_testbed = os.path.join(tmp_in_testbed, snap_file_name) cmd = [ 'sudo', 'snap', 'install', '--force-dangerous', snap_path_in_testbed ] if devmode: cmd.append('--devmode') if classic: cmd.append('--classic') try: self.snappy_testbed.run_command(cmd) except subprocess.CalledProcessError as e: self.addDetail('ssh output', content.text_content(str(e.output))) raise # Uninstall the snap from the testbed. snap_name = snap_file_name[:snap_file_name.index('_')] self.addCleanup(self.snappy_testbed.run_command, ['sudo', 'snap', 'remove', snap_name]) list_output = self.snappy_testbed.run_command(['snap', 'list']) expected = '.*{}.*'.format(snap_name) self.assertThat(list_output, MatchesRegex(expected, flags=re.DOTALL))
def _run_core(self): # Add an observer to trap all logged errors. self.case.reactor = self._reactor error_observer = _log_observer full_log = StringIO() full_observer = log.FileLogObserver(full_log) spinner = self._make_spinner() successful, unhandled = run_with_log_observers( [error_observer.gotEvent, full_observer.emit], self._blocking_run_deferred, spinner) self.case.addDetail('twisted-log', Content(UTF8_TEXT, full_log.readlines)) logged_errors = error_observer.flushErrors() for logged_error in logged_errors: successful = False self._got_user_failure(logged_error, tb_label='logged-error') if unhandled: successful = False for debug_info in unhandled: f = debug_info.failResult info = debug_info._getDebugTracebacks() if info: self.case.addDetail('unhandled-error-in-deferred-debug', text_content(info)) self._got_user_failure(f, 'unhandled-error-in-deferred') junk = spinner.clear_junk() if junk: successful = False self._log_user_exception(UncleanReactorError(junk)) if successful: self.result.addSuccess(self.case, details=self.case.getDetails())
def run_snapcraft( self, command, project_dir=None, debug=True, pre_func=lambda: None): if project_dir: self.copy_project_to_cwd(project_dir) if isinstance(command, str): command = [command] snapcraft_command = [self.snapcraft_command] if debug: snapcraft_command.append('-d') try: pre_func() snapcraft_output = subprocess.check_output( snapcraft_command + command, stderr=subprocess.STDOUT, universal_newlines=True) except subprocess.CalledProcessError as e: self.addDetail('output', content.text_content(e.output)) raise if not os.getenv('SNAPCRAFT_IGNORE_APT_AUTOREMOVE', False): self.addCleanup(self.run_apt_autoremove) return snapcraft_output
def test_volumes(self): '''Test volume and snapshot functionality''' volume_name = self.getUniqueString() snapshot_name = self.getUniqueString() self.addDetail('volume', content.text_content(volume_name)) self.addCleanup(self.cleanup, volume_name, snapshot_name) volume = self.demo_cloud.create_volume(display_name=volume_name, size=1) snapshot = self.demo_cloud.create_volume_snapshot( volume['id'], display_name=snapshot_name) volume_ids = [v['id'] for v in self.demo_cloud.list_volumes()] self.assertIn(volume['id'], volume_ids) snapshot_list = self.demo_cloud.list_volume_snapshots() snapshot_ids = [s['id'] for s in snapshot_list] self.assertIn(snapshot['id'], snapshot_ids) ret_snapshot = self.demo_cloud.get_volume_snapshot_by_id( snapshot['id']) self.assertEqual(snapshot['id'], ret_snapshot['id']) self.demo_cloud.delete_volume_snapshot(snapshot_name, wait=True) self.demo_cloud.delete_volume(volume_name, wait=True)
def test_flake8(self): with tempfile.NamedTemporaryFile(mode='w', delete=False) as f: f.write(''.join(self.lines)) cmd = [ sys.executable, '-mflake8', '--isolated', '--select=%s' % self.code, '--ignore=F', '--format=%(code)s\t%(path)s\t%(row)d', f.name ] out, _ = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate() out = out.decode('utf-8') if self.code == 'Okay': self.assertEqual('', out) else: self.addDetail( 'reason', content.text_content("Failed to trigger rule %s" % self.code)) self.assertNotEqual('', out) self.assertEqual(self.code, out.split('\t')[0].rstrip(':'), out) os.remove(f.name)
def test_create_object(self): '''Test uploading small and large files.''' container_name = self.getUniqueString('container') self.addDetail('container', content.text_content(container_name)) self.addCleanup(self.demo_cloud.delete_container, container_name) self.demo_cloud.create_container(container_name) self.assertEqual(container_name, self.demo_cloud.list_containers()[0]['name']) sizes = ( (64 * 1024, 1), # 64K, one segment (64 * 1024, 5) # 64MB, 5 segments ) for size, nseg in sizes: segment_size = int(round(size / nseg)) with tempfile.NamedTemporaryFile() as fake_file: fake_content = ''.join(random.SystemRandom().choice( string.ascii_uppercase + string.digits) for _ in range(size)).encode('latin-1') fake_file.write(fake_content) fake_file.flush() name = 'test-%d' % size self.addCleanup( self.demo_cloud.delete_object, container_name, name) self.demo_cloud.create_object( container_name, name, fake_file.name, segment_size=segment_size, metadata={'foo': 'bar'}) self.assertFalse(self.demo_cloud.is_object_stale( container_name, name, fake_file.name ) ) self.assertEqual( 'bar', self.demo_cloud.get_object_metadata( container_name, name)['x-object-meta-foo'] ) self.demo_cloud.update_object(container=container_name, name=name, metadata={'testk': 'testv'}) self.assertEqual( 'testv', self.demo_cloud.get_object_metadata( container_name, name)['x-object-meta-testk'] ) try: self.assertIsNotNone( self.demo_cloud.get_object(container_name, name)) except exc.OpenStackCloudException as e: self.addDetail( 'failed_response', content.text_content(str(e.response.headers))) self.addDetail( 'failed_response', content.text_content(e.response.text)) self.assertEqual( name, self.demo_cloud.list_objects(container_name)[0]['name']) self.assertTrue( self.demo_cloud.delete_object(container_name, name)) self.assertEqual([], self.demo_cloud.list_objects(container_name)) self.assertEqual(container_name, self.demo_cloud.list_containers()[0]['name']) self.demo_cloud.delete_container(container_name)
def get_details(self): return { 'expected': content.text_content(self.expected), 'actual': content.text_content(self.actual), }
def addDetail(self, logfile, text): if type(text) is str: super(BaseTestCase, self).addDetail(logfile, content.text_content(text)) else: super(BaseTestCase, self).addDetail(logfile, text)
def _add_detail(self, detail_str): frame = inspect.stack()[1] self.addDetail('%s:%s ' %(frame[1],frame[2]), content.text_content(detail_str))
def test_update_policy_on_cluster(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": base.IMAGE_NAME, "networks": [{ "network": "private" }], "security_groups": ["default"] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) cluster_name = 'example_cluster' desired_capacity = 0 self.addDetail('cluster', content.text_content(cluster_name)) # Test that we can create a cluster and we get it returned cluster = self.user_cloud.create_cluster( name=cluster_name, profile=profile, desired_capacity=desired_capacity) self.addCleanup(self.cleanup_cluster, cluster['cluster']['id']) policy_name = 'example_policy' spec = { "properties": { "adjustment": { "min_step": 1, "number": 1, "type": "CHANGE_IN_CAPACITY" }, "event": "CLUSTER_SCALE_IN" }, "type": "senlin.policy.scaling", "version": "1.0" } self.addDetail('policy', content.text_content(policy_name)) # Test that we can create a policy and we get it returned policy = self.user_cloud.create_cluster_policy(name=policy_name, spec=spec) self.addCleanup(self.cleanup_policy, policy['id'], cluster['cluster']['id']) # Test that we can attach policy to cluster and get True returned attach_cluster = self.user_cloud.get_cluster_by_id( cluster['cluster']['id']) attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id']) self.user_cloud.attach_policy_to_cluster(attach_cluster, attach_policy, is_enabled=True) wait_attach = wait_for_status(self.user_cloud.get_cluster_by_id, {'name_or_id': cluster['cluster']['id']}, 'policies', ["{policy}".format(policy=policy['id'])]) get_old_policy = self.user_cloud.get_policy_on_cluster( cluster['cluster']["id"], policy['id']) # Test that we can update the policy on cluster policy_update = self.user_cloud.update_policy_on_cluster( attach_cluster, attach_policy, is_enabled=False) get_old_policy.update({'enabled': False}) wait_update = wait_for_status( self.user_cloud.get_policy_on_cluster, { 'name_or_id': cluster['cluster']['id'], 'policy_name_or_id': policy['id'] }, 'enabled', False) get_new_policy = self.user_cloud.get_policy_on_cluster( cluster['cluster']["id"], policy['id']) get_old_policy['last_op'] = None get_new_policy['last_op'] = None self.assertTrue(policy_update) self.assertEqual(get_new_policy, get_old_policy) self.assertTrue(wait_attach) self.assertTrue(wait_update)
def test_delete_cluster(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": base.IMAGE_NAME, "networks": [{ "network": "private" }], "security_groups": ["default"] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) cluster_name = 'example_cluster' desired_capacity = 0 self.addDetail('cluster', content.text_content(cluster_name)) # Test that we can create a cluster and we get it returned cluster = self.user_cloud.create_cluster( name=cluster_name, profile=profile, desired_capacity=desired_capacity) self.addCleanup(self.cleanup_cluster, cluster['cluster']['id']) policy_name = 'example_policy' spec = { "properties": { "adjustment": { "min_step": 1, "number": 1, "type": "CHANGE_IN_CAPACITY" }, "event": "CLUSTER_SCALE_IN" }, "type": "senlin.policy.scaling", "version": "1.0" } self.addDetail('policy', content.text_content(policy_name)) # Test that we can create a policy and we get it returned policy = self.user_cloud.create_cluster_policy(name=policy_name, spec=spec) self.addCleanup(self.cleanup_policy, policy['id']) # Test that we can attach policy to cluster and get True returned attach_cluster = self.user_cloud.get_cluster_by_id( cluster['cluster']['id']) attach_policy = self.user_cloud.get_cluster_policy_by_id(policy['id']) self.user_cloud.attach_policy_to_cluster(attach_cluster, attach_policy, is_enabled=True) receiver_name = "example_receiver" receiver_type = "webhook" self.addDetail('receiver', content.text_content(receiver_name)) # Test that we can create a receiver and we get it returned self.user_cloud.create_cluster_receiver( name=receiver_name, receiver_type=receiver_type, cluster_name_or_id=cluster['cluster']['id'], action='CLUSTER_SCALE_OUT') # Test that we can delete cluster and get True returned cluster_delete = self.user_cloud.delete_cluster( cluster['cluster']['id']) self.assertTrue(cluster_delete)
def _setUp(self): fixtures.Fixture._setUp(self) self.addDetail('broken', content.text_content("foobar")) raise Exception("_setUp broke")
def test_add_xfail_details(self): self.result.startTest(self) details = {"foo": text_content("bar")} self.result.addExpectedFailure(self, details=details) self.result.stopTest(self) self.assertCalled(status='xfail', details=details)
def _add_output_detail(self, output): self.addDetail('output', content.text_content(str(output)))
def _add_reason(self, reason): self.addDetail('reason', content.text_content(reason))
def setUp(self): fixtures.Fixture.setUp(self) self.addDetail('aaa', content.text_content("foo")) self.addDetail('bbb', content.text_content("bar"))
def test_foo(self): self.addDetail('foo_content', content.text_content("foo ok")) self.useFixture(fixture)
# case. Use AsynchronousDeferredRunTestForBrokenTwisted, which loops the # reactor a couple of times after the test is done. async_factory = AsynchronousDeferredRunTestForBrokenTwisted.make_factory( timeout=timeout.total_seconds(), suppress_twisted_logging=False, store_twisted_logs=False, ) return retry_flaky(async_factory) # By default, asynchronous tests are timed out after 2 minutes. DEFAULT_ASYNC_TIMEOUT = timedelta(minutes=2) def _test_skipped(case, result, exception): result.addSkip(case, details={'reason': text_content(unicode(exception))}) class AsyncTestCase(testtools.TestCase, _MktempMixin): """ Base class for asynchronous test cases. :ivar reactor: The Twisted reactor that the test is being run in. Set by ``async_runner`` and only available for the duration of the test. """ run_tests_with = async_runner(timeout=DEFAULT_ASYNC_TIMEOUT) # See comment on TestCase.skipException. skipException = SkipTest def __init__(self, *args, **kwargs):
def test_update_cluster_receiver(self): profile_name = "test_profile" spec = { "properties": { "flavor": "m1.tiny", "image": base.IMAGE_NAME, "networks": [{ "network": "private" }], "security_groups": ["default"] }, "type": "os.nova.server", "version": 1.0 } self.addDetail('profile', content.text_content(profile_name)) # Test that we can create a profile and we get it returned profile = self.user_cloud.create_cluster_profile(name=profile_name, spec=spec) self.addCleanup(self.cleanup_profile, profile['id']) cluster_name = 'example_cluster' desired_capacity = 0 self.addDetail('cluster', content.text_content(cluster_name)) # Test that we can create a cluster and we get it returned cluster = self.user_cloud.create_cluster( name=cluster_name, profile=profile, desired_capacity=desired_capacity) self.addCleanup(self.cleanup_cluster, cluster['cluster']['id']) receiver_name = "example_receiver" receiver_type = "webhook" self.addDetail('receiver', content.text_content(receiver_name)) # Test that we can create a receiver and we get it returned receiver = self.user_cloud.create_cluster_receiver( name=receiver_name, receiver_type=receiver_type, cluster_name_or_id=cluster['cluster']['id'], action='CLUSTER_SCALE_OUT') self.addCleanup(self.cleanup_receiver, receiver['id']) # Test that we can update a field on the receiver and only that field # is updated receiver_update = self.user_cloud.update_cluster_receiver( receiver['id'], new_name='new_receiver_name') self.assertEqual(receiver_update['receiver']['id'], receiver['id']) self.assertEqual(receiver_update['receiver']['type'], receiver['type']) self.assertEqual(receiver_update['receiver']['cluster_id'], receiver['cluster_id']) self.assertEqual(receiver_update['receiver']['name'], 'new_receiver_name')
def test_yaml_snippet(self, mock): if not self.in_filename: return jjb_config = self._get_config() expected_xml = self._read_utf8_content() yaml_content = self._read_yaml_content(self.in_filename) plugins_info = None if self.plugins_info_filename: plugins_info = self._read_yaml_content(self.plugins_info_filename) self.addDetail("plugins-info-filename", text_content(self.plugins_info_filename)) self.addDetail("plugins-info", text_content(str(plugins_info))) parser = YamlParser(jjb_config) e = pkg_resources.EntryPoint.parse d = pkg_resources.Distribution() config = configparser.ConfigParser() config.read(os.path.dirname(__file__) + "/../setup.cfg") groups = {} for key in config["entry_points"]: groups[key] = list() for line in config["entry_points"][key].split("\n"): if "" == line.strip(): continue groups[key].append(e(line, dist=d)) def mock_iter_entry_points(group, name=None): return (entry for entry in groups[group] if name is None or name == entry.name) mock.side_effect = mock_iter_entry_points registry = ModuleRegistry(jjb_config, plugins_info) registry.set_parser_data(parser.data) pub = self.klass(registry) project = None if "project-type" in yaml_content: if yaml_content["project-type"] == "maven": project = project_maven.Maven(registry) elif yaml_content["project-type"] == "matrix": project = project_matrix.Matrix(registry) elif yaml_content["project-type"] == "flow": project = project_flow.Flow(registry) elif yaml_content["project-type"] == "githuborg": project = project_githuborg.GithubOrganization(registry) elif yaml_content["project-type"] == "multijob": project = project_multijob.MultiJob(registry) elif yaml_content["project-type"] == "multibranch": project = project_multibranch.WorkflowMultiBranch(registry) elif yaml_content["project-type"] == "multibranch-defaults": project = project_multibranch.WorkflowMultiBranchDefaults( registry) # noqa elif yaml_content["project-type"] == "externaljob": project = project_externaljob.ExternalJob(registry) if "view-type" in yaml_content: if yaml_content["view-type"] == "all": project = view_all.All(registry) elif yaml_content["view-type"] == "delivery_pipeline": project = view_delivery_pipeline.DeliveryPipeline(registry) elif yaml_content["view-type"] == "list": project = view_list.List(registry) elif yaml_content["view-type"] == "nested": project = view_nested.Nested(registry) elif yaml_content["view-type"] == "pipeline": project = view_pipeline.Pipeline(registry) elif yaml_content["view-type"] == "sectioned": project = view_sectioned.Sectioned(registry) else: raise InvalidAttributeError("view-type", yaml_content["view-type"]) if project: xml_project = project.root_xml(yaml_content) else: xml_project = XML.Element("project") # Generate the XML tree directly with modules/general pub.gen_xml(xml_project, yaml_content) # check output file is under correct path if "name" in yaml_content: prefix = os.path.dirname(self.in_filename) # split using '/' since fullname uses URL path separator expected_folders = [ os.path.normpath( os.path.join( prefix, "/".join( parser._getfullname(yaml_content).split("/")[:-1]), )) ] actual_folders = [os.path.dirname(f) for f in self.out_filenames] self.assertEquals( expected_folders, actual_folders, "Output file under wrong path, was '%s', should be '%s'" % ( self.out_filenames[0], os.path.join(expected_folders[0], os.path.basename(self.out_filenames[0])), ), ) # Prettify generated XML pretty_xml = XmlJob(xml_project, "fixturejob").output().decode("utf-8") self.assertThat( pretty_xml, testtools.matchers.DocTestMatches( expected_xml, doctest.ELLIPSIS | doctest.REPORT_NDIFF), )
def setUp(self): fixtures.Fixture.setUp(self) self.addDetail('content', content.text_content("foobar")) raise Exception()
def test_add_error_details(self): self.result.startTest(self) details = {"foo": text_content("bar")} self.result.addError(self, details=details) self.result.stopTest(self) self.assertCalled(status='error', details=details)
def run(self, result): result.startTest(self) result.addError(self, None, details={'traceback': content.text_content("tb")}) result.stopTest(self)
# Optimization to stop running early if there's no way that we can # reach the minimum number of successes. max_fails = flaky.max_runs - flaky.min_passes while (successes < flaky.min_passes and len(results) - successes <= max_fails): was_successful, result_type, details = self._attempt_test(case) if was_successful: successes += 1 results.append((result_type, details)) successful = successes >= flaky.min_passes flaky_data = flaky.to_dict() flaky_data.update({'runs': len(results), 'passes': successes}) flaky_details = { 'flaky': text_content(pformat(flaky_data)), } combined_details = _combine_details([flaky_details] + list(r[1] for r in results)) if successful: skip_reported = False for result_type, details in results: if result_type == _ResultType.skip: result.addSkip(case, details=details) skip_reported = True if not skip_reported: Message.new( message_type=u"flocker:test:flaky", id=case.id(),
def test_cluster_templates(self): '''Test cluster_templates functionality''' name = 'fake-cluster_template' server_type = 'vm' public = False image_id = 'fedora-atomic-f23-dib' tls_disabled = False registry_enabled = False coe = 'kubernetes' keypair_id = 'testkey' self.addDetail('cluster_template', content.text_content(name)) self.addCleanup(self.cleanup, name) # generate a keypair to add to nova ssh_directory = '/tmp/.ssh' if not os.path.isdir(ssh_directory): os.mkdir(ssh_directory) subprocess.call([ 'ssh-keygen', '-t', 'rsa', '-N', '', '-f', '%s/id_rsa_shade' % ssh_directory ]) # add keypair to nova with open('%s/id_rsa_shade.pub' % ssh_directory) as f: key_content = f.read() self.demo_cloud.create_keypair('testkey', key_content) # Test we can create a cluster_template and we get it returned self.ct = self.demo_cloud.create_cluster_template( name=name, image_id=image_id, keypair_id=keypair_id, coe=coe) self.assertEqual(self.ct['name'], name) self.assertEqual(self.ct['image_id'], image_id) self.assertEqual(self.ct['keypair_id'], keypair_id) self.assertEqual(self.ct['coe'], coe) self.assertEqual(self.ct['registry_enabled'], registry_enabled) self.assertEqual(self.ct['tls_disabled'], tls_disabled) self.assertEqual(self.ct['public'], public) self.assertEqual(self.ct['server_type'], server_type) # Test that we can list cluster_templates cluster_templates = self.demo_cloud.list_cluster_templates() self.assertIsNotNone(cluster_templates) # Test we get the same cluster_template with the # get_cluster_template method cluster_template_get = self.demo_cloud.get_cluster_template( self.ct['uuid']) self.assertEqual(cluster_template_get['uuid'], self.ct['uuid']) # Test the get method also works by name cluster_template_get = self.demo_cloud.get_cluster_template(name) self.assertEqual(cluster_template_get['name'], self.ct['name']) # Test we can update a field on the cluster_template and only that # field is updated cluster_template_update = self.demo_cloud.update_cluster_template( self.ct['uuid'], 'replace', tls_disabled=True) self.assertEqual(cluster_template_update['uuid'], self.ct['uuid']) self.assertEqual(cluster_template_update['tls_disabled'], True) # Test we can delete and get True returned cluster_template_delete = self.demo_cloud.delete_cluster_template( self.ct['uuid']) self.assertTrue(cluster_template_delete)