class JunitRunIntegrationTest(PantsRunIntegrationTest): def _testjvms(self, spec_name): spec = 'testprojects/tests/java/org/pantsbuild/testproject/testjvms:{}'.format(spec_name) self.assert_success(self.run_pants(['clean-all', 'test.junit', '--strict-jvm-version', spec])) @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_java_eight(self): self._testjvms('eight') @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_with_test_platform(self): self._testjvms('eight-test-platform') def test_junit_run_against_class_succeeds(self): pants_run = self.run_pants(['clean-all', 'test.junit', '--test=org.pantsbuild.testproject.matcher.MatcherTest', 'testprojects/tests/java/org/pantsbuild/testproject/matcher']) self.assert_success(pants_run) def report_file_path(self, relpath): return os.path.join(get_buildroot(), 'dist', relpath) def cucumber_coverage(self, processor, xml_path, html_path, tests=(), args=()): return self.coverage( processor, xml_path, html_path, 'testprojects/tests/java/org/pantsbuild/testproject/unicode/cucumber', 'org.pantsbuild.testproject.unicode.cucumber.CucumberTest', tests, args ) @contextmanager def coverage(self, processor, xml_path, html_path, test_project, test_class='', tests=(), args=()): def test_specifier_arg(test): return '--test={}#{}'.format(test_class, test) with self.pants_results(['clean-all', 'test.junit'] + list(args) + [test_specifier_arg(name) for name in tests] + [test_project, '--test-junit-coverage-processor={}'.format(processor), '--test-junit-coverage']) as results: self.assert_success(results) coverage_xml = self.report_file_path(xml_path) self.assertTrue(os.path.isfile(coverage_xml)) coverage_html = self.report_file_path(html_path) self.assertTrue(os.path.isfile(coverage_html)) def read_utf8(path): with codecs.open(path, 'r', encoding='utf8') as fp: return fp.read() yield ET.parse(coverage_xml).getroot(), read_utf8(coverage_html) def do_test_junit_run_with_coverage_succeeds_cobertura(self, tests=(), args=()): html_path = ('test/junit/coverage/reports/html/' 'org.pantsbuild.testproject.unicode.cucumber.CucumberAnnotatedExample.html') with self.cucumber_coverage(processor='cobertura', xml_path='test/junit/coverage/reports/xml/coverage.xml', html_path=html_path, tests=tests, args=args) as (xml_report, html_report_string): # Validate 100% coverage; ie a line coverage rate of 1. self.assertEqual('coverage', xml_report.tag) self.assertEqual(1.0, float(xml_report.attrib['line-rate'])) # Validate that the html report was able to find sources for annotation. self.assertIn('String pleasantry1()', html_report_string) self.assertIn('String pleasantry2()', html_report_string) self.assertIn('String pleasantry3()', html_report_string) def test_junit_run_with_coverage_succeeds_cobertura(self): self.do_test_junit_run_with_coverage_succeeds_cobertura() def test_junit_run_with_coverage_succeeds_cobertura_merged(self): self.do_test_junit_run_with_coverage_succeeds_cobertura(tests=['testUnicodeClass1', 'testUnicodeClass2', 'testUnicodeClass3'], args=['--batch-size=2']) def do_test_junit_run_with_coverage_succeeds_jacoco(self, tests=(), args=()): html_path = ('test/junit/coverage/reports/html/' 'org.pantsbuild.testproject.unicode.cucumber/CucumberAnnotatedExample.html') with self.cucumber_coverage(processor='jacoco', xml_path='test/junit/coverage/reports/xml', html_path=html_path, tests=tests, args=args) as (xml_report, html_report_string): # Validate 100% coverage; ie: 0 missed instructions. self.assertEqual('report', xml_report.tag) counters = xml_report.findall('counter[@type="INSTRUCTION"]') self.assertEqual(1, len(counters)) total_instruction_counter = counters[0] self.assertEqual(0, int(total_instruction_counter.attrib['missed'])) self.assertGreater(int(total_instruction_counter.attrib['covered']), 0) # Validate that the html report was able to find sources for annotation. self.assertIn('class="el_method">pleasantry1()</a>', html_report_string) self.assertIn('class="el_method">pleasantry2()</a>', html_report_string) self.assertIn('class="el_method">pleasantry3()</a>', html_report_string) def test_junit_run_with_coverage_succeeds_jacoco(self): self.do_test_junit_run_with_coverage_succeeds_jacoco() def test_junit_run_with_coverage_succeeds_jacoco_merged(self): self.do_test_junit_run_with_coverage_succeeds_jacoco(tests=['testUnicodeClass1', 'testUnicodeClass2', 'testUnicodeClass3'], args=['--batch-size=2']) def test_junit_run_with_coverage_filters_targets_jacoco(self): coverage_test_project = 'testprojects/tests/java/org/pantsbuild/testproject/coverage' html_path = ('test/junit/coverage/reports/html/' 'index.html') filter_arg = '--jacoco-target-filters=one' with self.coverage(processor='jacoco', xml_path='test/junit/coverage/reports/xml', html_path=html_path, test_project=coverage_test_project, args=[filter_arg]) as (xml_report, html_report_string): coverage_one = xml_report.find('package/class[@name="org/pantsbuild/testproject/coverage/one/CoverageClassOne"]') coverage_two = xml_report.find('package/class[@name="org/pantsbuild/testproject/coverage/two/CoverageClassTwo"]') self.assertNotEqual(None, coverage_one) self.assertEqual(None, coverage_two) def test_junit_run_against_invalid_class_fails(self): pants_run = self.run_pants(['clean-all', 'test.junit', '--test=org.pantsbuild.testproject.matcher.MatcherTest_BAD_CLASS', 'testprojects/tests/java/org/pantsbuild/testproject/matcher']) self.assert_failure(pants_run) self.assertIn("No target found for test specifier", pants_run.stdout_data) def test_junit_run_timeout_succeeds(self): sleeping_target = 'testprojects/tests/java/org/pantsbuild/testproject/timeout:sleeping_target' pants_run = self.run_pants(['clean-all', 'test.junit', '--timeouts', '--timeout-default=5', '--timeout-terminate-wait=1', '--test=org.pantsbuild.testproject.timeout.ShortSleeperTest', sleeping_target]) self.assert_success(pants_run) def test_junit_run_timeout_fails(self): sleeping_target = 'testprojects/tests/java/org/pantsbuild/testproject/timeout:sleeping_target' start = time.time() pants_run = self.run_pants(['clean-all', 'test.junit', '--timeouts', '--timeout-default=5', '--timeout-terminate-wait=1', '--test=org.pantsbuild.testproject.timeout.LongSleeperTest', sleeping_target]) end = time.time() self.assert_failure(pants_run) # Ensure that the failure took less than 120 seconds to run. self.assertLess(end - start, 120) # Ensure that the timeout triggered. self.assertIn(" timed out after 5 seconds", pants_run.stdout_data) def test_junit_tests_using_cucumber(self): test_spec = 'testprojects/tests/java/org/pantsbuild/testproject/cucumber' with self.pants_results(['clean-all', 'test.junit', '--per-test-timer', test_spec]) as results: self.assert_success(results) def test_disable_synthetic_jar(self): synthetic_jar_target = 'testprojects/tests/java/org/pantsbuild/testproject/syntheticjar:test' output = self.run_pants(['test.junit', '--output-mode=ALL', synthetic_jar_target]).stdout_data self.assertIn('Synthetic jar run is detected', output) output = self.run_pants(['test.junit', '--output-mode=ALL', '--no-jvm-synthetic-classpath', synthetic_jar_target]).stdout_data self.assertIn('Synthetic jar run is not detected', output) def do_test_junit_run_with_html_report(self, tests=(), args=()): def html_report_test(test): return '--test=org.pantsbuild.testproject.htmlreport.HtmlReportTest#{}'.format(test) with self.pants_results(['clean-all', 'test.junit'] + list(args) + [html_report_test(name) for name in tests] + ['testprojects/tests/java/org/pantsbuild/testproject/htmlreport::', '--test-junit-html-report']) as results: self.assert_failure(results) report_html = self.report_file_path('test/junit/reports/junit-report.html') self.assertTrue(os.path.isfile(report_html)) with codecs.open(report_html, 'r', encoding='utf8') as src: html = src.read() self.assertIn('testPasses', html) self.assertIn('testFails', html) self.assertIn('testErrors', html) self.assertIn('testSkipped', html) def test_junit_run_with_html_report(self): self.do_test_junit_run_with_html_report() def test_junit_run_with_html_report_merged(self): self.do_test_junit_run_with_html_report(tests=['testPasses', 'testFails', 'testErrors', 'testSkipped'], args=['--batch-size=3'])
# coding=utf-8 # Copyright 2014 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import absolute_import, division, print_function, unicode_literals from unittest import skipIf from pants_test.backend.jvm.tasks.jvm_compile.base_compile_integration_test import BaseCompileIT from pants_test.backend.jvm.tasks.missing_jvm_check import is_missing_jvm @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') class JavacPluginIntegrationTest(BaseCompileIT): example_dir = 'examples/src/java/org/pantsbuild/example/javac/plugin' def _do_test(self, expected_args, config, target): with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( ['compile', '{}:{}'.format(self.example_dir, target)], workdir, config) self.assert_success(pants_run) self.assertIn( 'SimpleJavacPlugin ran with {} args: {}'.format( len(expected_args), ' '.join(expected_args)), pants_run.stdout_data) # Note that in the terminology of this test, "global" means specified via options for # all targets, and "local" means specified on an individual target. def _do_test_global(self, args): config = {
# Copyright 2014 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from unittest import skipIf from pants_test.backend.jvm.tasks.jvm_compile.base_compile_integration_test import BaseCompileIT from pants_test.backend.jvm.tasks.missing_jvm_check import is_missing_jvm @skipIf(is_missing_jvm("1.8"), "no java 1.8 installation on testing machine") class JavacPluginIntegrationTest(BaseCompileIT): example_dir = "examples/src/java/org/pantsbuild/example/javac/plugin" def _do_test(self, expected_args, config, target): with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( ["compile", f"{self.example_dir}:{target}"], workdir, config) self.assert_success(pants_run) self.assertIn( "SimpleJavacPlugin ran with {} args: {}".format( len(expected_args), " ".join(expected_args)), pants_run.stdout_data, ) # Note that in the terminology of this test, "global" means specified via options for # all targets, and "local" means specified on an individual target. def _do_test_global(self, args): config = { "java": { "javac_plugins": ["simple_javac_plugin"], "javac_plugin_args": {
class ZincCompileIntegrationTest(BaseCompileIT): def test_java_src_zinc_compile(self): # TODO: Remove the --exclude-target-regexp once we're on Java 8 everywhere. with self.do_test_compile( 'examples/src/java/::', extra_args= [ '--exclude-target-regexp=examples/src/java/org/pantsbuild/example/plugin' ]): # run succeeded as expected pass with self.do_test_compile('examples/tests/java/::'): # run succeeded as expected pass def test_in_process(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=['-ldebug'], clean_all=True) self.assertIn( 'Attempting to call com.sun.tools.javac.api.JavacTool', pants_run.stdout_data) self.assertNotIn('Forking javac', pants_run.stdout_data) def test_log_level(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target' pants_run = self.run_test_compile(workdir, cachedir, target, extra_args=['--no-colors'], clean_all=True) self.assertIn('[warn] import sun.security.x509.X500Name;', pants_run.stdout_data) self.assertIn( '[error] System2.out.println("Hello World!");', pants_run.stdout_data) def test_unicode_source_symbol(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/scala/org/pantsbuild/testproject/unicode/unicodedep/consumer' pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=[ '--cache-compile-zinc-write-to=["{}/dummy_artifact_cache_dir"]' .format(cachedir), ], clean_all=True, ) self.assert_success(pants_run) def test_apt_compile(self): with self.do_test_compile( 'testprojects/src/java/org/pantsbuild/testproject/annotation/processor', expected_files=[ 'ResourceMappingProcessor.class', 'javax.annotation.processing.Processor' ]) as found: self.assertTrue( self.get_only(found, 'ResourceMappingProcessor.class'). endswith( 'org/pantsbuild/testproject/annotation/processor/ResourceMappingProcessor.class' )) processor_service_files = found[ 'javax.annotation.processing.Processor'] # There should be only a per-target service info file. self.assertEqual(1, len(processor_service_files)) processor_service_file = list(processor_service_files)[0] self.assertTrue( processor_service_file.endswith( 'META-INF/services/javax.annotation.processing.Processor')) with open(processor_service_file) as fp: self.assertEqual( 'org.pantsbuild.testproject.annotation.processor.ResourceMappingProcessor', fp.read().strip()) def test_apt_compile_and_run(self): with self.do_test_compile( 'testprojects/src/java/org/pantsbuild/testproject/annotation/main', expected_files=['Main.class', 'deprecation_report.txt']) as found: self.assertTrue( self.get_only(found, 'Main.class').endswith( 'org/pantsbuild/testproject/annotation/main/Main.class')) # This is the proof that the ResourceMappingProcessor annotation processor was compiled in a # round and then the Main was compiled in a later round with the annotation processor and its # service info file from on its compile classpath. with open(self.get_only(found, 'deprecation_report.txt')) as fp: self.assertIn( 'org.pantsbuild.testproject.annotation.main.Main', fp.read().splitlines()) def test_stale_apt_with_deps(self): """An annotation processor with a dependency doesn't pollute other annotation processors. At one point, when you added an annotation processor, it stayed configured for all subsequent compiles. Meaning that if that annotation processor had a dep that wasn't on the classpath, subsequent compiles would fail with missing symbols required by the stale annotation processor. """ # Demonstrate that the annotation processor is working with self.do_test_compile( 'testprojects/src/java/org/pantsbuild/testproject/annotation/processorwithdep/main', expected_files=[ 'Main.class', 'Main_HelloWorld.class', 'Main_HelloWorld.java' ]) as found: gen_file = self.get_only(found, 'Main_HelloWorld.java') self.assertTrue(gen_file.endswith( 'org/pantsbuild/testproject/annotation/processorwithdep/main/Main_HelloWorld.java' ), msg='{} does not match'.format(gen_file)) # Try to reproduce second compile that fails with missing symbol with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: # This annotation processor has a unique external dependency self.assert_success( self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/annotation/processorwithdep::' )) # When we run a second compile with annotation processors, make sure the previous annotation # processor doesn't stick around to spoil the compile self.assert_success( self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/annotation/processor::', clean_all=False)) def test_fatal_warning(self): def test_combination(target, default_fatal_warnings, expect_success): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: if default_fatal_warnings: arg = '--java-fatal-warnings' else: arg = '--no-java-fatal-warnings' pants_run = self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/compilation_warnings:{}' .format(target), extra_args=[ arg, '--compile-zinc-warning-args=-C-Xlint:all' ]) if expect_success: self.assert_success(pants_run) else: self.assert_failure(pants_run) test_combination('defaultfatal', default_fatal_warnings=True, expect_success=False) test_combination('defaultfatal', default_fatal_warnings=False, expect_success=True) test_combination('fatal', default_fatal_warnings=True, expect_success=False) test_combination('fatal', default_fatal_warnings=False, expect_success=False) test_combination('nonfatal', default_fatal_warnings=True, expect_success=True) test_combination('nonfatal', default_fatal_warnings=False, expect_success=True) def test_classpath_does_not_include_extra_classes_dirs(self): target_rel_spec = 'testprojects/src/java/org/pantsbuild/testproject/phrases:' classpath_file_by_target_id = {} for target_name in [ 'there-was-a-duck', 'lesser-of-two', 'once-upon-a-time', 'ten-thousand' ]: target_id = Target.compute_target_id( Address.parse('{}{}'.format(target_rel_spec, target_name))) classpath_file_by_target_id[target_id] = '{}.txt'.format(target_id) with self.do_test_compile( target_rel_spec, expected_files=classpath_file_by_target_id.values(), extra_args=['--compile-zinc-capture-classpath']) as found: for target_id, filename in classpath_file_by_target_id.items(): found_classpath_file = self.get_only(found, filename) with open(found_classpath_file, 'r') as f: contents = f.read() self.assertIn(target_id, contents) other_target_ids = set( classpath_file_by_target_id.keys()) - {target_id} for other_id in other_target_ids: self.assertNotIn(other_id, contents) def test_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile( target_spec, expected_files=[classpath_filename, 'PrintVersion.class'], extra_args=['--compile-zinc-capture-classpath']) as found: found_classpath_file = self.get_only(found, classpath_filename) self.assertTrue( found_classpath_file.endswith( os.path.join('compile_classpath', classpath_filename))) with open(found_classpath_file, 'r') as f: self.assertIn(target_id, f.read()) def test_no_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile( target_spec, expected_files=['PrintVersion.class'], extra_args=['--no-compile-zinc-capture-classpath']) as found: self.assertFalse(classpath_filename in found) @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_custom_javac(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=[ '--java-javac=testprojects/3rdparty/javactool:custom_javactool_for_testing' ], clean_all=True) self.assertNotEquals( 0, pants_run.returncode) # Our custom javactool always fails. self.assertIn('Pants caused Zinc to load a custom JavacTool', pants_run.stdout_data) def test_no_zinc_file_manager(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/bench:jmh' with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile(workdir, cachedir, target_spec, clean_all=True) self.assertEquals(0, pants_run.returncode)
# coding=utf-8 # Copyright 2014 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import (absolute_import, division, generators, nested_scopes, print_function, unicode_literals, with_statement) from unittest import skipIf from pants_test.backend.jvm.tasks.jvm_compile.base_compile_integration_test import BaseCompileIT from pants_test.backend.jvm.tasks.missing_jvm_check import is_missing_jvm @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') class JavacPluginIntegrationTest(BaseCompileIT): # A target without a dep on the plugin. independent_tgt = 'testprojects/src/java/org/pantsbuild/testproject/publish/hello/main' # A target with a dep on the plugin. dependent_tgt = 'examples/src/java/org/pantsbuild/example/plugin:hello_plugin' def _do_test_plugin(self, args, compile_tgt, global_plugin): config = { 'compile.zinc': { 'javac_plugins': 'simple_javac_plugin', 'javac_plugin_args': { 'simple_javac_plugin': args } } } if global_plugin:
class ZincCompileIntegrationTest(BaseCompileIT): def test_java_src_zinc_compile(self): with self.do_test_compile('examples/src/java/::'): # run succeeded as expected pass with self.do_test_compile('examples/tests/java/::'): # run succeeded as expected pass def test_in_process(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=['-ldebug'], clean_all=True ) self.assertIn('Attempting to call com.sun.tools.javac.api.JavacTool', pants_run.stdout_data) self.assertNotIn('Forking javac', pants_run.stdout_data) def test_log_level(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target' pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=['--no-colors'], clean_all=True ) self.assert_failure(pants_run) self.assertIn('[warn] import sun.security.x509.X500Name;', pants_run.stdout_data) self.assertIn('[error] System2.out.println("Hello World!");', pants_run.stdout_data) def test_unicode_source_symbol(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/scala/org/pantsbuild/testproject/unicode/unicodedep/consumer' pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=[ '--cache-compile-zinc-write-to=["{}/dummy_artifact_cache_dir"]'.format(cachedir), ], clean_all=True, ) self.assert_success(pants_run) def test_fatal_warning(self): def test_combination(target, expect_success): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/compilation_warnings:{}'.format(target), extra_args=['--compile-zinc-warning-args=-C-Xlint:all']) if expect_success: self.assert_success(pants_run) else: self.assert_failure(pants_run) test_combination('fatal', expect_success=False) test_combination('nonfatal', expect_success=True) def test_classpath_does_not_include_extra_classes_dirs(self): target_rel_spec = 'testprojects/src/java/org/pantsbuild/testproject/phrases:' classpath_file_by_target_id = {} for target_name in ['there-was-a-duck', 'lesser-of-two', 'once-upon-a-time', 'ten-thousand']: target_id = Target.compute_target_id(Address.parse('{}{}' .format(target_rel_spec, target_name))) classpath_file_by_target_id[target_id] = '{}.txt'.format(target_id) with self.do_test_compile(target_rel_spec, expected_files = list(classpath_file_by_target_id.values()), extra_args=['--compile-zinc-capture-classpath']) as found: for target_id, filename in classpath_file_by_target_id.items(): found_classpath_file = self.get_only(found, filename) with open(found_classpath_file, 'r') as f: contents = f.read() self.assertIn(target_id, contents) other_target_ids = set(classpath_file_by_target_id.keys()) - {target_id} for other_id in other_target_ids: self.assertNotIn(other_id, contents) def test_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile(target_spec, expected_files=[classpath_filename, 'PrintVersion.class'], extra_args=['--compile-zinc-capture-classpath']) as found: found_classpath_file = self.get_only(found, classpath_filename) self.assertTrue(found_classpath_file .endswith(os.path.join('compile_classpath', classpath_filename))) with open(found_classpath_file, 'r') as f: self.assertIn(target_id, f.read()) def test_no_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile(target_spec, expected_files=['PrintVersion.class'], extra_args=['--no-compile-zinc-capture-classpath']) as found: self.assertFalse(classpath_filename in found) @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_custom_javac(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=['--java-javac=testprojects/3rdparty/javactool:custom_javactool_for_testing'], clean_all=True ) self.assertNotEqual(0, pants_run.returncode) # Our custom javactool always fails. self.assertIn('Pants caused Zinc to load a custom JavacTool', pants_run.stdout_data) def test_no_zinc_file_manager(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/bench:jmh' with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile(workdir, cachedir, target_spec, clean_all=True) self.assertEqual(0, pants_run.returncode) def test_failed_hermetic_incremental_compile(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': {'write_to': [cache_dir]}, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': True, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_failure(pants_run) self.assertIn('Please use --no-compile-zinc-incremental', pants_run.stdout_data) def test_failed_compile_with_hermetic(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': {'write_to': [cache_dir]}, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'compile', 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', ], workdir, config, ) self.assert_failure(pants_run) self.assertIn('package System2 does not exist', pants_run.stderr_data) self.assertIn( 'Failed jobs: compile(testprojects/src/java/org/pantsbuild/testproject/dummies:' 'compilation_failure_target)', pants_run.stdout_data) def test_failed_compile_with_subprocess(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': {'write_to': [cache_dir]}, 'compile.zinc': { 'execution_strategy': 'subprocess', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ # NB: We don't use -q here because subprocess squashes the error output # See https://github.com/pantsbuild/pants/issues/5646 'compile', 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', ], workdir, config, ) self.assert_failure(pants_run) self.assertIn('package System2 does not exist', pants_run.stdout_data) self.assertIn( 'Failed jobs: compile(testprojects/src/java/org/pantsbuild/testproject/dummies:' 'compilation_failure_target)', pants_run.stdout_data) def test_hermetic_binary_with_dependencies(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': {'write_to': [cache_dir]}, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'zinc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) def test_hermetic_binary_cache_with_dependencies(self): file_abs_path = os.path.join(get_buildroot(), 'examples/src/scala/org/pantsbuild/example/hello/exe/Exe.scala') with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': {'write_to': [cache_dir]}, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'zinc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) with self.with_overwritten_file_content(file_abs_path): new_temp_test = '''package org.pantsbuild.example.hello.exe import java.io.{BufferedReader, InputStreamReader} import org.pantsbuild.example.hello.welcome // A simple jvm binary to illustrate Scala BUILD targets object Exe { /** Test that resources are properly namespaced. */ def getWorld: String = { val is = this.getClass.getClassLoader.getResourceAsStream( "org/pantsbuild/example/hello/world.txt" ) try { new BufferedReader(new InputStreamReader(is)).readLine() } finally { is.close() } } def main(args: Array[String]) { println("Num args passed: " + args.size + ". Stand by for welcome...") if (args.size <= 0) { println("Hello, and welcome to " + getWorld + "!") } else { val w = welcome.WelcomeEverybody(args) w.foreach(s => println(s)) } } }''' with open(file_abs_path, 'w') as f: f.write(new_temp_test) pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, and welcome to Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'zinc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) def test_hermetic_binary_with_3rdparty_dependencies(self): for resolver in ('ivy', 'coursier'): for use_classpath_jars in (False, True): config = { 'resolve.ivy': {'capture_snapshots': True}, 'resolve.coursier': {'capture_snapshots': True}, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': use_classpath_jars, 'incremental': False, }, 'resolver': { 'resolver': resolver, } } with self.temporary_workdir() as workdir: with self.temporary_file_content("readme.txt", b"yo"): pants_run = self.run_pants_with_workdir( [ 'run', 'testprojects/src/java/org/pantsbuild/testproject/cwdexample', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Found readme.txt', pants_run.stdout_data, )
class ZincCompileIntegrationTest(BaseCompileIT): def test_in_process(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=['-ldebug'], clean_all=True) self.assertIn( 'Attempting to call com.sun.tools.javac.api.JavacTool', pants_run.stdout_data) self.assertNotIn('Forking javac', pants_run.stdout_data) def test_log_level(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target' pants_run = self.run_test_compile(workdir, cachedir, target, extra_args=['--no-colors'], clean_all=True) self.assert_failure(pants_run) self.assertIn('[warn] import sun.security.x509.X500Name;', pants_run.stdout_data) self.assertIn( '[error] System2.out.println("Hello World!");', pants_run.stdout_data) def test_unicode_source_symbol(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/scala/org/pantsbuild/testproject/unicode/unicodedep/consumer' pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=[ '--cache-compile-rsc-write-to=["{}/dummy_artifact_cache_dir"]' .format(cachedir), ], clean_all=True, ) self.assert_success(pants_run) def test_fatal_warning(self): def test_combination(target, expect_success): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/compilation_warnings:{}' .format(target), extra_args=['--compile-rsc-warning-args=-C-Xlint:all']) if expect_success: self.assert_success(pants_run) else: self.assert_failure(pants_run) test_combination('fatal', expect_success=False) test_combination('nonfatal', expect_success=True) def test_classpath_does_not_include_extra_classes_dirs(self): target_rel_spec = 'testprojects/src/java/org/pantsbuild/testproject/phrases:' classpath_file_by_target_id = {} for target_name in [ 'there-was-a-duck', 'lesser-of-two', 'once-upon-a-time', 'ten-thousand' ]: target_id = Target.compute_target_id( Address.parse('{}{}'.format(target_rel_spec, target_name))) classpath_file_by_target_id[target_id] = '{}.txt'.format(target_id) with self.do_test_compile( target_rel_spec, expected_files=list(classpath_file_by_target_id.values()), extra_args=['--compile-rsc-capture-classpath']) as found: for target_id, filename in classpath_file_by_target_id.items(): found_classpath_file = self.get_only(found, filename) with open(found_classpath_file, 'r') as f: contents = f.read() self.assertIn(target_id, contents) other_target_ids = set( classpath_file_by_target_id.keys()) - {target_id} for other_id in other_target_ids: self.assertNotIn(other_id, contents) def test_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile( target_spec, expected_files=[classpath_filename, 'PrintVersion.class'], extra_args=['--compile-rsc-capture-classpath']) as found: found_classpath_file = self.get_only(found, classpath_filename) self.assertTrue( found_classpath_file.endswith( os.path.join('compile_classpath', classpath_filename))) with open(found_classpath_file, 'r') as f: self.assertIn(target_id, f.read()) def test_no_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile( target_spec, expected_files=['PrintVersion.class'], extra_args=['--no-compile-rsc-capture-classpath']) as found: self.assertFalse(classpath_filename in found) @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_custom_javac(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=[ '--java-javac=testprojects/3rdparty/javactool:custom_javactool_for_testing' ], clean_all=True) self.assertNotEqual( 0, pants_run.returncode) # Our custom javactool always fails. self.assertIn('Pants caused Zinc to load a custom JavacTool', pants_run.stdout_data) def test_no_zinc_file_manager(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/bench:jmh' with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile(workdir, cachedir, target_spec, clean_all=True) self.assertEqual(0, pants_run.returncode) def test_hermetic_incremental_compile(self): """ 1) create a target containing two scala files 2) compile the target, which would be a full compile 3) modify a scala file slightly 4) recompile, and make sure the compile is incremental by checking the zinc outputs """ with self.temporary_workdir(cleanup=False) as tmp_build_root: # Make sure the tmp build root is recognized by Pants as a build root # by touching BUILDROOT. with open(os.path.join(tmp_build_root, 'BUILDROOT'), 'w') as f: f.write('') def _create_file(relpath, contents='', mode='w'): """Writes to a file under the buildroot. :API: public relpath: The relative path to the file from the build root. contents: A string containing the contents of the file - '' by default.. mode: The mode to write to the file in - over-write by default. """ path = os.path.join(tmp_build_root, relpath) with safe_open(path, mode=mode) as fp: fp.write(contents) return path def _create_a_target_containing_two_sources(): _srcfile_a = 'org/pantsbuild/incr/A.scala' _srcfile_b = 'org/pantsbuild/incr/B.scala' _build_file = 'org/pantsbuild/incr/BUILD' _lib_spec = 'org/pantsbuild/incr/' _create_file(_build_file, 'scala_library()') _srcfile_content = dedent(""" package org.pantsbuild.cachetest object A { def x(y: Option[Int] = None) = { println("hello"); } } """) _create_file(_srcfile_a, _srcfile_content) _create_file( _srcfile_b, dedent(""" package org.pantsbuild.cachetest object B extends App { A.x(); System.exit(0); } """)) return _lib_spec, _srcfile_a, _srcfile_content with temporary_dir() as cache_dir, \ temporary_dir(root_dir=tmp_build_root, suffix='.pants.d') as workdir: config = { 'cache.compile.rsc': { 'write_to': [cache_dir] }, 'compile.rsc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': True, 'incremental': True, } } lib_spec, src_file_a, srcfile_content = _create_a_target_containing_two_sources( ) pants_run = self.run_pants_with_workdir( ['-ldebug', 'compile', lib_spec], workdir=workdir, config=config, cwd=tmp_build_root) self.assert_success(pants_run) self.assertIn( 'Full compilation, no sources in previous analysis', pants_run.stdout_data) self.assertIn('Compiling 2 Scala sources', pants_run.stdout_data) # Modify the source file slightly _create_file(src_file_a, srcfile_content.replace('hello', 'bye')) pants_run = self.run_pants_with_workdir( ['-ldebug', 'compile', lib_spec], workdir=workdir, config=config, cwd=tmp_build_root) self.assert_success(pants_run) self.assertIn('Compiling 1 Scala source', pants_run.stdout_data) def test_failed_compile_with_hermetic(self): with temporary_dir() as cache_dir: config = { 'cache.compile.rsc': { 'write_to': [cache_dir] }, 'compile.rsc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'compile', 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', ], workdir, config, ) self.assert_failure(pants_run) self.assertIn('package System2 does not exist', pants_run.stderr_data) self.assertTrue( re.search( 'Compilation failure.*testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', pants_run.stdout_data)) def test_failed_compile_with_subprocess(self): with temporary_dir() as cache_dir: config = { 'cache.compile.rsc': { 'write_to': [cache_dir] }, 'compile.rsc': { 'execution_strategy': 'subprocess', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ # NB: We don't use -q here because subprocess squashes the error output # See https://github.com/pantsbuild/pants/issues/5646 'compile', 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', ], workdir, config, ) self.assert_failure(pants_run) self.assertIn('package System2 does not exist', pants_run.stdout_data) self.assertTrue( re.search( 'Compilation failure.*testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', pants_run.stdout_data)) def test_hermetic_binary_with_dependencies(self): with temporary_dir() as cache_dir: config = { 'cache.compile.rsc': { 'write_to': [cache_dir] }, 'compile.rsc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'rsc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/zinc/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/zinc/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) def test_hermetic_binary_cache_with_dependencies(self): file_abs_path = os.path.join( get_buildroot(), 'examples/src/scala/org/pantsbuild/example/hello/exe/Exe.scala') with temporary_dir() as cache_dir: config = { 'cache.compile.rsc': { 'write_to': [cache_dir], 'read_from': [cache_dir] }, 'compile.rsc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'rsc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/zinc/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/zinc/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) with self.with_overwritten_file_content(file_abs_path): new_temp_test = '''package org.pantsbuild.example.hello.exe import java.io.{BufferedReader, InputStreamReader} import org.pantsbuild.example.hello import org.pantsbuild.example.hello.welcome // A simple jvm binary to illustrate Scala BUILD targets object Exe { /** Test that resources are properly namespaced. */ def getWorld: String = { val is = this.getClass.getClassLoader.getResourceAsStream( "org/pantsbuild/example/hello/world.txt" ) try { new BufferedReader(new InputStreamReader(is)).readLine() } finally { is.close() } } def main(args: Array[String]) { println("Num args passed: " + args.size + ". Stand by for welcome...") if (args.size <= 0) { println("Hello, and welcome to " + getWorld + "!") } else { val w = welcome.WelcomeEverybody(args) w.foreach(s => println(s)) } } }''' with open(file_abs_path, 'w') as f: f.write(new_temp_test) pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, and welcome to Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'rsc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/zinc/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/zinc/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path))
class JunitRunIntegrationTest(PantsRunIntegrationTest): def _testjvms(self, spec_name): spec = 'testprojects/tests/java/org/pantsbuild/testproject/testjvms:{}'.format(spec_name) self.assert_success(self.run_pants(['clean-all', 'test.junit', '--strict-jvm-version', spec])) @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_java_eight(self): self._testjvms('eight') @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_with_test_platform(self): self._testjvms('eight-test-platform') def test_junit_run_against_class_succeeds(self): pants_run = self.run_pants(['clean-all', 'test.junit', '--test=org.pantsbuild.testproject.matcher.MatcherTest', 'testprojects/tests/java/org/pantsbuild/testproject/matcher']) self.assert_success(pants_run) def test_junit_run_with_cobertura_coverage_succeeds(self): with self.pants_results(['clean-all', 'test.junit', 'testprojects/tests/java/org/pantsbuild/testproject/unicode::', '--test-junit-coverage-processor=cobertura', '--test-junit-coverage']) as results: self.assert_success(results) # validate that the expected coverage file exists, and it reflects 100% line rate coverage coverage_xml = os.path.join(results.workdir, 'test/junit/coverage/xml/coverage.xml') self.assertTrue(os.path.isfile(coverage_xml)) with codecs.open(coverage_xml, 'r', encoding='utf8') as xml: self.assertIn('line-rate="1.0"', xml.read()) # validate that the html report was able to find sources for annotation cucumber_src_html = os.path.join( results.workdir, 'test/junit/coverage/html/' 'org.pantsbuild.testproject.unicode.cucumber.CucumberAnnotatedExample.html') self.assertTrue(os.path.isfile(cucumber_src_html)) with codecs.open(cucumber_src_html, 'r', encoding='utf8') as src: self.assertIn('String pleasantry()', src.read()) def test_junit_run_with_jacoco_coverage_succeeds(self): with self.pants_results(['clean-all', 'test.junit', 'testprojects/tests/java/org/pantsbuild/testproject/unicode::', '--test-junit-coverage-processor=jacoco', '--test-junit-coverage']) as results: self.assert_success(results) # validate that the expected coverage file exists, and it reflects 100% line rate coverage coverage_xml = os.path.join(results.workdir, 'test/junit/coverage/reports/xml') self.assertTrue(os.path.isfile(coverage_xml)) with codecs.open(coverage_xml, 'r', encoding='utf8') as xml: self.assertIn('<class name="org/pantsbuild/testproject/unicode/cucumber/CucumberAnnotatedExample"><method name="<init>" desc="()V" line="13"><counter type="INSTRUCTION" missed="0" covered="3"/>', xml.read()) # validate that the html report was able to find sources for annotation cucumber_src_html = os.path.join( results.workdir, 'test/junit/coverage/reports/html/' 'org.pantsbuild.testproject.unicode.cucumber/CucumberAnnotatedExample.html') self.assertTrue(os.path.isfile(cucumber_src_html)) with codecs.open(cucumber_src_html, 'r', encoding='utf8') as src: self.assertIn('class="el_method">pleasantry()</a>', src.read()) def test_junit_run_against_invalid_class_fails(self): pants_run = self.run_pants(['clean-all', 'test.junit', '--test=org.pantsbuild.testproject.matcher.MatcherTest_BAD_CLASS', 'testprojects/tests/java/org/pantsbuild/testproject/matcher']) self.assert_failure(pants_run) self.assertIn("No target found for test specifier", pants_run.stdout_data) def test_junit_run_timeout_succeeds(self): sleeping_target = 'testprojects/tests/java/org/pantsbuild/testproject/timeout:sleeping_target' pants_run = self.run_pants(['clean-all', 'test.junit', '--timeouts', '--timeout-default=1', '--timeout-terminate-wait=1', '--test=org.pantsbuild.testproject.timeout.ShortSleeperTest', sleeping_target]) self.assert_success(pants_run) def test_junit_run_timeout_fails(self): sleeping_target = 'testprojects/tests/java/org/pantsbuild/testproject/timeout:sleeping_target' start = time.time() pants_run = self.run_pants(['clean-all', 'test.junit', '--timeouts', '--timeout-default=1', '--timeout-terminate-wait=1', '--test=org.pantsbuild.testproject.timeout.LongSleeperTest', sleeping_target]) end = time.time() self.assert_failure(pants_run) # Ensure that the failure took less than 120 seconds to run. self.assertLess(end - start, 120) # Ensure that the timeout triggered. self.assertIn(" timed out after 1 seconds", pants_run.stdout_data) def test_junit_tests_using_cucumber(self): test_spec = 'testprojects/tests/java/org/pantsbuild/testproject/cucumber' with self.pants_results(['clean-all', 'test.junit', '--per-test-timer', test_spec]) as results: self.assert_success(results) def test_disable_synthetic_jar(self): synthetic_jar_target = 'testprojects/tests/java/org/pantsbuild/testproject/syntheticjar:test' output = self.run_pants(['test.junit', '--output-mode=ALL', synthetic_jar_target]).stdout_data self.assertIn('Synthetic jar run is detected', output) output = self.run_pants(['test.junit', '--output-mode=ALL', '--no-jvm-synthetic-classpath', synthetic_jar_target]).stdout_data self.assertIn('Synthetic jar run is not detected', output) def test_junit_run_with_html_report(self): with self.pants_results(['clean-all', 'test.junit', 'testprojects/tests/java/org/pantsbuild/testproject/htmlreport::', '--test-junit-html-report']) as results: self.assert_failure(results) report_html = os.path.join(results.workdir, 'test/junit/reports/junit-report.html') self.assertTrue(os.path.isfile(report_html)) with codecs.open(report_html, 'r', encoding='utf8') as src: html = src.read() self.assertIn('testPasses', html) self.assertIn('testFails', html) self.assertIn('testErrors', html) self.assertIn('testSkipped', html)
class ZincCompileIntegrationTest(BaseCompileIT): def test_java_src_zinc_compile(self): with self.do_test_compile('examples/src/java/::'): # run succeeded as expected pass with self.do_test_compile('examples/tests/java/::'): # run succeeded as expected pass def test_in_process(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=['-ldebug'], clean_all=True) self.assertIn( 'Attempting to call com.sun.tools.javac.api.JavacTool', pants_run.stdout_data) self.assertNotIn('Forking javac', pants_run.stdout_data) def test_log_level(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target' pants_run = self.run_test_compile(workdir, cachedir, target, extra_args=['--no-colors'], clean_all=True) self.assert_failure(pants_run) self.assertIn('[warn] import sun.security.x509.X500Name;', pants_run.stdout_data) self.assertIn( '[error] System2.out.println("Hello World!");', pants_run.stdout_data) def test_unicode_source_symbol(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = 'testprojects/src/scala/org/pantsbuild/testproject/unicode/unicodedep/consumer' pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=[ '--cache-compile-zinc-write-to=["{}/dummy_artifact_cache_dir"]' .format(cachedir), ], clean_all=True, ) self.assert_success(pants_run) def test_apt_compile(self): with self.do_test_compile( 'testprojects/src/java/org/pantsbuild/testproject/annotation/processor', expected_files=[ 'ResourceMappingProcessor.class', 'javax.annotation.processing.Processor' ]) as found: self.assertTrue( self.get_only(found, 'ResourceMappingProcessor.class'). endswith( 'org/pantsbuild/testproject/annotation/processor/ResourceMappingProcessor.class' )) processor_service_files = found[ 'javax.annotation.processing.Processor'] # There should be only a per-target service info file. self.assertEqual(1, len(processor_service_files)) processor_service_file = list(processor_service_files)[0] self.assertTrue( processor_service_file.endswith( 'META-INF/services/javax.annotation.processing.Processor')) with open(processor_service_file, 'r') as fp: self.assertEqual( 'org.pantsbuild.testproject.annotation.processor.ResourceMappingProcessor', fp.read().strip()) def test_apt_compile_and_run(self): with self.do_test_compile( 'testprojects/src/java/org/pantsbuild/testproject/annotation/main', expected_files=['Main.class', 'deprecation_report.txt']) as found: self.assertTrue( self.get_only(found, 'Main.class').endswith( 'org/pantsbuild/testproject/annotation/main/Main.class')) # This is the proof that the ResourceMappingProcessor annotation processor was compiled in a # round and then the Main was compiled in a later round with the annotation processor and its # service info file from on its compile classpath. with open(self.get_only(found, 'deprecation_report.txt'), 'r') as fp: self.assertIn( 'org.pantsbuild.testproject.annotation.main.Main', fp.read().splitlines()) def test_stale_apt_with_deps(self): """An annotation processor with a dependency doesn't pollute other annotation processors. At one point, when you added an annotation processor, it stayed configured for all subsequent compiles. Meaning that if that annotation processor had a dep that wasn't on the classpath, subsequent compiles would fail with missing symbols required by the stale annotation processor. """ # Demonstrate that the annotation processor is working with self.do_test_compile( 'testprojects/src/java/org/pantsbuild/testproject/annotation/processorwithdep/main', expected_files=[ 'Main.class', 'Main_HelloWorld.class', 'Main_HelloWorld.java' ]) as found: gen_file = self.get_only(found, 'Main_HelloWorld.java') self.assertTrue(gen_file.endswith( 'org/pantsbuild/testproject/annotation/processorwithdep/main/Main_HelloWorld.java' ), msg='{} does not match'.format(gen_file)) # Try to reproduce second compile that fails with missing symbol with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: # This annotation processor has a unique external dependency self.assert_success( self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/annotation/processorwithdep::' )) # When we run a second compile with annotation processors, make sure the previous annotation # processor doesn't stick around to spoil the compile self.assert_success( self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/annotation/processor::', clean_all=False)) def test_fatal_warning(self): def test_combination(target, expect_success): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'testprojects/src/java/org/pantsbuild/testproject/compilation_warnings:{}' .format(target), extra_args=[ '--compile-zinc-warning-args=-C-Xlint:all' ]) if expect_success: self.assert_success(pants_run) else: self.assert_failure(pants_run) test_combination('fatal', expect_success=False) test_combination('nonfatal', expect_success=True) def test_classpath_does_not_include_extra_classes_dirs(self): target_rel_spec = 'testprojects/src/java/org/pantsbuild/testproject/phrases:' classpath_file_by_target_id = {} for target_name in [ 'there-was-a-duck', 'lesser-of-two', 'once-upon-a-time', 'ten-thousand' ]: target_id = Target.compute_target_id( Address.parse('{}{}'.format(target_rel_spec, target_name))) classpath_file_by_target_id[target_id] = '{}.txt'.format(target_id) with self.do_test_compile( target_rel_spec, expected_files=list(classpath_file_by_target_id.values()), extra_args=['--compile-zinc-capture-classpath']) as found: for target_id, filename in classpath_file_by_target_id.items(): found_classpath_file = self.get_only(found, filename) with open(found_classpath_file, 'r') as f: contents = f.read() self.assertIn(target_id, contents) other_target_ids = set( classpath_file_by_target_id.keys()) - {target_id} for other_id in other_target_ids: self.assertNotIn(other_id, contents) def test_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile( target_spec, expected_files=[classpath_filename, 'PrintVersion.class'], extra_args=['--compile-zinc-capture-classpath']) as found: found_classpath_file = self.get_only(found, classpath_filename) self.assertTrue( found_classpath_file.endswith( os.path.join('compile_classpath', classpath_filename))) with open(found_classpath_file, 'r') as f: self.assertIn(target_id, f.read()) def test_no_record_classpath(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/printversion:printversion' target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = '{}.txt'.format(target_id) with self.do_test_compile( target_spec, expected_files=['PrintVersion.class'], extra_args=['--no-compile-zinc-capture-classpath']) as found: self.assertFalse(classpath_filename in found) @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_custom_javac(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, 'examples/src/java/org/pantsbuild/example/hello/main', extra_args=[ '--java-javac=testprojects/3rdparty/javactool:custom_javactool_for_testing' ], clean_all=True) self.assertNotEqual( 0, pants_run.returncode) # Our custom javactool always fails. self.assertIn('Pants caused Zinc to load a custom JavacTool', pants_run.stdout_data) def test_no_zinc_file_manager(self): target_spec = 'testprojects/src/java/org/pantsbuild/testproject/bench:jmh' with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile(workdir, cachedir, target_spec, clean_all=True) self.assertEqual(0, pants_run.returncode) def test_failed_hermetic_incremental_compile(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': { 'write_to': [cache_dir] }, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': True, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_failure(pants_run) def test_failed_compile_with_hermetic(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': { 'write_to': [cache_dir] }, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'compile', 'testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target', ], workdir, config, ) self.assert_failure(pants_run) self.assertIn( 'Failed jobs: compile(testprojects/src/java/org/pantsbuild/testproject/dummies:' 'compilation_failure_target)', pants_run.stdout_data) def test_hermetic_binary_with_dependencies(self): with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': { 'write_to': [cache_dir] }, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'zinc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) def test_hermetic_binary_cache_with_dependencies(self): file_abs_path = os.path.join( get_buildroot(), 'examples/src/scala/org/pantsbuild/example/hello/exe/Exe.scala') with temporary_dir() as cache_dir: config = { 'cache.compile.zinc': { 'write_to': [cache_dir] }, 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'zinc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) with with_overwritten_file_content(file_abs_path): new_temp_test = '''package org.pantsbuild.example.hello.exe import java.io.{BufferedReader, InputStreamReader} import org.pantsbuild.example.hello.welcome // A simple jvm binary to illustrate Scala BUILD targets object Exe { /** Test that resources are properly namespaced. */ def getWorld: String = { val is = this.getClass.getClassLoader.getResourceAsStream( "org/pantsbuild/example/hello/world.txt" ) try { new BufferedReader(new InputStreamReader(is)).readLine() } finally { is.close() } } def main(args: Array[String]) { println("Num args passed: " + args.size + ". Stand by for welcome...") if (args.size <= 0) { println("Hello, and welcome to " + getWorld + "!") } else { val w = welcome.WelcomeEverybody(args) w.foreach(s => println(s)) } } }''' with open(file_abs_path, 'w') as f: f.write(new_temp_test) pants_run = self.run_pants_with_workdir( [ '-q', 'run', 'examples/src/scala/org/pantsbuild/example/hello/exe', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Num args passed: 0. Stand by for welcome...\nHello, and welcome to Resource World!', pants_run.stdout_data, ) compile_dir = os.path.join(workdir, 'compile', 'zinc', 'current') for path_suffix in [ 'examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/classes/org/pantsbuild/example/hello/exe/Exe.class', 'examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class', ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), "Want path {} to exist".format(path)) def test_hermetic_binary_with_3rdparty_dependencies(self): config = { 'compile.zinc': { 'execution_strategy': 'hermetic', 'use_classpath_jars': False, 'incremental': False, } } with self.temporary_workdir() as workdir: with self.temporary_file_content("readme.txt", "yo"): pants_run = self.run_pants_with_workdir( [ 'run', 'testprojects/src/java/org/pantsbuild/testproject/cwdexample', ], workdir, config, ) self.assert_success(pants_run) self.assertIn( 'Found readme.txt', pants_run.stdout_data, )
class ZincCompileIntegrationTest(BaseCompileIT): def test_in_process(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, "examples/src/java/org/pantsbuild/example/hello/main", extra_args=["-ldebug"], clean_all=True, ) self.assertIn( "Attempting to call com.sun.tools.javac.api.JavacTool", pants_run.stdout_data ) self.assertNotIn("Forking javac", pants_run.stdout_data) def test_log_level(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = "testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target" pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=["--no-colors"], clean_all=True ) self.assert_failure(pants_run) self.assertIn("[warn] import sun.security.x509.X500Name;", pants_run.stdout_data) self.assertIn( '[error] System2.out.println("Hello World!");', pants_run.stdout_data ) def test_unicode_source_symbol(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: target = ( "testprojects/src/scala/org/pantsbuild/testproject/unicode/unicodedep/consumer" ) pants_run = self.run_test_compile( workdir, cachedir, target, extra_args=[ f'--cache-compile-rsc-write-to=["{cachedir}/dummy_artifact_cache_dir"]', ], clean_all=True, ) self.assert_success(pants_run) def test_fatal_warning(self): def test_combination(target, expect_success): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, f"testprojects/src/java/org/pantsbuild/testproject/compilation_warnings:{target}", extra_args=["--compile-rsc-warning-args=-C-Xlint:all"], ) if expect_success: self.assert_success(pants_run) else: self.assert_failure(pants_run) test_combination("fatal", expect_success=False) test_combination("nonfatal", expect_success=True) def test_classpath_does_not_include_extra_classes_dirs(self): target_rel_spec = "testprojects/src/java/org/pantsbuild/testproject/phrases:" classpath_file_by_target_id = {} for target_name in [ "there-was-a-duck", "lesser-of-two", "once-upon-a-time", "ten-thousand", ]: target_id = Target.compute_target_id( Address.parse("{}{}".format(target_rel_spec, target_name)) ) classpath_file_by_target_id[target_id] = f"{target_id}.txt" with self.do_test_compile( target_rel_spec, expected_files=list(classpath_file_by_target_id.values()), extra_args=["--compile-rsc-capture-classpath"], ) as found: for target_id, filename in classpath_file_by_target_id.items(): found_classpath_file = self.get_only(found, filename) with open(found_classpath_file, "r") as f: contents = f.read() self.assertIn(target_id, contents) other_target_ids = set(classpath_file_by_target_id.keys()) - {target_id} for other_id in other_target_ids: self.assertNotIn(other_id, contents) def test_record_classpath(self): target_spec = "testprojects/src/java/org/pantsbuild/testproject/printversion:printversion" target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = f"{target_id}.txt" with self.do_test_compile( target_spec, expected_files=[classpath_filename, "PrintVersion.class"], extra_args=["--compile-rsc-capture-classpath"], ) as found: found_classpath_file = self.get_only(found, classpath_filename) self.assertTrue( found_classpath_file.endswith(os.path.join("compile_classpath", classpath_filename)) ) with open(found_classpath_file, "r") as f: self.assertIn(target_id, f.read()) def test_no_record_classpath(self): target_spec = "testprojects/src/java/org/pantsbuild/testproject/printversion:printversion" target_id = Target.compute_target_id(Address.parse(target_spec)) classpath_filename = f"{target_id}.txt" with self.do_test_compile( target_spec, expected_files=["PrintVersion.class"], extra_args=["--no-compile-rsc-capture-classpath"], ) as found: self.assertFalse(classpath_filename in found) @skipIf(is_missing_jvm("1.8"), "no java 1.8 installation on testing machine") def test_custom_javac(self): with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile( workdir, cachedir, "examples/src/java/org/pantsbuild/example/hello/main", extra_args=[ "--java-javac=testprojects/3rdparty/javactool:custom_javactool_for_testing" ], clean_all=True, ) self.assertNotEqual(0, pants_run.returncode) # Our custom javactool always fails. self.assertIn("Pants caused Zinc to load a custom JavacTool", pants_run.stdout_data) def test_no_zinc_file_manager(self): target_spec = "testprojects/src/java/org/pantsbuild/testproject/bench:jmh" with self.temporary_workdir() as workdir: with self.temporary_cachedir() as cachedir: pants_run = self.run_test_compile(workdir, cachedir, target_spec, clean_all=True) self.assertEqual(0, pants_run.returncode) def test_failed_compile_with_hermetic(self): with temporary_dir() as cache_dir: config = { "cache.compile.rsc": {"write_to": [cache_dir]}, "compile.rsc": { "execution_strategy": "hermetic", "use_classpath_jars": False, "incremental": False, }, } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ "-q", "compile", "testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target", ], workdir, config, ) self.assert_failure(pants_run) self.assertIn("package System2 does not exist", pants_run.stderr_data) self.assertTrue( re.search( "Compilation failure.*testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target", pants_run.stdout_data, ) ) def test_failed_compile_with_subprocess(self): with temporary_dir() as cache_dir: config = { "cache.compile.rsc": {"write_to": [cache_dir]}, "compile.rsc": { "execution_strategy": "subprocess", "use_classpath_jars": False, "incremental": False, }, } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( [ # NB: We don't use -q here because subprocess squashes the error output # See https://github.com/pantsbuild/pants/issues/5646 "compile", "testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target", ], workdir, config, ) self.assert_failure(pants_run) self.assertIn("package System2 does not exist", pants_run.stdout_data) self.assertTrue( re.search( "Compilation failure.*testprojects/src/java/org/pantsbuild/testproject/dummies:compilation_failure_target", pants_run.stdout_data, ) ) def test_hermetic_binary_with_dependencies(self): with temporary_dir() as cache_dir: config = { "cache.compile.rsc": {"write_to": [cache_dir]}, "compile.rsc": { "execution_strategy": "hermetic", "use_classpath_jars": False, "incremental": False, }, } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( ["-q", "run", "examples/src/scala/org/pantsbuild/example/hello/exe"], workdir, config, ) self.assert_success(pants_run) self.assertIn( "Num args passed: 0. Stand by for welcome...\nHello, Resource World!", pants_run.stdout_data, ) compile_dir = os.path.join(workdir, "compile", "rsc", "current") for path_suffix in [ "examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/zinc/classes/org/pantsbuild/example/hello/exe/Exe.class", "examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/zinc/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class", ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), f"Want path {path} to exist") def test_hermetic_binary_cache_with_dependencies(self): file_abs_path = os.path.join( get_buildroot(), "examples/src/scala/org/pantsbuild/example/hello/exe/Exe.scala" ) with temporary_dir() as cache_dir: config = { "cache.compile.rsc": {"write_to": [cache_dir], "read_from": [cache_dir]}, "compile.rsc": { "execution_strategy": "hermetic", "use_classpath_jars": False, "incremental": False, }, } with self.temporary_workdir() as workdir: pants_run = self.run_pants_with_workdir( ["-q", "run", "examples/src/scala/org/pantsbuild/example/hello/exe"], workdir, config, ) self.assert_success(pants_run) self.assertIn( "Num args passed: 0. Stand by for welcome...\nHello, Resource World!", pants_run.stdout_data, ) compile_dir = os.path.join(workdir, "compile", "rsc", "current") for path_suffix in [ "examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/zinc/classes/org/pantsbuild/example/hello/exe/Exe.class", "examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/zinc/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class", ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), f"Want path {path} to exist") with self.with_overwritten_file_content(file_abs_path): new_temp_test = """package org.pantsbuild.example.hello.exe import java.io.{BufferedReader, InputStreamReader} import org.pantsbuild.example.hello import org.pantsbuild.example.hello.welcome // A simple jvm binary to illustrate Scala BUILD targets object Exe { /** Test that resources are properly namespaced. */ def getWorld: String = { val is = this.getClass.getClassLoader.getResourceAsStream( "org/pantsbuild/example/hello/world.txt" ) try { new BufferedReader(new InputStreamReader(is)).readLine() } finally { is.close() } } def main(args: Array[String]) { println("Num args passed: " + args.size + ". Stand by for welcome...") if (args.size <= 0) { println("Hello, and welcome to " + getWorld + "!") } else { val w = welcome.WelcomeEverybody(args) w.foreach(s => println(s)) } } }""" with open(file_abs_path, "w") as f: f.write(new_temp_test) pants_run = self.run_pants_with_workdir( ["-q", "run", "examples/src/scala/org/pantsbuild/example/hello/exe"], workdir, config, ) self.assert_success(pants_run) self.assertIn( "Num args passed: 0. Stand by for welcome...\nHello, and welcome to Resource World!", pants_run.stdout_data, ) compile_dir = os.path.join(workdir, "compile", "rsc", "current") for path_suffix in [ "examples.src.scala.org.pantsbuild.example.hello.exe.exe/current/zinc/classes/org/pantsbuild/example/hello/exe/Exe.class", "examples.src.scala.org.pantsbuild.example.hello.welcome.welcome/current/zinc/classes/org/pantsbuild/example/hello/welcome/WelcomeEverybody.class", ]: path = os.path.join(compile_dir, path_suffix) self.assertTrue(os.path.exists(path), f"Want path {path} to exist")
class JunitRunIntegrationTest(PantsRunIntegrationTest): def _testjvms(self, spec_name): spec = 'testprojects/tests/java/org/pantsbuild/testproject/testjvms:{}'.format( spec_name) self.assert_success( self.run_pants( ['clean-all', 'test.junit', '--strict-jvm-version', spec])) # See https://github.com/pantsbuild/pants/issues/2894 for details on why this is # marked xfail. @expectedFailure @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_java_eight(self): self._testjvms('eight') @skipIf(is_missing_jvm('1.7'), 'no java 1.7 installation on testing machine') def test_java_seven(self): self._testjvms('seven') @skipIf(is_missing_jvm('1.6'), 'no java 1.6 installation on testing machine') def test_java_six(self): self._testjvms('six') @skipIf(is_missing_jvm('1.8'), 'no java 1.8 installation on testing machine') def test_with_test_platform(self): self._testjvms('eight-test-platform') def test_junit_run_against_class_succeeds(self): self.assert_success( self.run_pants([ 'clean-all', 'test.junit', '--test=org.pantsbuild.testproject.matcher.MatcherTest', 'testprojects/tests/java/org/pantsbuild/testproject/matcher' ])) def test_junit_run_with_cobertura_coverage_succeeds(self): with self.pants_results([ 'clean-all', 'test.junit', 'testprojects/tests/java/org/pantsbuild/testproject/unicode::', '--test-junit-coverage-processor=cobertura', '--test-junit-coverage' ]) as results: self.assert_success(results) # validate that the expected coverage file exists, and it reflects 100% line rate coverage coverage_xml = os.path.join( results.workdir, 'test/junit/coverage/xml/coverage.xml') self.assertTrue(os.path.isfile(coverage_xml)) with codecs.open(coverage_xml, 'r', encoding='utf8') as xml: self.assertIn('line-rate="1.0"', xml.read()) # validate that the html report was able to find sources for annotation cucumber_src_html = os.path.join( results.workdir, 'test/junit/coverage/html/org.pantsbuild.testproject.unicode.cucumber.CucumberAnnotatedExample.html' ) self.assertTrue(os.path.isfile(cucumber_src_html)) with codecs.open(cucumber_src_html, 'r', encoding='utf8') as src: self.assertIn('String pleasantry()', src.read()) def test_junit_run_against_invalid_class_fails(self): pants_run = self.run_pants([ 'clean-all', 'test.junit', '--test=org.pantsbuild.testproject.matcher.MatcherTest_BAD_CLASS', 'testprojects/tests/java/org/pantsbuild/testproject/matcher' ]) self.assert_failure(pants_run) self.assertIn("No target found for test specifier", pants_run.stdout_data) def test_junit_run_timeout_succeeds(self): pants_run = self.run_pants([ 'clean-all', 'test.junit', '--timeout-default=1', '--test=org.pantsbuild.testproject.timeout.SleeperTestShort', 'testprojects/tests/java/org/pantsbuild/testproject/timeout:sleeping_target' ]) self.assert_success(pants_run) def test_junit_run_timeout_fails(self): start = time.time() pants_run = self.run_pants([ 'clean-all', 'test.junit', '--timeout-default=1', '--test=org.pantsbuild.testproject.timeout.SleeperTestLong', 'testprojects/tests/java/org/pantsbuild/testproject/timeout:sleeping_target' ]) end = time.time() self.assert_failure(pants_run) # Ensure that the failure took less than 120 seconds to run. self.assertLess(end - start, 120) # Ensure that the timeout triggered. self.assertIn("FAILURE: Timeout of 1 seconds reached", pants_run.stdout_data) @expectedFailure def test_junit_tests_using_cucumber(self): test_spec = 'testprojects/tests/java/org/pantsbuild/testproject/cucumber' with self.pants_results( ['clean-all', 'test.junit', '--per-test-timer', test_spec]) as results: self.assert_success(results) def test_disable_synthetic_jar(self): output = self.run_pants([ 'test.junit', '--output-mode=ALL', 'testprojects/tests/java/org/pantsbuild/testproject/syntheticjar:test' ]).stdout_data self.assertIn('Synthetic jar run is detected', output) output = self.run_pants([ 'test.junit', '--output-mode=ALL', '--no-jvm-synthetic-classpath', 'testprojects/tests/java/org/pantsbuild/testproject/syntheticjar:test' ]).stdout_data self.assertIn('Synthetic jar run is not detected', output) def test_junit_run_with_html_report(self): with self.pants_results([ 'clean-all', 'test.junit', 'testprojects/tests/java/org/pantsbuild/testproject/htmlreport::', '--test-junit-html-report' ]) as results: self.assert_failure(results) report_html = os.path.join(results.workdir, 'test/junit/reports/junit-report.html') self.assertTrue(os.path.isfile(report_html)) with codecs.open(report_html, 'r', encoding='utf8') as src: html = src.read() self.assertIn('testPasses', html) self.assertIn('testFails', html) self.assertIn('testErrors', html) self.assertIn('testSkipped', html)