move test files out of py lib proper
* separate all tests from plugins * simplify implicit inclusion of plugins under test * have test_initpkg perform direct checks instead of yielding tests * fix example tests for 3k --HG-- branch : trunk
This commit is contained in:
holger krekel
@@ -1 +0,0 @@
|
||||
#
|
||||
@@ -1,215 +0,0 @@
|
||||
|
||||
import py
|
||||
import sys, os, subprocess, inspect
|
||||
from py.__.execnet import gateway_base, gateway
|
||||
from py.__.execnet.gateway_base import Message, Channel, ChannelFactory
|
||||
|
||||
def test_subprocess_interaction(anypython):
|
||||
line = gateway.popen_bootstrapline
|
||||
compile(line, 'xyz', 'exec')
|
||||
args = [str(anypython), '-c', line]
|
||||
popen = subprocess.Popen(args, bufsize=0, stderr=subprocess.STDOUT,
|
||||
stdin=subprocess.PIPE, stdout=subprocess.PIPE)
|
||||
def send(line):
|
||||
popen.stdin.write(line.encode('ascii'))
|
||||
if sys.version_info > (3,0): # 3k still buffers
|
||||
popen.stdin.flush()
|
||||
def receive():
|
||||
return popen.stdout.readline().decode('ascii')
|
||||
|
||||
try:
|
||||
source = py.code.Source(read_write_loop, "read_write_loop()")
|
||||
repr_source = repr(str(source)) + "\n"
|
||||
sendline = repr_source
|
||||
send(sendline)
|
||||
s = receive()
|
||||
assert s == "ok\n"
|
||||
send("hello\n")
|
||||
s = receive()
|
||||
assert s == "received: hello\n"
|
||||
send("world\n")
|
||||
s = receive()
|
||||
assert s == "received: world\n"
|
||||
finally:
|
||||
popen.stdin.close()
|
||||
popen.stdout.close()
|
||||
popen.wait()
|
||||
|
||||
def read_write_loop():
|
||||
import os, sys
|
||||
sys.stdout.write("ok\n")
|
||||
sys.stdout.flush()
|
||||
while 1:
|
||||
try:
|
||||
line = sys.stdin.readline()
|
||||
sys.stdout.write("received: %s" % line)
|
||||
sys.stdout.flush()
|
||||
except (IOError, EOFError):
|
||||
break
|
||||
|
||||
def pytest_generate_tests(metafunc):
|
||||
if 'anypython' in metafunc.funcargnames:
|
||||
for name in 'python3.1', 'python2.4', 'python2.5', 'python2.6':
|
||||
metafunc.addcall(id=name, param=name)
|
||||
|
||||
def pytest_funcarg__anypython(request):
|
||||
name = request.param
|
||||
executable = py.path.local.sysfind(name)
|
||||
if executable is None:
|
||||
py.test.skip("no %s found" % (name,))
|
||||
return executable
|
||||
|
||||
def test_io_message(anypython, tmpdir):
|
||||
check = tmpdir.join("check.py")
|
||||
check.write(py.code.Source(gateway_base, """
|
||||
try:
|
||||
from io import BytesIO
|
||||
except ImportError:
|
||||
from StringIO import StringIO as BytesIO
|
||||
import tempfile
|
||||
temp_out = BytesIO()
|
||||
temp_in = BytesIO()
|
||||
io = Popen2IO(temp_out, temp_in)
|
||||
for i, msg_cls in Message._types.items():
|
||||
print ("checking %s %s" %(i, msg_cls))
|
||||
for data in "hello", "hello".encode('ascii'):
|
||||
msg1 = msg_cls(i, data)
|
||||
msg1.writeto(io)
|
||||
x = io.outfile.getvalue()
|
||||
io.outfile.truncate(0)
|
||||
io.outfile.seek(0)
|
||||
io.infile.seek(0)
|
||||
io.infile.write(x)
|
||||
io.infile.seek(0)
|
||||
msg2 = Message.readfrom(io)
|
||||
assert msg1.channelid == msg2.channelid, (msg1, msg2)
|
||||
assert msg1.data == msg2.data
|
||||
print ("all passed")
|
||||
"""))
|
||||
#out = py.process.cmdexec("%s %s" %(executable,check))
|
||||
out = anypython.sysexec(check)
|
||||
print (out)
|
||||
assert "all passed" in out
|
||||
|
||||
def test_popen_io(anypython, tmpdir):
|
||||
check = tmpdir.join("check.py")
|
||||
check.write(py.code.Source(gateway_base, """
|
||||
do_exec(Popen2IO.server_stmt, globals())
|
||||
io.write("hello".encode('ascii'))
|
||||
s = io.read(1)
|
||||
assert s == "x".encode('ascii')
|
||||
"""))
|
||||
from subprocess import Popen, PIPE
|
||||
args = [str(anypython), str(check)]
|
||||
proc = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
|
||||
proc.stdin.write("x".encode('ascii'))
|
||||
stdout, stderr = proc.communicate()
|
||||
print (stderr)
|
||||
ret = proc.wait()
|
||||
assert "hello".encode('ascii') in stdout
|
||||
|
||||
|
||||
def test_rinfo_source(anypython, tmpdir):
|
||||
check = tmpdir.join("check.py")
|
||||
check.write(py.code.Source("""
|
||||
class Channel:
|
||||
def send(self, data):
|
||||
assert eval(repr(data), {}) == data
|
||||
channel = Channel()
|
||||
""", gateway.rinfo_source, """
|
||||
print ('all passed')
|
||||
"""))
|
||||
out = anypython.sysexec(check)
|
||||
print (out)
|
||||
assert "all passed" in out
|
||||
|
||||
def test_geterrortext(anypython, tmpdir):
|
||||
check = tmpdir.join("check.py")
|
||||
check.write(py.code.Source(gateway_base, """
|
||||
class Arg:
|
||||
pass
|
||||
errortext = geterrortext((Arg, "1", 4))
|
||||
assert "Arg" in errortext
|
||||
import sys
|
||||
try:
|
||||
raise ValueError("17")
|
||||
except ValueError:
|
||||
excinfo = sys.exc_info()
|
||||
s = geterrortext(excinfo)
|
||||
assert "17" in s
|
||||
print ("all passed")
|
||||
"""))
|
||||
out = anypython.sysexec(check)
|
||||
print (out)
|
||||
assert "all passed" in out
|
||||
|
||||
def test_getsource_import_modules():
|
||||
for dottedname in gateway.startup_modules:
|
||||
yield gateway.getsource, dottedname
|
||||
|
||||
def test_getsource_no_colision():
|
||||
seen = {}
|
||||
for dottedname in gateway.startup_modules:
|
||||
mod = __import__(dottedname, None, None, ['__doc__'])
|
||||
for name, value in vars(mod).items():
|
||||
if py.std.inspect.isclass(value):
|
||||
if name in seen:
|
||||
olddottedname, oldval = seen[name]
|
||||
if oldval is not value:
|
||||
py.test.fail("duplicate class %r in %s and %s" %
|
||||
(name, dottedname, olddottedname))
|
||||
seen[name] = (dottedname, value)
|
||||
|
||||
def test_stdouterrin_setnull():
|
||||
cap = py.io.StdCaptureFD()
|
||||
from py.__.execnet.gateway import stdouterrin_setnull
|
||||
stdouterrin_setnull()
|
||||
import os
|
||||
os.write(1, "hello".encode('ascii'))
|
||||
if os.name == "nt":
|
||||
os.write(2, "world")
|
||||
os.read(0, 1)
|
||||
out, err = cap.reset()
|
||||
assert not out
|
||||
assert not err
|
||||
|
||||
|
||||
class TestMessage:
|
||||
def test_wire_protocol(self):
|
||||
for cls in Message._types.values():
|
||||
one = py.io.BytesIO()
|
||||
data = '23'.encode('ascii')
|
||||
cls(42, data).writeto(one)
|
||||
two = py.io.BytesIO(one.getvalue())
|
||||
msg = Message.readfrom(two)
|
||||
assert isinstance(msg, cls)
|
||||
assert msg.channelid == 42
|
||||
assert msg.data == data
|
||||
assert isinstance(repr(msg), str)
|
||||
# == "<Message.%s channelid=42 '23'>" %(msg.__class__.__name__, )
|
||||
|
||||
class TestPureChannel:
|
||||
def setup_method(self, method):
|
||||
self.fac = ChannelFactory(None)
|
||||
|
||||
def test_factory_create(self):
|
||||
chan1 = self.fac.new()
|
||||
assert chan1.id == 1
|
||||
chan2 = self.fac.new()
|
||||
assert chan2.id == 3
|
||||
|
||||
def test_factory_getitem(self):
|
||||
chan1 = self.fac.new()
|
||||
assert self.fac._channels[chan1.id] == chan1
|
||||
chan2 = self.fac.new()
|
||||
assert self.fac._channels[chan2.id] == chan2
|
||||
|
||||
def test_channel_timeouterror(self):
|
||||
channel = self.fac.new()
|
||||
py.test.raises(IOError, channel.waitclose, timeout=0.01)
|
||||
|
||||
def test_channel_makefile_incompatmode(self):
|
||||
channel = self.fac.new()
|
||||
py.test.raises(ValueError, 'channel.makefile("rw")')
|
||||
|
||||
|
||||
@@ -1,566 +0,0 @@
|
||||
from __future__ import generators
|
||||
import os, sys, time
|
||||
import py
|
||||
from py.__.execnet import gateway_base, gateway
|
||||
queue = py.builtin._tryimport('queue', 'Queue')
|
||||
|
||||
pytest_plugins = "pytester"
|
||||
|
||||
TESTTIMEOUT = 10.0 # seconds
|
||||
|
||||
class PopenGatewayTestSetup:
|
||||
def setup_class(cls):
|
||||
cls.gw = py.execnet.PopenGateway()
|
||||
|
||||
#def teardown_class(cls):
|
||||
# cls.gw.exit()
|
||||
|
||||
class BasicRemoteExecution:
|
||||
def test_correct_setup(self):
|
||||
assert self.gw._receiverthread.isAlive()
|
||||
|
||||
def test_repr_doesnt_crash(self):
|
||||
assert isinstance(repr(self.gw), str)
|
||||
|
||||
def test_attribute__name__(self):
|
||||
channel = self.gw.remote_exec("channel.send(__name__)")
|
||||
name = channel.receive()
|
||||
assert name == "__channelexec__"
|
||||
|
||||
def test_correct_setup_no_py(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
import sys
|
||||
channel.send(list(sys.modules))
|
||||
""")
|
||||
remotemodules = channel.receive()
|
||||
assert 'py' not in remotemodules, (
|
||||
"py should not be imported on remote side")
|
||||
|
||||
def test_remote_exec_waitclose(self):
|
||||
channel = self.gw.remote_exec('pass')
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
|
||||
def test_remote_exec_waitclose_2(self):
|
||||
channel = self.gw.remote_exec('def gccycle(): pass')
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
|
||||
def test_remote_exec_waitclose_noarg(self):
|
||||
channel = self.gw.remote_exec('pass')
|
||||
channel.waitclose()
|
||||
|
||||
def test_remote_exec_error_after_close(self):
|
||||
channel = self.gw.remote_exec('pass')
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
py.test.raises(IOError, channel.send, 0)
|
||||
|
||||
def test_remote_exec_channel_anonymous(self):
|
||||
channel = self.gw.remote_exec('''
|
||||
obj = channel.receive()
|
||||
channel.send(obj)
|
||||
''')
|
||||
channel.send(42)
|
||||
result = channel.receive()
|
||||
assert result == 42
|
||||
|
||||
def test_channel_close_and_then_receive_error(self):
|
||||
channel = self.gw.remote_exec('raise ValueError')
|
||||
py.test.raises(channel.RemoteError, channel.receive)
|
||||
|
||||
def test_channel_finish_and_then_EOFError(self):
|
||||
channel = self.gw.remote_exec('channel.send(42)')
|
||||
x = channel.receive()
|
||||
assert x == 42
|
||||
py.test.raises(EOFError, channel.receive)
|
||||
py.test.raises(EOFError, channel.receive)
|
||||
py.test.raises(EOFError, channel.receive)
|
||||
|
||||
def test_channel_close_and_then_receive_error_multiple(self):
|
||||
channel = self.gw.remote_exec('channel.send(42) ; raise ValueError')
|
||||
x = channel.receive()
|
||||
assert x == 42
|
||||
py.test.raises(channel.RemoteError, channel.receive)
|
||||
|
||||
def test_channel__local_close(self):
|
||||
channel = self.gw._channelfactory.new()
|
||||
self.gw._channelfactory._local_close(channel.id)
|
||||
channel.waitclose(0.1)
|
||||
|
||||
def test_channel__local_close_error(self):
|
||||
channel = self.gw._channelfactory.new()
|
||||
self.gw._channelfactory._local_close(channel.id,
|
||||
channel.RemoteError("error"))
|
||||
py.test.raises(channel.RemoteError, channel.waitclose, 0.01)
|
||||
|
||||
def test_channel_error_reporting(self):
|
||||
channel = self.gw.remote_exec('def foo():\n return foobar()\nfoo()\n')
|
||||
try:
|
||||
channel.receive()
|
||||
except channel.RemoteError:
|
||||
e = sys.exc_info()[1]
|
||||
assert str(e).startswith('Traceback (most recent call last):')
|
||||
assert str(e).find('NameError: global name \'foobar\' '
|
||||
'is not defined') > -1
|
||||
else:
|
||||
py.test.fail('No exception raised')
|
||||
|
||||
def test_channel_syntax_error(self):
|
||||
# missing colon
|
||||
channel = self.gw.remote_exec('def foo()\n return 1\nfoo()\n')
|
||||
try:
|
||||
channel.receive()
|
||||
except channel.RemoteError:
|
||||
e = sys.exc_info()[1]
|
||||
assert str(e).startswith('Traceback (most recent call last):')
|
||||
assert str(e).find('SyntaxError') > -1
|
||||
|
||||
def test_channel_iter(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
for x in range(3):
|
||||
channel.send(x)
|
||||
""")
|
||||
l = list(channel)
|
||||
assert l == [0, 1, 2]
|
||||
|
||||
def test_channel_passing_over_channel(self):
|
||||
channel = self.gw.remote_exec('''
|
||||
c = channel.gateway.newchannel()
|
||||
channel.send(c)
|
||||
c.send(42)
|
||||
''')
|
||||
c = channel.receive()
|
||||
x = c.receive()
|
||||
assert x == 42
|
||||
|
||||
# check that the both sides previous channels are really gone
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
#assert c.id not in self.gw._channelfactory
|
||||
newchan = self.gw.remote_exec('''
|
||||
assert %d not in channel.gateway._channelfactory._channels
|
||||
''' % (channel.id))
|
||||
newchan.waitclose(TESTTIMEOUT)
|
||||
assert channel.id not in self.gw._channelfactory._channels
|
||||
|
||||
def test_channel_receiver_callback(self):
|
||||
l = []
|
||||
#channel = self.gw.newchannel(receiver=l.append)
|
||||
channel = self.gw.remote_exec(source='''
|
||||
channel.send(42)
|
||||
channel.send(13)
|
||||
channel.send(channel.gateway.newchannel())
|
||||
''')
|
||||
channel.setcallback(callback=l.append)
|
||||
py.test.raises(IOError, channel.receive)
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
assert len(l) == 3
|
||||
assert l[:2] == [42,13]
|
||||
assert isinstance(l[2], channel.__class__)
|
||||
|
||||
def test_channel_callback_after_receive(self):
|
||||
l = []
|
||||
channel = self.gw.remote_exec(source='''
|
||||
channel.send(42)
|
||||
channel.send(13)
|
||||
channel.send(channel.gateway.newchannel())
|
||||
''')
|
||||
x = channel.receive()
|
||||
assert x == 42
|
||||
channel.setcallback(callback=l.append)
|
||||
py.test.raises(IOError, channel.receive)
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
assert len(l) == 2
|
||||
assert l[0] == 13
|
||||
assert isinstance(l[1], channel.__class__)
|
||||
|
||||
def test_waiting_for_callbacks(self):
|
||||
l = []
|
||||
def callback(msg):
|
||||
import time; time.sleep(0.2)
|
||||
l.append(msg)
|
||||
channel = self.gw.remote_exec(source='''
|
||||
channel.send(42)
|
||||
''')
|
||||
channel.setcallback(callback)
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
assert l == [42]
|
||||
|
||||
def test_channel_callback_stays_active(self):
|
||||
self.check_channel_callback_stays_active(earlyfree=True)
|
||||
|
||||
def check_channel_callback_stays_active(self, earlyfree=True):
|
||||
# with 'earlyfree==True', this tests the "sendonly" channel state.
|
||||
l = []
|
||||
channel = self.gw.remote_exec(source='''
|
||||
try:
|
||||
import thread
|
||||
except ImportError:
|
||||
import _thread as thread
|
||||
import time
|
||||
def producer(subchannel):
|
||||
for i in range(5):
|
||||
time.sleep(0.15)
|
||||
subchannel.send(i*100)
|
||||
channel2 = channel.receive()
|
||||
thread.start_new_thread(producer, (channel2,))
|
||||
del channel2
|
||||
''')
|
||||
subchannel = self.gw.newchannel()
|
||||
subchannel.setcallback(l.append)
|
||||
channel.send(subchannel)
|
||||
if earlyfree:
|
||||
subchannel = None
|
||||
counter = 100
|
||||
while len(l) < 5:
|
||||
if subchannel and subchannel.isclosed():
|
||||
break
|
||||
counter -= 1
|
||||
print(counter)
|
||||
if not counter:
|
||||
py.test.fail("timed out waiting for the answer[%d]" % len(l))
|
||||
time.sleep(0.04) # busy-wait
|
||||
assert l == [0, 100, 200, 300, 400]
|
||||
return subchannel
|
||||
|
||||
def test_channel_callback_remote_freed(self):
|
||||
channel = self.check_channel_callback_stays_active(earlyfree=False)
|
||||
channel.waitclose(TESTTIMEOUT) # freed automatically at the end of producer()
|
||||
|
||||
def test_channel_endmarker_callback(self):
|
||||
l = []
|
||||
channel = self.gw.remote_exec(source='''
|
||||
channel.send(42)
|
||||
channel.send(13)
|
||||
channel.send(channel.gateway.newchannel())
|
||||
''')
|
||||
channel.setcallback(l.append, 999)
|
||||
py.test.raises(IOError, channel.receive)
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
assert len(l) == 4
|
||||
assert l[:2] == [42,13]
|
||||
assert isinstance(l[2], channel.__class__)
|
||||
assert l[3] == 999
|
||||
|
||||
def test_channel_endmarker_callback_error(self):
|
||||
q = queue.Queue()
|
||||
channel = self.gw.remote_exec(source='''
|
||||
raise ValueError()
|
||||
''')
|
||||
channel.setcallback(q.put, endmarker=999)
|
||||
val = q.get(TESTTIMEOUT)
|
||||
assert val == 999
|
||||
err = channel._getremoteerror()
|
||||
assert err
|
||||
assert str(err).find("ValueError") != -1
|
||||
|
||||
@py.test.mark.xfail
|
||||
def test_remote_redirect_stdout(self):
|
||||
out = py.io.TextIO()
|
||||
handle = self.gw._remote_redirect(stdout=out)
|
||||
c = self.gw.remote_exec("print 42")
|
||||
c.waitclose(TESTTIMEOUT)
|
||||
handle.close()
|
||||
s = out.getvalue()
|
||||
assert s.strip() == "42"
|
||||
|
||||
@py.test.mark.xfail
|
||||
def test_remote_exec_redirect_multi(self):
|
||||
num = 3
|
||||
l = [[] for x in range(num)]
|
||||
channels = [self.gw.remote_exec("print %d" % i,
|
||||
stdout=l[i].append)
|
||||
for i in range(num)]
|
||||
for x in channels:
|
||||
x.waitclose(TESTTIMEOUT)
|
||||
|
||||
for i in range(num):
|
||||
subl = l[i]
|
||||
assert subl
|
||||
s = subl[0]
|
||||
assert s.strip() == str(i)
|
||||
|
||||
def test_channel_file_write(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
f = channel.makefile()
|
||||
f.write("hello world\\n")
|
||||
f.close()
|
||||
channel.send(42)
|
||||
""")
|
||||
first = channel.receive()
|
||||
assert first.strip() == 'hello world'
|
||||
second = channel.receive()
|
||||
assert second == 42
|
||||
|
||||
def test_channel_file_write_error(self):
|
||||
channel = self.gw.remote_exec("pass")
|
||||
f = channel.makefile()
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
py.test.raises(IOError, f.write, 'hello')
|
||||
|
||||
def test_channel_file_proxyclose(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
f = channel.makefile(proxyclose=True)
|
||||
f.write("hello world")
|
||||
f.close()
|
||||
channel.send(42)
|
||||
""")
|
||||
first = channel.receive()
|
||||
assert first.strip() == 'hello world'
|
||||
py.test.raises(EOFError, channel.receive)
|
||||
|
||||
def test_channel_file_read(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
f = channel.makefile(mode='r')
|
||||
s = f.read(2)
|
||||
channel.send(s)
|
||||
s = f.read(5)
|
||||
channel.send(s)
|
||||
""")
|
||||
channel.send("xyabcde")
|
||||
s1 = channel.receive()
|
||||
s2 = channel.receive()
|
||||
assert s1 == "xy"
|
||||
assert s2 == "abcde"
|
||||
|
||||
def test_channel_file_read_empty(self):
|
||||
channel = self.gw.remote_exec("pass")
|
||||
f = channel.makefile(mode="r")
|
||||
s = f.read(3)
|
||||
assert s == ""
|
||||
s = f.read(5)
|
||||
assert s == ""
|
||||
|
||||
def test_channel_file_readline_remote(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
channel.send('123\\n45')
|
||||
""")
|
||||
channel.waitclose(TESTTIMEOUT)
|
||||
f = channel.makefile(mode="r")
|
||||
s = f.readline()
|
||||
assert s == "123\n"
|
||||
s = f.readline()
|
||||
assert s == "45"
|
||||
|
||||
def test_channel_makefile_incompatmode(self):
|
||||
channel = self.gw.newchannel()
|
||||
py.test.raises(ValueError, 'channel.makefile("rw")')
|
||||
|
||||
def test_confusion_from_os_write_stdout(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
import os
|
||||
os.write(1, 'confusion!'.encode('ascii'))
|
||||
channel.send(channel.receive() * 6)
|
||||
channel.send(channel.receive() * 6)
|
||||
""")
|
||||
channel.send(3)
|
||||
res = channel.receive()
|
||||
assert res == 18
|
||||
channel.send(7)
|
||||
res = channel.receive()
|
||||
assert res == 42
|
||||
|
||||
def test_confusion_from_os_write_stderr(self):
|
||||
channel = self.gw.remote_exec("""
|
||||
import os
|
||||
os.write(2, 'test'.encode('ascii'))
|
||||
channel.send(channel.receive() * 6)
|
||||
channel.send(channel.receive() * 6)
|
||||
""")
|
||||
channel.send(3)
|
||||
res = channel.receive()
|
||||
assert res == 18
|
||||
channel.send(7)
|
||||
res = channel.receive()
|
||||
assert res == 42
|
||||
|
||||
def test__rinfo(self):
|
||||
rinfo = self.gw._rinfo()
|
||||
assert rinfo.executable
|
||||
assert rinfo.cwd
|
||||
assert rinfo.version_info
|
||||
s = repr(rinfo)
|
||||
old = self.gw.remote_exec("""
|
||||
import os.path
|
||||
cwd = os.getcwd()
|
||||
channel.send(os.path.basename(cwd))
|
||||
os.chdir('..')
|
||||
""").receive()
|
||||
try:
|
||||
rinfo2 = self.gw._rinfo()
|
||||
assert rinfo2.cwd == rinfo.cwd
|
||||
rinfo3 = self.gw._rinfo(update=True)
|
||||
assert rinfo3.cwd != rinfo2.cwd
|
||||
finally:
|
||||
self.gw._cache_rinfo = rinfo
|
||||
self.gw.remote_exec("import os ; os.chdir(%r)" % old).waitclose()
|
||||
|
||||
class BasicCmdbasedRemoteExecution(BasicRemoteExecution):
|
||||
def test_cmdattr(self):
|
||||
assert hasattr(self.gw, '_cmd')
|
||||
|
||||
#class TestBlockingIssues:
|
||||
# def test_join_blocked_execution_gateway(self):
|
||||
# gateway = py.execnet.PopenGateway()
|
||||
# channel = gateway.remote_exec("""
|
||||
# time.sleep(5.0)
|
||||
# """)
|
||||
# def doit():
|
||||
# gateway.exit()
|
||||
# gateway.join(joinexec=True)
|
||||
# return 17
|
||||
#
|
||||
# pool = py._thread.WorkerPool()
|
||||
# reply = pool.dispatch(doit)
|
||||
# x = reply.get(timeout=1.0)
|
||||
# assert x == 17
|
||||
|
||||
class TestPopenGateway(PopenGatewayTestSetup, BasicRemoteExecution):
|
||||
def test_rinfo_popen(self):
|
||||
rinfo = self.gw._rinfo()
|
||||
assert rinfo.executable == py.std.sys.executable
|
||||
assert rinfo.cwd == py.std.os.getcwd()
|
||||
assert rinfo.version_info == py.std.sys.version_info
|
||||
|
||||
def test_chdir_separation(self, tmpdir):
|
||||
old = tmpdir.chdir()
|
||||
try:
|
||||
gw = py.execnet.PopenGateway()
|
||||
finally:
|
||||
waschangedir = old.chdir()
|
||||
c = gw.remote_exec("import os ; channel.send(os.getcwd())")
|
||||
x = c.receive()
|
||||
assert x == str(waschangedir)
|
||||
|
||||
def test_many_popen(self):
|
||||
num = 4
|
||||
l = []
|
||||
for i in range(num):
|
||||
l.append(py.execnet.PopenGateway())
|
||||
channels = []
|
||||
for gw in l:
|
||||
channel = gw.remote_exec("""channel.send(42)""")
|
||||
channels.append(channel)
|
||||
## try:
|
||||
## while channels:
|
||||
## channel = channels.pop()
|
||||
## try:
|
||||
## ret = channel.receive()
|
||||
## assert ret == 42
|
||||
## finally:
|
||||
## channel.gateway.exit()
|
||||
## finally:
|
||||
## for x in channels:
|
||||
## x.gateway.exit()
|
||||
while channels:
|
||||
channel = channels.pop()
|
||||
ret = channel.receive()
|
||||
assert ret == 42
|
||||
|
||||
@py.test.mark.xfail # "fix needed: dying remote process does not cause waitclose() to fail"
|
||||
def test_waitclose_on_remote_killed(self):
|
||||
gw = py.execnet.PopenGateway()
|
||||
channel = gw.remote_exec("""
|
||||
import os
|
||||
import time
|
||||
channel.send(os.getpid())
|
||||
while 1:
|
||||
channel.send("#" * 100)
|
||||
""")
|
||||
remotepid = channel.receive()
|
||||
py.process.kill(remotepid)
|
||||
py.test.raises(channel.RemoteError, "channel.waitclose(TESTTIMEOUT)")
|
||||
py.test.raises(EOFError, channel.send, None)
|
||||
py.test.raises(EOFError, channel.receive)
|
||||
|
||||
@py.test.mark.xfail
|
||||
def test_endmarker_delivery_on_remote_killterm():
|
||||
if not hasattr(py.std.os, 'kill'):
|
||||
py.test.skip("no os.kill()")
|
||||
gw = py.execnet.PopenGateway()
|
||||
try:
|
||||
q = queue.Queue()
|
||||
channel = gw.remote_exec(source='''
|
||||
import os
|
||||
os.kill(os.getpid(), 15)
|
||||
''')
|
||||
channel.setcallback(q.put, endmarker=999)
|
||||
val = q.get(TESTTIMEOUT)
|
||||
assert val == 999
|
||||
err = channel._getremoteerror()
|
||||
finally:
|
||||
gw.exit()
|
||||
assert "killed" in str(err)
|
||||
assert "15" in str(err)
|
||||
|
||||
|
||||
class SocketGatewaySetup:
|
||||
def setup_class(cls):
|
||||
# open a gateway to a fresh child process
|
||||
cls.proxygw = py.execnet.PopenGateway()
|
||||
cls.gw = py.execnet.SocketGateway.new_remote(cls.proxygw,
|
||||
("127.0.0.1", 0)
|
||||
)
|
||||
def test_host_not_found(self):
|
||||
py.test.raises(py.execnet.HostNotFound,
|
||||
'py.execnet.SocketGateway("qowieuqowe", 9000)'
|
||||
)
|
||||
|
||||
## def teardown_class(cls):
|
||||
## cls.gw.exit()
|
||||
## cls.proxygw.exit()
|
||||
|
||||
class TestSocketGateway(SocketGatewaySetup, BasicRemoteExecution):
|
||||
pass
|
||||
|
||||
class TestSshGateway(BasicRemoteExecution):
|
||||
def setup_class(cls):
|
||||
from py.__.conftest import getspecssh
|
||||
cls.sshhost = getspecssh().ssh
|
||||
cls.gw = py.execnet.SshGateway(cls.sshhost)
|
||||
|
||||
def test_sshconfig_functional(self, tmpdir):
|
||||
ssh_config = tmpdir.join("ssh_config")
|
||||
ssh_config.write(
|
||||
"Host alias123\n"
|
||||
" HostName %s\n" % self.sshhost)
|
||||
gw = py.execnet.SshGateway("alias123", ssh_config=ssh_config)
|
||||
pid = gw.remote_exec("import os ; channel.send(os.getpid())").receive()
|
||||
gw.exit()
|
||||
|
||||
def test_sshaddress(self):
|
||||
assert self.gw.remoteaddress == self.sshhost
|
||||
|
||||
def test_connexion_failes_on_non_existing_hosts(self):
|
||||
py.test.raises(py.execnet.HostNotFound,
|
||||
"py.execnet.SshGateway('nowhere.codespeak.net')")
|
||||
|
||||
def test_threads():
|
||||
gw = py.execnet.PopenGateway()
|
||||
gw.remote_init_threads(3)
|
||||
c1 = gw.remote_exec("channel.send(channel.receive())")
|
||||
c2 = gw.remote_exec("channel.send(channel.receive())")
|
||||
c2.send(1)
|
||||
res = c2.receive()
|
||||
assert res == 1
|
||||
c1.send(42)
|
||||
res = c1.receive()
|
||||
assert res == 42
|
||||
gw.exit()
|
||||
|
||||
def test_threads_twice():
|
||||
gw = py.execnet.PopenGateway()
|
||||
gw.remote_init_threads(3)
|
||||
py.test.raises(IOError, gw.remote_init_threads, 3)
|
||||
gw.exit()
|
||||
|
||||
class TestExecnetEvents:
|
||||
def test_popengateway(self, _pytest):
|
||||
rec = _pytest.gethookrecorder(gateway_base.ExecnetAPI)
|
||||
gw = py.execnet.PopenGateway()
|
||||
call = rec.popcall("pyexecnet_gateway_init")
|
||||
assert call.gateway == gw
|
||||
gw.exit()
|
||||
call = rec.popcall("pyexecnet_gateway_exit")
|
||||
assert call.gateway == gw
|
||||
|
||||
def test_nodebug():
|
||||
from py.__.execnet import gateway_base
|
||||
assert not gateway_base.debug
|
||||
@@ -1,151 +0,0 @@
|
||||
"""
|
||||
tests for
|
||||
- gateway management
|
||||
- manage rsyncing of hosts
|
||||
|
||||
"""
|
||||
|
||||
import py
|
||||
import os
|
||||
from py.__.execnet.gwmanage import GatewayManager, HostRSync
|
||||
|
||||
class TestGatewayManagerPopen:
|
||||
def test_popen_no_default_chdir(self):
|
||||
gm = GatewayManager(["popen"])
|
||||
assert gm.specs[0].chdir is None
|
||||
|
||||
def test_default_chdir(self):
|
||||
l = ["ssh=noco", "socket=xyz"]
|
||||
for spec in GatewayManager(l).specs:
|
||||
assert spec.chdir == "pyexecnetcache"
|
||||
for spec in GatewayManager(l, defaultchdir="abc").specs:
|
||||
assert spec.chdir == "abc"
|
||||
|
||||
def test_popen_makegateway_events(self, _pytest):
|
||||
rec = _pytest.gethookrecorder(py.execnet._HookSpecs)
|
||||
hm = GatewayManager(["popen"] * 2)
|
||||
hm.makegateways()
|
||||
call = rec.popcall("pyexecnet_gwmanage_newgateway")
|
||||
assert call.gateway.id == "[1]"
|
||||
assert call.platinfo.executable == call.gateway._rinfo().executable
|
||||
call = rec.popcall("pyexecnet_gwmanage_newgateway")
|
||||
assert call.gateway.id == "[2]"
|
||||
assert len(hm.gateways) == 2
|
||||
hm.exit()
|
||||
assert not len(hm.gateways)
|
||||
|
||||
def test_popens_rsync(self, mysetup):
|
||||
source = mysetup.source
|
||||
hm = GatewayManager(["popen"] * 2)
|
||||
hm.makegateways()
|
||||
assert len(hm.gateways) == 2
|
||||
for gw in hm.gateways:
|
||||
gw.remote_exec = None
|
||||
l = []
|
||||
hm.rsync(source, notify=lambda *args: l.append(args))
|
||||
assert not l
|
||||
hm.exit()
|
||||
assert not len(hm.gateways)
|
||||
|
||||
def test_rsync_popen_with_path(self, mysetup):
|
||||
source, dest = mysetup.source, mysetup.dest
|
||||
hm = GatewayManager(["popen//chdir=%s" %dest] * 1)
|
||||
hm.makegateways()
|
||||
source.ensure("dir1", "dir2", "hello")
|
||||
l = []
|
||||
hm.rsync(source, notify=lambda *args: l.append(args))
|
||||
assert len(l) == 1
|
||||
assert l[0] == ("rsyncrootready", hm.gateways[0].spec, source)
|
||||
hm.exit()
|
||||
dest = dest.join(source.basename)
|
||||
assert dest.join("dir1").check()
|
||||
assert dest.join("dir1", "dir2").check()
|
||||
assert dest.join("dir1", "dir2", 'hello').check()
|
||||
|
||||
def test_hostmanage_rsync_same_popen_twice(self, mysetup, _pytest):
|
||||
source, dest = mysetup.source, mysetup.dest
|
||||
rec = _pytest.gethookrecorder(py.execnet._HookSpecs)
|
||||
hm = GatewayManager(["popen//chdir=%s" %dest] * 2)
|
||||
hm.makegateways()
|
||||
source.ensure("dir1", "dir2", "hello")
|
||||
hm.rsync(source)
|
||||
call = rec.popcall("pyexecnet_gwmanage_rsyncstart")
|
||||
assert call.source == source
|
||||
assert len(call.gateways) == 1
|
||||
assert hm.gateways[0] == call.gateways[0]
|
||||
call = rec.popcall("pyexecnet_gwmanage_rsyncfinish")
|
||||
|
||||
def test_multi_chdir_popen_with_path(self, testdir):
|
||||
hm = GatewayManager(["popen//chdir=hello"] * 2)
|
||||
testdir.tmpdir.chdir()
|
||||
hellopath = testdir.tmpdir.mkdir("hello").realpath()
|
||||
hm.makegateways()
|
||||
l = hm.multi_exec(
|
||||
"import os ; channel.send(os.getcwd())").receive_each()
|
||||
paths = [x[1] for x in l]
|
||||
assert l == [str(hellopath)] * 2
|
||||
py.test.raises(hm.RemoteError,
|
||||
'hm.multi_chdir("world", inplacelocal=False)')
|
||||
worldpath = hellopath.mkdir("world")
|
||||
hm.multi_chdir("world", inplacelocal=False)
|
||||
l = hm.multi_exec(
|
||||
"import os ; channel.send(os.getcwd())").receive_each()
|
||||
assert len(l) == 2
|
||||
assert l[0] == l[1]
|
||||
curwd = os.getcwd()
|
||||
assert l[0].startswith(curwd)
|
||||
assert l[0].endswith("world")
|
||||
|
||||
def test_multi_chdir_popen(self, testdir):
|
||||
import os
|
||||
hm = GatewayManager(["popen"] * 2)
|
||||
testdir.tmpdir.chdir()
|
||||
hellopath = testdir.tmpdir.mkdir("hello")
|
||||
hm.makegateways()
|
||||
hm.multi_chdir("hello", inplacelocal=False)
|
||||
l = hm.multi_exec("import os ; channel.send(os.getcwd())").receive_each()
|
||||
assert len(l) == 2
|
||||
curwd = os.path.realpath(os.getcwd())
|
||||
assert l == [curwd] * 2
|
||||
|
||||
hm.multi_chdir("hello")
|
||||
l = hm.multi_exec("import os ; channel.send(os.getcwd())").receive_each()
|
||||
assert len(l) == 2
|
||||
assert l[0] == l[1]
|
||||
assert l[0].startswith(curwd)
|
||||
assert l[0].endswith("hello")
|
||||
|
||||
class pytest_funcarg__mysetup:
|
||||
def __init__(self, request):
|
||||
tmp = request.getfuncargvalue('tmpdir')
|
||||
self.source = tmp.mkdir("source")
|
||||
self.dest = tmp.mkdir("dest")
|
||||
request.getfuncargvalue("_pytest") # to have patching of py._com.comregistry
|
||||
|
||||
class TestHRSync:
|
||||
def test_hrsync_filter(self, mysetup):
|
||||
source, dest = mysetup.source, mysetup.dest
|
||||
source.ensure("dir", "file.txt")
|
||||
source.ensure(".svn", "entries")
|
||||
source.ensure(".somedotfile", "moreentries")
|
||||
source.ensure("somedir", "editfile~")
|
||||
syncer = HostRSync(source)
|
||||
l = list(source.visit(rec=syncer.filter,
|
||||
fil=syncer.filter))
|
||||
assert len(l) == 3
|
||||
basenames = [x.basename for x in l]
|
||||
assert 'dir' in basenames
|
||||
assert 'file.txt' in basenames
|
||||
assert 'somedir' in basenames
|
||||
|
||||
def test_hrsync_one_host(self, mysetup):
|
||||
source, dest = mysetup.source, mysetup.dest
|
||||
gw = py.execnet.makegateway("popen//chdir=%s" % dest)
|
||||
finished = []
|
||||
rsync = HostRSync(source)
|
||||
rsync.add_target_host(gw, finished=lambda: finished.append(1))
|
||||
source.join("hello.py").write("world")
|
||||
rsync.send()
|
||||
gw.exit()
|
||||
assert dest.join(source.basename, "hello.py").check()
|
||||
assert len(finished) == 1
|
||||
@@ -1,58 +0,0 @@
|
||||
"""
|
||||
tests for
|
||||
- multi channels and multi gateways
|
||||
|
||||
"""
|
||||
|
||||
import py
|
||||
|
||||
class TestMultiChannelAndGateway:
|
||||
def test_multichannel_receive_each(self):
|
||||
class pseudochannel:
|
||||
def receive(self):
|
||||
return 12
|
||||
|
||||
pc1 = pseudochannel()
|
||||
pc2 = pseudochannel()
|
||||
multichannel = py.execnet.MultiChannel([pc1, pc2])
|
||||
l = multichannel.receive_each(withchannel=True)
|
||||
assert len(l) == 2
|
||||
assert l == [(pc1, 12), (pc2, 12)]
|
||||
l = multichannel.receive_each(withchannel=False)
|
||||
assert l == [12,12]
|
||||
|
||||
def test_multichannel_send_each(self):
|
||||
l = [py.execnet.PopenGateway() for x in range(2)]
|
||||
gm = py.execnet.MultiGateway(l)
|
||||
mc = gm.remote_exec("""
|
||||
import os
|
||||
channel.send(channel.receive() + 1)
|
||||
""")
|
||||
mc.send_each(41)
|
||||
l = mc.receive_each()
|
||||
assert l == [42,42]
|
||||
|
||||
def test_multichannel_receive_queue_for_two_subprocesses(self):
|
||||
l = [py.execnet.PopenGateway() for x in range(2)]
|
||||
gm = py.execnet.MultiGateway(l)
|
||||
mc = gm.remote_exec("""
|
||||
import os
|
||||
channel.send(os.getpid())
|
||||
""")
|
||||
queue = mc.make_receive_queue()
|
||||
ch, item = queue.get(timeout=10)
|
||||
ch2, item2 = queue.get(timeout=10)
|
||||
assert ch != ch2
|
||||
assert ch.gateway != ch2.gateway
|
||||
assert item != item2
|
||||
mc.waitclose()
|
||||
|
||||
def test_multichannel_waitclose(self):
|
||||
l = []
|
||||
class pseudochannel:
|
||||
def waitclose(self):
|
||||
l.append(0)
|
||||
multichannel = py.execnet.MultiChannel([pseudochannel(), pseudochannel()])
|
||||
multichannel.waitclose()
|
||||
assert len(l) == 2
|
||||
|
||||
@@ -1,148 +0,0 @@
|
||||
import py
|
||||
from py.execnet import RSync
|
||||
|
||||
|
||||
def pytest_funcarg__gw1(request):
|
||||
return request.cached_setup(
|
||||
setup=py.execnet.PopenGateway,
|
||||
teardown=lambda val: val.exit(),
|
||||
scope="module"
|
||||
)
|
||||
pytest_funcarg__gw2 = pytest_funcarg__gw1
|
||||
|
||||
def pytest_funcarg__dirs(request):
|
||||
t = request.getfuncargvalue('tmpdir')
|
||||
class dirs:
|
||||
source = t.join("source")
|
||||
dest1 = t.join("dest1")
|
||||
dest2 = t.join("dest2")
|
||||
return dirs
|
||||
|
||||
class TestRSync:
|
||||
def test_notargets(self, dirs):
|
||||
rsync = RSync(dirs.source)
|
||||
py.test.raises(IOError, "rsync.send()")
|
||||
assert rsync.send(raises=False) is None
|
||||
|
||||
def test_dirsync(self, dirs, gw1, gw2):
|
||||
dest = dirs.dest1
|
||||
dest2 = dirs.dest2
|
||||
source = dirs.source
|
||||
|
||||
for s in ('content1', 'content2', 'content2-a-bit-longer'):
|
||||
source.ensure('subdir', 'file1').write(s)
|
||||
rsync = RSync(dirs.source)
|
||||
rsync.add_target(gw1, dest)
|
||||
rsync.add_target(gw2, dest2)
|
||||
rsync.send()
|
||||
assert dest.join('subdir').check(dir=1)
|
||||
assert dest.join('subdir', 'file1').check(file=1)
|
||||
assert dest.join('subdir', 'file1').read() == s
|
||||
assert dest2.join('subdir').check(dir=1)
|
||||
assert dest2.join('subdir', 'file1').check(file=1)
|
||||
assert dest2.join('subdir', 'file1').read() == s
|
||||
for x in dest, dest2:
|
||||
fn = x.join("subdir", "file1")
|
||||
fn.setmtime(0)
|
||||
|
||||
source.join('subdir').remove('file1')
|
||||
rsync = RSync(source)
|
||||
rsync.add_target(gw2, dest2)
|
||||
rsync.add_target(gw1, dest)
|
||||
rsync.send()
|
||||
assert dest.join('subdir', 'file1').check(file=1)
|
||||
assert dest2.join('subdir', 'file1').check(file=1)
|
||||
rsync = RSync(source)
|
||||
rsync.add_target(gw1, dest, delete=True)
|
||||
rsync.add_target(gw2, dest2)
|
||||
rsync.send()
|
||||
assert not dest.join('subdir', 'file1').check()
|
||||
assert dest2.join('subdir', 'file1').check()
|
||||
|
||||
def test_dirsync_twice(self, dirs, gw1, gw2):
|
||||
source = dirs.source
|
||||
source.ensure("hello")
|
||||
rsync = RSync(source)
|
||||
rsync.add_target(gw1, dirs.dest1)
|
||||
rsync.send()
|
||||
assert dirs.dest1.join('hello').check()
|
||||
py.test.raises(IOError, "rsync.send()")
|
||||
assert rsync.send(raises=False) is None
|
||||
rsync.add_target(gw1, dirs.dest2)
|
||||
rsync.send()
|
||||
assert dirs.dest2.join('hello').check()
|
||||
py.test.raises(IOError, "rsync.send()")
|
||||
assert rsync.send(raises=False) is None
|
||||
|
||||
def test_rsync_default_reporting(self, capsys, dirs, gw1):
|
||||
source = dirs.source
|
||||
source.ensure("hello")
|
||||
rsync = RSync(source)
|
||||
rsync.add_target(gw1, dirs.dest1)
|
||||
rsync.send()
|
||||
out, err = capsys.readouterr()
|
||||
assert out.find("hello") != -1
|
||||
|
||||
def test_rsync_non_verbose(self, capsys, dirs, gw1):
|
||||
source = dirs.source
|
||||
source.ensure("hello")
|
||||
rsync = RSync(source, verbose=False)
|
||||
rsync.add_target(gw1, dirs.dest1)
|
||||
rsync.send()
|
||||
out, err = capsys.readouterr()
|
||||
assert not out
|
||||
assert not err
|
||||
|
||||
def test_symlink_rsync(self, dirs, gw1):
|
||||
if py.std.sys.platform == 'win32':
|
||||
py.test.skip("symlinks are unsupported on Windows.")
|
||||
source = dirs.source
|
||||
dest = dirs.dest1
|
||||
dirs.source.ensure("existant")
|
||||
source.join("rellink").mksymlinkto(source.join("existant"), absolute=0)
|
||||
source.join('abslink').mksymlinkto(source.join("existant"))
|
||||
|
||||
rsync = RSync(source)
|
||||
rsync.add_target(gw1, dest)
|
||||
rsync.send()
|
||||
|
||||
assert dest.join('rellink').readlink() == dest.join("existant")
|
||||
assert dest.join('abslink').readlink() == dest.join("existant")
|
||||
|
||||
def test_callback(self, dirs, gw1):
|
||||
dest = dirs.dest1
|
||||
source = dirs.source
|
||||
source.ensure("existant").write("a" * 100)
|
||||
source.ensure("existant2").write("a" * 10)
|
||||
total = {}
|
||||
def callback(cmd, lgt, channel):
|
||||
total[(cmd, lgt)] = True
|
||||
|
||||
rsync = RSync(source, callback=callback)
|
||||
#rsync = RSync()
|
||||
rsync.add_target(gw1, dest)
|
||||
rsync.send()
|
||||
|
||||
assert total == {("list", 110):True, ("ack", 100):True, ("ack", 10):True}
|
||||
|
||||
def test_file_disappearing(self, dirs, gw1):
|
||||
dest = dirs.dest1
|
||||
source = dirs.source
|
||||
source.ensure("ex").write("a" * 100)
|
||||
source.ensure("ex2").write("a" * 100)
|
||||
|
||||
class DRsync(RSync):
|
||||
def filter(self, x):
|
||||
assert x != source
|
||||
if x.endswith("ex2"):
|
||||
self.x = 1
|
||||
source.join("ex2").remove()
|
||||
return True
|
||||
|
||||
rsync = DRsync(source)
|
||||
rsync.add_target(gw1, dest)
|
||||
rsync.send()
|
||||
assert rsync.x == 1
|
||||
assert len(dest.listdir()) == 1
|
||||
assert len(source.listdir()) == 1
|
||||
|
||||
@@ -1,140 +0,0 @@
|
||||
import py
|
||||
|
||||
XSpec = py.execnet.XSpec
|
||||
|
||||
class TestXSpec:
|
||||
def test_norm_attributes(self):
|
||||
spec = XSpec("socket=192.168.102.2:8888//python=c:/this/python2.5//chdir=d:\hello")
|
||||
assert spec.socket == "192.168.102.2:8888"
|
||||
assert spec.python == "c:/this/python2.5"
|
||||
assert spec.chdir == "d:\hello"
|
||||
assert spec.nice is None
|
||||
assert not hasattr(spec, 'xyz')
|
||||
|
||||
py.test.raises(AttributeError, "spec._hello")
|
||||
|
||||
spec = XSpec("socket=192.168.102.2:8888//python=python2.5//nice=3")
|
||||
assert spec.socket == "192.168.102.2:8888"
|
||||
assert spec.python == "python2.5"
|
||||
assert spec.chdir is None
|
||||
assert spec.nice == "3"
|
||||
|
||||
spec = XSpec("ssh=user@host//chdir=/hello/this//python=/usr/bin/python2.5")
|
||||
assert spec.ssh == "user@host"
|
||||
assert spec.python == "/usr/bin/python2.5"
|
||||
assert spec.chdir == "/hello/this"
|
||||
|
||||
spec = XSpec("popen")
|
||||
assert spec.popen == True
|
||||
|
||||
def test__samefilesystem(self):
|
||||
assert XSpec("popen")._samefilesystem()
|
||||
assert XSpec("popen//python=123")._samefilesystem()
|
||||
assert not XSpec("popen//chdir=hello")._samefilesystem()
|
||||
|
||||
def test__spec_spec(self):
|
||||
for x in ("popen", "popen//python=this"):
|
||||
assert XSpec(x)._spec == x
|
||||
|
||||
def test_repr_and_string(self):
|
||||
for x in ("popen", "popen//python=this"):
|
||||
assert repr(XSpec(x)).find("popen") != -1
|
||||
assert str(XSpec(x)) == x
|
||||
|
||||
def test_hash_equality(self):
|
||||
assert XSpec("popen") == XSpec("popen")
|
||||
assert hash(XSpec("popen")) == hash(XSpec("popen"))
|
||||
assert XSpec("popen//python=123") != XSpec("popen")
|
||||
assert hash(XSpec("socket=hello:8080")) != hash(XSpec("popen"))
|
||||
|
||||
class TestMakegateway:
|
||||
def test_popen(self):
|
||||
gw = py.execnet.makegateway("popen")
|
||||
assert gw.spec.python == None
|
||||
rinfo = gw._rinfo()
|
||||
assert rinfo.executable == py.std.sys.executable
|
||||
assert rinfo.cwd == py.std.os.getcwd()
|
||||
assert rinfo.version_info == py.std.sys.version_info
|
||||
|
||||
def test_popen_nice(self):
|
||||
gw = py.execnet.makegateway("popen//nice=5")
|
||||
remotenice = gw.remote_exec("""
|
||||
import os
|
||||
if hasattr(os, 'nice'):
|
||||
channel.send(os.nice(0))
|
||||
else:
|
||||
channel.send(None)
|
||||
""").receive()
|
||||
if remotenice is not None:
|
||||
assert remotenice == 5
|
||||
|
||||
def test_popen_explicit(self):
|
||||
gw = py.execnet.makegateway("popen//python=%s" % py.std.sys.executable)
|
||||
assert gw.spec.python == py.std.sys.executable
|
||||
rinfo = gw._rinfo()
|
||||
assert rinfo.executable == py.std.sys.executable
|
||||
assert rinfo.cwd == py.std.os.getcwd()
|
||||
assert rinfo.version_info == py.std.sys.version_info
|
||||
|
||||
def test_popen_cpython24(self):
|
||||
for trypath in ('python2.4', r'C:\Python24\python.exe'):
|
||||
cpython24 = py.path.local.sysfind(trypath)
|
||||
if cpython24 is not None:
|
||||
cpython24 = cpython24.realpath()
|
||||
break
|
||||
else:
|
||||
py.test.skip("cpython2.4 not found")
|
||||
gw = py.execnet.makegateway("popen//python=%s" % cpython24)
|
||||
rinfo = gw._rinfo()
|
||||
if py.std.sys.platform != "darwin": # it's confusing there
|
||||
assert rinfo.executable == cpython24
|
||||
assert rinfo.cwd == py.std.os.getcwd()
|
||||
assert rinfo.version_info[:2] == (2,4)
|
||||
|
||||
def test_popen_cpython26(self):
|
||||
for trypath in ('python2.6', r'C:\Python26\python.exe'):
|
||||
cpython26 = py.path.local.sysfind(trypath)
|
||||
if cpython26 is not None:
|
||||
break
|
||||
else:
|
||||
py.test.skip("cpython2.6 not found")
|
||||
gw = py.execnet.makegateway("popen//python=%s" % cpython26)
|
||||
rinfo = gw._rinfo()
|
||||
assert rinfo.executable == cpython26
|
||||
assert rinfo.cwd == py.std.os.getcwd()
|
||||
assert rinfo.version_info[:2] == (2,6)
|
||||
|
||||
def test_popen_chdir_absolute(self, testdir):
|
||||
gw = py.execnet.makegateway("popen//chdir=%s" % testdir.tmpdir)
|
||||
rinfo = gw._rinfo()
|
||||
assert rinfo.cwd == str(testdir.tmpdir.realpath())
|
||||
|
||||
def test_popen_chdir_newsub(self, testdir):
|
||||
testdir.chdir()
|
||||
gw = py.execnet.makegateway("popen//chdir=hello")
|
||||
rinfo = gw._rinfo()
|
||||
assert rinfo.cwd == str(testdir.tmpdir.join("hello").realpath())
|
||||
|
||||
def test_ssh(self, specssh):
|
||||
sshhost = specssh.ssh
|
||||
gw = py.execnet.makegateway("ssh=%s" % sshhost)
|
||||
rinfo = gw._rinfo()
|
||||
gw2 = py.execnet.SshGateway(sshhost)
|
||||
rinfo2 = gw2._rinfo()
|
||||
assert rinfo.executable == rinfo2.executable
|
||||
assert rinfo.cwd == rinfo2.cwd
|
||||
assert rinfo.version_info == rinfo2.version_info
|
||||
|
||||
def test_socket(self, specsocket):
|
||||
gw = py.execnet.makegateway("socket=%s" % specsocket.socket)
|
||||
rinfo = gw._rinfo()
|
||||
assert rinfo.executable
|
||||
assert rinfo.cwd
|
||||
assert rinfo.version_info
|
||||
# we cannot instantiate a second gateway
|
||||
|
||||
#gw2 = py.execnet.SocketGateway(*specsocket.socket.split(":"))
|
||||
#rinfo2 = gw2._rinfo()
|
||||
#assert rinfo.executable == rinfo2.executable
|
||||
#assert rinfo.cwd == rinfo2.cwd
|
||||
#assert rinfo.version_info == rinfo2.version_info
|
||||
Reference in New Issue
Block a user