def bundle_and_run(self, target, bundle_name, bundle_jar_name=None, bundle_options=None,
args=None,
expected_bundle_jar_content=None,
expected_bundle_content=None,
library_jars_are_symlinks=True):
"""Creates the bundle with pants, then does java -jar {bundle_name}.jar to execute the bundle.
:param target: target name to compile
:param bundle_name: resulting bundle filename (minus .zip extension)
:param bundle_jar_name: monolithic jar filename (minus .jar extension), if None will be the
same as bundle_name
:param bundle_options: additional options for bundle
:param args: optional arguments to pass to executable
:param expected_bundle_content: verify the bundle zip content
:param expected_bundle_jar_content: verify the bundle jar content
:param library_jars_are_symlinks: verify library jars are symlinks if True, and actual
files if False. Default `True` because we always create symlinks for both external and internal
dependencies, only exception is when shading is used.
:return: stdout as a string on success, raises an Exception on error
"""
bundle_jar_name = bundle_jar_name or bundle_name
bundle_options = bundle_options or []
bundle_options = ['bundle.jvm'] + bundle_options + ['--archive=zip', target]
with self.pants_results(bundle_options) as pants_run:
self.assert_success(pants_run)
self.assertTrue(check_symlinks(f'dist/{bundle_name}-bundle/libs', library_jars_are_symlinks))
# TODO(John Sirois): We need a zip here to suck in external library classpath elements
# pointed to by symlinks in the run_pants ephemeral tmpdir. Switch run_pants to be a
# contextmanager that yields its results while the tmpdir workdir is still active and change
# this test back to using an un-archived bundle.
with temporary_dir() as workdir:
ZIP.extract(f'dist/{bundle_name}.zip', workdir)
if expected_bundle_content:
self.assertTrue(contains_exact_files(workdir, expected_bundle_content))
if expected_bundle_jar_content:
with temporary_dir() as check_bundle_jar_dir:
bundle_jar = os.path.join(workdir, f'{bundle_jar_name}.jar')
ZIP.extract(bundle_jar, check_bundle_jar_dir)
self.assertTrue(contains_exact_files(check_bundle_jar_dir, expected_bundle_jar_content))
optional_args = []
if args:
optional_args = args
java_run = subprocess.Popen(
['java', '-jar', f'{bundle_jar_name}.jar'] + optional_args,
stdout=subprocess.PIPE,
cwd=workdir
)
stdout, _ = java_run.communicate()
java_returncode = java_run.returncode
self.assertEqual(java_returncode, 0)
return stdout.decode()
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_canonical_classpath_helper(
self,
classpath_products,
targets,
libs_dir,
expected_canonical_classpath,
expected_classpath_files,
excludes=None,
):
"""Helper method to call `create_canonical_classpath` and verify generated canonical
classpath.
:param ClasspathProducts classpath_products: Classpath products.
:param list targets: List of targets to generate canonical classpath from.
:param string libs_dir: Directory where canonical classpath are to be generated.
:param list expected_canonical_classpath: List of canonical classpath relative to a base directory.
:param dict expected_classpath_files: A dict of classpath.txt path to its expected content.
"""
canonical_classpath = ClasspathProducts.create_canonical_classpath(
classpath_products,
targets,
libs_dir,
save_classpath_file=True,
internal_classpath_only=False,
excludes=excludes,
)
# check canonical path returned
self.assertEqual(expected_canonical_classpath,
relativize_paths(canonical_classpath, libs_dir))
# check canonical path created contain the exact set of files, no more, no less
self.assertTrue(
contains_exact_files(
libs_dir, expected_canonical_classpath +
list(expected_classpath_files.keys())))
# check the content of classpath.txt
for classpath_file in expected_classpath_files:
self.assertTrue(
check_file_content(
os.path.join(libs_dir, classpath_file),
expected_classpath_files[classpath_file],
))
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))
