| // Copyright 2020 The Bazel Authors. All rights reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package com.google.devtools.build.lib.skyframe; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static com.google.common.truth.Truth.assertWithMessage; |
| |
| import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider; |
| import com.google.devtools.build.lib.analysis.util.BuildViewTestCase; |
| import com.google.devtools.build.lib.analysis.util.MockRule; |
| import com.google.devtools.build.lib.testutil.TestRuleClassProvider; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** |
| * Tests for Starlark builtin injection. |
| * |
| * <p>Essentially these are integration tests between {@link StarlarkBuiltinsFunction} and {@link |
| * BzlLoadFunction}. |
| */ |
| @RunWith(JUnit4.class) |
| public class BuiltinsInjectionTest extends BuildViewTestCase { |
| |
| private static final MockRule OVERRIDABLE_RULE = () -> MockRule.define("overridable_rule"); |
| |
| @Override |
| protected ConfiguredRuleClassProvider createRuleClassProvider() { |
| // Add a fake rule and top-level symbol to override. |
| ConfiguredRuleClassProvider.Builder builder = |
| new ConfiguredRuleClassProvider.Builder() |
| .addRuleDefinition(OVERRIDABLE_RULE) |
| .addStarlarkAccessibleTopLevels("overridable_symbol", "original_value"); |
| TestRuleClassProvider.addStandardRules(builder); |
| return builder.build(); |
| } |
| |
| @Before |
| public void setUp() throws Exception { |
| setBuildLanguageOptions("--experimental_builtins_bzl_path=tools/builtins_staging"); |
| } |
| |
| /** |
| * Writes an exports.bzl file with the given content, in the builtins location. |
| * |
| * <p>See {@link StarlarkBuiltinsFunction#EXPORTS_ENTRYPOINT} for the significance of exports.bzl. |
| */ |
| private void writeExportsBzl(String... lines) throws Exception { |
| scratch.file("tools/builtins_staging/exports.bzl", lines); |
| } |
| |
| /** |
| * Writes a pkg/dummy.bzl file that prints a marker phrase when it finishes evaluating, and an |
| * accompanying BUILD file that loads it. |
| */ |
| private void writePkgBzl(String... lines) throws Exception { |
| scratch.file("pkg/BUILD", "load(':dummy.bzl', 'dummy_symbol')"); |
| scratch.file("pkg/dummy"); |
| List<String> modifiedLines = new ArrayList<>(Arrays.asList(lines)); |
| modifiedLines.add("dummy_symbol = None"); |
| // The marker phrase might not be needed, but I don't entirely trust BuildViewTestCase. |
| modifiedLines.add("print('dummy.bzl evaluation completed')"); |
| scratch.file("pkg/dummy.bzl", modifiedLines.toArray(lines)); |
| } |
| |
| /** Builds {@code //pkg} and asserts success, including that the marker print() event occurs. */ |
| private void buildAndAssertSuccess() throws Exception { |
| Object result = getConfiguredTarget("//pkg:BUILD"); |
| assertContainsEvent("dummy.bzl evaluation completed"); |
| // On error, getConfiguredTarget sometimes returns null without emitting events; see b/26382502. |
| // Though in that case it seems unlikely the above assertion would've passed. |
| assertThat(result).isNotNull(); |
| } |
| |
| /** Builds {@code //pkg:dummy} and asserts on the absence of the marker print() event. */ |
| private void buildAndAssertFailure() throws Exception { |
| reporter.removeHandler(failFastHandler); |
| Object result = getConfiguredTarget("//pkg:BUILD"); |
| assertDoesNotContainEvent("dummy.bzl evaluation completed"); |
| assertWithMessage("Loading of //pkg succeeded unexpectedly").that(result).isNull(); |
| } |
| |
| @Test |
| public void basicFunctionality() throws Exception { |
| writeExportsBzl( |
| "exported_toplevels = {'overridable_symbol': 'new_value'}", |
| "exported_rules = {'overridable_rule': 'new_rule'}", |
| "exported_to_java = {}"); |
| writePkgBzl( |
| "print('overridable_symbol :: ' + str(overridable_symbol))", |
| "print('overridable_rule :: ' + str(native.overridable_rule))"); |
| |
| buildAndAssertSuccess(); |
| assertContainsEvent("overridable_symbol :: new_value"); |
| assertContainsEvent("overridable_rule :: new_rule"); |
| } |
| |
| @Test |
| public void builtinsCanLoadFromBuiltins() throws Exception { |
| // Define a few files that we can load with different kinds of label syntax. In each case, |
| // access the `_internal` symbol to demonstrate that we're being loaded as a builtins bzl. |
| scratch.file( |
| "tools/builtins_staging/absolute.bzl", // |
| "_internal", |
| "a = 'A'"); |
| scratch.file( |
| "tools/builtins_staging/repo_relative.bzl", // |
| "_internal", |
| "b = 'B'"); |
| scratch.file( |
| "tools/builtins_staging/subdir/pkg_relative1.bzl", // |
| // Do a relative load within a load, to show it's relative to the (pseudo) package, i.e. the |
| // root, and not relative to the file. That is, we specify 'subdir/pkg_relative2.bzl', not |
| // just 'pkg_relative2.bzl'. |
| "load('subdir/pkg_relative2.bzl', 'c2')", |
| "_internal", |
| "c = c2"); |
| scratch.file( |
| "tools/builtins_staging/subdir/pkg_relative2.bzl", // |
| "_internal", |
| "c2 = 'C'"); |
| |
| // Also create a file in the main repo whose package path coincides with a file in the builtins |
| // pseudo-repo, to show that we get the right one. |
| scratch.file("BUILD"); |
| scratch.file("repo_relative.bzl"); |
| |
| writeExportsBzl( |
| "load('@_builtins//:absolute.bzl', 'a')", |
| "load('//:repo_relative.bzl', 'b')", // default repo is @_builtins, not main repo |
| "load('subdir/pkg_relative1.bzl', 'c')", // relative to (pseudo) package, which is repo root |
| "exported_toplevels = {'overridable_symbol': a + b + c}", |
| "exported_rules = {}", |
| "exported_to_java = {}"); |
| writePkgBzl("print('overridable_symbol :: ' + str(overridable_symbol))"); |
| |
| buildAndAssertSuccess(); |
| assertContainsEvent("overridable_symbol :: ABC"); |
| } |
| |
| @Test |
| public void otherBzlsCannotLoadFromBuiltins() throws Exception { |
| writeExportsBzl( |
| "exported_toplevels = {}", // |
| "exported_rules = {}", |
| "exported_to_java = {}"); |
| writePkgBzl("load('@_builtins//:exports.bzl', 'exported_toplevels')"); |
| |
| buildAndAssertFailure(); |
| assertContainsEvent("The repository '@_builtins' could not be resolved"); |
| } |
| |
| @Test |
| public void builtinsCannotLoadFromNonBuiltins() throws Exception { |
| scratch.file("BUILD"); |
| scratch.file( |
| "a_user_written.bzl", // |
| "toplevels = {'overridable_symbol': 'new_value'}"); |
| writeExportsBzl( |
| // Use @// syntax to specify the main repo. Otherwise, the load would be relative to the |
| // @_builtins pseudo-repo. |
| "load('@//:a_user_written.bzl', 'toplevels')", |
| "exported_toplevels = toplevels", |
| "exported_rules = {}", |
| "exported_to_java = {}"); |
| writePkgBzl(); |
| |
| buildAndAssertFailure(); |
| assertContainsEvent( |
| "in load statement: .bzl files in @_builtins cannot load from outside of @_builtins"); |
| } |
| |
| @Test |
| public void builtinsCannotLoadWithMisplacedColon() throws Exception { |
| scratch.file( |
| "tools/builtins_staging/subdir/helper.bzl", // |
| "toplevels = {'overridable_symbol': 'new_value'}"); |
| writeExportsBzl( |
| "load('//subdir:helper.bzl', 'toplevels')", // Should've been loaded as //:subdir/helper.bzl |
| "exported_toplevels = toplevels", |
| "exported_rules = {}", |
| "exported_to_java = {}"); |
| writePkgBzl(); |
| |
| buildAndAssertFailure(); |
| assertContainsEvent("@_builtins cannot have subpackages"); |
| } |
| |
| @Test |
| public void errorInEvaluatingBuiltinsDependency() throws Exception { |
| // Test case with a Starlark error in the @_builtins pseudo-repo itself. |
| scratch.file( |
| "tools/builtins_staging/helper.bzl", // |
| "toplevels = {'overridable_symbol': 1//0} # <-- dynamic error"); |
| writeExportsBzl( |
| "load('@_builtins//:helper.bzl', 'toplevels')", |
| "exported_toplevels = toplevels", |
| "exported_rules = {}", |
| "exported_to_java = {}"); |
| writePkgBzl(); |
| |
| buildAndAssertFailure(); |
| assertContainsEvent( |
| "File \"/workspace/tools/builtins_staging/helper.bzl\", line 1, column 37, in <toplevel>"); |
| assertContainsEvent("Error: integer division by zero"); |
| assertContainsEvent( |
| "error loading package 'pkg': Internal error while loading Starlark builtins for " |
| + "//pkg:dummy.bzl: Failed to load builtins sources: in " |
| + "/workspace/tools/builtins_staging/exports.bzl: Extension file " |
| + "'helper.bzl' (internal) has errors"); |
| } |
| |
| @Test |
| public void errorInProcessingExports() throws Exception { |
| // Test case with an error in the symbols exported by exports.bzl, but no actual Starlark errors |
| // in the builtins files themselves. |
| writeExportsBzl( |
| "exported_toplevels = None", // should be dict |
| "exported_rules = {}", |
| "exported_to_java = {}"); |
| writePkgBzl(); |
| |
| buildAndAssertFailure(); |
| assertContainsEvent( |
| "error loading package 'pkg': Internal error while loading Starlark builtins for " |
| + "//pkg:dummy.bzl: Failed to apply declared builtins: got NoneType for " |
| + "'exported_toplevels dict', want dict"); |
| } |
| |
| // TODO(#11437): Remove once disabling is not allowed. |
| @Test |
| public void injectionDisabledByFlag() throws Exception { |
| writeExportsBzl( |
| "exported_toplevels = {'overridable_symbol': 'new_value'}", |
| "exported_rules = {'overridable_rule': 'new_rule'}", |
| "exported_to_java = {}"); |
| writePkgBzl( |
| "print('overridable_symbol :: ' + str(overridable_symbol))", |
| "print('overridable_rule :: ' + str(native.overridable_rule))"); |
| setBuildLanguageOptions("--experimental_builtins_bzl_path="); |
| |
| buildAndAssertSuccess(); |
| assertContainsEvent("overridable_symbol :: original_value"); |
| assertContainsEvent("overridable_rule :: <built-in rule overridable_rule>"); |
| } |
| |
| // TODO(#11437): Remove once disabling is not allowed. |
| @Test |
| public void exportsBzlMayBeInErrorWhenInjectionIsDisabled() throws Exception { |
| writeExportsBzl( // |
| "PARSE ERROR"); |
| writePkgBzl( |
| "print('overridable_symbol :: ' + str(overridable_symbol))", |
| "print('overridable_rule :: ' + str(native.overridable_rule))"); |
| setBuildLanguageOptions("--experimental_builtins_bzl_path="); |
| |
| buildAndAssertSuccess(); |
| assertContainsEvent("overridable_symbol :: original_value"); |
| assertContainsEvent("overridable_rule :: <built-in rule overridable_rule>"); |
| } |
| |
| // TODO(#11954): Once WORKSPACE- and BUILD-loaded bzls use the exact same environments, we'll want |
| // to apply injection to both. This is for uniformity, not because we actually care about builtins |
| // injection for WORKSPACE bzls. In the meantime, assert the status quo: WORKSPACE bzls do not use |
| // injection. |
| @Test |
| public void workspaceBzlDoesNotUseInjection() throws Exception { |
| writeExportsBzl( |
| "exported_toplevels = {'overridable_symbol': 'new_value'}", |
| "exported_rules = {'overridable_rule': 'new_rule'}", |
| "exported_to_java = {}"); |
| writePkgBzl(); |
| scratch.appendFile( |
| "WORKSPACE", // |
| "load(':foo.bzl', 'dummy_symbol')", |
| "print(dummy_symbol)"); |
| scratch.file("BUILD"); |
| scratch.file( |
| "foo.bzl", |
| "dummy_symbol = None", |
| "print('overridable_symbol :: ' + str(overridable_symbol))"); |
| |
| buildAndAssertSuccess(); |
| // Builtins for WORKSPACE bzls are populated essentially the same as for BUILD bzls, except that |
| // injection doesn't apply. |
| assertContainsEvent("overridable_symbol :: original_value"); |
| // We don't assert that the rule isn't injected because the workspace native object doesn't |
| // contain our original mock rule. We can test this for WORKSPACE files at the top-level though. |
| } |
| |
| // TODO(#11437): Add tests of the _internal symbol's usage within builtins bzls. |
| |
| // TODO(#11437): Add test cases for BUILD file injection, and WORKSPACE file non-injection, when |
| // we add injection support to PackageFunction. |
| |
| /** |
| * Tests for injection, under inlining of {@link BzlLoadFunction}. |
| * |
| * <p>See {@link BzlLoadFunction#computeInline} for an explanation of inlining. |
| */ |
| @RunWith(JUnit4.class) |
| public static class BuiltinsInjectionTestWithInlining extends BuiltinsInjectionTest { |
| |
| @Override |
| protected boolean usesInliningBzlLoadFunction() { |
| return true; |
| } |
| } |
| } |