| // Copyright 2019 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.analysis; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static org.junit.Assert.assertThrows; |
| |
| import com.google.devtools.build.lib.analysis.util.AnalysisTestCase; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| /** Test for visibility of targets. */ |
| @RunWith(JUnit4.class) |
| public class VisibilityTest extends AnalysisTestCase { |
| |
| void setupArgsScenario() throws Exception { |
| scratch.file("tool/tool.sh", "#!/bin/sh", "echo Hello > $2", "cat $1 >> $2"); |
| scratch.file("rule/BUILD"); |
| scratch.file( |
| "rule/rule.bzl", |
| """ |
| def _impl(ctx): |
| output = ctx.actions.declare_file(ctx.label.name + ".out") |
| ctx.actions.run( |
| inputs = ctx.files._tool + ctx.files.data, |
| executable = ctx.files._tool[0].path, |
| arguments = [f.path for f in ctx.files.data] + [output.path], |
| outputs = [output], |
| ) |
| |
| greet = rule( |
| implementation = _impl, |
| attrs = { |
| "data": attr.label(allow_files = True), |
| "_tool": attr.label( |
| cfg = "exec", |
| allow_files = True, |
| default = Label("//tool:tool.sh"), |
| ), |
| }, |
| outputs = {"out": "%{name}.out"}, |
| ) |
| """); |
| scratch.file("data/data.txt", "World"); |
| scratch.file( |
| "use/BUILD", |
| """ |
| load("//rule:rule.bzl", "greet") |
| |
| greet( |
| name = "world", |
| data = "//data:data.txt", |
| ) |
| """); |
| } |
| |
| @Test |
| public void testToolVisibilityRuleCheckAtRule() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//visibility:public'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//rule:__pkg__'])"); |
| update("//use:world"); |
| assertThat(hasErrors(getConfiguredTarget("//use:world"))).isFalse(); |
| } |
| |
| @Test |
| public void testToolVisibilityUseCheckAtUse() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//visibility:public'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//use:__pkg__'])"); |
| update("//use:world"); |
| assertThat(hasErrors(getConfiguredTarget("//use:world"))).isFalse(); |
| } |
| |
| @Test |
| public void testToolVisibilityUseCheckAtRule_fallbackToUse() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//visibility:public'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//use:__pkg__'])"); |
| |
| update("//use:world"); |
| |
| assertThat(hasErrors(getConfiguredTarget("//use:world"))).isFalse(); |
| } |
| |
| @Test |
| public void testToolVisibilityPrivateCheckAtUse() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//visibility:public'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//visibility:private'])"); |
| |
| reporter.removeHandler(failFastHandler); |
| assertThrows(ViewCreationFailedException.class, () -> update("//use:world")); |
| } |
| |
| @Test |
| public void testToolVisibilityPrivate() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//visibility:public'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//visibility:private'])"); |
| |
| reporter.removeHandler(failFastHandler); |
| assertThrows(ViewCreationFailedException.class, () -> update("//use:world")); |
| } |
| |
| @Test |
| public void testDataVisibilityUseCheckPrivateAtRule() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//use:__pkg__'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//visibility:public'])"); |
| update("//use:world"); |
| assertThat(hasErrors(getConfiguredTarget("//use:world"))).isFalse(); |
| } |
| |
| @Test |
| public void testDataVisibilityPrivate() throws Exception { |
| setupArgsScenario(); |
| scratch.file("data/BUILD", "exports_files(['data.txt'], visibility=['//visibility:private'])"); |
| scratch.file("tool/BUILD", "exports_files(['tool.sh'], visibility=['//visibility:public'])"); |
| |
| reporter.removeHandler(failFastHandler); |
| assertThrows(ViewCreationFailedException.class, () -> update("//use:world")); |
| } |
| |
| @Test |
| public void testConfigSettingVisibilityAlwaysCheckedAtUse() throws Exception { |
| scratch.file( |
| "BUILD", |
| "load('//build_defs:defs.bzl', 'my_rule')", |
| "my_rule(", |
| " name = 'my_target',", |
| " value = select({", |
| " '//config_setting:my_setting': 'foo',", |
| " '//conditions:default': 'bar',", |
| " }),", |
| ")"); |
| scratch.file("build_defs/BUILD"); |
| scratch.file( |
| "build_defs/defs.bzl", |
| """ |
| def _my_rule_impl(ctx): |
| pass |
| |
| my_rule = rule( |
| implementation = _my_rule_impl, |
| attrs = { |
| "value": attr.string(mandatory = True), |
| }, |
| ) |
| """); |
| scratch.file( |
| "config_setting/BUILD", |
| """ |
| config_setting( |
| name = "my_setting", |
| values = {"cpu": "does_not_matter"}, |
| visibility = ["//:__pkg__"], |
| ) |
| """); |
| |
| update("//:my_target"); |
| assertThat(hasErrors(getConfiguredTarget("//:my_target"))).isFalse(); |
| } |
| |
| @Test |
| public void testImplicitDependency_samePackageAsDefinition_visible() throws Exception { |
| scratch.file( |
| "aspect_def/BUILD", |
| """ |
| sh_binary( |
| name = "aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//visibility:private"], |
| ) |
| """); |
| scratch.file( |
| "aspect_def/lib.bzl", |
| """ |
| def _impl_my_aspect(ctx, target): |
| return [] |
| |
| my_aspect = aspect( |
| _impl_my_aspect, |
| attrs = {"_aspect_tool": attr.label(default = "//aspect_def:aspect_tool")}, |
| ) |
| """); |
| scratch.file( |
| "rule_def/BUILD", |
| """ |
| sh_binary( |
| name = "rule_tool", |
| srcs = ["a.sh"], |
| visibility = ["//visibility:private"], |
| ) |
| """); |
| scratch.file( |
| "rule_def/lib.bzl", |
| """ |
| load("//aspect_def:lib.bzl", "my_aspect") |
| |
| def _impl(ctx): |
| pass |
| |
| my_rule = rule( |
| _impl, |
| attrs = { |
| "dep": attr.label(aspects = [my_aspect]), |
| "_rule_tool": attr.label(default = "//rule_def:rule_tool"), |
| }, |
| ) |
| simple_starlark_rule = rule( |
| _impl, |
| ) |
| """); |
| scratch.file( |
| "foo/BUILD", |
| """ |
| load("//rule_def:lib.bzl", "my_rule", "simple_starlark_rule") |
| |
| simple_starlark_rule(name = "simple_dep") |
| |
| my_rule( |
| name = "my_target", |
| dep = ":simple_dep", |
| ) |
| """); |
| |
| update("//foo:my_target"); |
| |
| assertThat(hasErrors(getConfiguredTarget("//foo:my_target"))).isFalse(); |
| } |
| |
| @Test |
| public void testAspectImplicitDependencyCheckedAtDefinition_visible() throws Exception { |
| scratch.file("inner_aspect/BUILD"); |
| scratch.file( |
| "inner_aspect/lib.bzl", |
| """ |
| InnerAspectInfo = provider() |
| |
| def _impl_inner_aspect(ctx, target): |
| return [InnerAspectInfo()] |
| |
| inner_aspect = aspect( |
| _impl_inner_aspect, |
| attrs = {"_inner_aspect_tool": attr.label(default = "//tool:inner_aspect_tool")}, |
| provides = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("outer_aspect/BUILD"); |
| scratch.file( |
| "outer_aspect/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "InnerAspectInfo") |
| |
| def _impl_outer_aspect(ctx, target): |
| return [] |
| |
| outer_aspect = aspect( |
| _impl_outer_aspect, |
| attrs = {"_outer_aspect_tool": attr.label(default = "//tool:outer_aspect_tool")}, |
| required_aspect_providers = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("rule/BUILD"); |
| scratch.file( |
| "rule/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "inner_aspect") |
| load("//outer_aspect:lib.bzl", "outer_aspect") |
| |
| def _impl(ctx): |
| pass |
| |
| my_rule = rule( |
| _impl, |
| attrs = { |
| "dep": attr.label(aspects = [inner_aspect, outer_aspect]), |
| "_rule_tool": attr.label(default = "//tool:rule_tool"), |
| }, |
| ) |
| simple_starlark_rule = rule( |
| _impl, |
| ) |
| """); |
| scratch.file( |
| "foo/BUILD", |
| """ |
| load("//rule:lib.bzl", "my_rule", "simple_starlark_rule") |
| |
| simple_starlark_rule(name = "simple_dep") |
| |
| my_rule( |
| name = "target_with_aspects", |
| dep = ":simple_dep", |
| ) |
| """); |
| scratch.file( |
| "tool/BUILD", |
| """ |
| sh_binary( |
| name = "outer_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//outer_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "inner_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//inner_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "rule_tool", |
| srcs = ["a.sh"], |
| visibility = ["//rule:__pkg__"], |
| ) |
| """); |
| |
| update("//foo:target_with_aspects"); |
| |
| assertThat(hasErrors(getConfiguredTarget("//foo:target_with_aspects"))).isFalse(); |
| } |
| |
| @Test |
| public void testAspectImplicitDependencyCheckedAtDefinition_visibleWithNameCollision() |
| throws Exception { |
| scratch.file("inner_aspect/BUILD"); |
| scratch.file( |
| "inner_aspect/lib.bzl", |
| """ |
| InnerAspectInfo = provider() |
| |
| def _impl_inner_aspect(ctx, target): |
| return [InnerAspectInfo()] |
| |
| inner_aspect = aspect( |
| _impl_inner_aspect, |
| attrs = {"_tool": attr.label(default = "//tool:inner_aspect_tool")}, |
| provides = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("outer_aspect/BUILD"); |
| scratch.file( |
| "outer_aspect/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "InnerAspectInfo") |
| |
| def _impl_outer_aspect(ctx, target): |
| return [] |
| |
| outer_aspect = aspect( |
| _impl_outer_aspect, |
| attrs = {"_tool": attr.label(default = "//tool:outer_aspect_tool")}, |
| required_aspect_providers = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("rule/BUILD"); |
| scratch.file( |
| "rule/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "inner_aspect") |
| load("//outer_aspect:lib.bzl", "outer_aspect") |
| |
| def _impl(ctx): |
| pass |
| |
| my_rule = rule( |
| _impl, |
| attrs = { |
| "dep": attr.label(aspects = [inner_aspect, outer_aspect]), |
| "_tool": attr.label(default = "//tool:rule_tool"), |
| }, |
| ) |
| simple_starlark_rule = rule( |
| _impl, |
| ) |
| """); |
| scratch.file( |
| "foo/BUILD", |
| """ |
| load("//rule:lib.bzl", "my_rule", "simple_starlark_rule") |
| |
| simple_starlark_rule(name = "simple_dep") |
| |
| my_rule( |
| name = "target_with_aspects", |
| dep = ":simple_dep", |
| ) |
| """); |
| scratch.file( |
| "tool/BUILD", |
| """ |
| sh_binary( |
| name = "outer_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//outer_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "inner_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//inner_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "rule_tool", |
| srcs = ["a.sh"], |
| visibility = ["//rule:__pkg__"], |
| ) |
| """); |
| |
| update("//foo:target_with_aspects"); |
| |
| assertThat(hasErrors(getConfiguredTarget("//foo:target_with_aspects"))).isFalse(); |
| } |
| |
| @Test |
| public void testAspectImplicitDependencyCheckedAtDefinition_outerAspectToolNotVisible() |
| throws Exception { |
| scratch.file("inner_aspect/BUILD"); |
| scratch.file( |
| "inner_aspect/lib.bzl", |
| """ |
| InnerAspectInfo = provider() |
| |
| def _impl_inner_aspect(ctx, target): |
| return [InnerAspectInfo()] |
| |
| inner_aspect = aspect( |
| _impl_inner_aspect, |
| attrs = {"_inner_aspect_tool": attr.label(default = "//tool:inner_aspect_tool")}, |
| provides = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("outer_aspect/BUILD"); |
| scratch.file( |
| "outer_aspect/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "InnerAspectInfo") |
| |
| def _impl_outer_aspect(ctx, target): |
| return [] |
| |
| outer_aspect = aspect( |
| _impl_outer_aspect, |
| attrs = {"_outer_aspect_tool": attr.label(default = "//tool:outer_aspect_tool")}, |
| required_aspect_providers = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("rule/BUILD"); |
| scratch.file( |
| "rule/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "inner_aspect") |
| load("//outer_aspect:lib.bzl", "outer_aspect") |
| |
| def _impl(ctx): |
| pass |
| |
| my_rule = rule( |
| _impl, |
| attrs = { |
| "dep": attr.label(aspects = [inner_aspect, outer_aspect]), |
| "_rule_tool": attr.label(default = "//tool:rule_tool"), |
| }, |
| ) |
| simple_starlark_rule = rule( |
| _impl, |
| ) |
| """); |
| scratch.file( |
| "foo/BUILD", |
| """ |
| load("//rule:lib.bzl", "my_rule", "simple_starlark_rule") |
| |
| simple_starlark_rule(name = "simple_dep") |
| |
| my_rule( |
| name = "target_with_aspects", |
| dep = ":simple_dep", |
| ) |
| """); |
| scratch.file( |
| "tool/BUILD", |
| """ |
| sh_binary( |
| name = "outer_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = [ |
| "//inner_aspect:__pkg__", |
| "//rule:__pkg__", |
| ], |
| ) |
| |
| sh_binary( |
| name = "inner_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//inner_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "rule_tool", |
| srcs = ["a.sh"], |
| visibility = ["//rule:__pkg__"], |
| ) |
| """); |
| reporter.removeHandler(failFastHandler); |
| |
| assertThrows(ViewCreationFailedException.class, () -> update("//foo:target_with_aspects")); |
| assertContainsEvent( |
| "in //inner_aspect:lib.bzl%inner_aspect,//outer_aspect:lib.bzl%outer_aspect " |
| + "aspect on simple_starlark_rule rule //foo:simple_dep: Visibility error:\n" |
| + "target '//tool:outer_aspect_tool' is not visible from\n" |
| + "target '//outer_aspect:lib.bzl'"); |
| } |
| |
| @Test |
| public void testAspectImplicitDependencyCheckedAtDefinition_innerAspectToolNotVisible() |
| throws Exception { |
| scratch.file("inner_aspect/BUILD"); |
| scratch.file( |
| "inner_aspect/lib.bzl", |
| """ |
| InnerAspectInfo = provider() |
| |
| def _impl_inner_aspect(ctx, target): |
| return [InnerAspectInfo()] |
| |
| inner_aspect = aspect( |
| _impl_inner_aspect, |
| attrs = {"_inner_aspect_tool": attr.label(default = "//tool:inner_aspect_tool")}, |
| provides = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("outer_aspect/BUILD"); |
| scratch.file( |
| "outer_aspect/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "InnerAspectInfo") |
| |
| def _impl_outer_aspect(ctx, target): |
| return [] |
| |
| outer_aspect = aspect( |
| _impl_outer_aspect, |
| attrs = {"_outer_aspect_tool": attr.label(default = "//tool:outer_aspect_tool")}, |
| required_aspect_providers = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("rule/BUILD"); |
| scratch.file( |
| "rule/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "inner_aspect") |
| load("//outer_aspect:lib.bzl", "outer_aspect") |
| |
| def _impl(ctx): |
| pass |
| |
| my_rule = rule( |
| _impl, |
| attrs = { |
| "dep": attr.label(aspects = [inner_aspect, outer_aspect]), |
| "_rule_tool": attr.label(default = "//tool:rule_tool"), |
| }, |
| ) |
| simple_starlark_rule = rule( |
| _impl, |
| ) |
| """); |
| scratch.file( |
| "foo/BUILD", |
| """ |
| load("//rule:lib.bzl", "my_rule", "simple_starlark_rule") |
| |
| simple_starlark_rule(name = "simple_dep") |
| |
| my_rule( |
| name = "target_with_aspects", |
| dep = ":simple_dep", |
| ) |
| """); |
| scratch.file( |
| "tool/BUILD", |
| """ |
| sh_binary( |
| name = "outer_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//outer_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "inner_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = [ |
| "//outer_aspect:__pkg__", |
| "//rule:__pkg__", |
| ], |
| ) |
| |
| sh_binary( |
| name = "rule_tool", |
| srcs = ["a.sh"], |
| visibility = ["//rule:__pkg__"], |
| ) |
| """); |
| reporter.removeHandler(failFastHandler); |
| |
| assertThrows(ViewCreationFailedException.class, () -> update("//foo:target_with_aspects")); |
| assertContainsEvent( |
| "in //inner_aspect:lib.bzl%inner_aspect aspect on simple_starlark_rule " |
| + "rule //foo:simple_dep: Visibility error:\n" |
| + "target '//tool:inner_aspect_tool' is not visible from\n" |
| + "target '//inner_aspect:lib.bzl'"); |
| } |
| |
| @Test |
| public void testAspectImplicitDependencyCheckedAtDefinition_ruleToolNotVisible() |
| throws Exception { |
| scratch.file("inner_aspect/BUILD"); |
| scratch.file( |
| "inner_aspect/lib.bzl", |
| """ |
| InnerAspectInfo = provider() |
| |
| def _impl_inner_aspect(ctx, target): |
| return [InnerAspectInfo()] |
| |
| inner_aspect = aspect( |
| _impl_inner_aspect, |
| attrs = {"_inner_aspect_tool": attr.label(default = "//tool:inner_aspect_tool")}, |
| provides = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("outer_aspect/BUILD"); |
| scratch.file( |
| "outer_aspect/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "InnerAspectInfo") |
| |
| def _impl_outer_aspect(ctx, target): |
| return [] |
| |
| outer_aspect = aspect( |
| _impl_outer_aspect, |
| attrs = {"_outer_aspect_tool": attr.label(default = "//tool:outer_aspect_tool")}, |
| required_aspect_providers = [InnerAspectInfo], |
| ) |
| """); |
| scratch.file("rule/BUILD"); |
| scratch.file( |
| "rule/lib.bzl", |
| """ |
| load("//inner_aspect:lib.bzl", "inner_aspect") |
| load("//outer_aspect:lib.bzl", "outer_aspect") |
| |
| def _impl(ctx): |
| pass |
| |
| my_rule = rule( |
| _impl, |
| attrs = { |
| "dep": attr.label(aspects = [inner_aspect, outer_aspect]), |
| "_rule_tool": attr.label(default = "//tool:rule_tool"), |
| }, |
| ) |
| simple_starlark_rule = rule( |
| _impl, |
| ) |
| """); |
| scratch.file( |
| "foo/BUILD", |
| """ |
| load("//rule:lib.bzl", "my_rule", "simple_starlark_rule") |
| |
| simple_starlark_rule(name = "simple_dep") |
| |
| my_rule( |
| name = "target_with_aspects", |
| dep = ":simple_dep", |
| ) |
| """); |
| scratch.file( |
| "tool/BUILD", |
| """ |
| sh_binary( |
| name = "outer_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//outer_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "inner_aspect_tool", |
| srcs = ["a.sh"], |
| visibility = ["//inner_aspect:__pkg__"], |
| ) |
| |
| sh_binary( |
| name = "rule_tool", |
| srcs = ["a.sh"], |
| visibility = [ |
| "//inner_aspect:__pkg__", |
| "//outer_aspect:__pkg__", |
| ], |
| ) |
| """); |
| reporter.removeHandler(failFastHandler); |
| |
| assertThrows(ViewCreationFailedException.class, () -> update("//foo:target_with_aspects")); |
| assertContainsEvent( |
| "in my_rule rule //foo:target_with_aspects: Visibility error:\n" |
| + "target '//tool:rule_tool' is not visible from\n" |
| + "target '//rule:lib.bzl'"); |
| } |
| |
| void setupFilesScenario(String wantRead) throws Exception { |
| scratch.file("src/source.txt", "source"); |
| scratch.file("src/BUILD", "exports_files(['source.txt'], visibility=['//pkg:__pkg__'])"); |
| scratch.file("pkg/foo.txt", "foo"); |
| scratch.file("pkg/bar.txt", "bar"); |
| scratch.file("pkg/groupfile.txt", "groupfile"); |
| scratch.file("pkg/unused.txt", "unused"); |
| scratch.file("pkg/exported.txt", "exported"); |
| scratch.file( |
| "pkg/BUILD", |
| """ |
| package(default_visibility = ["//visibility:public"]) |
| |
| exports_files(["exported.txt"]) |
| |
| genrule( |
| name = "foobar", |
| srcs = [ |
| "foo.txt", |
| "bar.txt", |
| ], |
| outs = ["foobar.txt"], |
| cmd = "cat $(SRCS) > $@", |
| ) |
| |
| filegroup( |
| name = "remotegroup", |
| srcs = ["//src:source.txt"], |
| ) |
| |
| filegroup( |
| name = "localgroup", |
| srcs = [":groupfile.txt"], |
| ) |
| """); |
| scratch.file( |
| "otherpkg/BUILD", |
| "genrule(", |
| " name = 'it',", |
| " srcs = ['//pkg:" + wantRead + "'],", |
| " outs = ['it.xt'],", |
| " cmd = 'cp $< $@',", |
| ")"); |
| } |
| |
| @Test |
| public void testTargetImplicitExport() throws Exception { |
| setupFilesScenario("foobar"); |
| useConfiguration("--noincompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testTargetNoImplicitExport() throws Exception { |
| setupFilesScenario("foobar"); |
| useConfiguration("--incompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testLocalFilegroupImplicitExport() throws Exception { |
| setupFilesScenario("localgroup"); |
| useConfiguration("--noincompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testLocalFilegroupNoImplicitExport() throws Exception { |
| setupFilesScenario("localgroup"); |
| useConfiguration("--incompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testRemoteFilegroupImplicitExport() throws Exception { |
| setupFilesScenario("remotegroup"); |
| useConfiguration("--noincompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testRemoteFilegroupNoImplicitExport() throws Exception { |
| setupFilesScenario("remotegroup"); |
| useConfiguration("--incompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testExportedImplicitExport() throws Exception { |
| setupFilesScenario("exported.txt"); |
| useConfiguration("--noincompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testExportedNoImplicitExport() throws Exception { |
| setupFilesScenario("exported.txt"); |
| useConfiguration("--incompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testUnusedImplicitExport() throws Exception { |
| setupFilesScenario("unused.txt"); |
| useConfiguration("--noincompatible_no_implicit_file_export"); |
| |
| reporter.removeHandler(failFastHandler); |
| assertThrows(ViewCreationFailedException.class, () -> update("//otherpkg:it")); |
| } |
| |
| @Test |
| public void testUnusedNoImplicitExport() throws Exception { |
| setupFilesScenario("unused.txt"); |
| useConfiguration("--incompatible_no_implicit_file_export"); |
| |
| reporter.removeHandler(failFastHandler); |
| assertThrows(ViewCreationFailedException.class, () -> update("//otherpkg:it")); |
| } |
| |
| @Test |
| public void testSourcefileImplicitExport() throws Exception { |
| setupFilesScenario("foo.txt"); |
| useConfiguration("--noincompatible_no_implicit_file_export"); |
| update("//otherpkg:it"); |
| assertThat(hasErrors(getConfiguredTarget("//otherpkg:it"))).isFalse(); |
| } |
| |
| @Test |
| public void testSourcefileNoImplicitExport() throws Exception { |
| setupFilesScenario("foo.txt"); |
| useConfiguration("--incompatible_no_implicit_file_export"); |
| |
| reporter.removeHandler(failFastHandler); |
| assertThrows(ViewCreationFailedException.class, () -> update("//otherpkg:it")); |
| } |
| } |