| // Copyright 2021 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.packages; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider; |
| import com.google.devtools.build.lib.analysis.util.BuildViewTestCase; |
| import com.google.devtools.build.lib.testutil.TestRuleClassProvider; |
| import java.util.HashMap; |
| import java.util.Map; |
| import net.starlark.java.annot.Param; |
| import net.starlark.java.annot.StarlarkBuiltin; |
| import net.starlark.java.annot.StarlarkMethod; |
| import net.starlark.java.eval.Dict; |
| import net.starlark.java.eval.Starlark; |
| import net.starlark.java.eval.StarlarkInt; |
| import net.starlark.java.eval.StarlarkList; |
| import net.starlark.java.eval.StarlarkValue; |
| import net.starlark.java.eval.Tuple; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** |
| * Tests for {@code native.existing_rule} and {@code native.existing_rules} functions. |
| * |
| * <p>This class covers the legacy behavior where the {@code |
| * --incompatible_existing_rules_immutable_view} flag is disabled. The enabled case is covered by |
| * the subclass, {@link WithImmutableView}. |
| */ |
| @RunWith(JUnit4.class) |
| public class NativeExistingRulesTest extends BuildViewTestCase { |
| private TestStarlarkBuiltin testStarlarkBuiltin; // initialized by createRuleClassProvider() |
| |
| // Intended to be overridden by this test case's subclasses. Note that overriding of JUnit's |
| // @Before methods is not recommended. |
| protected void setupOptions() throws Exception { |
| // --noincompatible_existing_rules_immutable_view is the default; set it explicitly for clarity. |
| setBuildLanguageOptions("--noincompatible_existing_rules_immutable_view"); |
| } |
| |
| @Before |
| public final void setUp() throws Exception { |
| setupOptions(); |
| } |
| |
| @StarlarkBuiltin(name = "test") |
| private static final class TestStarlarkBuiltin implements StarlarkValue { |
| |
| private final Map<String, Object> saved = new HashMap<>(); |
| |
| @StarlarkMethod( |
| name = "save", |
| parameters = { |
| @Param(name = "name", doc = "Name under which to save the value"), |
| @Param(name = "value", doc = "Value to save") |
| }, |
| doc = "Saves a Starlark value for testing from Java") |
| public synchronized void save(String name, Object value) { |
| saved.put(name, value); |
| } |
| } |
| |
| @Override |
| protected ConfiguredRuleClassProvider createRuleClassProvider() { |
| ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder(); |
| TestRuleClassProvider.addStandardRules(builder); |
| testStarlarkBuiltin = new TestStarlarkBuiltin(); |
| builder.addBzlToplevel("test", testStarlarkBuiltin); |
| return builder.build(); |
| } |
| |
| private Object getSaved(String name) { |
| return testStarlarkBuiltin.saved.get(name); |
| } |
| |
| @Test |
| public void existingRule_handlesSelect() throws Exception { |
| scratch.file("test/starlark/BUILD"); |
| scratch.file( |
| "test/starlark/rulestr.bzl", |
| """ |
| def rule_dict(name): |
| return native.existing_rule(name) |
| """); |
| |
| scratch.file( |
| "test/getrule/BUILD", |
| """ |
| load("//test/starlark:rulestr.bzl", "rule_dict") |
| |
| cc_library( |
| name = "x", |
| srcs = select({"//conditions:default": []}), |
| ) |
| |
| rule_dict("x") |
| """); |
| |
| // Parse the BUILD file, to make sure select() makes it out of native.existing_rule(). |
| assertThat(getConfiguredTarget("//test/getrule:x")).isNotNull(); |
| } |
| |
| @Test |
| public void existingRule_returnsNone() throws Exception { |
| scratch.file( |
| "test/rulestr.bzl", |
| """ |
| def test_rule(name, x): |
| print(native.existing_rule(x)) |
| if native.existing_rule(x) == None: |
| native.cc_library(name = name) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:rulestr.bzl", "test_rule") |
| |
| test_rule("a", "does not exist") |
| |
| test_rule("b", "BUILD") |
| """); // exists, but as a target and not a rule |
| |
| assertThat(getConfiguredTarget("//test:a")).isNotNull(); |
| assertThat(getConfiguredTarget("//test:b")).isNotNull(); |
| } |
| |
| @Test |
| public void existingRule_roundTripsSelect() throws Exception { |
| scratch.file( |
| "test/existing_rule.bzl", |
| """ |
| def macro(): |
| s = select({"//foo": ["//bar"]}) |
| print("Passed: " + repr(s)) |
| native.cc_library(name = "x", srcs = s) |
| print("Returned: " + repr(native.existing_rule("x")["srcs"])) |
| |
| # The value returned here should round-trip fine. |
| native.cc_library(name = "y", srcs = native.existing_rule("x")["srcs"]) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:existing_rule.bzl", "macro") |
| |
| macro() |
| |
| cc_library( |
| name = "a", |
| srcs = [], |
| ) |
| """); |
| getConfiguredTarget("//test:a"); |
| assertContainsEvent("Passed: select({\"//foo\": [\"//bar\"]}"); |
| // The short labels are now in their canonical form, and the sequence is represented as |
| // tuple instead of list, but the meaning is unchanged. |
| assertContainsEvent("Returned: select({\"//foo:foo\": (\"//bar:bar\",)}"); |
| } |
| |
| @Test |
| public void existingRule_shortensLabelsInSamePackage() throws Exception { |
| scratch.file( |
| "test/existing_rule.bzl", |
| """ |
| def save_deps(): |
| r = native.existing_rule("b") |
| test.save("r['deps']", r["deps"]) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:existing_rule.bzl", "save_deps") |
| |
| cc_library( |
| name = "a", |
| srcs = [], |
| ) |
| |
| cc_binary( |
| name = "b", |
| deps = ["//test:a"], |
| ) |
| |
| save_deps() |
| """); |
| getConfiguredTarget("//test:b"); |
| assertThat(Starlark.toIterable(getSaved("r['deps']"))) |
| .containsExactly(":a"); // as opposed to "//test:a" |
| } |
| |
| @Test |
| public void existingRules_findsRulesAndAttributes() throws Exception { |
| scratch.file("test/BUILD"); |
| scratch.file("test/starlark/BUILD"); |
| scratch.file( |
| "test/starlark/rulestr.bzl", |
| """ |
| def rule_dict(name): |
| return native.existing_rule(name) |
| |
| def rules_dict(): |
| return native.existing_rules() |
| |
| def nop(ctx): |
| pass |
| |
| nop_rule = rule(attrs = {"x": attr.label()}, implementation = nop) |
| |
| def test_save(name, value): |
| test.save(name, value) |
| """); |
| |
| scratch.file( |
| "test/getrule/BUILD", |
| """ |
| load("//test/starlark:rulestr.bzl", "nop_rule", "rule_dict", "rules_dict", "test_save") |
| |
| genrule( |
| name = "a", |
| outs = ["a.txt"], |
| cmd = "touch $@", |
| licenses = ["notice"], |
| output_to_bindir = False, |
| tools = ["//test:bla"], |
| ) |
| |
| nop_rule( |
| name = "c", |
| x = ":a", |
| ) |
| |
| rlist = rules_dict() |
| |
| test_save( |
| "all_str", |
| [ |
| rlist["a"]["kind"], |
| rlist["a"]["name"], |
| rlist["c"]["kind"], |
| rlist["c"]["name"], |
| ], |
| ) |
| |
| adict = rule_dict("a") |
| |
| cdict = rule_dict("c") |
| |
| test_save( |
| "a_str", |
| [ |
| adict["kind"], |
| adict["name"], |
| adict["outs"][0], |
| adict["tools"][0], |
| ], |
| ) |
| |
| test_save( |
| "c_str", |
| [ |
| cdict["kind"], |
| cdict["name"], |
| cdict["x"], |
| ], |
| ) |
| |
| test_save( |
| "adict.keys()", |
| adict.keys(), |
| ) |
| """); |
| |
| getConfiguredTarget("//test/getrule:BUILD"); |
| assertThat(Starlark.toIterable(getSaved("all_str"))) |
| .containsExactly("genrule", "a", "nop_rule", "c") |
| .inOrder(); |
| assertThat(Starlark.toIterable(getSaved("a_str"))) |
| .containsExactly("genrule", "a", ":a.txt", "//test:bla") |
| .inOrder(); |
| assertThat(Starlark.toIterable(getSaved("c_str"))) |
| .containsExactly("nop_rule", "c", ":a") |
| .inOrder(); |
| assertThat(Starlark.toIterable(getSaved("adict.keys()"))) |
| .containsAtLeast( |
| "name", |
| "visibility", |
| "transitive_configs", |
| "tags", |
| "generator_name", |
| "generator_function", |
| "generator_location", |
| "features", |
| "compatible_with", |
| "target_compatible_with", |
| "restricted_to", |
| "srcs", |
| "tools", |
| "toolchains", |
| "outs", |
| "cmd", |
| "output_to_bindir", |
| "local", |
| "message", |
| "executable", |
| "stamp", |
| "heuristic_label_expansion", |
| "kind"); |
| } |
| |
| @Test |
| public void existingRule_ignoresHiddenAttributes() throws Exception { |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def _check_hidden_attr_exists(ctx): |
| if ctx.attr._hidden_attr != "hidden_val": |
| fail('ctx.attr._hidden_attr != "hidden_val"') |
| pass |
| |
| my_rule = rule( |
| attrs = { |
| "_hidden_attr": attr.string(default = "hidden_val"), |
| "normal_attr": attr.string(default = "normal_val"), |
| }, |
| implementation = _check_hidden_attr_exists, |
| ) |
| |
| def f(): |
| my_rule(name = "rulename") |
| r = native.existing_rule("rulename") |
| test.save("r.keys()", r.keys()) |
| test.save("r.values()", r.values()) |
| test.save('"_hidden_attr" in r', "_hidden_attr" in r) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| |
| assertThat(getConfiguredTarget("//test:rulename")).isNotNull(); |
| assertThat(Starlark.toIterable(getSaved("r.keys()"))) |
| .containsAtLeast("name", "kind", "normal_attr"); |
| assertThat(Starlark.toIterable(getSaved("r.keys()"))).doesNotContain("_hidden_attr"); |
| assertThat(Starlark.toIterable(getSaved("r.values()"))) |
| .containsAtLeast("rulename", "my_rule", "normal_val"); |
| assertThat(Starlark.toIterable(getSaved("r.values()"))).doesNotContain("hidden_val"); |
| assertThat((Boolean) getSaved("\"_hidden_attr\" in r")).isFalse(); |
| } |
| |
| @Test |
| public void existingRule_returnsObjectWithCorrectMutability() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key": "value"}) |
| r = native.existing_rule("x") |
| r["no_such_attribute"] = "foo" |
| r["define_values"]["key"] = 123 |
| """); // mutate the dict |
| |
| assertThat(getConfiguredTarget("//test:BUILD")).isNotNull(); // no error on mutation |
| } |
| |
| @Test |
| public void existingRule_returnsDictLikeObject() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key": "value"}) |
| r = native.existing_rule("x") |
| print("r == %s" % repr(r)) |
| test.save("[key for key in r]", [key for key in r]) |
| test.save("list(r)", list(r)) |
| test.save("r.keys()", r.keys()) |
| test.save("r.values()", r.values()) |
| test.save("r.items()", r.items()) |
| test.save("r['define_values']", r["define_values"]) |
| test.save("r.get('define_values', 123)", r.get("define_values", 123)) |
| test.save("r.get('invalid_attr', 123)", r.get("invalid_attr", 123)) |
| test.save("'define_values' in r", "define_values" in r) |
| test.save("'invalid_attr' in r", "invalid_attr" in r) |
| """); |
| |
| Dict<?, ?> expectedDefineValues = Dict.builder().put("key", "value").buildImmutable(); |
| assertThat(getConfiguredTarget("//test:BUILD")).isNotNull(); // no error |
| assertThat(Starlark.toIterable(getSaved("[key for key in r]"))) |
| .containsAtLeast("define_values", "name", "kind"); |
| assertThat(Starlark.toIterable(getSaved("list(r)"))) |
| .containsAtLeast("define_values", "name", "kind"); |
| assertThat(Starlark.toIterable(getSaved("r.keys()"))) |
| .containsAtLeast("define_values", "name", "kind"); |
| assertThat(Starlark.toIterable(getSaved("r.values()"))) |
| .containsAtLeast(expectedDefineValues, "x", "config_setting"); |
| assertThat(Starlark.toIterable(getSaved("r.items()"))) |
| .containsAtLeast( |
| Tuple.of("define_values", expectedDefineValues), |
| Tuple.of("name", "x"), |
| Tuple.of("kind", "config_setting")); |
| assertThat(getSaved("r['define_values']")).isEqualTo(expectedDefineValues); |
| assertThat(getSaved("r.get('define_values', 123)")).isEqualTo(expectedDefineValues); |
| assertThat(getSaved("r.get('invalid_attr', 123)")).isEqualTo(StarlarkInt.of(123)); |
| assertThat(getSaved("'define_values' in r")).isEqualTo(true); |
| assertThat(getSaved("'invalid_attr' in r")).isEqualTo(false); |
| } |
| |
| @Test |
| public void existingRule_asDictArgument() throws Exception { |
| scratch.file( |
| "test/test.bzl", |
| """ |
| def save_as_dict(r): |
| test.save("type(dict(r))", type(dict(r))) |
| test.save('dict(r)["name"]', dict(r)["name"]) |
| test.save('dict(r)["kind"]', dict(r)["kind"]) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:test.bzl", "save_as_dict") |
| |
| cc_library( |
| name = "rulename", |
| ) |
| |
| save_as_dict(existing_rule("rulename")) |
| """); |
| getConfiguredTarget("//test:rulename"); |
| assertThat(getSaved("type(dict(r))")).isEqualTo("dict"); |
| assertThat(getSaved("dict(r)[\"name\"]")).isEqualTo("rulename"); |
| assertThat(getSaved("dict(r)[\"kind\"]")).isEqualTo("cc_library"); |
| } |
| |
| @Test |
| public void existingRule_asDictUpdateArgument() throws Exception { |
| // We do not test `existing_rule(r).update({...})` because `existing_rule(r)` may be immutable |
| // (as verified by other test cases). |
| scratch.file( |
| "test/test.bzl", |
| """ |
| def save_as_updated_dict(r): |
| updated_dict = {"name": "dictname", "dictkey": 1} |
| updated_dict.update(r) |
| test.save('updated_dict["name"]', updated_dict["name"]) |
| test.save('updated_dict["kind"]', updated_dict["kind"]) |
| test.save('updated_dict["dictkey"]', updated_dict["dictkey"]) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:test.bzl", "save_as_updated_dict") |
| |
| cc_library( |
| name = "rulename", |
| ) |
| |
| save_as_updated_dict(existing_rule("rulename")) |
| """); |
| getConfiguredTarget("//test:rulename"); |
| assertThat(getSaved("updated_dict[\"name\"]")).isEqualTo("rulename"); |
| assertThat(getSaved("updated_dict[\"kind\"]")).isEqualTo("cc_library"); |
| assertThat(getSaved("updated_dict[\"dictkey\"]")).isEqualTo(StarlarkInt.of(1)); |
| } |
| |
| @Test |
| public void existingRule_unionableWithDict() throws Exception { |
| scratch.file( |
| "test/test.bzl", |
| """ |
| def save_as_union(dict_val, r): |
| test.save("dict_val | r", dict_val | r) |
| test.save("r | dict_val", r | dict_val) |
| dict_val |= r |
| test.save("dict_val |= r", dict_val) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:test.bzl", "save_as_union") |
| |
| cc_library( |
| name = "rulename", |
| ) |
| |
| save_as_union( |
| { |
| "name": "dictname", |
| "dictkey": 1, |
| }, |
| existing_rule("rulename"), |
| ) |
| """); |
| getConfiguredTarget("//test:rulename"); |
| Map<String, Object> unionDictWithExistingRule = |
| Dict.cast(getSaved("dict_val | r"), String.class, Object.class, "dict_val | r"); |
| assertThat(unionDictWithExistingRule) |
| .containsAtLeast("name", "rulename", "dictkey", StarlarkInt.of(1), "kind", "cc_library"); |
| Map<String, Object> unionExistingRuleWithDict = |
| Dict.cast(getSaved("r | dict_val"), String.class, Object.class, "r | dict_val"); |
| assertThat(unionExistingRuleWithDict) |
| .containsAtLeast("name", "dictname", "dictkey", StarlarkInt.of(1), "kind", "cc_library"); |
| Map<String, Object> inPlaceUnionDictWithExistingRule = |
| Dict.cast(getSaved("dict_val |= r"), String.class, Object.class, "dict_val | r"); |
| assertThat(inPlaceUnionDictWithExistingRule) |
| .containsAtLeast("name", "rulename", "dictkey", StarlarkInt.of(1), "kind", "cc_library"); |
| } |
| |
| @Test |
| public void existingRule_asKwargs() throws Exception { |
| scratch.file( |
| "test/test.bzl", |
| """ |
| def save_kwargs(**kwargs): |
| test.save('kwargs["name"]', kwargs["name"]) |
| test.save('kwargs["kind"]', kwargs["kind"]) |
| |
| def save_kwargs_of_existing_rule(name): |
| save_kwargs(**native.existing_rule(name)) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:test.bzl", "save_kwargs_of_existing_rule") |
| |
| cc_library( |
| name = "rulename", |
| ) |
| |
| save_kwargs_of_existing_rule("rulename") |
| """); |
| getConfiguredTarget("//test:rulename"); |
| assertThat(getSaved("kwargs[\"name\"]")).isEqualTo("rulename"); |
| assertThat(getSaved("kwargs[\"kind\"]")).isEqualTo("cc_library"); |
| } |
| |
| // Regression test for https://github.com/bazelbuild/bazel/issues/16256 |
| @Test |
| public void existingRule_encodesToJson() throws Exception { |
| // We need a Starlark rule - native rules can have attribute values that the json encoder |
| // doesn't handle. |
| scratch.file( |
| "test/test.bzl", |
| """ |
| def _dummy_impl(ctx): |
| pass |
| |
| test_library = rule( |
| implementation = _dummy_impl, |
| attrs = {"srcs": attr.label_list(allow_files = True)}, |
| ) |
| |
| # TODO(b/249397668): simplifying this to `json_encode = json.encode` etc. causes a |
| # NoCodecException. Need to investigate. |
| def json_encode(value): |
| return json.encode(value) |
| |
| def json_decode(text): |
| return json.decode(text) |
| |
| def save(name, object): |
| test.save(name, object) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:test.bzl", "json_decode", "json_encode", "save", "test_library") |
| |
| test_library( |
| name = "foo", |
| srcs = ["foo.cc"], |
| ) |
| |
| save( |
| "foo", |
| json_decode(json_encode(existing_rule("foo"))), |
| ) |
| """); |
| scratch.file("test/foo.cc"); |
| getConfiguredTarget("//test:foo"); |
| // We test a subset of attributes after an encode-decode round trip because the rule also has |
| // default attributes with default values, which will get encoded to json and which will change |
| // whenever default attributes get introduced, making string comparison of encoded json fragile. |
| Map<String, Object> jsonRoundTripValue = |
| Dict.cast( |
| getSaved("foo"), String.class, Object.class, "json round trip of existing_rule('foo')"); |
| assertThat(jsonRoundTripValue) |
| .containsAtLeast( |
| "name", "foo", "kind", "test_library", "srcs", StarlarkList.immutableOf(":foo.cc")); |
| } |
| |
| @Test |
| public void existingRules_returnsObjectWithCorrectMutability() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key": "value"}) |
| rs = native.existing_rules() |
| rs["no_such_rule"] = {"name": "no_such_rule", "kind": "config_setting"} |
| """); // mutate |
| |
| assertThat(getConfiguredTarget("//test:BUILD")).isNotNull(); // no error on mutation |
| } |
| |
| @Test |
| public void existingRules_returnsDictLikeObject() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", // |
| "def f():", |
| " native.config_setting(name='x', define_values={'key_x': 'value_x'})", |
| " native.config_setting(name='y', define_values={'key_y': 'value_y'})", |
| " rs = native.existing_rules()", |
| " print('rs == %s' % repr(rs))", |
| " test.save('[key for key in rs]', [key for key in rs])", |
| " test.save('list(rs)', list(rs))", |
| " test.save('rs.keys()', rs.keys())", |
| " test.save(\"[v['name'] for v in rs.values()]\", [v['name'] for v in rs.values()])", |
| " test.save(\"[(i[0], i[1]['name']) for i in rs.items()]\", [(i[0], i[1]['name']) for i in" |
| + " rs.items()])", |
| " test.save(\"rs['x']['define_values']\", rs['x']['define_values'])", |
| " test.save(\"rs.get('x', {'name': 'z'})['name']\", rs.get('x', {'name': 'z'})['name'])", |
| " test.save(\"rs.get('invalid_rule', {'name': 'invalid_rule'})\", rs.get('invalid_rule'," |
| + " {'name': 'invalid_rule'}))", |
| " test.save(\"'x' in rs\", 'x' in rs)", |
| " test.save(\"'invalid_rule' in rs\", 'invalid_rule' in rs)"); |
| |
| assertThat(getConfiguredTarget("//test:BUILD")).isNotNull(); // no error |
| assertThat(Starlark.toIterable(getSaved("[key for key in rs]"))).containsExactly("x", "y"); |
| assertThat(Starlark.toIterable(getSaved("list(rs)"))).containsExactly("x", "y"); |
| assertThat(Starlark.toIterable(getSaved("rs.keys()"))).containsExactly("x", "y"); |
| assertThat(Starlark.toIterable(getSaved("[v['name'] for v in rs.values()]"))) |
| .containsExactly("x", "y"); |
| assertThat(Starlark.toIterable(getSaved("[(i[0], i[1]['name']) for i in rs.items()]"))) |
| .containsExactly(Tuple.of("x", "x"), Tuple.of("y", "y")); |
| assertThat(getSaved("rs['x']['define_values']")) |
| .isEqualTo(Dict.builder().put("key_x", "value_x").buildImmutable()); |
| assertThat(getSaved("rs.get('x', {'name': 'z'})['name']")).isEqualTo("x"); |
| assertThat(getSaved("rs.get('invalid_rule', {'name': 'invalid_rule'})")) |
| .isEqualTo(Dict.builder().put("name", "invalid_rule").buildImmutable()); |
| assertThat(getSaved("'x' in rs")).isEqualTo(true); |
| assertThat(getSaved("'invalid_rule' in rs")).isEqualTo(false); |
| } |
| |
| @Test |
| public void existingRules_returnsSnapshotOfOnlyRulesInstantiatedUpToThatPoint() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key_x": "value_x"}) |
| rs1 = native.existing_rules() |
| native.config_setting(name = "y", define_values = {"key_y": "value_y"}) |
| rs2 = native.existing_rules() |
| native.config_setting(name = "z", define_values = {"key_z": "value_z"}) |
| rs3 = native.existing_rules() |
| test.save("rs1.keys()", rs1.keys()) |
| test.save("rs2.keys()", rs2.keys()) |
| test.save("rs3.keys()", rs3.keys()) |
| """); |
| |
| assertThat(getConfiguredTarget("//test:BUILD")).isNotNull(); // no error |
| assertThat(Starlark.toIterable(getSaved("rs1.keys()"))).containsExactly("x"); |
| assertThat(Starlark.toIterable(getSaved("rs2.keys()"))).containsExactly("x", "y"); |
| assertThat(Starlark.toIterable(getSaved("rs3.keys()"))).containsExactly("x", "y", "z"); |
| } |
| |
| // Regression test for https://github.com/bazelbuild/bazel/issues/16256 |
| @Test |
| public void existingRules_encodeToJson() throws Exception { |
| // We need a Starlark rule - native rules can have attribute values that the json encoder |
| // doesn't handle. |
| scratch.file( |
| "test/test.bzl", |
| """ |
| def _dummy_impl(ctx): |
| pass |
| |
| test_library = rule( |
| implementation = _dummy_impl, |
| attrs = {"srcs": attr.label_list(allow_files = True)}, |
| ) |
| |
| # TODO(b/249397668): simplifying this to `json_encode = json.encode` etc. causes a |
| # NoCodecException. Need to investigate. |
| def json_encode(value): |
| return json.encode(value) |
| |
| def json_decode(text): |
| return json.decode(text) |
| |
| def save(name, object): |
| test.save(name, object) |
| """); |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("//test:test.bzl", "json_decode", "json_encode", "save", "test_library") |
| |
| test_library( |
| name = "foo", |
| srcs = ["foo.cc"], |
| ) |
| |
| test_library( |
| name = "bar", |
| srcs = ["bar.cc"], |
| ) |
| |
| save( |
| "rules", |
| json_decode(json_encode(existing_rules())), |
| ) |
| """); |
| scratch.file("test/foo.cc"); |
| getConfiguredTarget("//test:bar"); |
| // We test a subset of attributes after an encode-decode round trip because the rule also has |
| // default attributes with default values, which will get encoded to json and which will change |
| // whenever default attributes get introduced, making string comparison of encoded json fragile. |
| Dict<String, Object> jsonRoundTripRulesValue = |
| Dict.cast( |
| getSaved("rules"), String.class, Object.class, "json round trip of `existing_rules()`"); |
| assertThat(jsonRoundTripRulesValue.keySet()).containsExactly("foo", "bar"); |
| Map<String, Object> jsonRoundTripFooValue = |
| Dict.cast( |
| jsonRoundTripRulesValue.get("foo"), |
| String.class, |
| Object.class, |
| "json round trip of `existing_rule('foo')`"); |
| assertThat(jsonRoundTripFooValue) |
| .containsAtLeast( |
| "name", "foo", "kind", "test_library", "srcs", StarlarkList.immutableOf(":foo.cc")); |
| Map<String, Object> jsonRoundTripBarValue = |
| Dict.cast( |
| jsonRoundTripRulesValue.get("bar"), |
| String.class, |
| Object.class, |
| "json round trip of `existing_rule('bar')`"); |
| assertThat(jsonRoundTripBarValue) |
| .containsAtLeast( |
| "name", "bar", "kind", "test_library", "srcs", StarlarkList.immutableOf(":bar.cc")); |
| } |
| |
| /** |
| * Tests for {@code native.existing_rule} and {@code native.existing_rules} Starlark functions |
| * with the {@code --incompatible_existing_rules_immutable_view} flag set. |
| */ |
| @RunWith(JUnit4.class) |
| public static final class WithImmutableView extends NativeExistingRulesTest { |
| |
| @Override |
| protected void setupOptions() throws Exception { |
| setBuildLanguageOptions("--incompatible_existing_rules_immutable_view"); |
| } |
| |
| @Test |
| @Override |
| public void existingRule_returnsObjectWithCorrectMutability() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key": "value"}) |
| r = native.existing_rule("x") |
| r["no_such_attribute"] = 123 |
| """); // mutate the view |
| |
| reporter.removeHandler(failFastHandler); |
| assertThat(getConfiguredTarget("//test:BUILD")).isNull(); // mutation fails |
| assertContainsEvent("can only assign an element in a dictionary or a list"); |
| } |
| |
| @Test |
| @Override |
| public void existingRules_returnsObjectWithCorrectMutability() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key": "value"}) |
| rs = native.existing_rules() |
| rs["no_such_rule"] = {"name": "no_such_rule", "kind": "config_setting"} |
| """); // mutate |
| |
| reporter.removeHandler(failFastHandler); |
| assertThat(getConfiguredTarget("//test:BUILD")).isNull(); // mutation fails |
| assertContainsEvent("can only assign an element in a dictionary or a list"); |
| } |
| |
| @Test |
| public void existingRules_returnsDeeplyImmutableView() throws Exception { |
| scratch.file( |
| "test/BUILD", |
| """ |
| load("inc.bzl", "f") |
| |
| f() |
| """); |
| scratch.file( |
| "test/inc.bzl", |
| """ |
| def f(): |
| native.config_setting(name = "x", define_values = {"key": "value"}) |
| rs = native.existing_rules() |
| rs["x"]["define_values"]["key"] = 123 |
| """); // mutate an attribute value within the view |
| |
| reporter.removeHandler(failFastHandler); |
| assertThat(getConfiguredTarget("//test:BUILD")).isNull(); |
| assertContainsEvent("trying to mutate a frozen dict value"); |
| } |
| } |
| } |