def test_output_receives_start_with_pid(self):
proc = Process('echo 123')
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
self.assertEqual('start', msg.type)
self.assertEqual({'pid': 66}, msg.data)
def run(self, options):
"Run a command using your application's environment"
self.set_env(self.read_env(options))
cmd = ' '.join(shellquote(arg) for arg in options.command)
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
def test_output_receives_start_with_pid(self):
proc = Process('echo 123')
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
assert msg.type == 'start'
assert msg.data == {'pid': 66}
def run(self, options):
"Run a command using your application's environment"
self.read_env(options)
cmd = ' '.join(options.command)
p = Process(cmd, stdout=sys.stdout)
p.wait()
def test_output_receives_start_with_pid(self):
proc = Process('echo 123')
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
assert msg.type == 'start'
assert msg.data == {'pid': 66}
def run(self, options):
"Run a command using your application's environment"
self.read_env(options)
cmd = ' '.join(options.command)
p = Process(cmd, stdout=sys.stdout)
p.wait()
def test_message_contains_time(self):
proc = Process('echo 123')
proc._env = FakeEnv()
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
assert msg.time == datetime.datetime(2012, 8, 11, 12, 42)
def test_output_receives_lines_invalid_utf8(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.stdout = FakeOutput(lines=[b"\xfe\xff\n"])
return popen
proc = Process('echo 123')
proc._child_ctor = _ctor
proc.run(self.q)
self.assertTrue(self.q.got_message(b"\xfe\xff\n"))
def test_output_receives_lines_invalid_utf8(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.stdout = FakeOutput(lines=[b"\xfe\xff\n"])
return popen
proc = Process('echo 123')
proc._child_ctor = _ctor
proc.run(self.q)
assert self.q.got_message(b"\xfe\xff\n")
def test_output_receives_lines(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.stdout = FakeOutput(lines=[b"hello\n", b"world\n"])
return popen
proc = Process('echo 123')
proc._child_ctor = _ctor
proc.run(self.q)
self.assertTrue(self.q.got_message(b"hello\n"))
self.assertTrue(self.q.got_message(b"world\n"))
def test_output_does_not_receive_lines_when_quiet(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.stdout = FakeOutput(lines=[b"hello\n", b"world\n"])
return popen
proc = Process('echo 123', quiet=True)
proc._child_ctor = _ctor
proc.run(self.q)
self.assertFalse(self.q.got_message(b"hello\n"))
self.assertFalse(self.q.got_message(b"world\n"))
def test_output_receives_stop_with_returncode(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.returncode = 42
return popen
proc = Process('echo 123')
proc._child_ctor = _ctor
proc.run(self.q)
msg = self.q.find_message({'returncode': 42})
self.assertEqual('stop', msg.type)
def test_output_receives_lines(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.stdout = FakeOutput(lines=[b"hello\n", b"world\n"])
return popen
proc = Process('echo 123')
proc._child_ctor = _ctor
proc.run(self.q)
assert self.q.got_message(b"hello\n")
assert self.q.got_message(b"world\n")
def test_output_does_not_receive_lines_when_quiet(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.stdout = FakeOutput(lines=[b"hello\n", b"world\n"])
return popen
proc = Process('echo 123', quiet=True)
proc._child_ctor = _ctor
proc.run(self.q)
assert not self.q.got_message(b"hello\n")
assert not self.q.got_message(b"world\n")
def test_output_receives_stop_with_returncode(self):
def _ctor(*args, **kwargs):
popen = FakePopen(*args, **kwargs)
popen.returncode = 42
return popen
proc = Process('echo 123')
proc._child_ctor = _ctor
proc.run(self.q)
msg = self.q.find_message({'returncode': 42})
assert msg.type == 'stop'
def run(self, options):
"Run a command using your application's environment"
self.set_env(self.read_env(options))
if compat.ON_WINDOWS:
# do not quote on Windows, subprocess will handle it for us
# using the MSFT quoting rules
cmd = options.command
else:
cmd = ' '.join(shellquote(arg) for arg in options.command)
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
def run(self, options):
"Run a command using your application's environment"
self.set_env(self.read_env(options))
if compat.ON_WINDOWS:
# do not quote on Windows, subprocess will handle it for us
# using the MSFT quoting rules
cmd = options.command
else:
cmd = ' '.join(shellquote(arg) for arg in options.command)
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
def command_run(args):
procfile_path = _procfile_path(args.app_root, args.procfile)
os.environ.update(_read_env(procfile_path, args.env))
if compat.ON_WINDOWS:
# do not quote on Windows, subprocess will handle it for us
# using the MSFT quoting rules
cmd = args.command
else:
cmd = ' '.join(compat.shellquote(arg) for arg in args.command)
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
sys.exit(p.returncode)
def command_run(args):
procfile_path = _procfile_path(args.app_root, args.procfile)
os.environ.update(_read_env(procfile_path, args.env))
if compat.ON_WINDOWS:
# do not quote on Windows, subprocess will handle it for us
# using the MSFT quoting rules
cmd = args.command
else:
cmd = ' '.join(compat.shellquote(arg) for arg in args.command)
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
sys.exit(p.returncode)
def test_message_contains_time(self):
proc = Process('echo 123')
proc._env = FakeEnv()
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
self.assertEqual(datetime.datetime(2012, 8, 11, 12, 42), msg.time)
def test_ctor_quiet(self):
proc = Process('echo 123', quiet=True)
self.assertTrue(proc.quiet)
def test_ctor_colour(self):
proc = Process('echo 123', colour='red')
self.assertEqual('red', proc.colour)
def test_ctor_name(self):
proc = Process('echo 123', name='foo')
self.assertEqual('foo', proc.name)
def test_wait(self):
proc = Process('echo 123', popen=FakePopen)
self.assertEqual(FakePopen.WAIT_RESULT, proc.wait())
def test_output_receives_stop(self):
proc = Process('echo 123')
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[-1]
assert msg.type == 'stop'
def run(args):
read_env(args)
cmd = ' '.join(args.command)
p = Process(cmd, stdout=sys.stdout)
p.wait()
def test_create_file(tmpdir):
old_wd = os.getcwd()
os.chdir(str(tmpdir))
print(str(tmpdir))
try:
os.system("python -m django_zero create --no-input project foo")
print(str(tmpdir.join("foo")))
os.chdir(str(tmpdir.join("foo")))
# TODO: move back into make install
os.system("python -m django_zero install")
os.system("yarn install")
os.system("python -m django_zero manage migrate")
# Run the webpack assets builder
os.system("python -m django_zero webpack")
target = "127.0.0.1", get_free_port()
print("Target:", *target)
events = multiprocessing.Queue()
server_command = "python -m django_zero manage runserver {0}:{1}".format(
*target)
print("Command:", server_command)
server = Process(server_command, name="server")
server_process = multiprocessing.Process(name="server",
target=server.run,
args=(events, True))
try:
server_process.start()
exit = False
pid = None
while 1:
try:
msg = events.get(timeout=0.1)
except Empty:
if exit:
break
else:
# print(msg)
if msg.type == "start":
pid = msg.data["pid"]
conn_ok = False
for i in range(10):
try:
s = socket.create_connection(target, 1)
s.close()
conn_ok = True
except socket.error:
sleep(1)
assert conn_ok
try:
target = "http://{}:{}".format(*target)
resp = requests.get(target + "/")
assert resp.status_code == 200
resp = requests.get(target +
"/static/bootstrap.css")
assert resp.status_code == 200
resp = requests.get(target +
"/static/bootstrap.js")
assert resp.status_code == 200
finally:
os.killpg(pid, signal.SIGKILL)
elif msg.type == "line":
print(">>>", msg.data.decode("utf-8"), end="")
elif msg.type == "stop":
pid = None
exit = True
finally:
server_process.terminate()
server_process.join(timeout=2)
if server_process.is_alive() and pid:
try:
os.killpg(pid, signal.SIGTERM)
except ProcessLookupError:
pass
finally:
os.chdir(old_wd)
def test_ctor_colour(self):
proc = Process('echo 123', colour='red')
assert proc.colour == 'red'
def run(cmd):
"""Run a single command and exit"""
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
print "finished running %s - returned %s" % (cmd, p.returncode)
def test_message_contains_colour(self):
proc = Process('echo 123', colour="red")
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
self.assertEqual("red", msg.colour)
def test_poll(self):
proc = Process('echo 123', popen=FakePopen)
self.assertEqual(FakePopen.POLL_RESULT, proc.poll())
def test_kill(self):
proc = Process('echo 123', popen=FakePopen)
proc.kill()
self.assertTrue(proc.proc.killed)
def test_cwd_passed_along(self):
proc = Process('echo 123', cwd='fake-dir')
proc._child_ctor = FakePopen
proc.run(self.q)
assert proc._child.kwargs['cwd'] == 'fake-dir'
def test_ctor_name(self):
proc = Process('echo 123', name='foo')
assert proc.name == 'foo'
def test_message_contains_name(self):
proc = Process('echo 123', name="barry")
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
assert msg.name == "barry"
def test_output_receives_stop(self):
proc = Process('echo 123')
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[-1]
self.assertEqual('stop', msg.type)
def test_message_contains_colour(self):
proc = Process('echo 123', colour="red")
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
assert msg.colour == "red"
def test_ctor_cmd(self):
proc = Process('echo 123')
assert proc.cmd == 'echo 123'
def run(cmd):
"""Run a single command and exit"""
p = Process(cmd, stdout=sys.stdout, stderr=sys.stderr)
p.wait()
print "finished running %s - returned %s" % (cmd, p.returncode)
def test_ctor_cmd(self):
proc = Process('echo 123')
self.assertEqual('echo 123', proc.cmd)
def test_message_contains_name(self):
proc = Process('echo 123', name="barry")
proc._child_ctor = FakePopen
proc.run(self.q)
msg = self.q.messages[0]
self.assertEqual("barry", msg.name)
def test_terminate(self):
proc = Process('echo 123', popen=FakePopen)
proc.terminate()
self.assertTrue(proc.proc.terminated)
