holger krekel
parent
04c41cb672
commit
22282eedb9
|
|
@ -1,6 +0,0 @@
|
||||||
|
|
||||||
|
|
||||||
py.test --dist=each $* \
|
|
||||||
--tx 'socket=192.168.1.106:8888'
|
|
||||||
#--tx 'popen//python=python2.6' \
|
|
||||||
#--tx 'ssh=noco//python=/usr/local/bin/python2.4//chdir=/tmp/pytest-python2.4' \
|
|
||||||
|
|
@ -1,76 +0,0 @@
|
||||||
#!/usr/bin/env python
|
|
||||||
|
|
||||||
import py
|
|
||||||
import inspect
|
|
||||||
import types
|
|
||||||
|
|
||||||
def report_strange_docstring(name, obj):
|
|
||||||
if obj.__doc__ is None:
|
|
||||||
print "%s misses a docstring" % (name, )
|
|
||||||
elif obj.__doc__ == "":
|
|
||||||
print "%s has an empty" % (name, )
|
|
||||||
elif "XXX" in obj.__doc__:
|
|
||||||
print "%s has an 'XXX' in its docstring" % (name, )
|
|
||||||
|
|
||||||
def find_code(method):
|
|
||||||
return getattr(getattr(method, "im_func", None), "func_code", None)
|
|
||||||
|
|
||||||
def report_different_parameter_names(name, cls):
|
|
||||||
bases = cls.__mro__
|
|
||||||
for base in bases:
|
|
||||||
for attr in dir(base):
|
|
||||||
meth1 = getattr(base, attr)
|
|
||||||
code1 = find_code(meth1)
|
|
||||||
if code1 is None:
|
|
||||||
continue
|
|
||||||
if not callable(meth1):
|
|
||||||
continue
|
|
||||||
if not hasattr(cls, attr):
|
|
||||||
continue
|
|
||||||
meth2 = getattr(cls, attr)
|
|
||||||
code2 = find_code(meth2)
|
|
||||||
if not callable(meth2):
|
|
||||||
continue
|
|
||||||
if code2 is None:
|
|
||||||
continue
|
|
||||||
args1 = inspect.getargs(code1)[0]
|
|
||||||
args2 = inspect.getargs(code2)[0]
|
|
||||||
for a1, a2 in zip(args1, args2):
|
|
||||||
if a1 != a2:
|
|
||||||
print "%s.%s have different argument names %s, %s than the version in %s" % (name, attr, a1, a2, base)
|
|
||||||
|
|
||||||
|
|
||||||
def find_all_exported():
|
|
||||||
stack = [(name, getattr(py, name)) for name in dir(py)[::-1]
|
|
||||||
if not name.startswith("_") and name != "compat"]
|
|
||||||
seen = {}
|
|
||||||
exported = []
|
|
||||||
while stack:
|
|
||||||
name, obj = stack.pop()
|
|
||||||
if id(obj) in seen:
|
|
||||||
continue
|
|
||||||
else:
|
|
||||||
seen[id(obj)] = True
|
|
||||||
exported.append((name, obj))
|
|
||||||
if isinstance(obj, type) or isinstance(obj, type(py)):
|
|
||||||
stack.extend([("%s.%s" % (name, s), getattr(obj, s)) for s in dir(obj)
|
|
||||||
if len(s) <= 1 or not (s[0] == '_' and s[1] != '_')])
|
|
||||||
return exported
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
if __name__ == '__main__':
|
|
||||||
all_exported = find_all_exported()
|
|
||||||
print "strange docstrings"
|
|
||||||
print "=================="
|
|
||||||
print
|
|
||||||
for name, obj in all_exported:
|
|
||||||
if callable(obj):
|
|
||||||
report_strange_docstring(name, obj)
|
|
||||||
print "\n\ndifferent parameters"
|
|
||||||
print "===================="
|
|
||||||
print
|
|
||||||
for name, obj in all_exported:
|
|
||||||
if isinstance(obj, type):
|
|
||||||
report_different_parameter_names(name, obj)
|
|
||||||
|
|
||||||
|
|
@ -1,25 +0,0 @@
|
||||||
#!/usr/bin/env python
|
|
||||||
|
|
||||||
XXX
|
|
||||||
|
|
||||||
import sys
|
|
||||||
import os
|
|
||||||
from _findpy import py
|
|
||||||
try:
|
|
||||||
import apigen
|
|
||||||
except ImportError:
|
|
||||||
print 'Can not find apigen - make sure PYTHONPATH is set correctly!'
|
|
||||||
py.std.sys.exit()
|
|
||||||
else:
|
|
||||||
args = list(sys.argv[1:])
|
|
||||||
args.extend(['-p', 'apigen'])
|
|
||||||
argkeys = [a.split('=')[0] for a in args]
|
|
||||||
if '--apigen' not in argkeys:
|
|
||||||
args.append('--apigen')
|
|
||||||
if '--apigenscript' not in argkeys:
|
|
||||||
fpath = os.path.join(
|
|
||||||
os.path.dirname(apigen.__file__), 'tool', 'py_build', 'build.py')
|
|
||||||
args.append('--apigenscript=%s' % (fpath,))
|
|
||||||
if '--apigenpath' not in argkeys:
|
|
||||||
args.append('--apigenpath=api')
|
|
||||||
py.test.cmdline.main(args)
|
|
||||||
|
|
@ -1,33 +0,0 @@
|
||||||
import py
|
|
||||||
|
|
||||||
bindir = py.path.local(__file__).dirpath().dirpath("bin")
|
|
||||||
assert bindir.check(), bindir
|
|
||||||
|
|
||||||
def getbasename(name):
|
|
||||||
assert name[:2] == "py"
|
|
||||||
return "py." + name[2:]
|
|
||||||
|
|
||||||
def genscript_unix(name):
|
|
||||||
basename = getbasename(name)
|
|
||||||
path = bindir.join(basename)
|
|
||||||
path.write(py.code.Source("""
|
|
||||||
#!/usr/bin/env python
|
|
||||||
from _findpy import py
|
|
||||||
py.cmdline.%s()
|
|
||||||
""" % name).strip())
|
|
||||||
path.chmod(0755)
|
|
||||||
|
|
||||||
def genscript_windows(name):
|
|
||||||
basename = getbasename(name)
|
|
||||||
winbasename = basename + ".cmd"
|
|
||||||
path = bindir.join("win32").join(winbasename)
|
|
||||||
path.write(py.code.Source("""
|
|
||||||
@echo off
|
|
||||||
python "%%~dp0\..\%s" %%*
|
|
||||||
""" % (basename)).strip())
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
for name in dir(py.cmdline):
|
|
||||||
if name[0] != "_":
|
|
||||||
genscript_unix(name)
|
|
||||||
genscript_windows(name)
|
|
||||||
|
|
@ -1,315 +0,0 @@
|
||||||
import sys
|
|
||||||
|
|
||||||
sys.path.insert(0, sys.argv[1])
|
|
||||||
import py
|
|
||||||
|
|
||||||
toolpath = py.path.local(__file__)
|
|
||||||
binpath = py.path.local(py.__file__).dirpath('bin')
|
|
||||||
|
|
||||||
def error(msg):
|
|
||||||
print >>sys.stderr, msg
|
|
||||||
raise SystemExit, 1
|
|
||||||
|
|
||||||
def reformat(text):
|
|
||||||
return " ".join(text.split())
|
|
||||||
|
|
||||||
class SetupWriter(object):
|
|
||||||
EXCLUDES = ("MANIFEST.in", "contrib")
|
|
||||||
|
|
||||||
def __init__(self, basedir, pkg, setuptools=False):
|
|
||||||
self.basedir = basedir
|
|
||||||
self.setuptools = setuptools
|
|
||||||
assert self.basedir.check()
|
|
||||||
self.pkg = pkg
|
|
||||||
self.meta = pkg.__pkg__
|
|
||||||
self.lines = []
|
|
||||||
self.allpaths = self.getallpath(self.basedir)
|
|
||||||
|
|
||||||
def getallpath(self, basedir):
|
|
||||||
contrib = self.basedir.join("contrib")
|
|
||||||
allpath = []
|
|
||||||
lines = py.process.cmdexec("hg st -mcan").split("\n")
|
|
||||||
for path in lines:
|
|
||||||
p = basedir.join(path)
|
|
||||||
assert p.check(), p
|
|
||||||
if not p.relto(contrib) and p != contrib and not self.isexcluded(p):
|
|
||||||
allpath.append(p)
|
|
||||||
return allpath
|
|
||||||
|
|
||||||
def append(self, string):
|
|
||||||
lines = string.split("\n")
|
|
||||||
while lines:
|
|
||||||
if not lines[0].strip():
|
|
||||||
lines.pop(0)
|
|
||||||
continue
|
|
||||||
break
|
|
||||||
if not lines:
|
|
||||||
self.lines.append("")
|
|
||||||
return
|
|
||||||
line = lines[0]
|
|
||||||
indent = len(line) - len(line.lstrip())
|
|
||||||
for line in lines:
|
|
||||||
if line.strip():
|
|
||||||
assert not line[:indent].strip(), line
|
|
||||||
line = line[indent:]
|
|
||||||
self.lines.append(line)
|
|
||||||
|
|
||||||
def write_winfuncs(self):
|
|
||||||
self.append('''
|
|
||||||
''')
|
|
||||||
|
|
||||||
def tip_info(self, indent=8):
|
|
||||||
old = self.basedir.chdir()
|
|
||||||
indent = " " * indent
|
|
||||||
try:
|
|
||||||
info = []
|
|
||||||
output = py.process.cmdexec(
|
|
||||||
"hg tip --template '" # tags: {tags}\n"
|
|
||||||
#"branch: {branches}\n"
|
|
||||||
"revision: {rev}:{node}\n'"
|
|
||||||
)
|
|
||||||
for line in output.split("\n"):
|
|
||||||
info.append("%s %s" %(indent, line.strip()))
|
|
||||||
return "\n".join(info)
|
|
||||||
finally:
|
|
||||||
old.chdir()
|
|
||||||
|
|
||||||
def setup_header(self):
|
|
||||||
#tooltime = "%s %s" %(py.std.time.asctime(), py.std.time.tzname[0])
|
|
||||||
toolname = toolpath.basename
|
|
||||||
#toolrevision = py.path.svnwc(toolpath).info().rev
|
|
||||||
|
|
||||||
pkgname = self.pkg.__name__
|
|
||||||
self.append('"""py lib / py.test setup.py file"""')
|
|
||||||
self.append('import os, sys')
|
|
||||||
self.append("from setuptools import setup")
|
|
||||||
|
|
||||||
def setup_trailer(self):
|
|
||||||
self.append('''
|
|
||||||
if __name__ == '__main__':
|
|
||||||
main()
|
|
||||||
''')
|
|
||||||
|
|
||||||
def setup_function(self):
|
|
||||||
params = self.__dict__.copy()
|
|
||||||
params.update(self.meta.__dict__)
|
|
||||||
self.append('long_description = """')
|
|
||||||
for line in params['long_description'].split('\n'):
|
|
||||||
self.append(line)
|
|
||||||
self.append('"""')
|
|
||||||
trunk = None
|
|
||||||
if params['version'] == 'trunk':
|
|
||||||
trunk = 'trunk'
|
|
||||||
self.append('trunk = %r' % trunk)
|
|
||||||
self.append('''
|
|
||||||
def main():
|
|
||||||
setup(
|
|
||||||
name=%(name)r,
|
|
||||||
description=%(description)r,
|
|
||||||
long_description = long_description,
|
|
||||||
version= trunk or %(version)r,
|
|
||||||
url=%(url)r,
|
|
||||||
license=%(license)r,
|
|
||||||
platforms=%(platforms)r,
|
|
||||||
author=%(author)r,
|
|
||||||
author_email=%(author_email)r,
|
|
||||||
''' % params)
|
|
||||||
indent = " " * 8
|
|
||||||
self.append_pprint(indent, entry_points={'console_scripts':self.getconsolescripts()})
|
|
||||||
self.append_pprint(indent, classifiers=self.meta.classifiers)
|
|
||||||
self.append_pprint(indent, packages=self.getpackages())
|
|
||||||
self.append_pprint(indent, package_data=self.getpackagedata())
|
|
||||||
self.append_pprint(indent, zip_safe=True)
|
|
||||||
self.append_pprint(indent, install_requires=['apipkg'])
|
|
||||||
self.lines.append(indent[4:] + ")\n")
|
|
||||||
|
|
||||||
def setup_scripts(self):
|
|
||||||
# XXX this was used for a different approach
|
|
||||||
not used
|
|
||||||
self.append("""
|
|
||||||
def getscripts():
|
|
||||||
if sys.platform == "win32":
|
|
||||||
base = "py/bin/win32/"
|
|
||||||
ext = ".cmd"
|
|
||||||
else:
|
|
||||||
base = "py/bin/"
|
|
||||||
ext = ""
|
|
||||||
l = []
|
|
||||||
for name in %r:
|
|
||||||
l.append(base + name + ext)
|
|
||||||
return l
|
|
||||||
""" % ([script.basename for script in binpath.listdir("py.*")]))
|
|
||||||
|
|
||||||
def append_pprint(self, indent, append=",", **kw):
|
|
||||||
for name, value in kw.items():
|
|
||||||
stringio = py.std.StringIO.StringIO()
|
|
||||||
value = py.std.pprint.pprint(value, stream=stringio)
|
|
||||||
stringio.seek(0)
|
|
||||||
lines = stringio.readlines()
|
|
||||||
line = lines.pop(0).rstrip()
|
|
||||||
self.lines.append(indent + "%s=%s" %(name, line))
|
|
||||||
indent = indent + " " * (len(name)+1)
|
|
||||||
for line in lines:
|
|
||||||
self.lines.append(indent + line.rstrip())
|
|
||||||
self.lines[-1] = self.lines[-1] + append
|
|
||||||
|
|
||||||
def getconsolescripts(self):
|
|
||||||
bindir = self.basedir.join('py', 'bin')
|
|
||||||
scripts = []
|
|
||||||
for p in self.allpaths:
|
|
||||||
if p.dirpath() == bindir:
|
|
||||||
if p.basename.startswith('py.'):
|
|
||||||
shortname = "py" + p.basename[3:]
|
|
||||||
scripts.append("%s = py.cmdline:%s" %
|
|
||||||
(p.basename, shortname))
|
|
||||||
return scripts
|
|
||||||
|
|
||||||
def getscripts(self):
|
|
||||||
bindir = self.basedir.join('py', 'bin')
|
|
||||||
scripts = []
|
|
||||||
for p in self.allpaths:
|
|
||||||
if p.dirpath() == bindir:
|
|
||||||
if p.basename.startswith('py.'):
|
|
||||||
scripts.append(p.relto(self.basedir))
|
|
||||||
return scripts
|
|
||||||
|
|
||||||
def getpackages(self):
|
|
||||||
packages = []
|
|
||||||
for p in self.allpaths: # contains no directories!
|
|
||||||
#if p.basename == "py":
|
|
||||||
# continue
|
|
||||||
if p.dirpath('__init__.py').check():
|
|
||||||
modpath = p.dirpath().relto(self.basedir).replace(p.sep, '.')
|
|
||||||
if modpath != "py" and not modpath.startswith("py."):
|
|
||||||
continue
|
|
||||||
if modpath in packages:
|
|
||||||
continue
|
|
||||||
for exclude in self.EXCLUDES:
|
|
||||||
if modpath.startswith(exclude):
|
|
||||||
print "EXCLUDING", modpath
|
|
||||||
break
|
|
||||||
else:
|
|
||||||
packages.append(modpath)
|
|
||||||
packages.sort()
|
|
||||||
return packages
|
|
||||||
|
|
||||||
def getpackagedata(self):
|
|
||||||
datafiles = []
|
|
||||||
pkgbase = self.basedir.join(self.pkg.__name__)
|
|
||||||
for p in self.allpaths:
|
|
||||||
if p.check(file=1) and (not p.dirpath("__init__.py").check()
|
|
||||||
or p.ext != ".py"):
|
|
||||||
if p.dirpath() != self.basedir:
|
|
||||||
x = p.relto(pkgbase)
|
|
||||||
if x:
|
|
||||||
datafiles.append(p.relto(pkgbase))
|
|
||||||
return {'py': datafiles}
|
|
||||||
|
|
||||||
def getdatafiles(self):
|
|
||||||
datafiles = []
|
|
||||||
for p in self.allpaths:
|
|
||||||
if p.check(file=1) and not p.ext == ".py":
|
|
||||||
if p.dirpath() != self.basedir:
|
|
||||||
datafiles.append(p.relto(self.basedir))
|
|
||||||
return datafiles
|
|
||||||
|
|
||||||
def setup_win32(self):
|
|
||||||
import winpath
|
|
||||||
self.append(py.std.inspect.getsource(winpath))
|
|
||||||
self.append("""
|
|
||||||
from distutils.command.install import install
|
|
||||||
class my_install(install):
|
|
||||||
def finalize_other(self):
|
|
||||||
install.finalize_other(self)
|
|
||||||
on_win32_add_to_PATH()
|
|
||||||
cmdclass = {'install': my_install}
|
|
||||||
""")
|
|
||||||
|
|
||||||
def setup_win32(self):
|
|
||||||
self.append(r'''
|
|
||||||
# scripts for windows: turn "py.SCRIPT" into "py_SCRIPT" and create
|
|
||||||
# "py.SCRIPT.cmd" files invoking "py_SCRIPT"
|
|
||||||
from distutils.command.install_scripts import install_scripts
|
|
||||||
class my_install_scripts(install_scripts):
|
|
||||||
def run(self):
|
|
||||||
install_scripts.run(self)
|
|
||||||
#print self.outfiles
|
|
||||||
for fn in self.outfiles:
|
|
||||||
basename = os.path.basename(fn)
|
|
||||||
if basename.startswith("py.") and not basename.endswith(".cmd"):
|
|
||||||
newbasename = basename.replace(".", "_")
|
|
||||||
newfn = os.path.join(os.path.dirname(fn), newbasename)
|
|
||||||
if os.path.exists(newfn):
|
|
||||||
os.remove(newfn)
|
|
||||||
os.rename(fn, newfn)
|
|
||||||
fncmd = fn + ".cmd"
|
|
||||||
if os.path.exists(fncmd):
|
|
||||||
os.remove(fncmd)
|
|
||||||
f = open(fncmd, 'w')
|
|
||||||
f.write("@echo off\n")
|
|
||||||
f.write('python "%%~dp0\%s" %%*' %(newbasename))
|
|
||||||
f.close()
|
|
||||||
if sys.platform == "win32":
|
|
||||||
cmdclass = {'install_scripts': my_install_scripts}
|
|
||||||
else:
|
|
||||||
cmdclass = {}
|
|
||||||
''')
|
|
||||||
|
|
||||||
def write_setup(self):
|
|
||||||
self.setup_header()
|
|
||||||
self.setup_function()
|
|
||||||
#self.setup_scripts()
|
|
||||||
#self.setup_win32()
|
|
||||||
self.setup_trailer()
|
|
||||||
targetfile = self.basedir.join("setup.py")
|
|
||||||
targetfile.write("\n".join(self.lines))
|
|
||||||
print "wrote", targetfile
|
|
||||||
|
|
||||||
def isexcluded(self, wcpath):
|
|
||||||
return wcpath.basename[0] == "."
|
|
||||||
rel = wcpath.relto(self.basedir)
|
|
||||||
if rel.find("testing") != -1:
|
|
||||||
return True
|
|
||||||
|
|
||||||
def write_manifest(self):
|
|
||||||
lines = []
|
|
||||||
for p in self.allpaths:
|
|
||||||
if p.check(dir=1):
|
|
||||||
continue
|
|
||||||
toadd = p.relto(self.basedir)
|
|
||||||
if toadd:
|
|
||||||
for exclude in self.EXCLUDES:
|
|
||||||
if toadd.startswith(exclude):
|
|
||||||
break
|
|
||||||
assert toadd.find(exclude) == -1, (toadd, exclude)
|
|
||||||
else:
|
|
||||||
lines.append("%s" %(toadd))
|
|
||||||
lines.sort()
|
|
||||||
targetfile = self.basedir.join("MANIFEST")
|
|
||||||
targetfile.write("\n".join(lines))
|
|
||||||
print "wrote", targetfile
|
|
||||||
|
|
||||||
def write_all(self):
|
|
||||||
#self.write_manifest()
|
|
||||||
self.write_setup()
|
|
||||||
|
|
||||||
def parseargs():
|
|
||||||
basedir = py.path.local(sys.argv[1])
|
|
||||||
if not basedir.check():
|
|
||||||
error("basedir not found: %s" %(basedir,))
|
|
||||||
pydir = basedir.join('py')
|
|
||||||
if not pydir.check():
|
|
||||||
error("no 'py' directory found in: %s" %(pydir,))
|
|
||||||
actualpydir = py.path.local(py.__file__).dirpath()
|
|
||||||
if pydir != actualpydir:
|
|
||||||
error("package dir conflict, %s != %s" %(pydir, actualpydir))
|
|
||||||
return basedir
|
|
||||||
|
|
||||||
def main(basedir=None):
|
|
||||||
if basedir is None:
|
|
||||||
basedir = parseargs()
|
|
||||||
writer = SetupWriter(basedir, py, setuptools=True)
|
|
||||||
writer.write_all()
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
main()
|
|
||||||
|
|
@ -1,26 +0,0 @@
|
||||||
import os, sys, subprocess, urllib
|
|
||||||
|
|
||||||
BUILDNAME=os.environ.get('BUILD_NUMBER', "1")
|
|
||||||
|
|
||||||
def call(*args):
|
|
||||||
ret = subprocess.call(list(args))
|
|
||||||
assert ret == 0
|
|
||||||
|
|
||||||
def bincall(*args):
|
|
||||||
args = list(args)
|
|
||||||
args[0] = os.path.join(BIN, args[0])
|
|
||||||
call(*args)
|
|
||||||
|
|
||||||
call("virtualenv", os.path.abspath(BUILDNAME), '--no-site-packages')
|
|
||||||
BIN=os.path.abspath(os.path.join(BUILDNAME, 'bin'))
|
|
||||||
if not os.path.exists(BIN):
|
|
||||||
BIN=os.path.abspath(os.path.join(BUILDNAME, 'Scripts'))
|
|
||||||
assert os.path.exists(BIN)
|
|
||||||
|
|
||||||
PYTHON=os.path.join(BIN, 'python')
|
|
||||||
bincall("python", "setup.py", "develop", "-q")
|
|
||||||
bincall("pip", "install", "-r", "testing/pip-reqs1.txt",
|
|
||||||
"-q", "--download-cache=download")
|
|
||||||
bincall("py.test", "--ignore", BUILDNAME,
|
|
||||||
"--xml=junit.xml",
|
|
||||||
"--report=skipped", "--runslowtest", *sys.argv[1:])
|
|
||||||
|
|
@ -1,301 +0,0 @@
|
||||||
|
|
||||||
import os, sys
|
|
||||||
WIDTH = 75
|
|
||||||
|
|
||||||
plugins = [
|
|
||||||
('advanced python testing',
|
|
||||||
'skipping mark pdb figleaf '
|
|
||||||
'monkeypatch coverage cov capture capturelog recwarn tmpdir',),
|
|
||||||
('distributed testing, CI and deployment',
|
|
||||||
'xdist pastebin junitxml resultlog genscript',),
|
|
||||||
('testing domains and conventions codecheckers',
|
|
||||||
'oejskit django unittest nose doctest restdoc'),
|
|
||||||
('internal, debugging, help functionality',
|
|
||||||
'helpconfig terminal hooklog')
|
|
||||||
#('internal plugins / core functionality',
|
|
||||||
# #'runner execnetcleanup # pytester',
|
|
||||||
# 'runner execnetcleanup' # pytester',
|
|
||||||
#)
|
|
||||||
]
|
|
||||||
|
|
||||||
externals = {
|
|
||||||
'oejskit': "run javascript tests in real life browsers",
|
|
||||||
'xdist': None,
|
|
||||||
'figleaf': None,
|
|
||||||
'capturelog': None,
|
|
||||||
'coverage': None,
|
|
||||||
'cov': None,
|
|
||||||
'codecheckers': None,
|
|
||||||
'django': "for testing django applications",
|
|
||||||
}
|
|
||||||
|
|
||||||
def warn(*args):
|
|
||||||
msg = " ".join(map(str, args))
|
|
||||||
print >>sys.stderr, "WARN:", msg
|
|
||||||
|
|
||||||
class RestWriter:
|
|
||||||
_all_links = {}
|
|
||||||
|
|
||||||
def __init__(self, target):
|
|
||||||
self.target = py.path.local(target)
|
|
||||||
self.links = []
|
|
||||||
|
|
||||||
def _getmsg(self, args):
|
|
||||||
return " ".join(map(str, args))
|
|
||||||
|
|
||||||
def Print(self, *args, **kwargs):
|
|
||||||
msg = self._getmsg(args)
|
|
||||||
if 'indent' in kwargs:
|
|
||||||
indent = kwargs['indent'] * " "
|
|
||||||
lines = [(indent + x) for x in msg.split("\n")]
|
|
||||||
msg = "\n".join(lines)
|
|
||||||
self.out.write(msg)
|
|
||||||
if not msg or msg[-1] != "\n":
|
|
||||||
self.out.write("\n")
|
|
||||||
self.out.flush()
|
|
||||||
|
|
||||||
def sourcecode(self, source):
|
|
||||||
lines = str(source).split("\n")
|
|
||||||
self.Print(".. sourcecode:: python")
|
|
||||||
self.Print()
|
|
||||||
for line in lines:
|
|
||||||
self.Print(" ", line)
|
|
||||||
|
|
||||||
def _sep(self, separator, args):
|
|
||||||
msg = self._getmsg(args)
|
|
||||||
sep = len(msg) * separator
|
|
||||||
self.Print()
|
|
||||||
self.Print(msg)
|
|
||||||
self.Print(sep)
|
|
||||||
self.Print()
|
|
||||||
|
|
||||||
|
|
||||||
def h1(self, *args):
|
|
||||||
self._sep('=', args)
|
|
||||||
|
|
||||||
def h2(self, *args):
|
|
||||||
self._sep('-', args)
|
|
||||||
|
|
||||||
def h3(self, *args):
|
|
||||||
self._sep('+', args)
|
|
||||||
|
|
||||||
def li(self, *args):
|
|
||||||
msg = self._getmsg(args)
|
|
||||||
sep = "* %s" %(msg)
|
|
||||||
self.Print(sep)
|
|
||||||
|
|
||||||
def dt(self, term):
|
|
||||||
self.Print("``%s``" % term)
|
|
||||||
|
|
||||||
def dd(self, doc):
|
|
||||||
self.Print(doc, indent=4)
|
|
||||||
|
|
||||||
def para(self, *args):
|
|
||||||
msg = self._getmsg(args)
|
|
||||||
self.Print(msg)
|
|
||||||
|
|
||||||
def add_internal_link(self, name, path):
|
|
||||||
relpath = path.new(ext=".html").relto(self.target.dirpath())
|
|
||||||
self.links.append((name, relpath))
|
|
||||||
|
|
||||||
def write_links(self):
|
|
||||||
self.Print()
|
|
||||||
self.Print(".. include:: links.txt")
|
|
||||||
for link in self.links:
|
|
||||||
key = link[0]
|
|
||||||
if key in self._all_links:
|
|
||||||
assert self._all_links[key] == link[1], (key, link[1])
|
|
||||||
else:
|
|
||||||
self._all_links[key] = link[1]
|
|
||||||
|
|
||||||
def write_all_links(cls, linkpath):
|
|
||||||
p = linkpath.new(basename="links.txt")
|
|
||||||
p_writer = RestWriter(p)
|
|
||||||
p_writer.out = p_writer.target.open("w")
|
|
||||||
for name, value in cls._all_links.items():
|
|
||||||
p_writer.Print(".. _`%s`: %s" % (name, value))
|
|
||||||
p_writer.out.close()
|
|
||||||
del p_writer.out
|
|
||||||
write_all_links = classmethod(write_all_links)
|
|
||||||
|
|
||||||
def make(self, **kwargs):
|
|
||||||
self.out = self.target.open("w")
|
|
||||||
self.makerest(**kwargs)
|
|
||||||
self.write_links()
|
|
||||||
|
|
||||||
self.out.close()
|
|
||||||
print "wrote", self.target
|
|
||||||
del self.out
|
|
||||||
|
|
||||||
class PluginOverview(RestWriter):
|
|
||||||
def makerest(self, config):
|
|
||||||
plugindir = py._pydir.join('plugin')
|
|
||||||
for cat, specs in plugins:
|
|
||||||
pluginlist = specs.split()
|
|
||||||
self.h1(cat)
|
|
||||||
for name in pluginlist:
|
|
||||||
oneliner = externals.get(name, None)
|
|
||||||
docpath = self.target.dirpath(name).new(ext=".txt")
|
|
||||||
if oneliner is not None:
|
|
||||||
htmlpath = docpath.new(ext='.html')
|
|
||||||
self.para("%s_ (external) %s" %(name, oneliner))
|
|
||||||
self.add_internal_link(name, htmlpath)
|
|
||||||
else:
|
|
||||||
doc = PluginDoc(docpath)
|
|
||||||
doc.make(config=config, name=name)
|
|
||||||
self.add_internal_link(name, doc.target)
|
|
||||||
if name in externals:
|
|
||||||
self.para("%s_ (external) %s" %(name, doc.oneliner))
|
|
||||||
else:
|
|
||||||
self.para("%s_ %s" %(name, doc.oneliner))
|
|
||||||
self.Print()
|
|
||||||
|
|
||||||
class HookSpec(RestWriter):
|
|
||||||
def makerest(self, config):
|
|
||||||
for module in config.pluginmanager.hook._hookspecs:
|
|
||||||
source = py.code.Source(module)
|
|
||||||
self.h1("hook specification sourcecode")
|
|
||||||
self.sourcecode(source)
|
|
||||||
|
|
||||||
class PluginDoc(RestWriter):
|
|
||||||
def makerest(self, config, name):
|
|
||||||
config.pluginmanager.import_plugin(name)
|
|
||||||
plugin = config.pluginmanager.getplugin(name)
|
|
||||||
assert plugin is not None, plugin
|
|
||||||
print plugin
|
|
||||||
doc = plugin.__doc__.strip()
|
|
||||||
i = doc.find("\n")
|
|
||||||
if i == -1:
|
|
||||||
oneliner = doc
|
|
||||||
moduledoc = ""
|
|
||||||
else:
|
|
||||||
oneliner = doc[:i].strip()
|
|
||||||
moduledoc = doc[i+1:].strip()
|
|
||||||
|
|
||||||
self.name = oneliner # plugin.__name__.split(".")[-1]
|
|
||||||
self.oneliner = oneliner
|
|
||||||
self.moduledoc = moduledoc
|
|
||||||
|
|
||||||
#self.h1("%s plugin" % self.name) # : %s" %(self.name, self.oneliner))
|
|
||||||
self.h1(oneliner)
|
|
||||||
#self.Print(self.oneliner)
|
|
||||||
self.Print()
|
|
||||||
self.Print(".. contents::")
|
|
||||||
self.Print(" :local:")
|
|
||||||
self.Print()
|
|
||||||
|
|
||||||
self.Print(moduledoc)
|
|
||||||
|
|
||||||
self.emit_funcargs(plugin)
|
|
||||||
self.emit_options(plugin)
|
|
||||||
if name not in externals:
|
|
||||||
self.emit_source(plugin, config.hg_changeset)
|
|
||||||
#self.sourcelink = (purename,
|
|
||||||
# "http://bitbucket.org/hpk42/py-trunk/src/tip/py/test/plugin/" +
|
|
||||||
# purename + ".py")
|
|
||||||
#
|
|
||||||
def emit_source(self, plugin, hg_changeset):
|
|
||||||
basename = py.path.local(plugin.__file__).basename
|
|
||||||
if basename.endswith("pyc"):
|
|
||||||
basename = basename[:-1]
|
|
||||||
#self.para("`%s`_ source code" % basename)
|
|
||||||
#self.links.append((basename,
|
|
||||||
# "http://bitbucket.org/hpk42/py-trunk/src/tip/py/test/plugin/" +
|
|
||||||
# basename))
|
|
||||||
self.h1("Start improving this plugin in 30 seconds")
|
|
||||||
self.para(py.code.Source("""
|
|
||||||
1. Download `%s`_ plugin source code
|
|
||||||
2. put it somewhere as ``%s`` into your import path
|
|
||||||
3. a subsequent ``py.test`` run will use your local version
|
|
||||||
|
|
||||||
Checkout customize_, other plugins_ or `get in contact`_.
|
|
||||||
""" % (basename, basename)))
|
|
||||||
# your work appreciated if you offer back your version. In this case
|
|
||||||
# it probably makes sense if you `checkout the py.test
|
|
||||||
# development version`_ and apply your changes to the plugin
|
|
||||||
# version in there.
|
|
||||||
#self.links.append((basename,
|
|
||||||
# "http://bitbucket.org/hpk42/py-trunk/raw/%s/"
|
|
||||||
# "py/test/plugin/%s" %(hg_changeset, basename)))
|
|
||||||
self.links.append((basename,
|
|
||||||
"http://bitbucket.org/hpk42/py-trunk/raw/%s/"
|
|
||||||
"py/_plugin/%s" %(pyversion, basename)))
|
|
||||||
self.links.append(('customize', '../customize.html'))
|
|
||||||
self.links.append(('plugins', 'index.html'))
|
|
||||||
self.links.append(('get in contact', '../../contact.html'))
|
|
||||||
self.links.append(('checkout the py.test development version',
|
|
||||||
'../../install.html#checkout'))
|
|
||||||
|
|
||||||
if 0: # this breaks the page layout and makes large doc files
|
|
||||||
#self.h2("plugin source code")
|
|
||||||
self.Print()
|
|
||||||
self.para("For your convenience here is also an inlined version "
|
|
||||||
"of ``%s``:" %basename)
|
|
||||||
#self(or copy-paste from below)
|
|
||||||
self.Print()
|
|
||||||
self.sourcecode(py.code.Source(plugin))
|
|
||||||
|
|
||||||
def emit_funcargs(self, plugin):
|
|
||||||
funcargfuncs = []
|
|
||||||
prefix = "pytest_funcarg__"
|
|
||||||
for name in vars(plugin):
|
|
||||||
if name.startswith(prefix):
|
|
||||||
funcargfuncs.append(getattr(plugin, name))
|
|
||||||
if not funcargfuncs:
|
|
||||||
return
|
|
||||||
for func in funcargfuncs:
|
|
||||||
argname = func.__name__[len(prefix):]
|
|
||||||
self.Print()
|
|
||||||
self.Print(".. _`%s funcarg`:" % argname)
|
|
||||||
self.Print()
|
|
||||||
self.h2("the %r test function argument" % argname)
|
|
||||||
if func.__doc__:
|
|
||||||
doclines = func.__doc__.split("\n")
|
|
||||||
source = py.code.Source("\n".join(doclines[1:]))
|
|
||||||
source.lines.insert(0, doclines[0])
|
|
||||||
self.para(str(source))
|
|
||||||
else:
|
|
||||||
self.para("XXX missing docstring")
|
|
||||||
warn("missing docstring", func)
|
|
||||||
|
|
||||||
def emit_options(self, plugin):
|
|
||||||
from pytest.parseopt import Parser
|
|
||||||
options = []
|
|
||||||
parser = Parser(processopt=options.append)
|
|
||||||
if hasattr(plugin, 'pytest_addoption'):
|
|
||||||
plugin.pytest_addoption(parser)
|
|
||||||
if not options:
|
|
||||||
return
|
|
||||||
self.h2("command line options")
|
|
||||||
self.Print()
|
|
||||||
formatter = py.std.optparse.IndentedHelpFormatter()
|
|
||||||
for opt in options:
|
|
||||||
switches = formatter.format_option_strings(opt)
|
|
||||||
self.Print("``%s``" % switches)
|
|
||||||
self.Print(opt.help, indent=4)
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
|
||||||
if os.path.exists("py"):
|
|
||||||
sys.path.insert(0, os.getcwd())
|
|
||||||
import py
|
|
||||||
_config = py.test.config
|
|
||||||
_config.parse([])
|
|
||||||
_config.pluginmanager.do_configure(_config)
|
|
||||||
|
|
||||||
pydir = py.path.local(py.__file__).dirpath()
|
|
||||||
pyversion = py.version
|
|
||||||
|
|
||||||
cmd = "hg tip --template '{node}'"
|
|
||||||
old = pydir.dirpath().chdir()
|
|
||||||
_config.hg_changeset = py.process.cmdexec(cmd).strip()
|
|
||||||
|
|
||||||
testdir = pydir.dirpath("doc", 'test')
|
|
||||||
|
|
||||||
ov = PluginOverview(testdir.join("plugin", "index.txt"))
|
|
||||||
ov.make(config=_config)
|
|
||||||
|
|
||||||
ov = HookSpec(testdir.join("plugin", "hookspec.txt"))
|
|
||||||
ov.make(config=_config)
|
|
||||||
|
|
||||||
RestWriter.write_all_links(testdir.join("plugin", "links.txt"))
|
|
||||||
|
|
||||||
|
|
@ -1,228 +0,0 @@
|
||||||
import py
|
|
||||||
import subprocess
|
|
||||||
import os, sys
|
|
||||||
|
|
||||||
execnet = py.test.importorskip("execnet")
|
|
||||||
|
|
||||||
|
|
||||||
#
|
|
||||||
# experimental funcargs for venv/install-tests
|
|
||||||
#
|
|
||||||
|
|
||||||
pytest_plugins = 'pytest_pytester',
|
|
||||||
|
|
||||||
def pytest_funcarg__venv(request):
|
|
||||||
p = request.config.mktemp(request.function.__name__, numbered=True)
|
|
||||||
venv = VirtualEnv(str(p))
|
|
||||||
return venv
|
|
||||||
|
|
||||||
def pytest_funcarg__py_setup(request):
|
|
||||||
testdir = request.getfuncargvalue('testdir')
|
|
||||||
rootdir = py.path.local(py.__file__).dirpath().dirpath()
|
|
||||||
setup = rootdir.join('setup.py')
|
|
||||||
if not setup.check():
|
|
||||||
py.test.skip("not found: %r" % setup)
|
|
||||||
return SetupBuilder(setup, testdir.tmpdir)
|
|
||||||
|
|
||||||
class SetupBuilder:
|
|
||||||
def __init__(self, setup_path, tmpdir):
|
|
||||||
self.setup_path = setup_path
|
|
||||||
self.tmpdir = tmpdir
|
|
||||||
assert setup_path.check()
|
|
||||||
|
|
||||||
def make_sdist(self, destdir=None):
|
|
||||||
temp = self.tmpdir.mkdir('dist')
|
|
||||||
args = ['python', 'setup.py', 'sdist', '--dist-dir', str(temp)]
|
|
||||||
old = self.setup_path.dirpath().chdir()
|
|
||||||
try:
|
|
||||||
subcall(args)
|
|
||||||
finally:
|
|
||||||
old.chdir()
|
|
||||||
l = temp.listdir('py-*')
|
|
||||||
assert len(l) == 1
|
|
||||||
sdist = l[0]
|
|
||||||
if destdir is None:
|
|
||||||
destdir = self.setup_path.dirpath('build')
|
|
||||||
assert destdir.check()
|
|
||||||
else:
|
|
||||||
destdir = py.path.local(destdir)
|
|
||||||
target = destdir.join(sdist.basename)
|
|
||||||
sdist.copy(target)
|
|
||||||
return target
|
|
||||||
|
|
||||||
def subcall(args):
|
|
||||||
if hasattr(subprocess, 'check_call'):
|
|
||||||
subprocess.check_call(args)
|
|
||||||
else:
|
|
||||||
subprocess.call(args)
|
|
||||||
# code taken from Ronny Pfannenschmidt's virtualenvmanager
|
|
||||||
|
|
||||||
class VirtualEnv(object):
|
|
||||||
def __init__(self, path):
|
|
||||||
#XXX: supply the python executable
|
|
||||||
self.path = path
|
|
||||||
|
|
||||||
def __repr__(self):
|
|
||||||
return "<VirtualEnv at %r>" %(self.path)
|
|
||||||
|
|
||||||
def _cmd(self, name):
|
|
||||||
if sys.platform == "win32":
|
|
||||||
return os.path.join(self.path, 'Scripts', name)
|
|
||||||
else:
|
|
||||||
return os.path.join(self.path, 'bin', name)
|
|
||||||
|
|
||||||
def ensure(self):
|
|
||||||
if not os.path.exists(self._cmd('python')):
|
|
||||||
self.create()
|
|
||||||
|
|
||||||
def create(self, sitepackages=False):
|
|
||||||
args = ['virtualenv', self.path]
|
|
||||||
if not sitepackages:
|
|
||||||
args.append('--no-site-packages')
|
|
||||||
subcall(args)
|
|
||||||
|
|
||||||
def makegateway(self):
|
|
||||||
python = self._cmd('python')
|
|
||||||
return execnet.makegateway("popen//python=%s" %(python,))
|
|
||||||
|
|
||||||
def pcall(self, cmd, *args, **kw):
|
|
||||||
self.ensure()
|
|
||||||
return subprocess.call([
|
|
||||||
self._cmd(cmd)
|
|
||||||
] + list(args),
|
|
||||||
**kw)
|
|
||||||
|
|
||||||
def pytest_getouterr(self, *args):
|
|
||||||
self.ensure()
|
|
||||||
args = [self._cmd("py.test")] + list(args)
|
|
||||||
popen = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
|
||||||
out, err = popen.communicate()
|
|
||||||
return out
|
|
||||||
|
|
||||||
def setup_develop(self):
|
|
||||||
self.ensure()
|
|
||||||
return self.pcall("python", "setup.py", "develop")
|
|
||||||
|
|
||||||
def easy_install(self, *packages, **kw):
|
|
||||||
args = []
|
|
||||||
if 'index' in kw:
|
|
||||||
index = kw['index']
|
|
||||||
if isinstance(index, (list, tuple)):
|
|
||||||
for i in index:
|
|
||||||
args.extend(['-i', i])
|
|
||||||
else:
|
|
||||||
args.extend(['-i', index])
|
|
||||||
|
|
||||||
args.extend(packages)
|
|
||||||
self.pcall('easy_install', *args)
|
|
||||||
|
|
||||||
|
|
||||||
def test_make_sdist_and_run_it(py_setup, venv):
|
|
||||||
sdist = py_setup.make_sdist(venv.path)
|
|
||||||
venv.easy_install(str(sdist))
|
|
||||||
gw = venv.makegateway()
|
|
||||||
ch = gw.remote_exec("import py ; channel.send(py.__version__)")
|
|
||||||
version = ch.receive()
|
|
||||||
assert version == py.__version__
|
|
||||||
|
|
||||||
def test_plugin_setuptools_entry_point_integration(py_setup, venv, tmpdir):
|
|
||||||
sdist = py_setup.make_sdist(venv.path)
|
|
||||||
venv.easy_install(str(sdist))
|
|
||||||
# create a sample plugin
|
|
||||||
basedir = tmpdir.mkdir("testplugin")
|
|
||||||
basedir.join("setup.py").write("""if 1:
|
|
||||||
from setuptools import setup
|
|
||||||
setup(name="testplugin",
|
|
||||||
entry_points = {'pytest11': ['testplugin=tp1']},
|
|
||||||
py_modules = ['tp1'],
|
|
||||||
)
|
|
||||||
""")
|
|
||||||
basedir.join("tp1.py").write(py.code.Source("""
|
|
||||||
def pytest_addoption(parser):
|
|
||||||
parser.addoption("--testpluginopt", action="store_true")
|
|
||||||
"""))
|
|
||||||
basedir.chdir()
|
|
||||||
print ("created sample plugin in %s" %basedir)
|
|
||||||
venv.setup_develop()
|
|
||||||
out = venv.pytest_getouterr("-h")
|
|
||||||
assert "testpluginopt" in out
|
|
||||||
|
|
||||||
def test_cmdline_entrypoints(monkeypatch):
|
|
||||||
monkeypatch.syspath_prepend(py.path.local(__file__).dirpath().dirpath())
|
|
||||||
from setup import cmdline_entrypoints
|
|
||||||
versioned_scripts = ['py.test', 'py.which']
|
|
||||||
unversioned_scripts = versioned_scripts + [ 'py.cleanup',
|
|
||||||
'py.convert_unittest', 'py.countloc', 'py.lookup', 'py.svnwcrevert']
|
|
||||||
for ver in [(2,4,0), (2,5,0), (2,6,0), (2,7,0), (3,0,1), (3,1,1)]:
|
|
||||||
for platform in ('posix', 'win32'):
|
|
||||||
points = cmdline_entrypoints(ver, "posix", 'python')
|
|
||||||
for script in versioned_scripts:
|
|
||||||
script_ver = script + "-%s.%s" % ver[:2]
|
|
||||||
assert script_ver in points
|
|
||||||
for script in unversioned_scripts:
|
|
||||||
assert script in points
|
|
||||||
points = cmdline_entrypoints((2,5,1), "java1.6.123", 'jython')
|
|
||||||
for script in versioned_scripts:
|
|
||||||
expected = "%s-jython" % script
|
|
||||||
assert expected in points
|
|
||||||
for script in unversioned_scripts:
|
|
||||||
assert script in points
|
|
||||||
|
|
||||||
points = cmdline_entrypoints((2,5,1), "xyz", 'pypy-c-XYZ')
|
|
||||||
for script in versioned_scripts:
|
|
||||||
expected = "%s-pypy-c-XYZ" % script
|
|
||||||
assert expected in points
|
|
||||||
for script in unversioned_scripts:
|
|
||||||
assert script in points
|
|
||||||
|
|
||||||
def test_slave_popen_needs_no_pylib(testdir, venv, pytestconfig):
|
|
||||||
pytestconfig.pluginmanager.skipifmissing("xdist")
|
|
||||||
venv.ensure()
|
|
||||||
#xxx execnet optimizes popen
|
|
||||||
#ch = venv.makegateway().remote_exec("import execnet")
|
|
||||||
#py.test.raises(ch.RemoteError, ch.waitclose)
|
|
||||||
python = venv._cmd("python")
|
|
||||||
p = testdir.makepyfile("""
|
|
||||||
import py
|
|
||||||
def test_func():
|
|
||||||
pass
|
|
||||||
""")
|
|
||||||
result = testdir.runpytest(p, '--rsyncdir=%s' % str(p),
|
|
||||||
'--dist=each', '--tx=popen//python=%s' % python)
|
|
||||||
result.stdout.fnmatch_lines([
|
|
||||||
"*1 passed*"
|
|
||||||
])
|
|
||||||
|
|
||||||
def test_slave_needs_no_execnet(testdir, sshhost, pytestconfig):
|
|
||||||
pytestconfig.pluginmanager.skipifmissing("xdist")
|
|
||||||
xspec = "ssh=%s" % sshhost
|
|
||||||
gw = execnet.makegateway("ssh=%s" % sshhost)
|
|
||||||
ch = gw.remote_exec("""
|
|
||||||
import os, subprocess
|
|
||||||
subprocess.call(["virtualenv", "--no-site-packages", "subdir"])
|
|
||||||
channel.send(os.path.join(os.path.abspath("subdir"), 'bin', 'python'))
|
|
||||||
channel.send(os.path.join(os.path.abspath("subdir")))
|
|
||||||
""")
|
|
||||||
try:
|
|
||||||
path = ch.receive()
|
|
||||||
chdir = ch.receive()
|
|
||||||
except ch.RemoteError:
|
|
||||||
e = sys.exc_info()[1]
|
|
||||||
py.test.skip("could not prepare ssh slave:%s" % str(e))
|
|
||||||
gw.exit()
|
|
||||||
newspec = "%s//python=%s//chdir=%s" % (xspec, path, chdir)
|
|
||||||
gw = execnet.makegateway(newspec)
|
|
||||||
ch = gw.remote_exec("import execnet")
|
|
||||||
py.test.raises(ch.RemoteError, ch.waitclose)
|
|
||||||
gw.exit()
|
|
||||||
|
|
||||||
p = testdir.makepyfile("""
|
|
||||||
import py
|
|
||||||
def test_func():
|
|
||||||
pass
|
|
||||||
""")
|
|
||||||
result = testdir.runpytest(p, '--rsyncdir=%s' % str(p),
|
|
||||||
'--dist=each', '--tx=%s' % newspec)
|
|
||||||
result.stdout.fnmatch_lines([
|
|
||||||
"*1 passed*"
|
|
||||||
])
|
|
||||||
Loading…
Reference in New Issue