def test_flat_multisuite_mocking_calls(self):
test_cloc_out_path = os.path.join(os.path.dirname(__file__),
'fixtures', 'cloc_out.json')
cloc_out = read_file(test_cloc_out_path)
root_path = join(tempfile.gettempdir(), 'multisuite_test')
app_path = join(root_path, 'apps', 'mockapp')
log_path = join(root_path, 'logs')
args = [
"--log_dir", log_path, "--app_gen_output_dir", root_path,
"--test_build_only", "--switch_xcode_versions", "--full_clean"
]
# we need the unused named variable for mocking purposes
# noinspection PyUnusedLocal
def command_callable(command, stdin):
if 'cloc' in command:
return PopenBehaviour(stdout=cloc_out)
elif 'xcodebuild -version' in command:
return PopenBehaviour(
stdout=b'Xcode 10.0\nBuild version 10A255\n')
return PopenBehaviour(stdout=b'test_out', stderr=b'test_error')
with testfixtures.Replacer() as rep:
mock_popen = MockPopen()
rep.replace('subprocess.Popen', mock_popen)
mock_popen.set_default(behaviour=command_callable)
with mock.patch('distutils.spawn.find_executable') as mock_find:
mock_find.return_value = '/bin/ls' # A non empty return value basically means "I found that executable"
CommandLineMultisuite().main(args)
self.assertGreater(os.listdir(app_path), 0)
self.verify_genproj('MockLib53', 101, app_path)
def _setup_popen_mock(commands_mock):
Popen = MockPopen()
Popen.set_default(behaviour=commands_mock)
with Replacer() as replacer:
replacer.replace("subprocess.Popen", Popen)
yield
def test_docker_get_data_dir_host(mocker):
popen_mock = MockPopen()
popen_mock.set_default(stdout=DOCKER_OUTPUT.encode('utf-8'))
mocker.patch('subprocess.Popen', new=popen_mock)
data_dir_host, err = PostgreSQLAlt.docker_get_data_dir_host('foobar', '/data')
assert err is None
assert data_dir_host == '/mnt/storage/the_land_where_the_data_lives'
def test_callable_default_behaviour(self):
def some_callable(command, stdin):
return PopenBehaviour(BytesLiteral(command), BytesLiteral(stdin), 1, 345, 0)
Popen = MockPopen()
Popen.set_default(behaviour=some_callable)
process = Popen('a command', stdin='some stdin', stdout=PIPE, stderr=PIPE)
compare(process.pid, 345)
out, err = process.communicate()
compare(out, b'a command')
compare(err, b'some stdin')
compare(process.returncode, 1)
def _setup_popen_mock(commands_mock, commands_verifier=None):
"""
Mock subprocess.Popen's behavior and if applicable, intercept the commands
received by Popen and check if they are as expected using
commands_verifier provided by caller.
TODO(xwjiang): Ideally we should write a lexical analyzer that can parse
in a more intelligent way.
"""
Popen = MockPopen()
Popen.set_default(behaviour=commands_mock)
with Replacer() as replacer:
replacer.replace("subprocess.Popen", Popen)
yield
if commands_verifier:
assert commands_verifier(Popen.all_calls)
def test_default_command_max_args(self):
Popen = MockPopen()
Popen.set_default(b"out", b"err", 1, 345)
process = Popen("a command", stdout=PIPE, stderr=PIPE)
compare(process.pid, 345)
compare(None, process.returncode)
out, err = process.communicate()
# test the rest
compare(out, b"out")
compare(err, b"err")
compare(process.returncode, 1)
# test call list
compare(
[call.Popen("a command", stderr=-1, stdout=-1), call.Popen_instance.communicate()], Popen.mock.method_calls
)
def test_callable_default_behaviour(self):
def some_callable(command, stdin):
return PopenBehaviour(BytesLiteral(command), BytesLiteral(stdin),
1, 345, 0)
Popen = MockPopen()
Popen.set_default(behaviour=some_callable)
process = Popen('a command',
stdin='some stdin',
stdout=PIPE,
stderr=PIPE)
compare(process.pid, 345)
out, err = process.communicate()
compare(out, b'a command')
compare(err, b'some stdin')
compare(process.returncode, 1)
def test_default_command_max_args(self):
Popen = MockPopen()
Popen.set_default(b'out', b'err', 1, 345)
process = Popen('a command', stdout=PIPE, stderr=PIPE)
compare(process.pid, 345)
compare(None, process.returncode)
out, err = process.communicate()
# test the rest
compare(out, b'out')
compare(err, b'err')
compare(process.returncode, 1)
# test call list
compare([
call.Popen('a command', stderr=-1, stdout=-1),
call.Popen_instance.communicate(),
], Popen.mock.method_calls)
def test_default_command_min_args(self):
# setup
Popen = MockPopen()
Popen.set_default()
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE)
# process started, no return code
compare(process.pid, 1234)
compare(None, process.returncode)
out, err = process.communicate()
# test the rest
compare(out, b"")
compare(err, b"")
compare(process.returncode, 0)
# test call list
compare(
[call.Popen("a command", stderr=-1, stdout=-1), call.Popen_instance.communicate()], Popen.mock.method_calls
)
def test_default_command_min_args(self):
# setup
Popen = MockPopen()
Popen.set_default()
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE)
# process started, no return code
compare(process.pid, 1234)
compare(None, process.returncode)
out, err = process.communicate()
# test the rest
compare(out, b'')
compare(err, b'')
compare(process.returncode, 0)
# test call list
compare([
call.Popen('a command', stderr=-1, stdout=-1),
call.Popen_instance.communicate(),
], Popen.mock.method_calls)
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo', shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
def test_example_bad_returncode(self):
# set up
Popen.set_command('svn ls -R foo',
stdout=b'o',
stderr=b'e',
returncode=1)
# testing of error
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate('foo')
# test call list
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.communicate('foo'),
], Popen.mock.method_calls)
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', stdout=b'foo', stderr=b'bar')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b'foo')
compare(process.stderr.read(), b'bar')
# test call list
compare([
call.Popen('a command', shell=True, stderr=PIPE, stdout=PIPE),
], Popen.mock.method_calls)
def test_write_to_stdin(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdin=PIPE, shell=True)
process.stdin.write('some text')
process.stdin.close()
# test call list
compare([
call.Popen('a command', shell=True, stdin=PIPE),
call.Popen_instance.stdin.write('some text'),
call.Popen_instance.stdin.close(),
], Popen.mock.method_calls)
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3)
# usage
process = Popen('a command')
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare([
call.Popen('a command'),
call.Popen_instance.wait(),
], Popen.mock.method_calls)
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.send_signal(0),
], Popen.mock.method_calls)
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3, poll_count=2)
# example usage
process = Popen('a command')
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare([
call.Popen('a command'),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
], Popen.mock.method_calls)
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo', shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command("svn ls -R foo", stdout=b"o", stderr=b"e")
# testing of results
compare(my_func(), b"o")
# testing calls were in the right order and with the correct parameters:
compare(
[call.Popen("svn ls -R foo", shell=True, stderr=PIPE, stdout=PIPE), call.Popen_instance.communicate()],
Popen.mock.method_calls,
)
def test_example_bad_returncode(self):
# set up
Popen.set_command("svn ls -R foo", stdout=b"o", stderr=b"e", returncode=1)
# testing of error
with ShouldRaise(RuntimeError("something bad happened")):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command("a command")
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate("foo")
# test call list
compare(
[call.Popen("a command", shell=True, stderr=-1, stdout=-1), call.Popen_instance.communicate("foo")],
Popen.mock.method_calls,
)
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command("a command", stdout=b"foo", stderr=b"bar")
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b"foo")
compare(process.stderr.read(), b"bar")
# test call list
compare([call.Popen("a command", shell=True, stderr=PIPE, stdout=PIPE)], Popen.mock.method_calls)
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command("a command", returncode=3)
# usage
process = Popen("a command")
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare([call.Popen("a command"), call.Popen_instance.wait()], Popen.mock.method_calls)
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command("a command")
# usage
process = Popen("a command", stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare(
[call.Popen("a command", shell=True, stderr=-1, stdout=-1), call.Popen_instance.send_signal(0)],
Popen.mock.method_calls,
)
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command("a command", returncode=3, poll_count=2)
# example usage
process = Popen("a command")
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare(
[
call.Popen("a command"),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
],
Popen.mock.method_calls,
)
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b"o", stderr=b"e")
# testing of results
compare(my_func(), b"o")
# testing calls were in the right order and with the correct parameters:
compare(
[call.Popen("svn ls -R foo", shell=True, stderr=PIPE, stdout=PIPE), call.Popen_instance.communicate()],
Popen.mock.method_calls,
)
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo',
shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
def test_example_bad_returncode(self):
# set up
Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e',
returncode=1)
# testing of error
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate('foo')
# test call list
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.communicate('foo'),
], Popen.mock.method_calls)
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', stdout=b'foo', stderr=b'bar')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b'foo')
compare(process.stderr.read(), b'bar')
# test call list
compare([
call.Popen('a command', shell=True, stderr=PIPE, stdout=PIPE),
], Popen.mock.method_calls)
def test_write_to_stdin(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdin=PIPE, shell=True)
process.stdin.write('some text')
process.stdin.close()
# test call list
compare([
call.Popen('a command', shell=True, stdin=PIPE),
call.Popen_instance.stdin.write('some text'),
call.Popen_instance.stdin.close(),
], Popen.mock.method_calls)
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3)
# usage
process = Popen('a command')
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare([
call.Popen('a command'),
call.Popen_instance.wait(),
], Popen.mock.method_calls)
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare([
call.Popen('a command', shell=True, stderr=-1, stdout=-1),
call.Popen_instance.send_signal(0),
], Popen.mock.method_calls)
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3, poll_count=2)
# example usage
process = Popen('a command')
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare([
call.Popen('a command'),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
call.Popen_instance.poll(),
], Popen.mock.method_calls)
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo',
shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
def test_callable(self):
# set up
def command_callable(command, stdin):
return PopenBehaviour(stdout=b'stdout')
self.Popen.set_default(behaviour=command_callable)
# testing of results
compare(my_func(), b'stdout')
# testing calls were in the right order and with the correct parameters:
compare([
call.Popen('svn ls -R foo',
shell=True, stderr=PIPE, stdout=PIPE),
call.Popen_instance.communicate()
], Popen.mock.method_calls)
def test_multiple_responses(self):
# set up
behaviours = [
PopenBehaviour(stderr=b'e', returncode=1),
PopenBehaviour(stdout=b'o'),
]
def behaviour(command, stdin):
return behaviours.pop(0)
self.Popen.set_command('svn ls -R foo', behaviour=behaviour)
# testing of error:
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
# testing of second call:
compare(my_func(), b'o')
def test_count_down(self):
# set up
self.Popen.set_command('svn ls -R foo', behaviour=CustomBehaviour())
# testing of error:
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
# testing of second call:
compare(my_func(), b'o')
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
process = call.Popen('svn ls -R foo',
shell=True,
stderr=PIPE,
stdout=PIPE)
compare(Popen.all_calls, expected=[process, process.communicate()])
def test_example_bad_returncode(self):
# set up
Popen.set_command('svn ls -R foo',
stdout=b'o',
stderr=b'e',
returncode=1)
# testing of error
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate('foo')
# test call list
compare(Popen.all_calls,
expected=[
process.root_call,
process.root_call.communicate('foo'),
])
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', stdout=b'foo', stderr=b'bar')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b'foo')
compare(process.stderr.read(), b'bar')
def test_write_to_stdin(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdin=PIPE, shell=True)
process.stdin.write('some text')
process.stdin.close()
# test call list
compare(Popen.all_calls,
expected=[
process.root_call,
process.root_call.stdin.write('some text'),
process.root_call.stdin.close(),
])
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3)
# usage
process = Popen('a command')
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare(Popen.all_calls,
expected=[
call.Popen('a command'),
call.Popen('a command').wait(),
])
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare(Popen.all_calls,
expected=[
process.root_call,
process.root_call.send_signal(0),
])
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3, poll_count=2)
# example usage
process = Popen('a command')
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare(Popen.all_calls,
expected=[
process.root_call,
process.root_call.poll(),
process.root_call.poll(),
process.root_call.poll(),
])
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
root_call = call.Popen('svn ls -R foo',
shell=True,
stderr=PIPE,
stdout=PIPE)
compare(Popen.all_calls, expected=[root_call, root_call.communicate()])
def test_multiple_responses(self):
# set up
behaviours = [
PopenBehaviour(stderr=b'e', returncode=1),
PopenBehaviour(stdout=b'o'),
]
def behaviour(command, stdin):
return behaviours.pop(0)
self.Popen.set_command('svn ls -R foo', behaviour=behaviour)
# testing of error:
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
# testing of second call:
compare(my_func(), b'o')
def test_count_down(self):
# set up
self.Popen.set_command('svn ls -R foo', behaviour=CustomBehaviour())
# testing of error:
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
# testing of second call:
compare(my_func(), b'o')
def test_multiple_processes(self):
# set up
self.Popen.set_command('process --batch=0', stdout=b'42')
self.Popen.set_command('process --batch=1', stdout=b'13')
# testing of results
compare(process_in_batches(2), expected=55)
# testing of process management:
p1 = call.Popen('process --batch=0',
shell=True,
stderr=PIPE,
stdout=PIPE)
p2 = call.Popen('process --batch=1',
shell=True,
stderr=PIPE,
stdout=PIPE)
compare(Popen.all_calls,
expected=[
p1,
p2,
p1.communicate(),
p2.communicate(),
])
class TestMyFunc(TestCase):
def setUp(self):
self.Popen = MockPopen()
self.r = Replacer()
self.r.replace(dotted_path, self.Popen)
self.addCleanup(self.r.restore)
def test_example(self):
# set up
self.Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
process = call.Popen(['svn', 'ls', '-R', 'foo'], stderr=PIPE, stdout=PIPE)
compare(Popen.all_calls, expected=[
process,
process.communicate()
])
def test_example_bad_returncode(self):
# set up
Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e',
returncode=1)
# testing of error
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
def test_communicate_with_input(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
out, err = process.communicate('foo')
# test call list
compare(Popen.all_calls, expected=[
process.root_call,
process.root_call.communicate('foo'),
])
def test_read_from_stdout_and_stderr(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', stdout=b'foo', stderr=b'bar')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
compare(process.stdout.read(), b'foo')
compare(process.stderr.read(), b'bar')
def test_write_to_stdin(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdin=PIPE, shell=True)
process.stdin.write('some text')
process.stdin.close()
# test call list
compare(Popen.all_calls, expected=[
process.root_call,
process.root_call.stdin.write('some text'),
process.root_call.stdin.close(),
])
def test_wait_and_return_code(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3)
# usage
process = Popen('a command')
compare(process.returncode, None)
# result checking
compare(process.wait(), 3)
compare(process.returncode, 3)
# test call list
compare(Popen.all_calls, expected=[
call.Popen('a command'),
call.Popen('a command').wait(),
])
def test_send_signal(self):
# setup
Popen = MockPopen()
Popen.set_command('a command')
# usage
process = Popen('a command', stdout=PIPE, stderr=PIPE, shell=True)
process.send_signal(0)
# result checking
compare(Popen.all_calls, expected=[
process.root_call,
process.root_call.send_signal(0),
])
def test_poll_until_result(self):
# setup
Popen = MockPopen()
Popen.set_command('a command', returncode=3, poll_count=2)
# example usage
process = Popen('a command')
while process.poll() is None:
# you'd probably have a sleep here, or go off and
# do some other work.
pass
# result checking
compare(process.returncode, 3)
compare(Popen.all_calls, expected=[
process.root_call,
process.root_call.poll(),
process.root_call.poll(),
process.root_call.poll(),
])
def test_default_behaviour(self):
# set up
self.Popen.set_default(stdout=b'o', stderr=b'e')
# testing of results
compare(my_func(), b'o')
# testing calls were in the right order and with the correct parameters:
root_call = call.Popen(['svn', 'ls', '-R', 'foo'],
stderr=PIPE, stdout=PIPE)
compare(Popen.all_calls, expected=[
root_call,
root_call.communicate()
])
def test_multiple_responses(self):
# set up
behaviours = [
PopenBehaviour(stderr=b'e', returncode=1),
PopenBehaviour(stdout=b'o'),
]
def behaviour(command, stdin):
return behaviours.pop(0)
self.Popen.set_command('svn ls -R foo', behaviour=behaviour)
# testing of error:
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
# testing of second call:
compare(my_func(), b'o')
def test_count_down(self):
# set up
self.Popen.set_command('svn ls -R foo', behaviour=CustomBehaviour())
# testing of error:
with ShouldRaise(RuntimeError('something bad happened')):
my_func()
# testing of second call:
compare(my_func(), b'o')
def test_multiple_processes(self):
# set up
self.Popen.set_command('process --batch=0', stdout=b'42')
self.Popen.set_command('process --batch=1', stdout=b'13')
# testing of results
compare(process_in_batches(2), expected=55)
# testing of process management:
p1 = call.Popen('process --batch=0', shell=True, stderr=PIPE, stdout=PIPE)
p2 = call.Popen('process --batch=1', shell=True, stderr=PIPE, stdout=PIPE)
compare(Popen.all_calls, expected=[
p1,
p2,
p1.communicate(),
p2.communicate(),
])
