def assert_run_command(self, command, **kw_args):
"""
Passes if command is successfully ran and returns subprocess.Popen.
process = self.assert_run_command(["echo", "123"]) # => pass
self.assert_equal("123\\n", process.stdout.read()) # => pass
self.assert_run_command("false") # => fail
self.assert_run_command("unknown-command") # => fail
"""
import subprocess
popen_kw_args = {
"stdin": subprocess.PIPE,
"stdout": subprocess.PIPE,
"stderr": subprocess.PIPE,
}
popen_kw_args.update(kw_args)
try:
process = subprocess.Popen(command, **popen_kw_args)
except OSError:
exception_class, exception_value = sys.exc_info()[:2]
message = "expected: <%s> is successfully ran\n" \
" but was: <%s>(%s) is raised and failed to ran" % \
(pp.format(command),
pp.format_exception_class(exception_class),
str(exception_value))
self._fail(message)
return_code = process.wait()
if return_code != 0:
message = "expected: <%s> is successfully finished\n" \
" but was: <%d> is returned as exit code" % \
(pp.format(command), return_code)
self._fail(message)
self._pass_assertion()
return process
def assert_run_command(self, command, **kw_args):
"""
Passes if command is successfully ran and returns subprocess.Popen.
process = self.assert_run_command(["echo", "123"]) # => pass
self.assert_equal("123\\n", process.stdout.read()) # => pass
self.assert_run_command("false") # => fail
self.assert_run_command("unknown-command") # => fail
"""
import subprocess
popen_kw_args = {
"stdin": subprocess.PIPE,
"stdout": subprocess.PIPE,
"stderr": subprocess.PIPE,
}
popen_kw_args.update(kw_args)
try:
process = subprocess.Popen(command, **popen_kw_args)
except OSError:
exception_class, exception_value = sys.exc_info()[:2]
message = "expected: <%s> is successfully ran\n" \
" but was: <%s>(%s) is raised and failed to ran" % \
(pp.format(command),
pp.format_exception_class(exception_class),
str(exception_value))
self._fail(message)
return_code = process.wait()
if return_code != 0:
message = "expected: <%s> is successfully finished\n" \
" but was: <%d> is returned as exit code" % \
(pp.format(command), return_code)
self._fail(message)
self._pass_assertion()
return process
def assert_equal(self, expected, actual, message=None):
"""
Passes if expected == actual.
self.assert_equal(5, 2 + 3) # => pass
"""
if expected == actual:
self._pass_assertion()
else:
formatted_expected = pp.format(expected)
formatted_actual = pp.format(actual)
self._fail("", message, formatted_expected, formatted_actual)
def assert_equal(self, expected, actual, message=None):
"""
Passes if expected == actual.
self.assert_equal(5, 2 + 3) # => pass
"""
if expected == actual:
self._pass_assertion()
else:
formatted_expected = pp.format(expected)
formatted_actual = pp.format(actual)
self._fail("", message, formatted_expected, formatted_actual)
def assert_hasattr(self, object, name, message=None):
"""
Passes if hasattr(object, name) returns True.
self.assert_hasattr("string", "strip") # => pass
self.assert_hasattr("string", "unknown") # => fail
"""
if hasattr(object, name):
self._pass_assertion()
else:
object = pp.format(object)
name = pp.format(name)
system_message = "expected: hasattr(%s, %s)" % (object, name)
self._fail(system_message, message)
def assert_hasattr(self, object, name, message=None):
"""
Passes if hasattr(object, name) returns True.
self.assert_hasattr("string", "strip") # => pass
self.assert_hasattr("string", "unknown") # => fail
"""
if hasattr(object, name):
self._pass_assertion()
else:
object = pp.format(object)
name = pp.format(name)
system_message = "expected: hasattr(%s, %s)" % (object, name)
self._fail(system_message, message)
def assert_not_equal(self, not_expected, actual, message=None):
"""
Passes if not_expected != actual.
self.assert_not_equal(-5, 2 + 3) # => pass
"""
if not_expected != actual:
self._pass_assertion()
else:
formatted_not_expected = pp.format(not_expected)
formatted_actual = pp.format(actual)
system_message = "not expected: <%s>\n but was: <%s>" % \
(formatted_not_expected, formatted_actual)
if formatted_not_expected != formatted_actual:
system_message = pp.append_diff(system_message,
not_expected, actual)
self._fail(system_message, message)
def assert_not_equal(self, not_expected, actual, message=None):
"""
Passes if not_expected != actual.
self.assert_not_equal(-5, 2 + 3) # => pass
"""
if not_expected != actual:
self._pass_assertion()
else:
formatted_not_expected = pp.format(not_expected)
formatted_actual = pp.format(actual)
system_message = "not expected: <%s>\n but was: <%s>" % \
(formatted_not_expected, formatted_actual)
if formatted_not_expected != formatted_actual:
system_message = pp.append_diff(system_message, not_expected,
actual)
self._fail(system_message, message)
def assert_in_delta(self, expected, actual, delta, message=None):
"""
Passes if (expected - delta) <= actual <= (expected + delta).
self.assert_in_delta(3, 3.01, 0.001) # => pass
"""
lower = expected - delta
upper = expected + delta
if lower <= actual <= upper:
self._pass_assertion()
else:
expected = pp.format(expected)
actual = pp.format(actual)
delta = pp.format(delta)
range = pp.format([lower, upper])
system_message = "expected: <%s+-%s %s>\n but was: <%s>" % \
(expected, delta, range, actual)
self._fail(system_message, message)
def assert_in_delta(self, expected, actual, delta, message=None):
"""
Passes if (expected - delta) <= actual <= (expected + delta).
self.assert_in_delta(3, 3.01, 0.001) # => pass
"""
lower = expected - delta
upper = expected + delta
if lower <= actual <= upper:
self._pass_assertion()
else:
expected = pp.format(expected)
actual = pp.format(actual)
delta = pp.format(delta)
range = pp.format([lower, upper])
system_message = "expected: <%s+-%s %s>\n but was: <%s>" % \
(expected, delta, range, actual)
self._fail(system_message, message)
def search(pattern):
if isinstance(pattern, str):
pattern = re.compile(pattern)
content = b''
timeout = 1.5
while len(select.select([messages.stdout], [], [], timeout)[0]) > 0:
timeout = 0.1
added_content = messages.stdout.read()
if not added_content:
break
content += added_content
if re.search(pattern, str(content)):
return
message = \
"expected: <%s> is found in <%s>\n" \
" content: <%s>" % \
(pp.format_re(pattern),
pp.format(log_file),
pp.format(content))
self.fail(message)
def search(pattern):
if isinstance(pattern, str):
pattern = re.compile(pattern)
content = b''
timeout = 1.5
while len(select.select([messages.stdout], [], [],
timeout)[0]) > 0:
timeout = 0.1
added_content = messages.stdout.read()
if not added_content:
break
content += added_content
if re.search(pattern, str(content)):
return
message = \
"expected: <%s> is found in <%s>\n" \
" content: <%s>" % \
(pp.format_re(pattern),
pp.format(log_file),
pp.format(content))
self.fail(message)
def assert_callable(self, object, message=None):
"""
Passes if callable(object) returns True.
self.assert_callable(lambda: 1) # => pass
self.assert_callable("string") # => fail
"""
if callable(object):
self._pass_assertion()
else:
object = pp.format(object)
system_message = "expected: callable(%s)" % (object)
self._fail(system_message, message)
def assert_callable(self, object, message=None):
"""
Passes if callable(object) returns True.
self.assert_callable(lambda: 1) # => pass
self.assert_callable("string") # => fail
"""
if callable(object):
self._pass_assertion()
else:
object = pp.format(object)
system_message = "expected: callable(%s)" % (object)
self._fail(system_message, message)
def assert_match(self, pattern, target, message=None):
"""
Passes if re.match(pattern, target) doesn't return None.
self.assert_match("abc", "abcde") # => pass
self.assert_match("abc", "deabc") # => fail
"""
if re.match(pattern, target):
self._pass_assertion()
else:
pattern_repr = pp.format_re_repr(pattern)
pattern = pp.format_re(pattern)
target = pp.format(target)
format = \
"expected: re.match(%s, %s) doesn't return None\n" \
" pattern: <%s>\n" \
" target: <%s>"
system_message = format % (pattern_repr, target, pattern, target)
self._fail(system_message, message)
def assert_not_found(self, pattern, target, message=None):
"""
Passes if re.search(pattern, target) returns None.
self.assert_search("abc", "deABC") # => pass
self.assert_search("abc", "deabc") # => fail
"""
if re.search(pattern, target) is None:
self._pass_assertion()
else:
pattern_repr = pp.format_re_repr(pattern)
pattern = pp.format_re(pattern)
target = pp.format(target)
format = \
"expected: re.search(%s, %s) returns None\n" \
" pattern: <%s>\n" \
" target: <%s>"
system_message = format % (pattern_repr, target, pattern, target)
self._fail(system_message, message)
def assert_not_found(self, pattern, target, message=None):
"""
Passes if re.search(pattern, target) returns None.
self.assert_search("abc", "deABC") # => pass
self.assert_search("abc", "deabc") # => fail
"""
if re.search(pattern, target) is None:
self._pass_assertion()
else:
pattern_repr = pp.format_re_repr(pattern)
pattern = pp.format_re(pattern)
target = pp.format(target)
format = \
"expected: re.search(%s, %s) returns None\n" \
" pattern: <%s>\n" \
" target: <%s>"
system_message = format % (pattern_repr, target, pattern, target)
self._fail(system_message, message)
def assert_match(self, pattern, target, message=None):
"""
Passes if re.match(pattern, target) doesn't return None.
self.assert_match("abc", "abcde") # => pass
self.assert_match("abc", "deabc") # => fail
"""
if re.match(pattern, target):
self._pass_assertion()
else:
pattern_repr = pp.format_re_repr(pattern)
pattern = pp.format_re(pattern)
target = pp.format(target)
format = \
"expected: re.match(%s, %s) doesn't return None\n" \
" pattern: <%s>\n" \
" target: <%s>"
system_message = format % (pattern_repr, target, pattern, target)
self._fail(system_message, message)
def test_run_failed_dict_data(self):
class TestCase(pikzie.TestCase):
def test_fail_assertion_dict_data(self, data):
self.assert_equal(data, data)
self.assert_equal("dict", data)
label = "fail"
data = {"a": 1, "b": 2}
test = TestCase("test_fail_assertion_dict_data", label, data)
format = \
"\n" \
"1) Failure: TestCase.test_fail_assertion_dict_data (%s): %s\n" \
" data: %s\n" \
"%s:%d: %s\n" \
"expected: <'dict'>\n" \
" but was: <%s>\n" \
"\n"
target_line = "self.assert_equal(\"dict\", data)"
line_no = Source.find_target_line_no(target_line)
details = format % (label, target_line, str(data),
self.file_name, line_no, target_line,
pp.format(data))
self.assert_output("F", 1, 1, 1, 0, 0, 0, 0, details, [test])
