@Test public void sanitizeSymlinkedWorkingDirectory() throws IOException { TemporaryFolder folder = new TemporaryFolder(); folder.create(); // Setup up a symlink to our working directory. Path symlinkedRoot = folder.getRoot().toPath().resolve("symlinked-root"); java.nio.file.Files.createSymbolicLink(symlinkedRoot, tmp.getRootPath()); // Run the build, setting PWD to the above symlink. Typically, this causes compilers to use // the symlinked directory, even though it's not the right project root. Map<String, String> envCopy = Maps.newHashMap(System.getenv()); envCopy.put("PWD", symlinkedRoot.toString()); workspace .runBuckCommandWithEnvironmentAndContext( tmp.getRootPath(), Optional.<NGContext>absent(), Optional.<BuckEventListener>absent(), Optional.of(ImmutableMap.copyOf(envCopy)), "build", "//:simple#default,static") .assertSuccess(); // Verify that we still sanitized this path correctly. Path lib = workspace.getPath("buck-out/gen/simple#default,static/libsimple.a"); String contents = Files.asByteSource(lib.toFile()).asCharSource(Charsets.ISO_8859_1).read(); assertFalse(lib.toString(), contents.contains(tmp.getRootPath().toString())); assertFalse(lib.toString(), contents.contains(symlinkedRoot.toString())); folder.delete(); }
private void assertCompDir(Path compDir, Optional<String> failure) throws Exception { ProjectFilesystem filesystem = new ProjectFilesystem(tmp.getRoot().toPath()); CxxPlatform platform = DefaultCxxPlatforms.build(new CxxBuckConfig(new FakeBuckConfig())); // Build up the paths to various files the archive step will use. ImmutableList<String> compiler = platform.getCc().getCommandPrefix(new SourcePathResolver(new BuildRuleResolver())); Path output = filesystem.resolve(Paths.get("output.o")); Path relativeInput = Paths.get("input.c"); Path input = filesystem.resolve(relativeInput); filesystem.writeContentsToPath("int main() {}", relativeInput); ImmutableList.Builder<String> preprocessorCommand = ImmutableList.builder(); preprocessorCommand.addAll(compiler); ImmutableList.Builder<String> compilerCommand = ImmutableList.builder(); compilerCommand.addAll(compiler); compilerCommand.add("-g"); DebugPathSanitizer sanitizer = new DebugPathSanitizer(200, File.separatorChar, compDir, ImmutableBiMap.<Path, Path>of()); // Build an archive step. CxxPreprocessAndCompileStep step = new CxxPreprocessAndCompileStep( CxxPreprocessAndCompileStep.Operation.COMPILE_MUNGE_DEBUGINFO, output, relativeInput, CxxSource.Type.C, Optional.of(preprocessorCommand.build()), Optional.of(compilerCommand.build()), ImmutableMap.<Path, Path>of(), sanitizer); // Execute the archive step and verify it ran successfully. ExecutionContext executionContext = TestExecutionContext.newBuilder() .setProjectFilesystem(new ProjectFilesystem(tmp.getRoot().toPath())) .build(); TestConsole console = (TestConsole) executionContext.getConsole(); int exitCode = step.execute(executionContext); if (failure.isPresent()) { assertNotEquals("compile step succeeded", 0, exitCode); assertThat( console.getTextWrittenToStdErr(), console.getTextWrittenToStdErr(), Matchers.containsString(failure.get())); } else { assertEquals("compile step failed: " + console.getTextWrittenToStdErr(), 0, exitCode); // Verify that we find the expected compilation dir embedded in the file. String contents = new String(Files.readAllBytes(output)); assertThat(contents, Matchers.containsString(sanitizer.getCompilationDirectory())); } // Cleanup. Files.delete(input); Files.deleteIfExists(output); }
@Test public void binaryWithDependenciesCompilationDatabase() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "compilation_database", tmp); workspace.setUp(); Path compilationDatabase = workspace.buildAndReturnOutput("//:binary_with_dep#compilation-database"); assertEquals( Paths.get("buck-out/gen/__binary_with_dep#compilation-database.json"), tmp.getRootPath().relativize(compilationDatabase)); String binaryHeaderSymlinkTreeFolder = String.format( "buck-out/gen/binary_with_dep#default,%s", CxxDescriptionEnhancer.HEADER_SYMLINK_TREE_FLAVOR); String binaryExportedHeaderSymlinkTreeFoler = String.format( "buck-out/gen/library_with_header#default,%s", CxxDescriptionEnhancer.EXPORTED_HEADER_SYMLINK_TREE_FLAVOR); assertTrue(Files.exists(tmp.getRootPath().resolve(binaryHeaderSymlinkTreeFolder))); assertTrue(Files.exists(tmp.getRootPath().resolve(binaryExportedHeaderSymlinkTreeFoler))); String libraryExportedHeaderSymlinkTreeFoler = String.format( "buck-out/gen/library_with_header#default,%s", CxxDescriptionEnhancer.EXPORTED_HEADER_SYMLINK_TREE_FLAVOR); // Verify that symlink folders for headers are created and header file is linked. assertTrue(Files.exists(tmp.getRootPath().resolve(libraryExportedHeaderSymlinkTreeFoler))); assertTrue( Files.exists(tmp.getRootPath().resolve(libraryExportedHeaderSymlinkTreeFoler + "/bar.h"))); Map<String, CxxCompilationDatabaseEntry> fileToEntry = CxxCompilationDatabaseEntry.parseCompilationDatabaseJsonFile(compilationDatabase); assertEquals(1, fileToEntry.size()); assertHasEntry( fileToEntry, "foo.cpp", new ImmutableList.Builder<String>() .add(COMPILER_PATH) .add("-I") .add(headerSymlinkTreeIncludePath(binaryHeaderSymlinkTreeFolder)) .add("-I") .add(headerSymlinkTreeIncludePath(binaryExportedHeaderSymlinkTreeFoler)) .addAll(EXTRA_FLAGS_FOR_HEADER_MAPS) .addAll(COMPILER_SPECIFIC_FLAGS) .add("-x") .add("c++") .add("-c") .add("-o") .add("buck-out/gen/binary_with_dep#compile-foo.cpp.o,default/foo.cpp.o") .add("foo.cpp") .build()); }
@Test public void skipsFirstCacheBecauseIgnored() throws IOException { Path path = Paths.get("world.txt"); Path fullPath = tmp.getRootPath().resolve(path); ProjectFilesystem filesystem = new ProjectFilesystem(tmp.getRootPath(), ImmutableSet.of(path)); filesystem.touch(path); DefaultFileHashCache innerCache = new DefaultFileHashCache(filesystem); StackedFileHashCache cache = new StackedFileHashCache(ImmutableList.of(innerCache)); expectedException.expect(NoSuchFileException.class); cache.get(fullPath); }
@Before public void setUp() throws IOException, InterruptedException { executorService = Executors.newScheduledThreadPool(5); // In case root_restrict_files is enabled in /etc/watchmanconfig, assume // this is one of the entries so it doesn't give up. tmp.newFolder(".git"); Watchman watchman = Watchman.build(tmp.getRootPath(), getWatchmanEnv(), new TestConsole(), new FakeClock(0)); // We assume watchman has been installed and configured properly on the system, and that setting // up the watch is successful. assumeFalse(watchman == Watchman.NULL_WATCHMAN); }
@Test public void testAppleLibraryBuildsFramework() throws Exception { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue( AppleNativeIntegrationTestUtils.isApplePlatformAvailable( ApplePlatform.builder().setName(ApplePlatform.Name.MACOSX).build())); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_builds_something", tmp); workspace.setUp(); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand( "build", "//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64"); result.assertSuccess(); Path frameworkPath = tmp.getRootPath() .resolve(BuckConstant.GEN_DIR) .resolve( "Libraries/TestLibrary/TestLibrary#framework,macosx-x86_64/TestLibrary.framework"); assertThat(Files.exists(frameworkPath), is(true)); assertThat(Files.exists(frameworkPath.resolve("Contents/Info.plist")), is(true)); Path libraryPath = frameworkPath.resolve("Contents/MacOS/TestLibrary"); assertThat(Files.exists(libraryPath), is(true)); assertThat( workspace.runCommand("file", libraryPath.toString()).getStdout().get(), containsString("dynamically linked shared library")); }
@Test public void testGetDescription() throws IOException { Jsr199Javac javac = createJavac(/* withSyntaxError */ false); String pathToOutputDir = new File(tmp.getRoot(), "out").getAbsolutePath(); assertEquals( String.format( "javac -source %s -target %s -g " + "-d %s " + "-classpath '' " + "@" + pathToSrcsList.toString(), JavaBuckConfig.TARGETED_JAVA_VERSION, JavaBuckConfig.TARGETED_JAVA_VERSION, pathToOutputDir), javac.getDescription( ImmutableList.of( "-source", JavaBuckConfig.TARGETED_JAVA_VERSION, "-target", JavaBuckConfig.TARGETED_JAVA_VERSION, "-g", "-d", pathToOutputDir, "-classpath", "''"), SOURCE_PATHS, Optional.of(pathToSrcsList))); }
@Test public void sanitizeWorkingDirectory() throws IOException { workspace.runBuckBuild("//:simple#default,static").assertSuccess(); Path lib = workspace.getPath("buck-out/gen/simple#default,static/libsimple.a"); String contents = Files.asByteSource(lib.toFile()).asCharSource(Charsets.ISO_8859_1).read(); assertFalse(lib.toString(), contents.contains(tmp.getRootPath().toString())); }
@Test public void whenAndroidDirectoryResolverChangesParserInvalidated() throws IOException, InterruptedException { ProjectFilesystem filesystem = new ProjectFilesystem(tmp.getRoot().toPath()); Object daemon = Main.getDaemon( new TestCellBuilder() .setAndroidDirectoryResolver( new FakeAndroidDirectoryResolver( Optional.<Path>absent(), Optional.<Path>absent(), Optional.<Path>absent(), Optional.of("something"))) .setFilesystem(filesystem) .build(), new ObjectMapper()); assertNotEquals( "Daemon should be replaced when not equal.", daemon, Main.getDaemon( new TestCellBuilder() .setAndroidDirectoryResolver( new FakeAndroidDirectoryResolver( Optional.<Path>absent(), Optional.<Path>absent(), Optional.<Path>absent(), Optional.of("different"))) .setFilesystem(filesystem) .build(), new ObjectMapper())); }
@Test public void testAppleLibraryExportedHeaderSymlinkTree() throws IOException { assumeTrue(Platform.detect() == Platform.MACOS); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_header_symlink_tree", tmp); workspace.setUp(); BuildTarget buildTarget = BuildTargetFactory.newInstance( "//Libraries/TestLibrary:TestLibrary#" + "default," + CxxDescriptionEnhancer.EXPORTED_HEADER_SYMLINK_TREE_FLAVOR); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", buildTarget.getFullyQualifiedName()); result.assertSuccess(); Path projectRoot = tmp.getRootPath().toRealPath(); Path inputPath = projectRoot.resolve(buildTarget.getBasePath()); Path outputPath = projectRoot.resolve(BuildTargets.getGenPath(buildTarget, "%s")); assertIsSymbolicLink( outputPath.resolve("TestLibrary/PublicHeader.h"), inputPath.resolve("PublicHeader.h")); }
@Test public void testAndroidInstrumentationTest() throws IOException { tmpFolder.doNotDeleteOnExit(); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "android_instrumentation_test_integration_test", tmpFolder); workspace.setUp(); workspace.runBuckCommand("test").assertSuccess(); }
@Test public void skipsFirstCache() throws IOException { Path fullPath = Paths.get("some/path"); ProjectFilesystem filesystem = new FakeProjectFilesystem(tmp.getRoot()); DefaultFileHashCache innerCache = new DefaultFileHashCache(filesystem); StackedFileHashCache cache = new StackedFileHashCache(ImmutableList.of(innerCache)); expectedException.expect(NoSuchFileException.class); cache.get(fullPath); }
@Test public void usesSecondCache() throws IOException { Path path = Paths.get("world.txt"); Path fullPath = tmp2.getRootPath().resolve(path); DefaultFileHashCache innerCache = new DefaultFileHashCache(new ProjectFilesystem(tmp.getRootPath())); // The second project filesystem has the file. ProjectFilesystem filesystem2 = new ProjectFilesystem(tmp2.getRootPath()); DefaultFileHashCache innerCache2 = new DefaultFileHashCache(filesystem2); filesystem2.touch(path); StackedFileHashCache cache = new StackedFileHashCache(ImmutableList.of(innerCache, innerCache2)); cache.get(fullPath); assertTrue(innerCache2.willGet(path)); }
private void assertHasEntry( Map<String, CxxCompilationDatabaseEntry> fileToEntry, String fileName, List<String> command) throws IOException { String key = tmp.getRootPath().toRealPath().resolve(fileName).toString(); CxxCompilationDatabaseEntry entry = fileToEntry.get(key); assertNotNull("There should be an entry for " + key + ".", entry); MoreAsserts.assertIterablesEquals(command, entry.args); assertEquals( Joiner.on(' ').join(Iterables.transform(command, Escaper.SHELL_ESCAPER)), entry.command); }
@Before public void enableVerboseRuleKeys() throws Exception { lastPositionInLog = 0; ruleKeyBuilderLogger = Logger.getLogger(RuleKeyBuilder.class.getName()); previousRuleKeyBuilderLevel = ruleKeyBuilderLogger.getLevel(); ruleKeyBuilderLogger.setLevel(Level.FINER); Path fullLogFilePath = tmp.getRootPath().resolve(LOG_FILE_PATH); Files.createDirectories(fullLogFilePath.getParent()); FileHandler handler = new FileHandler(fullLogFilePath.toString()); handler.setFormatter(new LogFormatter()); ruleKeyBuilderLogger.addHandler(handler); }
private ProcessExecutor.Result runRuleKeyDiffer(ProjectWorkspace workspace) throws IOException, InterruptedException { ProcessExecutor.Result result = workspace.runCommand( "python2.7", Paths.get("scripts", "diff_rulekeys.py").toString(), tmp.getRootPath().resolve("buck-0.log").toString(), tmp.getRootPath().resolve("buck-1.log").toString(), "//:java_lib_2"); assertThat(result.getStderr(), Matchers.equalTo(Optional.of(""))); assertThat(result.getExitCode(), Matchers.is(0)); return result; }
@Test public void testAppleLibraryBuildsSomething() throws IOException { assumeTrue(Platform.detect() == Platform.MACOS); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_builds_something", tmp); workspace.setUp(); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", "//Libraries/TestLibrary:TestLibrary#static,default"); result.assertSuccess(); assertTrue(Files.exists(tmp.getRootPath().resolve(BuckConstant.GEN_DIR))); }
private Jsr199Javac createJavac(boolean withSyntaxError, Optional<Path> javacJar) throws IOException { File exampleJava = tmp.newFile("Example.java"); Files.write( Joiner.on('\n') .join( "package com.example;", "", "public class Example {" + (withSyntaxError ? "" : "}")), exampleJava, Charsets.UTF_8); Path pathToOutputDirectory = Paths.get("out"); tmp.newFolder(pathToOutputDirectory.toString()); Optional<SourcePath> jar = javacJar.transform(SourcePaths.toSourcePath(new FakeProjectFilesystem())); if (jar.isPresent()) { return new JarBackedJavac("com.sun.tools.javac.api.JavacTool", ImmutableSet.of(jar.get())); } return new JdkProvidedInMemoryJavac(); }
@Test public void shouldFindNeededDependenciesFromSymbols() throws IOException, InterruptedException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "symbol_finder", temporaryFolder); workspace.setUp(); ProjectFilesystem projectFilesystem = new ProjectFilesystem(temporaryFolder.getRootPath()); ImmutableMap<String, String> environment = ImmutableMap.copyOf(System.getenv()); Config rawConfig = Config.createDefaultConfig( projectFilesystem.getRootPath(), ImmutableMap.<String, ImmutableMap<String, String>>of()); BuckConfig config = new BuckConfig( rawConfig, projectFilesystem, Architecture.detect(), Platform.detect(), environment); ImmutableSet<Description<?>> allDescriptions = DefaultKnownBuildRuleTypes.getDefaultKnownBuildRuleTypes(projectFilesystem) .getAllDescriptions(); BuckEventBus buckEventBus = BuckEventBusFactory.newInstance(); MissingSymbolsHandler missingSymbolsHandler = MissingSymbolsHandler.create( projectFilesystem, allDescriptions, config, buckEventBus, new TestConsole(), DEFAULT_JAVAC_OPTIONS, environment); MissingSymbolEvent missingSymbolEvent = MissingSymbolEvent.create( BuildTargetFactory.newInstance(workspace.getDestPath(), "//java/com/example/b:b"), "com.example.a.A", MissingSymbolEvent.SymbolType.Java); ImmutableSetMultimap<BuildTarget, BuildTarget> neededDeps = missingSymbolsHandler.getNeededDependencies(ImmutableList.of(missingSymbolEvent)); assertEquals( "MissingSymbolsHandler failed to find the needed dependency.", neededDeps, ImmutableSetMultimap.of( BuildTargetFactory.newInstance(workspace.getDestPath(), "//java/com/example/b:b"), BuildTargetFactory.newInstance(workspace.getDestPath(), "//java/com/example/a:a"))); }
@Test public void whenBuckConfigChangesParserInvalidated() throws IOException, InterruptedException { ProjectFilesystem filesystem = new ProjectFilesystem(tmp.getRoot().toPath()); Object daemon = Main.getDaemon( new TestCellBuilder() .setBuckConfig( FakeBuckConfig.builder() .setSections( ImmutableMap.of( "somesection", ImmutableMap.of("somename", "somevalue"))) .build()) .setFilesystem(filesystem) .build(), new ObjectMapper()); assertEquals( "Daemon should not be replaced when config equal.", daemon, Main.getDaemon( new TestCellBuilder() .setBuckConfig( FakeBuckConfig.builder() .setSections( ImmutableMap.of( "somesection", ImmutableMap.of("somename", "somevalue"))) .build()) .setFilesystem(filesystem) .build(), new ObjectMapper())); assertNotEquals( "Daemon should be replaced when config not equal.", daemon, Main.getDaemon( new TestCellBuilder() .setBuckConfig( FakeBuckConfig.builder() .setSections( ImmutableMap.of( "somesection", ImmutableMap.of("somename", "someothervalue"))) .build()) .setFilesystem(filesystem) .build(), new ObjectMapper())); }
@Test public void testAppleLibraryBuildsForWatchSimulator() throws IOException { assumeTrue( AppleNativeIntegrationTestUtils.isApplePlatformAvailable( ApplePlatform.builder().setName(ApplePlatform.Name.WATCHSIMULATOR).build())); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_builds_something", tmp); workspace.setUp(); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand( "build", "//Libraries/TestLibrary:TestLibrary#watchsimulator-i386,static"); result.assertSuccess(); assertTrue(Files.exists(tmp.getRootPath().resolve(BuckConstant.GEN_DIR))); }
@Test public void testAppleLibraryBuildsSomethingUsingAppleCxxPlatform() throws IOException { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue( AppleNativeIntegrationTestUtils.isApplePlatformAvailable( ApplePlatform.builder().setName(ApplePlatform.Name.MACOSX).build())); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_builds_something", tmp); workspace.setUp(); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand( "build", "//Libraries/TestLibrary:TestLibrary#static,macosx-x86_64"); result.assertSuccess(); assertTrue(Files.exists(tmp.getRootPath().resolve(BuckConstant.GEN_DIR))); }
@Test public void testKeepGoingWithBuildReport() throws IOException { ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "keep_going", tmp).setUp(); File buildReport = new File(tmpFolderForBuildReport.getRoot(), "build-report.txt"); workspace .runBuckBuild( "--build-report", buildReport.getAbsolutePath(), "--keep-going", "//:rule_with_output", "//:failing_rule") .assertFailure(); assertTrue(buildReport.exists()); String buildReportContents = com.google.common.io.Files.toString(buildReport, Charsets.UTF_8); String expectedReport = Joiner.on('\n') .join( "{", " \"success\" : false,", " \"results\" : {", " \"//:rule_with_output\" : {", " \"success\" : true,", " \"type\" : \"BUILT_LOCALLY\",", " \"output\" : \"" + GENRULE_OUTPUT + "\"", " },", " \"//:failing_rule\" : {", " \"success\" : false", " }", " },", " \"failures\" : {", " \"//:failing_rule\" : \"//:failing_rule failed with exit code 2:\\ngenrule\"", " }", "}"); assertEquals(expectedReport, buildReportContents); }
private Path createPath(String first, String... more) { return tmpFolder.getRootPath().getFileSystem().getPath(first, more); }
public VacationIntegrationTest() throws IOException { super(); temporaryFolder.create(); }
private ProjectFilesystem createProjectFilesystem() { return new ProjectFilesystem(tmp.getRootPath()); }
@Before public void setUp() { pathToSrcsList = Paths.get(tmp.getRoot().getPath(), "srcs_list"); }