def test_namespace_effective(self):
self.create_file('src/thrift/com/foo/one.thrift',
contents=dedent("""
namespace py foo.bar
struct One {}
"""))
one = self.make_target(spec='src/thrift/com/foo:one',
target_type=PythonThriftLibrary,
sources=['one.thrift'])
apache_thrift_gen, synthetic_target_one = self.generate_single_thrift_target(
one)
self.create_file('src/thrift2/com/foo/two.thrift',
contents=dedent("""
namespace py foo.baz
struct Two {}
"""))
two = self.make_target(spec='src/thrift2/com/foo:two',
target_type=PythonThriftLibrary,
sources=['two.thrift'])
_, synthetic_target_two = self.generate_single_thrift_target(two)
# Confirm separate PYTHONPATH entries, which we need to test namespace packages.
self.assertNotEqual(synthetic_target_one.target_base,
synthetic_target_two.target_base)
targets = (synthetic_target_one, synthetic_target_two)
python_repos = global_subsystem_instance(PythonRepos)
python_setup = global_subsystem_instance(PythonSetup)
interpreter_cache = PythonInterpreterCache(python_setup, python_repos)
interpreter = interpreter_cache.select_interpreter_for_targets(targets)
pythonpath = [
os.path.join(get_buildroot(), t.target_base) for t in targets
]
for dist in resolve(
['thrift=={}'.format(self.get_thrift_version(apache_thrift_gen))],
interpreter=interpreter,
context=python_repos.get_network_context(),
fetchers=python_repos.get_fetchers()):
pythonpath.append(dist.location)
process = subprocess.Popen([
interpreter.binary, '-c',
'from foo.bar.ttypes import One; from foo.baz.ttypes import Two'
],
env={
'PYTHONPATH':
os.pathsep.join(pythonpath)
},
stderr=subprocess.PIPE)
_, stderr = process.communicate()
self.assertEqual(0, process.returncode, stderr)
def test_namespace_effective(self):
self.create_file('src/thrift/com/foo/one.thrift', contents=dedent("""
namespace py foo.bar
struct One {}
"""))
one = self.make_target(spec='src/thrift/com/foo:one',
target_type=PythonThriftLibrary,
sources=['one.thrift'])
apache_thrift_gen, synthetic_target_one = self.generate_single_thrift_target(one)
self.create_file('src/thrift2/com/foo/two.thrift', contents=dedent("""
namespace py foo.baz
struct Two {}
"""))
two = self.make_target(spec='src/thrift2/com/foo:two',
target_type=PythonThriftLibrary,
sources=['two.thrift'])
_, synthetic_target_two = self.generate_single_thrift_target(two)
# Confirm separate PYTHONPATH entries, which we need to test namespace packages.
self.assertNotEqual(synthetic_target_one.target_base, synthetic_target_two.target_base)
targets = (synthetic_target_one, synthetic_target_two)
python_repos = global_subsystem_instance(PythonRepos)
python_setup = global_subsystem_instance(PythonSetup)
interpreter_cache = PythonInterpreterCache(python_setup, python_repos)
interpreter = interpreter_cache.select_interpreter_for_targets(targets)
# We need setuptools to import namespace packages (via pkg_resources), so we prime the
# PYTHONPATH with interpreter extras, which Pants always populates with setuptools and wheel.
# TODO(John Sirois): We really should be emitting setuptools in a
# `synthetic_target_extra_dependencies` override in `ApacheThriftPyGen`:
# https://github.com/pantsbuild/pants/issues/5975
pythonpath = interpreter.extras.values()
pythonpath.extend(os.path.join(get_buildroot(), t.target_base) for t in targets)
for dist in resolve(['thrift=={}'.format(self.get_thrift_version(apache_thrift_gen))],
interpreter=interpreter,
context=python_repos.get_network_context(),
fetchers=python_repos.get_fetchers()):
pythonpath.append(dist.location)
process = subprocess.Popen([interpreter.binary,
'-c',
'from foo.bar.ttypes import One; from foo.baz.ttypes import Two'],
env={'PYTHONPATH': os.pathsep.join(pythonpath)},
stderr=subprocess.PIPE)
_, stderr = process.communicate()
self.assertEqual(0, process.returncode, stderr)
def test_namespace_effective(self):
self.create_file('src/thrift/com/foo/one.thrift', contents=dedent("""
namespace py foo.bar
struct One {}
"""))
one = self.make_target(spec='src/thrift/com/foo:one',
target_type=PythonThriftLibrary,
sources=['one.thrift'])
apache_thrift_gen, synthetic_target_one = self.generate_single_thrift_target(one)
self.create_file('src/thrift2/com/foo/two.thrift', contents=dedent("""
namespace py foo.baz
struct Two {}
"""))
two = self.make_target(spec='src/thrift2/com/foo:two',
target_type=PythonThriftLibrary,
sources=['two.thrift'])
_, synthetic_target_two = self.generate_single_thrift_target(two)
# Confirm separate PYTHONPATH entries, which we need to test namespace packages.
self.assertNotEqual(synthetic_target_one.target_base, synthetic_target_two.target_base)
targets = (synthetic_target_one, synthetic_target_two)
python_repos = global_subsystem_instance(PythonRepos)
python_setup = global_subsystem_instance(PythonSetup)
interpreter_cache = PythonInterpreterCache(python_setup, python_repos)
interpreter = interpreter_cache.select_interpreter_for_targets(targets)
# We need setuptools to import namespace packages (via pkg_resources), so we prime the
# PYTHONPATH with interpreter extras, which Pants always populates with setuptools and wheel.
# TODO(John Sirois): We really should be emitting setuptools in a
# `synthetic_target_extra_dependencies` override in `ApacheThriftPyGen`:
# https://github.com/pantsbuild/pants/issues/5975
pythonpath = interpreter.extras.values()
pythonpath.extend(os.path.join(get_buildroot(), t.target_base) for t in targets)
for dist in resolve(['thrift=={}'.format(self.get_thrift_version(apache_thrift_gen))],
interpreter=interpreter,
context=python_repos.get_network_context(),
fetchers=python_repos.get_fetchers()):
pythonpath.append(dist.location)
process = subprocess.Popen([interpreter.binary,
'-c',
'from foo.bar.ttypes import One; from foo.baz.ttypes import Two'],
env={'PYTHONPATH': os.pathsep.join(pythonpath)},
stderr=subprocess.PIPE)
_, stderr = process.communicate()
self.assertEqual(0, process.returncode, stderr)
def test_gcc_version(self):
scheduler = self._sched()
platform = Platform.create()
gcc_subsystem = global_subsystem_instance(GCC)
gcc_version = gcc_subsystem.version()
gcc_c_compiler = self.execute_expecting_one_result(
scheduler, GCCCCompiler, self.toolchain).value
gcc = gcc_c_compiler.c_compiler
gcc_version_out = self._invoke_capturing_output(
[gcc.exe_filename, '--version'],
env=gcc.get_invocation_environment_dict(platform))
gcc_version_regex = re.compile('^gcc.*{}$'.format(
re.escape(gcc_version)),
flags=re.MULTILINE)
self.assertIsNotNone(gcc_version_regex.search(gcc_version_out))
gcc_cpp_compiler = self.execute_expecting_one_result(
scheduler, GCCCppCompiler, self.toolchain).value
gpp = gcc_cpp_compiler.cpp_compiler
gpp_version_out = self._invoke_capturing_output(
[gpp.exe_filename, '--version'],
env=gpp.get_invocation_environment_dict(platform))
gpp_version_regex = re.compile(r'^g\+\+.*{}$'.format(
re.escape(gcc_version)),
flags=re.MULTILINE)
self.assertIsNotNone(gpp_version_regex.search(gpp_version_out))
def test_clang_version(self):
scheduler = self._sched()
platform = Platform.create()
llvm_subsystem = global_subsystem_instance(LLVM)
llvm_version = llvm_subsystem.version()
llvm_version_regex = re.compile('^clang version {}'.format(
re.escape(llvm_version)),
flags=re.MULTILINE)
llvm_c_compiler = self.execute_expecting_one_result(
scheduler, LLVMCCompiler, self.toolchain).value
clang = llvm_c_compiler.c_compiler
llvm_version_out = self._invoke_capturing_output(
[clang.exe_filename, '--version'],
env=clang.get_invocation_environment_dict(platform))
self.assertIsNotNone(llvm_version_regex.search(llvm_version_out))
llvm_cpp_compiler = self.execute_expecting_one_result(
scheduler, LLVMCppCompiler, self.toolchain).value
clangpp = llvm_cpp_compiler.cpp_compiler
gpp_version_out = self._invoke_capturing_output(
[clangpp.exe_filename, '--version'],
env=clangpp.get_invocation_environment_dict(platform))
self.assertIsNotNone(llvm_version_regex.search(gpp_version_out))
def test_ivy_classifiers(self):
with self.temporary_workdir() as workdir:
test_target = 'testprojects/tests/java/org/pantsbuild/testproject/ivyclassifier:ivyclassifier'
json_data = self.run_export(test_target, workdir, load_libs=True)
ivy_subsystem = global_subsystem_instance(IvySubsystem)
ivy_cache_dir = ivy_subsystem.get_options().cache_dir
avro_lib_info = json_data.get('libraries').get(
'org.apache.avro:avro:1.7.7')
self.assertIsNotNone(avro_lib_info)
self.assertEquals(
avro_lib_info.get('default'),
os.path.join(ivy_cache_dir,
'org.apache.avro/avro/jars/avro-1.7.7.jar'))
self.assertEquals(
avro_lib_info.get('tests'),
os.path.join(ivy_cache_dir,
'org.apache.avro/avro/jars/avro-1.7.7-tests.jar'))
self.assertEquals(
avro_lib_info.get('javadoc'),
os.path.join(
ivy_cache_dir,
'org.apache.avro/avro/javadocs/avro-1.7.7-javadoc.jar'))
self.assertEquals(
avro_lib_info.get('sources'),
os.path.join(
ivy_cache_dir,
'org.apache.avro/avro/sources/avro-1.7.7-sources.jar'))
def _jar_dependency_management(self, **flags):
Subsystem.reset()
options = {
JarDependencyManagement.options_scope: flags,
}
return global_subsystem_instance(JarDependencyManagement,
options=options)
def _init_manager(self, **jar_dependency_management_options):
options = {
JarDependencyManagement.options_scope:
jar_dependency_management_options
}
return global_subsystem_instance(JarDependencyManagement,
options=options)
def setUp(self):
super(TestNativeToolchain, self).setUp()
init_subsystems([LibcDev, NativeToolchain], options={
'libc': {
'enable_libc_search': True,
},
})
self.platform = Platform.create()
self.toolchain = global_subsystem_instance(NativeToolchain)
self.rules = native_backend_rules()
gcc_subsystem = global_subsystem_instance(GCC)
self.gcc_version = gcc_subsystem.version()
llvm_subsystem = global_subsystem_instance(LLVM)
self.llvm_version = llvm_subsystem.version()
def execute_junit_runner(self, content, create_some_resources=True, **kwargs):
# Create the temporary base test directory
test_rel_path = 'tests/java/org/pantsbuild/foo'
test_abs_path = self.create_dir(test_rel_path)
# Generate the temporary java test source code.
test_java_file_rel_path = os.path.join(test_rel_path, 'FooTest.java')
test_java_file_abs_path = self.create_file(test_java_file_rel_path, content)
# Create the temporary classes directory under work dir
test_classes_abs_path = self.create_workdir_dir(test_rel_path)
# Invoke ivy to resolve classpath for junit.
classpath_file_abs_path = os.path.join(test_abs_path, 'junit.classpath')
ivy_subsystem = global_subsystem_instance(IvySubsystem)
distribution = DistributionLocator.cached(jdk=True)
ivy = Bootstrapper(ivy_subsystem=ivy_subsystem).ivy()
ivy.execute(args=['-cachepath', classpath_file_abs_path,
'-dependency', 'junit', 'junit-dep', '4.10'],
executor=SubprocessExecutor(distribution=distribution))
with open(classpath_file_abs_path) as fp:
classpath = fp.read()
# Now directly invoking javac to compile the test java code into java class
# so later we can inject the class into products mapping for JUnitRun to execute
# the test on.
javac = distribution.binary('javac')
subprocess.check_call(
[javac, '-d', test_classes_abs_path, '-cp', classpath, test_java_file_abs_path])
# If a target_name is specified create a target with it, otherwise create a java_tests target.
if 'target_name' in kwargs:
target = self.target(kwargs['target_name'])
else:
target = self.create_library(test_rel_path, 'java_tests', 'foo_test', ['FooTest.java'])
target_roots = []
if create_some_resources:
# Create a synthetic resource target.
target_roots.append(self.make_target('some_resources', Resources))
target_roots.append(target)
# Set the context with the two targets, one java_tests target and
# one synthetic resources target.
# The synthetic resources target is to make sure we won't regress
# in the future with bug like https://github.com/pantsbuild/pants/issues/508. Note
# in that bug, the resources target must be the first one in the list.
context = self.context(target_roots=target_roots)
# Before we run the task, we need to inject the "runtime_classpath" with
# the compiled test java classes that JUnitRun will know which test
# classes to execute. In a normal run, this "runtime_classpath" will be
# populated by java compilation step.
self.populate_runtime_classpath(context=context, classpath=[test_classes_abs_path])
# Finally execute the task.
self.execute(context)
def test_namespace_effective(self):
self.create_file('src/thrift/com/foo/one.thrift', contents=dedent("""
namespace py foo.bar
struct One {}
"""))
one = self.make_target(spec='src/thrift/com/foo:one',
target_type=PythonThriftLibrary,
sources=['one.thrift'])
apache_thrift_gen, synthetic_target_one = self.generate_single_thrift_target(one)
self.create_file('src/thrift2/com/foo/two.thrift', contents=dedent("""
namespace py foo.baz
struct Two {}
"""))
two = self.make_target(spec='src/thrift2/com/foo:two',
target_type=PythonThriftLibrary,
sources=['two.thrift'])
_, synthetic_target_two = self.generate_single_thrift_target(two)
# Confirm separate PYTHONPATH entries, which we need to test namespace packages.
self.assertNotEqual(synthetic_target_one.target_base, synthetic_target_two.target_base)
targets = (synthetic_target_one, synthetic_target_two)
python_repos = global_subsystem_instance(PythonRepos)
python_setup = global_subsystem_instance(PythonSetup)
interpreter_cache = PythonInterpreterCache(python_setup, python_repos)
interpreter = interpreter_cache.select_interpreter_for_targets(targets)
pythonpath = [os.path.join(get_buildroot(), t.target_base) for t in targets]
for dist in resolve(['thrift=={}'.format(self.get_thrift_version(apache_thrift_gen))],
interpreter=interpreter,
context=python_repos.get_network_context(),
fetchers=python_repos.get_fetchers()):
pythonpath.append(dist.location)
process = subprocess.Popen([interpreter.binary,
'-c',
'from foo.bar.ttypes import One; from foo.baz.ttypes import Two'],
env={'PYTHONPATH': os.pathsep.join(pythonpath)},
stderr=subprocess.PIPE)
_, stderr = process.communicate()
self.assertEqual(0, process.returncode, stderr)
def setUp(self):
super(TestNativeToolchain, self).setUp()
init_subsystems([LibcDev, NativeToolchain],
options={
'libc': {
'enable_libc_search': True,
},
})
self.platform = Platform.create()
self.toolchain = global_subsystem_instance(NativeToolchain)
self.rules = native_backend_rules()
gcc_subsystem = global_subsystem_instance(GCC)
self.gcc_version = gcc_subsystem.version()
llvm_subsystem = global_subsystem_instance(LLVM)
self.llvm_version = llvm_subsystem.version()
def test_parse_proxy_string(self):
ivy_subsystem = global_subsystem_instance(IvySubsystem)
self.assertEquals(('example.com', 1234),
ivy_subsystem._parse_proxy_string('http://example.com:1234'))
self.assertEquals(('secure-example.com', 999),
ivy_subsystem._parse_proxy_string('http://secure-example.com:999'))
# trailing slash is ok
self.assertEquals(('example.com', 1234),
ivy_subsystem._parse_proxy_string('http://example.com:1234/'))
def test_parse_proxy_string(self):
ivy_subsystem = global_subsystem_instance(IvySubsystem)
self.assertEqual(('example.com', 1234),
ivy_subsystem._parse_proxy_string('http://example.com:1234'))
self.assertEqual(('secure-example.com', 999),
ivy_subsystem._parse_proxy_string('http://secure-example.com:999'))
# trailing slash is ok
self.assertEqual(('example.com', 1234),
ivy_subsystem._parse_proxy_string('http://example.com:1234/'))
def setUp(self):
init_subsystems([LibcDev], options={
'libc': {
'enable_libc_search': True,
'host_compiler': 'this_executable_does_not_exist',
},
})
self.libc = global_subsystem_instance(LibcDev)
self.platform = Platform.current
def setUp(self):
init_subsystems([LibcDev], options={
'libc': {
'enable_libc_search': False,
'libc_dir': '/does/not/exist',
},
})
self.libc = global_subsystem_instance(LibcDev)
self.platform = Platform.current
def setUp(self):
init_subsystems([LibcDev], options={
'libc': {
'enable_libc_search': False,
'libc_dir': '/does/not/exist',
},
})
self.libc = global_subsystem_instance(LibcDev)
self.platform = Platform.current
def setUp(self):
init_subsystems([LibcDev], options={
'libc': {
'enable_libc_search': True,
'host_compiler': 'this_executable_does_not_exist',
},
})
self.libc = global_subsystem_instance(LibcDev)
self.platform = Platform.current
def test_validate_live(self):
with self.assertRaises(Distribution.Error):
Distribution(bin_path=os.path.dirname(self.JAVA), minimum_version='999.9.9').validate()
with self.assertRaises(Distribution.Error):
Distribution(bin_path=os.path.dirname(self.JAVA), maximum_version='0.0.1').validate()
Distribution(bin_path=os.path.dirname(self.JAVA)).validate()
Distribution(bin_path=os.path.dirname(self.JAVA), minimum_version='1.3.1').validate()
Distribution(bin_path=os.path.dirname(self.JAVA), maximum_version='999.999.999').validate()
Distribution(bin_path=os.path.dirname(self.JAVA), minimum_version='1.3.1',
maximum_version='999.999.999').validate()
locator = global_subsystem_instance(DistributionLocator)
locator.cached(jdk=False)
def test_validate_live(self):
with self.assertRaises(Distribution.Error):
Distribution(bin_path=os.path.dirname(self.JAVA), minimum_version='999.9.9').validate()
with self.assertRaises(Distribution.Error):
Distribution(bin_path=os.path.dirname(self.JAVA), maximum_version='0.0.1').validate()
Distribution(bin_path=os.path.dirname(self.JAVA)).validate()
Distribution(bin_path=os.path.dirname(self.JAVA), minimum_version='1.3.1').validate()
Distribution(bin_path=os.path.dirname(self.JAVA), maximum_version='999.999.999').validate()
Distribution(bin_path=os.path.dirname(self.JAVA), minimum_version='1.3.1',
maximum_version='999.999.999').validate()
locator = global_subsystem_instance(DistributionLocator)
locator.cached(jdk=False)
def requirements(cls, tools):
sdk_home = os.environ.get('ANDROID_HOME')
android_sdk = os.path.abspath(sdk_home) if sdk_home else None
if android_sdk:
for tool in tools:
if not os.path.isfile(os.path.join(android_sdk, tool)):
return False
else:
return False
try:
locator = global_subsystem_instance(DistributionLocator)
locator.cached(minimum_version=cls.JAVA_MIN, maximum_version=cls.JAVA_MAX)
except Distribution.Error:
return False
return True
def test_go_compile_simple(self):
with self.temporary_workdir() as workdir:
args = ['compile',
'contrib/go/examples/src/go/libA']
pants_run = self.run_pants_with_workdir(args, workdir)
self.assert_success(pants_run)
go_dist = global_subsystem_instance(GoDistribution)
goos = go_dist.create_go_cmd('env', args=['GOOS']).check_output().strip()
goarch = go_dist.create_go_cmd('env', args=['GOARCH']).check_output().strip()
expected_files = set('contrib.go.examples.src.go.{libname}.{libname}/'
'pkg/{goos}_{goarch}/{libname}.a'
.format(libname=libname, goos=goos, goarch=goarch)
for libname in ('libA', 'libB', 'libC', 'libD', 'libE'))
self.assertTrue(contains_exact_files(os.path.join(workdir, 'compile', 'go'),
expected_files, ignore_links=True))
def test_interpreter_constraints_parsing(self):
python_setup = global_subsystem_instance(PythonSetup)
target_adaptors = [
# NB: This target will use the global --python-setup-interpreter-constraints.
PythonTargetAdaptor(compatibility=None),
PythonTargetAdaptor(compatibility=["CPython>=400"]),
]
self.assertEqual(
parse_interpreter_constraints(python_setup, target_adaptors),
[
"--interpreter-constraint", "CPython>=2.7,<3",
"--interpreter-constraint", "CPython>=3.6,<4",
"--interpreter-constraint", "CPython>=400"
]
)
def test_go_compile_simple(self):
with self.temporary_workdir() as workdir:
args = ['compile',
'contrib/go/examples/src/go/libA']
pants_run = self.run_pants_with_workdir(args, workdir)
self.assert_success(pants_run)
go_dist = global_subsystem_instance(GoDistribution)
goos = go_dist.create_go_cmd('env', args=['GOOS']).check_output().decode().strip()
goarch = go_dist.create_go_cmd('env', args=['GOARCH']).check_output().decode().strip()
expected_files = set('contrib.go.examples.src.go.{libname}.{libname}/'
'pkg/{goos}_{goarch}/{libname}.a'
.format(libname=libname, goos=goos, goarch=goarch)
for libname in ('libA', 'libB', 'libC', 'libD', 'libE'))
self.assertTrue(contains_exact_files(os.path.join(workdir, 'compile', 'go'),
expected_files, ignore_links=True))
def test_proxy_from_env(self):
ivy_subsystem = global_subsystem_instance(IvySubsystem)
self.assertIsNone(ivy_subsystem.http_proxy())
self.assertIsNone(ivy_subsystem.https_proxy())
with environment_as(HTTP_PROXY='http://proxy.example.com:456',
HTTPS_PROXY='https://secure-proxy.example.com:789'):
self.assertEquals('http://proxy.example.com:456', ivy_subsystem.http_proxy())
self.assertEquals('https://secure-proxy.example.com:789', ivy_subsystem.https_proxy())
self.assertEquals([
'-Dhttp.proxyHost=proxy.example.com',
'-Dhttp.proxyPort=456',
'-Dhttps.proxyHost=secure-proxy.example.com',
'-Dhttps.proxyPort=789',
], ivy_subsystem.extra_jvm_options())
def test_proxy_from_env(self):
ivy_subsystem = global_subsystem_instance(IvySubsystem)
self.assertIsNone(ivy_subsystem.http_proxy())
self.assertIsNone(ivy_subsystem.https_proxy())
with environment_as(HTTP_PROXY='http://proxy.example.com:456',
HTTPS_PROXY='https://secure-proxy.example.com:789'):
self.assertEqual('http://proxy.example.com:456', ivy_subsystem.http_proxy())
self.assertEqual('https://secure-proxy.example.com:789', ivy_subsystem.https_proxy())
self.assertEqual([
'-Dhttp.proxyHost=proxy.example.com',
'-Dhttp.proxyPort=456',
'-Dhttps.proxyHost=secure-proxy.example.com',
'-Dhttps.proxyPort=789',
], ivy_subsystem.extra_jvm_options())
def test_ignore_dir(self):
"""Verify that passing --repro-ignore option ignores the directory"""
# Buildroot is is based on your cwd so we need to step into a fresh
# directory for repro to look at.
root_instance = BuildRoot()
with temporary_dir() as build_root:
with root_instance.temporary(build_root):
with pushd(build_root):
with temporary_dir() as capture_dir:
add_file = partial(self.add_file, build_root)
add_file('pants.ini', '')
add_file('.git/foo', 'foo')
add_file('dist/bar', 'bar')
add_file('foo/bar', 'baz')
add_file('src/test1', 'test1')
add_file('src/test2', 'test1')
repro_file = os.path.join(capture_dir, 'repro.tar.gz')
options = {
Reproducer.options_scope:
dict(
capture=repro_file,
ignore=['src'],
)
}
repro_sub = global_subsystem_instance(Reproducer,
options=options)
repro = repro_sub.create_repro(
) # This is normally called in pants_exe.
repro.capture(run_info_dict={})
extract_loc = os.path.join(capture_dir, 'extract')
TGZ.extract(repro_file, extract_loc)
assert_file = partial(self.assert_file, extract_loc)
assert_file('foo/bar', 'baz')
assert_not_exists = partial(self.assert_not_exists,
extract_loc)
assert_not_exists('.git')
assert_not_exists('src')
def test_export_jar_path(self):
with self.temporary_workdir() as workdir:
test_target = 'examples/tests/java/org/pantsbuild/example/usethrift:usethrift'
json_data = self.run_export(test_target, workdir, load_libs=True)
ivy_subsystem = global_subsystem_instance(IvySubsystem)
ivy_cache_dir = ivy_subsystem.get_options().cache_dir
common_lang_lib_info = json_data.get('libraries').get(
'junit:junit:4.12')
self.assertIsNotNone(common_lang_lib_info)
self.assertEquals(
common_lang_lib_info.get('default'),
os.path.join(ivy_cache_dir, 'junit/junit/jars/junit-4.12.jar'))
self.assertEquals(
common_lang_lib_info.get('javadoc'),
os.path.join(ivy_cache_dir,
'junit/junit/javadocs/junit-4.12-javadoc.jar'))
self.assertEquals(
common_lang_lib_info.get('sources'),
os.path.join(ivy_cache_dir,
'junit/junit/sources/junit-4.12-sources.jar'))
def test_export_jar_path(self):
with self.temporary_workdir() as workdir:
test_target = 'examples/tests/java/org/pantsbuild/example/usethrift:usethrift'
json_data = self.run_export(test_target, workdir, load_libs=True)
ivy_subsystem = global_subsystem_instance(IvySubsystem)
ivy_cache_dir = ivy_subsystem.get_options().cache_dir
common_lang_lib_info = json_data.get('libraries').get('junit:junit:4.12')
self.assertIsNotNone(common_lang_lib_info)
self.assertEquals(
common_lang_lib_info.get('default'),
os.path.join(ivy_cache_dir, 'junit/junit/jars/junit-4.12.jar')
)
self.assertEquals(
common_lang_lib_info.get('javadoc'),
os.path.join(ivy_cache_dir,
'junit/junit/javadocs/junit-4.12-javadoc.jar')
)
self.assertEquals(
common_lang_lib_info.get('sources'),
os.path.join(ivy_cache_dir,
'junit/junit/sources/junit-4.12-sources.jar')
)
def test_ignore_dir(self):
"""Verify that passing --repro-ignore option ignores the directory"""
# Buildroot is is based on your cwd so we need to step into a fresh
# directory for repro to look at.
root_instance = BuildRoot()
with temporary_dir() as build_root:
with root_instance.temporary(build_root):
with pushd(build_root):
with temporary_dir() as capture_dir:
add_file = partial(self.add_file, build_root)
add_file('pants.ini', '')
add_file('.git/foo', 'foo')
add_file('dist/bar', 'bar')
add_file('foo/bar', 'baz')
add_file('src/test1', 'test1')
add_file('src/test2', 'test1')
repro_file = os.path.join(capture_dir, 'repro.tar.gz')
options = {
Reproducer.options_scope: dict(
capture=repro_file,
ignore=['src'],
)}
repro_sub = global_subsystem_instance(Reproducer, options=options)
repro = repro_sub.create_repro() # This is normally called in pants_exe.
repro.capture(run_info_dict={})
extract_loc = os.path.join(capture_dir, 'extract')
TGZ.extract(repro_file, extract_loc)
assert_file = partial(self.assert_file, extract_loc)
assert_file('foo/bar', 'baz')
assert_not_exists = partial(self.assert_not_exists, extract_loc)
assert_not_exists('.git')
assert_not_exists('src')
def test_ivy_classifiers(self):
with self.temporary_workdir() as workdir:
test_target = 'testprojects/tests/java/org/pantsbuild/testproject/ivyclassifier:ivyclassifier'
json_data = self.run_export(test_target, workdir, load_libs=True)
ivy_subsystem = global_subsystem_instance(IvySubsystem)
ivy_cache_dir = ivy_subsystem.get_options().cache_dir
avro_lib_info = json_data.get('libraries').get('org.apache.avro:avro:1.7.7')
self.assertIsNotNone(avro_lib_info)
self.assertEquals(
avro_lib_info.get('default'),
os.path.join(ivy_cache_dir, 'org.apache.avro/avro/jars/avro-1.7.7.jar')
)
self.assertEquals(
avro_lib_info.get('tests'),
os.path.join(ivy_cache_dir, 'org.apache.avro/avro/jars/avro-1.7.7-tests.jar')
)
self.assertEquals(
avro_lib_info.get('javadoc'),
os.path.join(ivy_cache_dir, 'org.apache.avro/avro/javadocs/avro-1.7.7-javadoc.jar')
)
self.assertEquals(
avro_lib_info.get('sources'),
os.path.join(ivy_cache_dir, 'org.apache.avro/avro/sources/avro-1.7.7-sources.jar')
)
def setUp(self):
# Capture PythonSetup with the real BUILD_ROOT before that is reset to a tmpdir by super.
self.python_setup = global_subsystem_instance(PythonSetup)
super(PythonChrootTest, self).setUp()
def distribution(self): factory = global_subsystem_instance(GoDistribution.Factory) return factory.create()
def setUp(self): super(TestNativeToolchain, self).setUp() self.toolchain = global_subsystem_instance(NativeToolchain)
def test_validate_live_jdk(self):
Distribution(bin_path=os.path.dirname(self.JAVAC), jdk=True).validate()
Distribution(bin_path=os.path.dirname(self.JAVAC), jdk=True).binary('javap')
locator = global_subsystem_instance(DistributionLocator)
locator.cached(jdk=True)
def setUp(self):
super(TestNativeToolchain, self).setUp()
self.platform = Platform.create()
self.toolchain = global_subsystem_instance(NativeToolchain)
self.rules = native_backend_rules()
def _init_manager(self, **jar_dependency_management_options):
options = {JarDependencyManagement.options_scope: jar_dependency_management_options}
return global_subsystem_instance(JarDependencyManagement, options=options)
def _distribution_locator(distribution_locator_options=None):
options = {
DistributionLocator.options_scope: distribution_locator_options or {}
}
yield global_subsystem_instance(DistributionLocator, options=options)
def _distribution_locator(distribution_locator_options=None):
options = {
DistributionLocator.options_scope: distribution_locator_options or {}
}
yield global_subsystem_instance(DistributionLocator, options=options)
def setUp(self): # Capture PythonSetup with the real BUILD_ROOT before that is reset to a tmpdir by super. self.python_setup = global_subsystem_instance(PythonSetup) super(PythonChrootTest, self).setUp()
def get_thrift_version(apache_thrift_gen): thrift = global_subsystem_instance(Thrift).scoped_instance(apache_thrift_gen) return thrift.get_options().version
def watchman_launcher(self, options=None):
options = options or {}
return global_subsystem_instance(WatchmanLauncher.Factory, options=options).create()
def setUp(self): self.distribution = global_subsystem_instance(NodeDistribution.Factory).create()
def _jar_dependency_management(self, **flags):
Subsystem.reset()
options = {
JarDependencyManagement.options_scope: flags,
}
return global_subsystem_instance(JarDependencyManagement, options=options)
def distribution(self): return global_subsystem_instance(GoDistribution)
def fetcher(self, import_path): fetcher_factory = global_subsystem_instance(FetcherFactory) return fetcher_factory.get_fetcher(import_path)
def setUp(self):
self.distribution = global_subsystem_instance(NodeDistribution)
def _execute_junit_runner(self,
list_of_filename_content_tuples,
create_some_resources=True,
target_name=None):
# Create the temporary base test directory
test_rel_path = 'tests/java/org/pantsbuild/foo'
test_abs_path = self.create_dir(test_rel_path)
# Create the temporary classes directory under work dir
test_classes_abs_path = self.create_workdir_dir(test_rel_path)
test_java_file_abs_paths = []
# Generate the temporary java test source code.
for filename, content in list_of_filename_content_tuples:
test_java_file_rel_path = os.path.join(test_rel_path, filename)
test_java_file_abs_path = self.create_file(test_java_file_rel_path,
content)
test_java_file_abs_paths.append(test_java_file_abs_path)
# Invoke ivy to resolve classpath for junit.
classpath_file_abs_path = os.path.join(test_abs_path,
'junit.classpath')
ivy_subsystem = global_subsystem_instance(IvySubsystem)
distribution = DistributionLocator.cached(jdk=True)
ivy = Bootstrapper(ivy_subsystem=ivy_subsystem).ivy()
ivy.execute(args=[
'-cachepath', classpath_file_abs_path, '-dependency', 'junit',
'junit-dep', '4.10'
],
executor=SubprocessExecutor(distribution=distribution))
with open(classpath_file_abs_path) as fp:
classpath = fp.read()
# Now directly invoke javac to compile the test java code into classfiles that we can later
# inject into a product mapping for JUnitRun to execute against.
javac = distribution.binary('javac')
subprocess.check_call(
[javac, '-d', test_classes_abs_path, '-cp', classpath] +
test_java_file_abs_paths)
# If a target_name is specified create a target with it, otherwise create a junit_tests target.
if target_name:
target = self.target(target_name)
else:
target = self.create_library(test_rel_path, 'junit_tests',
'foo_test', ['FooTest.java'])
target_roots = []
if create_some_resources:
# Create a synthetic resource target.
target_roots.append(self.make_target('some_resources', Resources))
target_roots.append(target)
# Set the context with the two targets, one junit_tests target and
# one synthetic resources target.
# The synthetic resources target is to make sure we won't regress
# in the future with bug like https://github.com/pantsbuild/pants/issues/508. Note
# in that bug, the resources target must be the first one in the list.
context = self.context(target_roots=target_roots)
# Before we run the task, we need to inject the "runtime_classpath" with
# the compiled test java classes that JUnitRun will know which test
# classes to execute. In a normal run, this "runtime_classpath" will be
# populated by java compilation step.
self.populate_runtime_classpath(context=context,
classpath=[test_classes_abs_path])
# Finally execute the task.
self.execute(context)
def setUp(self): self.distribution = global_subsystem_instance(NodeDistribution)
def setUp(self): self.distribution = global_subsystem_instance(NodeDistribution.Factory).create()
def subprocess(self): return global_subsystem_instance(Subprocess.Factory).create()
def test_validate_live_jdk(self):
Distribution(bin_path=os.path.dirname(self.JAVAC), jdk=True).validate()
Distribution(bin_path=os.path.dirname(self.JAVAC), jdk=True).binary('javap')
locator = global_subsystem_instance(DistributionLocator)
locator.cached(jdk=True)
def pants_daemon_launcher(self): factory = global_subsystem_instance(PantsDaemonLauncher.Factory) pdl = factory.create(None) pdl.pantsd = self.mock_pantsd pdl.watchman_launcher = self.mock_watchman_launcher return pdl
def get_thrift_version(apache_thrift_gen): thrift = global_subsystem_instance(Thrift).scoped_instance(apache_thrift_gen) return thrift.get_options().version
def create_subsystem(subsystem_type, options=None):
return global_subsystem_instance(
subsystem_type,
options={subsystem_type.options_scope: options or {}})
