def postprocess(self): super(tag_base, self).postprocess() if self.config["docker_expected_result"] == "PASS": # Raise exception if problems found OutputGood(self.sub_stuff['cmdresult']) self.failif( self.sub_stuff['cmdresult'].exit_status != 0, "Non-zero tag exit status: %s" % self.sub_stuff['cmdresult']) img = self.get_images_by_name(self.sub_stuff["new_image_name"]) # Needed for cleanup self.sub_stuff['image_list'] += img self.failif(len(img) < 1, "Failed to look up tagted image ") elif self.config["docker_expected_result"] == "FAIL": chck = OutputGood(self.sub_stuff['cmdresult'], ignore_error=True) exit_code = self.sub_stuff['cmdresult'].exit_status self.failif( not chck or not exit_code, "Zero tag exit status: Command should fail due to" " wrong command arguments.") else: self.failif( True, "Improper 'docker_expected_result' value %s" % self.config["docker_expected_result"])
def postprocess(self): super(help_base, self).postprocess() # Prints out basic info for cmdresult in self.sub_stuff["success_cmdresults"]: no_usage = cmdresult.stdout.lower().find('usage:') == -1 self.failif( no_usage, "Did not return usage help on stdout for: " "%s" % cmdresult.command) outputgood = OutputGood( cmdresult, ignore_error=True, skip=['usage_check', 'error_check', 'nonprintables_check']) self.failif(not outputgood, str(outputgood)) for cmdresult in self.sub_stuff['failure_cmdresults']: defined = cmdresult.stdout.lower().find('flag provided but ' 'not defined') > -1 usage = cmdresult.stdout.lower().find('usage:') > -1 self.failif( defined or usage, 'Did not return undefined ' 'error or usage message for: ' "%s" % cmdresult.command) outputgood = OutputGood( cmdresult, ignore_error=True, skip=['usage_check', 'nonprintables_check']) self.failif(not outputgood, str(outputgood))
def postprocess(self): super(stop_base, self).postprocess() self.check_output() stop_results = self.sub_stuff['stop_results'] if self.config.get("stop_duration"): stop_duration = float(self.config.get("stop_duration")) self.failif( stop_results.duration > (stop_duration + 2), "'docker stop' cmd execution took longer, than " "expected: %ss (%s+-2s)" % (stop_results.duration, stop_duration)) self.failif( stop_results.duration < (stop_duration - 2), "'docker stop' cmd execution took shorter, than " "expected: %ss (%s+-2s)" % (stop_results.duration, stop_duration)) # Look for docker failures OutputGood(stop_results) OutputGood(self.sub_stuff['container_results'], skip=['nonprintables_check']) self.failif_ne( stop_results.exit_status, 0, "Exit status of the " "docker stop command was not 0: %s" % stop_results) exp = self.config.get('docker_exit_code', 0) self.failif_ne( self.sub_stuff['container_results'].exit_status, exp, "Exit status of the docker run command was not %s: %s" % (exp, self.sub_stuff['container_results']))
def verify_output(self): cmdresult = self.sub_stuff['cmdresult'] rm_cmdresult = self.sub_stuff['rm_cmdresult'] self.failif_ne(cmdresult.exit_status, 0, "Exit status: %s" % cmdresult) self.failif_ne(rm_cmdresult.exit_status, 0, "Expected zero exit: %s" % rm_cmdresult) OutputGood(cmdresult, skip=['nonprintables_check']) OutputGood(rm_cmdresult)
def verify_output(self): cmdresult = self.sub_stuff['cmdresult'] rm_cmdresult = self.sub_stuff['rm_cmdresult'] self.failif(cmdresult.exit_status == 0, ("Expected non-zero exit: %s" % cmdresult)) self.failif_ne(rm_cmdresult.exit_status, 0, ("Expected zero exit: %s" % rm_cmdresult)) OutputGood(cmdresult) OutputGood(rm_cmdresult)
def postprocess(self): OutputGood(self.sub_stuff['run_dkrcmd'].cmdresult) OutputGood(self.sub_stuff['top_dkrcmd'].cmdresult) pstable = TextTable(self.sub_stuff['top_dkrcmd'].stdout) self.failif(len(pstable) != 1) psrow = pstable[0] self.failif(psrow['USER'] != 'root') self.failif(int(psrow['PID']) == 1) self.failif(psrow['COMMAND'] != self.COMMAND)
def postprocess(self): OutputGood(self.sub_stuff['run_dkrcmd'].cmdresult) OutputGood(self.sub_stuff['top_dkrcmd'].cmdresult) pstable = TextTable(self.sub_stuff['top_dkrcmd'].stdout) self.failif_ne(len(pstable), 1, "Number of rows returned by top") psrow = pstable[0] self.failif_ne(psrow['USER'], 'root', 'Expected user') self.failif(int(psrow['PID']) == 1, 'Process PID is 1') self.failif_ne(psrow['COMMAND'], self.COMMAND, 'Expected command')
def postprocess(self): super(run_twice, self).postprocess() for cmdresult in self.stuff['cmdresults']: self.loginfo("command: '%s'" % cmdresult.command) outputgood = OutputGood(cmdresult) self.failif(not outputgood, str(outputgood)) for cmdresult in self.stuff['2nd_cmdresults']: self.loginfo("command: '%s'" % cmdresult.command) outputgood = OutputGood(cmdresult, ignore_error=True, skip=['error_check']) self.failif(cmdresult.exit_status == 0, str(outputgood)) if cmdresult.exit_status != 0: self.logerror("Intend to fail:\n%s" % cmdresult.stderr.strip())
def postprocess(self): super(psa, self).postprocess() OutputGood(self.stuff['cmdresult'], skip=['nonprintables_check']) dc = self.stuff['dc'] cnts = dc.list_containers_with_name(self.stuff['container_name']) self.failif(len(cnts) < 1, "Test container not found in list") cnt = cnts[0] estat1 = str(cnt.status).startswith("Exit 0") # pre docker 0.9.1 estat2 = str(cnt.status).startswith("Exited (0)") # docker 0.9.1+ msg = ("Exit status mismatch: %s does not" "start with %s or %s" % (str(cnt), "Exit 0", "Exited (0)")) self.failif(not (estat1 or estat2), msg) cid = self.stuff['container_id'] cl0_ids = [cnt.long_id for cnt in self.stuff['cl0']] cl1_ids = [cnt.long_id for cnt in self.stuff['cl1']] cl2_ids = [cnt.long_id for cnt in self.stuff['cl2']] try: self.failif( cid in cl0_ids, "Test container's ID found in ps " "output before this test started it!") self.failif( cid not in cl1_ids, "Test container's ID not found in " "ps output after starting it") self.failif( cid not in cl2_ids, "Test container's ID not found in " "ps output after it exited") except DockerTestFail: self.logdebug("Parsed docker ps table before starting: %s", self.stuff['cl0']) self.logdebug("Parsed docker ps table after starting: %s", self.stuff['cl1']) self.logdebug("Parsed docker ps table after exiting: %s", self.stuff['cl2']) raise
def basic_postprocess(self, build_def, command, parameter): del parameter # not used # June 2017: docker-1.13 ignores $TERM for build sub-command. # Jambs ANSI codes in output, BZ1403326 skip = ['nonprintables_check'] if self.config['enable_nonprintables_check']: skip = None if command == 'positive': # Verify zero exit status and healthy output opg = OutputGood(build_def.dockercmd.cmdresult, skip=skip, ignore_error=True) if opg: return build_def.dockercmd.cmdresult.exit_status == 0 self.logwarning('Positive output expected but check' ' failed: %s', str(opg)) return False elif command == 'negative': # Verify non-zero exit status and no panics notbad = OutputNotBad(build_def.dockercmd.cmdresult, skip=skip, ignore_error=True) if notbad: return build_def.dockercmd.cmdresult.exit_status != 0 self.logwarning( 'Negative output expected, but' ' this is worse: %s', str(notbad)) return False else: raise DockerTestError("Command error: %s" % command)
def basic_postprocess(build_def, command, parameter): del parameter # not used if command == 'positive': # Verify zero exit status + healthy output if OutputGood(build_def.dockercmd.cmdresult, ignore_error=True): return build_def.dockercmd.cmdresult.exit_status == 0 else: return False elif command == 'negative': # Verify non-zero exit status + healthy output if OutputGood(build_def.dockercmd.cmdresult, ignore_error=True, skip=['error_check']): return build_def.dockercmd.cmdresult.exit_status != 0 else: raise DockerTestError("Command error: %s" % command)
def basic_postprocess(self, build_def, command, parameter): del parameter # not used if command == 'positive': # Verify zero exit status and healthy output opg = OutputGood(build_def.dockercmd.cmdresult, ignore_error=True) if opg: return build_def.dockercmd.cmdresult.exit_status == 0 else: self.logwarning( 'Positive output expected but check' ' failed: %s', str(opg)) return False elif command == 'negative': # Verify non-zero exit status and no panics notbad = OutputNotBad(build_def.dockercmd.cmdresult, ignore_error=True) if notbad: return build_def.dockercmd.cmdresult.exit_status != 0 else: self.logwarning( 'Negative output expected, but' ' this is worse: %s', str(notbad)) return False else: raise DockerTestError("Command error: %s" % command)
def _common_post(self): # Raise exception if problems found OutputGood(self.sub_stuff['cmdresult'], skip=['error_check']) # error is expected self.failif(self.sub_stuff['cmdresult'].exit_status == 0, "Zero rmi exit status: Command should fail due to" " wrong image name.")
def postprocess(self): super(run_base, self).postprocess() # Prints out basic info dockercmd = self.sub_stuff['dkrcmd'] OutputGood(dockercmd.cmdresult) expected = self.config['exit_status'] self.failif_ne(dockercmd.exit_status, expected, "Exit status %s" % dockercmd.cmdresult)
def postprocess(self): super(history_base, self).postprocess() if self.config["docker_expected_result"] == "PASS": # Raise exception if problems found OutputGood(self.sub_stuff['cmdresult']) self.failif( self.sub_stuff['cmdresult'].exit_status != 0, "Non-zero history exit status: %s" % self.sub_stuff['cmdresult']) new_img_name = self.sub_stuff["new_image_name"] new_img_name2 = self.sub_stuff["new_image_name2"] base_img_name = DockerImage.full_name_from_defaults(self.config) self.failif( base_img_name in self.sub_stuff['cmdresult'].stdout, "Unable find image name %s in image history: %s" % (base_img_name, self.sub_stuff['cmdresult'].stdout)) self.failif( new_img_name in self.sub_stuff['cmdresult'].stdout, "Unable find image name %s in image history: %s" % (new_img_name, self.sub_stuff['cmdresult'].stdout)) self.failif( new_img_name2 in self.sub_stuff['cmdresult'].stdout, "Unable find image name %s in image history: %s" % (new_img_name2, self.sub_stuff['cmdresult'].stdout))
def postprocess(self): super(history_base, self).postprocess() # Raise exception if problems found expect = self.config["docker_expected_exit_status"] OutputGood(self.sub_stuff['cmdresult'], ignore_error=(expect != 0), skip=['nonprintables_check']) self.failif_ne(self.sub_stuff['cmdresult'].exit_status, expect, "Exit status") if expect == 0: new_img_name = self.sub_stuff["new_image_name"] new_img_name2 = self.sub_stuff["new_image_name2"] base_img_name = DockerImage.full_name_from_defaults(self.config) self.failif( base_img_name in self.sub_stuff['cmdresult'].stdout, "Unable find image name %s in image history: %s" % (base_img_name, self.sub_stuff['cmdresult'].stdout)) self.failif( new_img_name in self.sub_stuff['cmdresult'].stdout, "Unable find image name %s in image history: %s" % (new_img_name, self.sub_stuff['cmdresult'].stdout)) self.failif( new_img_name2 in self.sub_stuff['cmdresult'].stdout, "Unable find image name %s in image history: %s" % (new_img_name2, self.sub_stuff['cmdresult'].stdout))
def postprocess(self): # Raise exception on Go Panic or usage help message outputgood = OutputGood(self.stuff['cmdresult']) info_map = self._build_table(outputgood.stdout_strip) # Verify some individual items self.failif_ne(info_map['Storage Driver'].lower(), 'devicemapper', 'Storage Driver') self.failif_ne(info_map['Data file'].lower(), '', 'Data file') self.failif_ne(info_map['Metadata file'].lower(), '', 'Metadata file') di = DockerImages(self) # Make sure nothing is 'hidden' di.images_args = "%s --all" % di.images_args # Possible race-condition here... img_set = set(di.list_imgs_ids()) # don't count multi-tags # ...with this img_cnt = int(info_map['Images'].lower()) self.failif_ne( len(img_set), img_cnt, "More/less images %d than info reported %d" % (len(img_set), img_cnt)) # verify value of elements self.verify_pool_name(info_map['Pool Name']) data_name = 'Data loop file' metadata_name = 'Metadata loop file' if data_name in info_map: self.verify_sizes(info_map[data_name], info_map['Data Space Used'], info_map['Data Space Total'], info_map[metadata_name], info_map['Metadata Space Used'], info_map['Metadata Space Total']) else: data_name = 'Data file' metadata_name = 'Metadata file'
def postprocess(self): super(simple, self).postprocess() # Prints out basic info # Fail test if bad command or other stdout/stderr problems detected cmdresult = self.sub_stuff['cmdresult'] OutputGood(cmdresult) self.failif_ne(cmdresult.exit_status, 0, "Problem with export import cmd detail :%s" % cmdresult)
def postprocess(self): super(login_fail, self).postprocess() cmdresult = self.sub_stuff['cmdresult'] OutputGood(cmdresult, ignore_error=True) mustfail(cmdresult, 1) self.failif_not_in("401 Unauthorized", cmdresult.stderr, "stderr from failed docker login")
def postprocess(self): super(delete_wrong_name, self).postprocess() # Raise exception if problems found OutputGood(self.sub_stuff['cmdresult'], ignore_error=True) self.failif_ne(self.sub_stuff['cmdresult'].exit_status, self.config["docker_expected_exit_status"], "Docker exit status")
def postprocess(self): super(delete_wrong_name, self).postprocess() # Raise exception if problems found OutputGood(self.sub_stuff['cmdresult'], ignore_error=True) if self.config["docker_expected_result"] == "FAIL": self.failif(self.sub_stuff['cmdresult'].exit_status == 0, "Zero rmi exit status: Command should fail due to" " wrong image name.")
def postprocess(self): super(login_ok, self).postprocess() cmdresult = self.sub_stuff['cmdresult'] OutputGood(cmdresult) mustpass(cmdresult) self.failif_not_in("Login Succeeded", cmdresult.stdout, "stdout from docker login") self._check_credentials()
def postprocess(self): super(file_volume, self).postprocess() cmdresult = self.sub_stuff['cmdresults'][0] OutputGood(cmdresult) regex = re.compile(self.config['regex']) self.failif(not regex.search(cmdresult.stdout), "Fail match regex '%s' to: '%s'" % (regex.pattern, cmdresult.stdout))
def postprocess(self): super(sig_proxy_off_base, self).postprocess() OutputGood(self.sub_stuff['cmdresult']) c_name = self.sub_stuff["rand_name"] containers = self.sub_stuff['cont'].list_containers_with_name(c_name) self.check_containers(containers)
def postprocess(self): super(kill_base, self).postprocess() for kill_result in self.sub_stuff.get('kill_results', []): OutputGood(kill_result) self.failif( kill_result.exit_status != 0, "Exit status of the %s " "command was not 0 (%s)" % (kill_result.command, kill_result.exit_status))
def postprocess(self): super(version, self).postprocess() # Raise exception on Go Panic or usage help message outputgood = OutputGood(self.stuff['cmdresult']) docker_version = DockerVersion(outputgood.stdout_strip) self.loginfo("docker version client: %s server %s", docker_version.client, docker_version.server) self.verify_version(docker_version)
def postprocess(self): dkrcmd_exec = self.sub_stuff['dkrcmd_exec'] mustpass(dkrcmd_exec.cmdresult) OutputGood(dkrcmd_exec.cmdresult) pids = dkrcmd_exec.stdout.strip().splitlines() expected = self.config["pid_count"] self.failif_ne(len(pids), expected, "Number of pids: %s" % pids) super(exec_pid_count, self).postprocess()
def postprocess(self): super(run_cgroup_parent_base, self).postprocess() cmdresult = self.sub_stuff["cmdresult"] expected_status = self.sub_stuff["expected_status"] OutputGood(cmdresult, ignore_error=(expected_status != 0), skip=['nonprintables_check']) self.sub_stuff["cid"] = self._read_cid() path_exp = self.sub_stuff['expected_path'].format(**self.sub_stuff) stderr_exp = self.sub_stuff['expected_stderr'].format(**self.sub_stuff) # Check stderr first: that way if we're not expecting an error, but # get one, our user has a better chance of seeing something useful. # (Note: Running docker with -D (debug) produces lots of cruft: # time="...." level=debug msg="unwanted stuff" # Strip them out.) stderr = "\n".join([line for line in cmdresult.stderr.strip().split("\n") if not line.startswith('time="')]) if stderr_exp: re_stderr = re.compile(stderr_exp) if not re.match(re_stderr, stderr): raise DockerTestFail("expected '%s' not found in stderr ('%s')" % (stderr_exp, stderr)) else: self.failif_ne(stderr, stderr_exp, "unexpected stderr") # If we're expecting stdout, it must contain multiple lines each # of the form: # <num>:<cgroup controller>:<path> # ...where <path> must exactly match the one in our test setup. stdout = cmdresult.stdout.strip() if path_exp: re_cgroup = re.compile(r'^(\d+):([^:]*):(.*)') found_match = False for line in stdout.split("\n"): m = re.match(re_cgroup, line) if m is None: raise DockerTestFail("cgroup line does not conform to" " '<n>:<controller>:<path>': '%s'" % line) # bz1385924: 'pids' fails in docker-1.10; not worth fixing. if m.group(2) == 'pids': if DockerVersion().server.startswith("1.10"): continue self.failif_ne(m.group(3), path_exp, "cgroup path for %s:%s" % (m.group(1), m.group(2))) found_match = True # Must find at least one matching cgroup line if not found_match: raise DockerTestFail("No output from cgroups") else: self.failif_ne(stdout, '', "unexpected output on stdout") # Check exit code last: the stdout/stderr diagnostics are more helpful self.failif_ne(cmdresult.exit_status, expected_status, "exit status")
def postprocess(self): super(push_ok, self).postprocess() cmdresult = self.sub_stuff['pushresult'] OutputGood(cmdresult) mustpass(cmdresult) self.failif_not_in(": Pushed", cmdresult.stdout, "stdout from docker push") self.failif_not_in("tag_ok: digest:", cmdresult.stdout, "stdout from docker push")
def postprocess(self): super(create_signal, self).postprocess() sigdkrcmd = self.sub_stuff['sigdkrcmd'] OutputGood(sigdkrcmd) self.failif(sigdkrcmd.exit_status != 0, "Signaling created container returnd non-zero") # On success, docker kill should echo back CID of container expected_cid = self.get_cid() returned_cid = self.get_cid(sigdkrcmd) self.failif(expected_cid != returned_cid, "Container CID does not match kill --signal output")