@Before
public void setUp() throws IOException, InterruptedException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "query_command", tmp);
workspace.setUp();
Cell cell =
new TestCellBuilder().setFilesystem(new ProjectFilesystem(workspace.getDestPath())).build();
TestConsole console = new TestConsole();
CommandRunnerParams params =
CommandRunnerParamsForTesting.createCommandRunnerParamsForTesting(
console,
cell,
new FakeAndroidDirectoryResolver(),
new NoopArtifactCache(),
BuckEventBusFactory.newInstance(),
FakeBuckConfig.builder().build(),
Platform.detect(),
ImmutableMap.copyOf(System.getenv()),
new FakeJavaPackageFinder(),
new ObjectMapper(),
Optional.<WebServer>absent());
buckQueryEnvironment = new BuckQueryEnvironment(params, /* enableProfiling */ false);
cellRoot = workspace.getDestPath();
executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
}
@Before
public void setUp() throws IOException, InterruptedException {
console = new TestConsole();
workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "target_command", tmp);
workspace.setUp();
filesystem = new ProjectFilesystem(workspace.getDestPath().toRealPath().normalize());
Cell cell = new TestCellBuilder().setFilesystem(filesystem).build();
AndroidDirectoryResolver androidDirectoryResolver = new FakeAndroidDirectoryResolver();
ArtifactCache artifactCache = new NoopArtifactCache();
BuckEventBus eventBus = BuckEventBusFactory.newInstance();
objectMapper = new ObjectMapper();
targetsCommand = new TargetsCommand();
params =
CommandRunnerParamsForTesting.createCommandRunnerParamsForTesting(
console,
cell,
androidDirectoryResolver,
artifactCache,
eventBus,
FakeBuckConfig.builder().build(),
Platform.detect(),
ImmutableMap.copyOf(System.getenv()),
new FakeJavaPackageFinder(),
objectMapper,
Optional.<WebServer>absent());
executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
}
@BeforeClass
public static void createParser() {
ProjectFilesystem filesystem = new FakeProjectFilesystem();
FakeBuckConfig buckConfig = new FakeBuckConfig();
ParserConfig parserConfig = new ParserConfig(buckConfig);
PythonBuckConfig pythonBuckConfig = new PythonBuckConfig(buckConfig, new ExecutableFinder());
ImmutableSet<Description<?>> descriptions =
ImmutableSet.of(
new RemoteFileDescription(new ExplodingDownloader()), new PrebuiltJarDescription());
DefaultProjectBuildFileParserFactory parserFactory =
new DefaultProjectBuildFileParserFactory(
filesystem.getRootPath(),
pythonBuckConfig.getPythonInterpreter(),
parserConfig.getAllowEmptyGlobs(),
parserConfig.getBuildFileName(),
parserConfig.getDefaultIncludes(),
descriptions);
buildFileParser =
parserFactory.createParser(
new TestConsole(),
ImmutableMap.<String, String>of(),
BuckEventBusFactory.newInstance());
}
@Test
public void testShouldIncludeDxInEnvironmentIfPresent() {
File fakeDx = new File("."); // We do no checks on whether dx is executable, but it must exist
AndroidPlatformTarget android = EasyMock.createNiceMock(AndroidPlatformTarget.class);
EasyMock.expect(android.getDxExecutable()).andStubReturn(fakeDx);
EasyMock.replay(android);
Genrule rule =
Genrule.newGenruleBuilder(new FakeAbstractBuildRuleBuilderParams())
.setBuildTarget(BuildTargetFactory.newInstance("//example:genrule"))
.setBash(Optional.of("true"))
.setOut("/dev/null")
.build(new BuildRuleResolver());
ExecutionContext context =
ExecutionContext.builder()
.setConsole(new TestConsole())
.setProjectFilesystem(new ProjectFilesystem(new File(".")))
.setAndroidPlatformTarget(Optional.of(android))
.setEventBus(BuckEventBusFactory.newInstance())
.setPlatform(Platform.detect())
.build();
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
rule.addEnvironmentVariables(context, builder);
ImmutableMap<String, String> env = builder.build();
assertEquals(fakeDx.getAbsolutePath(), env.get("DX"));
EasyMock.verify(android);
}
public static ExecutionContext.Builder newBuilder() {
return ExecutionContext.builder()
.setConsole(new TestConsole())
.setProjectFilesystem(new ProjectFilesystem(new File(".")))
.setEventBus(BuckEventBusFactory.newInstance())
.setPlatform(Platform.detect())
.setEnvironment(ImmutableMap.copyOf(System.getenv()));
}
ProjectCommandForTest() {
super(
new CommandRunnerParams(
new TestConsole(),
new ProjectFilesystem(new File(".")),
new KnownBuildRuleTypes(),
new InstanceArtifactCacheFactory(artifactCache),
BuckEventBusFactory.newInstance(),
BuckTestConstant.PYTHON_INTERPRETER,
Platform.detect()));
}
@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 testLogError() {
BuckEventBus eventBus = BuckEventBusFactory.newInstance();
CapturingConsoleEventListener listener = new CapturingConsoleEventListener();
eventBus.register(listener);
BuildContext buildContext =
BuildContext.builder()
.setActionGraph(createMock(ActionGraph.class))
.setStepRunner(createMock(StepRunner.class))
.setProjectFilesystem(createMock(ProjectFilesystem.class))
.setArtifactCache(createMock(ArtifactCache.class))
.setJavaPackageFinder(createMock(JavaPackageFinder.class))
.setEventBus(eventBus)
.build();
buildContext.logError(new RuntimeException(), "Error detail: %s", "BUILD_ID");
assertEquals(ImmutableList.of("Error detail: BUILD_ID"), listener.getLogMessages());
}
private AuditOwnerCommand createAuditOwnerCommand(ProjectFilesystem filesystem) {
KnownBuildRuleTypes buildRuleTypes =
DefaultKnownBuildRuleTypes.getDefaultKnownBuildRuleTypes(filesystem);
ArtifactCache artifactCache = new NoopArtifactCache();
BuckEventBus eventBus = BuckEventBusFactory.newInstance();
AndroidDirectoryResolver androidDirectoryResolver = new FakeAndroidDirectoryResolver();
return new AuditOwnerCommand(
new CommandRunnerParams(
console,
filesystem,
androidDirectoryResolver,
buildRuleTypes,
new InstanceArtifactCacheFactory(artifactCache),
eventBus,
buckConfig.getPythonInterpreter(),
Platform.detect(),
ImmutableMap.copyOf(System.getenv())));
}
@Test(expected = HumanReadableException.class)
public void testGetAndroidBootclasspathSupplierWithoutAndroidPlatformTarget() {
BuildContext.Builder builder = BuildContext.builder();
// Set to non-null values.
builder.setActionGraph(createMock(ActionGraph.class));
builder.setStepRunner(createMock(StepRunner.class));
builder.setProjectFilesystem(createMock(ProjectFilesystem.class));
builder.setArtifactCache(createMock(ArtifactCache.class));
builder.setJavaPackageFinder(createMock(JavaPackageFinder.class));
builder.setEventBus(BuckEventBusFactory.newInstance());
BuildContext context = builder.build();
Supplier<String> androidBootclasspathSupplier = context.getAndroidBootclasspathSupplier();
// If no AndroidPlatformTarget is passed to the builder, it should return a Supplier whose get()
// method throws an exception.
androidBootclasspathSupplier.get();
}
private ExecutionContext newEmptyExecutionContext(Platform platform) {
return ExecutionContext.builder()
.setConsole(new Console(Verbosity.SILENT, System.out, System.err, Ansi.withoutTty()))
.setProjectFilesystem(
new ProjectFilesystem(new File(".")) {
@Override
public Function<String, Path> getPathRelativizer() {
return IdentityPathRelativizer.getIdentityRelativizer();
}
@Override
public Path resolve(Path path) {
return path;
}
})
.setEventBus(BuckEventBusFactory.newInstance())
.setPlatform(platform)
.build();
}
private CommandRunnerParams createAuditOwnerCommandRunnerParams(ProjectFilesystem filesystem)
throws IOException, InterruptedException {
ArtifactCache artifactCache = new NoopArtifactCache();
BuckEventBus eventBus = BuckEventBusFactory.newInstance();
AndroidDirectoryResolver androidDirectoryResolver = new FakeAndroidDirectoryResolver();
Cell cell = new TestCellBuilder().setFilesystem(filesystem).build();
return CommandRunnerParamsForTesting.createCommandRunnerParamsForTesting(
console,
cell,
androidDirectoryResolver,
artifactCache,
eventBus,
buckConfig,
Platform.detect(),
ImmutableMap.copyOf(System.getenv()),
new FakeJavaPackageFinder(),
new ObjectMapper(),
Optional.<WebServer>absent());
}
@Test
public void testGetAndroidBootclasspathSupplierWithAndroidPlatformTarget() {
BuildContext.Builder builder = BuildContext.builder();
// Set to non-null values.
builder.setActionGraph(createMock(ActionGraph.class));
builder.setStepRunner(createMock(StepRunner.class));
builder.setProjectFilesystem(createMock(ProjectFilesystem.class));
builder.setArtifactCache(createMock(ArtifactCache.class));
builder.setJavaPackageFinder(createMock(JavaPackageFinder.class));
builder.setEventBus(BuckEventBusFactory.newInstance());
AndroidPlatformTarget androidPlatformTarget = createMock(AndroidPlatformTarget.class);
List<Path> entries =
ImmutableList.of(
Paths.get("add-ons/addon-google_apis-google-15/libs/effects.jar"),
Paths.get("add-ons/addon-google_apis-google-15/libs/maps.jar"),
Paths.get("add-ons/addon-google_apis-google-15/libs/usb.jar"));
expect(androidPlatformTarget.getBootclasspathEntries()).andReturn(entries);
replay(androidPlatformTarget);
builder.setAndroidBootclasspathForAndroidPlatformTarget(Optional.of(androidPlatformTarget));
BuildContext context = builder.build();
Supplier<String> androidBootclasspathSupplier = context.getAndroidBootclasspathSupplier();
String androidBootclasspath =
MorePaths.pathWithUnixSeparators(androidBootclasspathSupplier.get());
assertEquals(
"add-ons/addon-google_apis-google-15/libs/effects.jar:"
+ "add-ons/addon-google_apis-google-15/libs/maps.jar:"
+ "add-ons/addon-google_apis-google-15/libs/usb.jar",
androidBootclasspath);
// Call get() again to ensure that the underlying getBootclasspathEntries() is not called again
// to verify that memoization is working as expected.
androidBootclasspathSupplier.get();
verify(androidPlatformTarget);
}
private BuildContext getBuildContext() {
return ImmutableBuildContext.builder()
.setArtifactCache(EasyMock.createMock(ArtifactCache.class))
.setEventBus(BuckEventBusFactory.newInstance())
.setClock(new DefaultClock())
.setBuildId(new BuildId())
.setJavaPackageFinder(
new JavaPackageFinder() {
@Override
public Path findJavaPackageFolder(Path pathRelativeToProjectRoot) {
return null;
}
@Override
public String findJavaPackage(Path pathRelativeToProjectRoot) {
return null;
}
@Override
public String findJavaPackage(BuildTarget buildTarget) {
return null;
}
})
.setActionGraph(new ActionGraph(ImmutableList.<BuildRule>of()))
.setStepRunner(
new StepRunner() {
@Override
public void runStepForBuildTarget(Step step, Optional<BuildTarget> buildTarget)
throws StepFailedException {
// Do nothing.
}
@Override
public <T> ListenableFuture<T> runStepsAndYieldResult(
List<Step> steps,
Callable<T> interpretResults,
Optional<BuildTarget> buildTarget,
ListeningExecutorService service,
StepRunner.StepRunningCallback callback) {
return null;
}
@Override
public void runStepsInParallelAndWait(
List<Step> steps,
Optional<BuildTarget> target,
ListeningExecutorService service,
StepRunner.StepRunningCallback callback)
throws StepFailedException {
// Do nothing.
}
@Override
public <T> ListenableFuture<Void> addCallback(
ListenableFuture<List<T>> allBuiltDeps,
FutureCallback<List<T>> futureCallback,
ListeningExecutorService service) {
// Do nothing.
return Futures.immediateFuture(null);
}
})
.build();
}
@Test
public void testBuildJson() throws IOException {
ProjectFilesystem projectFilesystem = new ProjectFilesystem(tmpDir.getRoot().toPath());
ObjectMapper mapper = new ObjectMapper();
ChromeTraceBuildListener listener =
new ChromeTraceBuildListener(
projectFilesystem,
new FakeClock(1409702151000000000L),
mapper,
Locale.US,
TimeZone.getTimeZone("America/Los_Angeles"),
/* tracesToKeep */ 42,
false);
BuildTarget target = BuildTargetFactory.newInstance("//fake:rule");
FakeBuildRule rule =
new FakeBuildRule(
target,
new SourcePathResolver(new BuildRuleResolver()),
ImmutableSortedSet.<BuildRule>of());
RuleKey ruleKey = new RuleKey("abc123");
rule.setRuleKey(ruleKey);
String stepShortName = "fakeStep";
String stepDescription = "I'm a Fake Step!";
UUID stepUuid = UUID.randomUUID();
ExecutionContext context = createMock(ExecutionContext.class);
replay(context);
ImmutableSet<BuildTarget> buildTargets = ImmutableSet.of(target);
Iterable<String> buildArgs = Iterables.transform(buildTargets, Functions.toStringFunction());
Clock fakeClock = new IncrementingFakeClock(TimeUnit.MILLISECONDS.toNanos(1));
BuckEventBus eventBus =
BuckEventBusFactory.newInstance(
fakeClock, new BuildId("ChromeTraceBuildListenerTestBuildId"));
eventBus.register(listener);
eventBus.post(
CommandEvent.started("party", ImmutableList.of("arg1", "arg2"), /* isDaemon */ true));
eventBus.post(ArtifactCacheConnectEvent.started());
eventBus.post(ArtifactCacheConnectEvent.finished());
eventBus.post(BuildEvent.started(buildArgs));
eventBus.post(
ArtifactCacheEvent.started(ArtifactCacheEvent.Operation.FETCH, ImmutableSet.of(ruleKey)));
eventBus.post(
ArtifactCacheEvent.finished(
ArtifactCacheEvent.Operation.FETCH, ImmutableSet.of(ruleKey), CacheResult.hit("http")));
eventBus.post(BuildRuleEvent.started(rule));
eventBus.post(StepEvent.started(stepShortName, stepDescription, stepUuid));
eventBus.post(StepEvent.finished(stepShortName, stepDescription, stepUuid, 0));
eventBus.post(
BuildRuleEvent.finished(
rule,
BuildRuleStatus.SUCCESS,
CacheResult.miss(),
Optional.of(BuildRuleSuccessType.BUILT_LOCALLY),
Optional.<HashCode>absent(),
Optional.<Long>absent()));
try (TraceEventLogger ignored =
TraceEventLogger.start(eventBus, "planning", ImmutableMap.of("nefarious", "true"))) {
eventBus.post(new TraceEvent("scheming", ChromeTraceEvent.Phase.BEGIN));
eventBus.post(
new TraceEvent(
"scheming", ChromeTraceEvent.Phase.END, ImmutableMap.of("success", "false")));
}
eventBus.post(BuildEvent.finished(buildArgs, 0));
eventBus.post(
CommandEvent.finished(
"party", ImmutableList.of("arg1", "arg2"), /* isDaemon */ true, /* exitCode */ 0));
listener.outputTrace(new BuildId("BUILD_ID"));
File resultFile = new File(tmpDir.getRoot(), BuckConstant.BUCK_TRACE_DIR + "/build.trace");
List<ChromeTraceEvent> resultMap =
mapper.readValue(resultFile, new TypeReference<List<ChromeTraceEvent>>() {});
assertEquals(17, resultMap.size());
assertEquals("process_name", resultMap.get(0).getName());
assertEquals(ChromeTraceEvent.Phase.METADATA, resultMap.get(0).getPhase());
assertEquals(ImmutableMap.of("name", "buck"), resultMap.get(0).getArgs());
assertEquals("party", resultMap.get(1).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(1).getPhase());
assertEquals(ImmutableMap.of("command_args", "arg1 arg2"), resultMap.get(1).getArgs());
assertEquals("artifact_connect", resultMap.get(2).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(2).getPhase());
assertEquals("artifact_connect", resultMap.get(3).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(3).getPhase());
assertEquals("build", resultMap.get(4).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(4).getPhase());
assertEquals("artifact_fetch", resultMap.get(5).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(5).getPhase());
assertEquals("artifact_fetch", resultMap.get(6).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(6).getPhase());
// BuildRuleEvent.Started
assertEquals("//fake:rule", resultMap.get(7).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(7).getPhase());
assertEquals(ImmutableMap.of("rule_key", "abc123"), resultMap.get(7).getArgs());
assertEquals("fakeStep", resultMap.get(8).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(8).getPhase());
assertEquals("fakeStep", resultMap.get(9).getName());
assertEquals(
ImmutableMap.of(
"description", "I'm a Fake Step!",
"exit_code", "0"),
resultMap.get(9).getArgs());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(9).getPhase());
// BuildRuleEvent.Finished
assertEquals("//fake:rule", resultMap.get(10).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(10).getPhase());
assertEquals(
ImmutableMap.of(
"cache_result", "miss",
"success_type", "BUILT_LOCALLY"),
resultMap.get(10).getArgs());
assertEquals("planning", resultMap.get(11).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(11).getPhase());
assertEquals(ImmutableMap.of("nefarious", "true"), resultMap.get(11).getArgs());
assertEquals("scheming", resultMap.get(12).getName());
assertEquals(ChromeTraceEvent.Phase.BEGIN, resultMap.get(12).getPhase());
assertEquals(ImmutableMap.of(), resultMap.get(12).getArgs());
assertEquals("scheming", resultMap.get(13).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(13).getPhase());
assertEquals(ImmutableMap.of("success", "false"), resultMap.get(13).getArgs());
assertEquals("planning", resultMap.get(14).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(14).getPhase());
assertEquals(ImmutableMap.of(), resultMap.get(14).getArgs());
assertEquals("build", resultMap.get(15).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(15).getPhase());
assertEquals("party", resultMap.get(16).getName());
assertEquals(ChromeTraceEvent.Phase.END, resultMap.get(16).getPhase());
assertEquals(
ImmutableMap.of(
"command_args", "arg1 arg2",
"daemon", "true"),
resultMap.get(16).getArgs());
verify(context);
}
@Test
public void shouldBeAbleToConstructACxxLibraryFromThrift() throws Exception {
ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "cxx", tmp);
workspace.setUp();
BuckEventBus eventBus = BuckEventBusFactory.newInstance();
ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath());
Path compiler =
new ExecutableFinder()
.getExecutable(Paths.get("echo"), ImmutableMap.copyOf(System.getenv()));
BuckConfig config =
FakeBuckConfig.builder()
.setFilesystem(filesystem)
.setSections(
"[thrift]",
"compiler = " + compiler,
"compiler2 = " + compiler,
"cpp_library = //thrift:fake",
"cpp_reflection_library = //thrift:fake")
.build();
TypeCoercerFactory typeCoercerFactory = new DefaultTypeCoercerFactory();
Parser parser =
new Parser(
new ParserConfig(config),
typeCoercerFactory,
new ConstructorArgMarshaller(typeCoercerFactory));
Cell cell =
Cell.createCell(
filesystem,
new TestConsole(),
Watchman.NULL_WATCHMAN,
config,
new KnownBuildRuleTypesFactory(
new ProcessExecutor(new TestConsole()),
new FakeAndroidDirectoryResolver(),
Optional.<Path>absent()),
new FakeAndroidDirectoryResolver(),
new DefaultClock());
BuildTarget target = BuildTargetFactory.newInstance(filesystem, "//thrift:exe");
TargetGraph targetGraph =
parser.buildTargetGraph(
eventBus, cell, false, Executors.newSingleThreadExecutor(), ImmutableSet.of(target));
TargetNodeToBuildRuleTransformer transformer = new BuildTargetNodeToBuildRuleTransformer();
// There was a case where the cxx library being generated wouldn't put the header into the tree
// with the right flavour. This catches this case without us needing to stick a working thrift
// compiler into buck's own source.
Pair<ActionGraph, BuildRuleResolver> actionGraphAndResolver =
new TargetGraphToActionGraph(eventBus, transformer).apply(targetGraph);
// This is to cover the case where we weren't passing flavors around correctly, which ended
// making the binary depend 'placeholder' BuildRules instead of real ones. This is the
// regression test for that case.
BuildRuleResolver ruleResolver = actionGraphAndResolver.getSecond();
BuildTarget binaryFlavor = target.withFlavors(ImmutableFlavor.of("binary"));
ImmutableSortedSet<BuildRule> deps = ruleResolver.getRule(binaryFlavor).getDeps();
assertThat(
FluentIterable.from(deps)
.anyMatch(
new Predicate<BuildRule>() {
@Override
public boolean apply(BuildRule input) {
return input instanceof NoopBuildRule;
}
}),
Matchers.is(false));
}
