def test_find_putative_targets_subset(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
f"src/sh/foo/{fp}": ""
for fp in (
"bar/bar.sh",
"bar/bar_test.sh",
"baz/baz.sh",
"baz/baz_test.sh",
"qux/qux.sh",
)
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeShellTargetsRequest(
PutativeTargetsSearchPaths(
("src/sh/foo/bar", "src/sh/foo/qux"))),
AllOwnedSources(["src/sh/foo/bar/bar.sh"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
Shunit2TestsGeneratorTarget,
path="src/sh/foo/bar",
name="tests",
triggering_sources=["bar_test.sh"],
),
PutativeTarget.for_target_type(
ShellSourcesGeneratorTarget,
path="src/sh/foo/qux",
name=None,
triggering_sources=["qux.sh"],
),
]) == pts)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
"src/kotlin/owned/BUILD": "kotlin_sources()\n",
"src/kotlin/owned/OwnedFile.kt": "package owned",
"src/kotlin/unowned/UnownedFile.kt": "package unowned\n",
}
)
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeKotlinTargetsRequest(("src/kotlin/owned", "src/kotlin/unowned")),
AllOwnedSources(["src/kotlin/owned/OwnedFile.kt"]),
],
)
assert (
PutativeTargets(
[
PutativeTarget.for_target_type(
KotlinSourcesGeneratorTarget,
"src/kotlin/unowned",
"unowned",
["UnownedFile.kt"],
),
]
)
== putative_targets
)
def test_find_putative_targets_for_entry_points(
rule_runner: RuleRunner) -> None:
mains = ("main1.py", "main2.py", "main3.py")
rule_runner.write_files({
f"src/python/foo/{name}": textwrap.dedent("""
if __name__ == "__main__":
main()
""")
for name in mains
})
rule_runner.write_files({
"src/python/foo/BUILD":
("pex_binary(name='main1', entry_point='main1.py')\n"
"pex_binary(name='main2', entry_point='foo.main2')\n"),
})
pts = rule_runner.request(
PutativeTargets,
[
PutativePythonTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources([f"src/python/foo/{name}" for name in mains]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
PexBinary,
"src/python/foo",
"main3",
[],
kwargs={"entry_point": "main3.py"},
),
]) == pts)
def test_find_putative_targets() -> None:
rule_runner = RuleRunner(
rules=[
*core_tailor_rules(),
*terraform_tailor_rules(),
QueryRule(PutativeTargets,
[PutativeTerraformTargetsRequest, AllOwnedSources]),
QueryRule(AllOwnedSources, ()),
],
target_types=[
TerraformModule,
TerraformModules,
],
)
rule_runner.write_files({
fp: ""
for fp in (
"prod/terraform/resources/foo/versions.tf",
"prod/terraform/resources/bar/versions.tf",
"prod/terraform/modules/bar/versions.tf",
"prod/terraform/modules/bar/hello/versions.tf",
"prod/terraform/modules/world/versions.tf",
"service1/src/terraform/versions.tf",
"service1/src/terraform/foo/versions.tf",
"service1/src/terraform/versions.tf",
"service2/src/terraform/versions.tf",
)
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeTerraformTargetsRequest(PutativeTargetsSearchPaths(
("", ))),
AllOwnedSources([
"src/terraform/root.tf",
"src/terraform/owned-module/main.tf",
"src/terraform/owned-module/foo.tf",
]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
TerraformModules,
"prod/terraform",
"tf_mods",
("prod/terraform/**/*.tf", ),
),
PutativeTarget.for_target_type(
TerraformModules,
"service1/src/terraform",
"tf_mods",
("service1/src/terraform/**/*.tf", ),
),
PutativeTarget.for_target_type(
TerraformModules,
"service2/src/terraform",
"tf_mods",
("service2/src/terraform/**/*.tf", ),
),
]) == pts)
def test_find_putative_targets() -> None:
rule_runner = RuleRunner(
rules=[
*docker_tailor_rules(),
QueryRule(PutativeTargets,
[PutativeDockerTargetsRequest, AllOwnedSources]),
],
target_types=[DockerImage],
)
rule_runner.write_files({
"src/docker_ok/Dockerfile": "",
"src/docker_orphan/Dockerfile": ""
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeDockerTargetsRequest(PutativeTargetsSearchPaths(
("src/", ))),
AllOwnedSources(["src/docker_ok/Dockerfile"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
DockerImage,
"src/docker_orphan",
"docker",
["Dockerfile"],
kwargs={"name": "docker"},
),
]) == pts)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
"src/java/owned/BUILD": "java_sources()\n",
"src/java/owned/OwnedFile.java": "package owned",
"src/java/unowned/UnownedFile.java": "package unowned\n",
"src/java/unowned/UnownedFileTest.java": "package unowned\n",
}
)
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeJavaTargetsRequest(PutativeTargetsSearchPaths(("",))),
AllOwnedSources(["src/java/owned/OwnedFile.java"]),
],
)
assert (
PutativeTargets(
[
PutativeTarget.for_target_type(
JavaSourcesGeneratorTarget, "src/java/unowned", "unowned", ["UnownedFile.java"]
),
PutativeTarget.for_target_type(
JunitTestsGeneratorTarget,
"src/java/unowned",
"tests",
["UnownedFileTest.java"],
kwargs={"name": "tests"},
),
]
)
== putative_targets
)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
"src/owned/BUILD": "javascript_sources()\n",
"src/owned/OwnedFile.js": "",
"src/unowned/UnownedFile1.js": "",
"src/unowned/UnownedFile2.js": "",
}
)
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeJSTargetsRequest(("src/owned", "src/unowned")),
AllOwnedSources(["src/owned/OwnedFile.js"]),
],
)
assert (
PutativeTargets(
[
PutativeTarget.for_target_type(
JSSourcesGeneratorTarget,
"src/unowned",
"unowned",
["UnownedFile1.js", "UnownedFile2.js"],
),
]
)
== putative_targets
)
def test_find_putative_targets_subset(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
f"src/python/foo/{fp}": ""
for fp in (
"__init__.py",
"bar/__init__.py",
"bar/bar.py",
"bar/bar_test.py",
"baz/baz.py",
"baz/baz_test.py",
"qux/qux.py",
)
})
pts = rule_runner.request(
PutativeTargets,
[
PutativePythonTargetsRequest(
PutativeTargetsSearchPaths(
("src/python/foo/bar", "src/python/foo/qux"))),
AllOwnedSources([
"src/python/foo/bar/__init__.py", "src/python/foo/bar/bar.py"
]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
PythonTestsGeneratorTarget,
"src/python/foo/bar",
"tests",
["bar_test.py"],
),
PutativeTarget.for_target_type(PythonSourcesGeneratorTarget,
"src/python/foo/qux", None, ["qux.py"]),
]) == pts)
def test_find_putative_targets_subset(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"protos/foo/f.proto": "",
"protos/foo/bar/bar.proto": "",
"protos/foo/baz/baz.proto": "",
"protos/foo/qux/qux.proto": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeProtobufTargetsRequest(
PutativeTargetsSearchPaths(
("protos/foo/bar", "protos/foo/qux"))),
AllOwnedSources([]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
ProtobufSourcesGeneratorTarget,
path="protos/foo/bar",
name=None,
triggering_sources=["bar.proto"],
),
PutativeTarget.for_target_type(
ProtobufSourcesGeneratorTarget,
path="protos/foo/qux",
name=None,
triggering_sources=["qux.proto"],
),
]) == pts)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"thrifts/foo/f.thrift": "",
"thrifts/foo/bar/baz1.thrift": "",
"thrifts/foo/bar/baz2.thrift": "",
"thrifts/foo/bar/baz3.thrift": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeThriftTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources(["thrifts/foo/bar/baz1.thrift"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
ThriftSourcesGeneratorTarget,
path="thrifts/foo",
name=None,
triggering_sources=["f.thrift"],
),
PutativeTarget.for_target_type(
ThriftSourcesGeneratorTarget,
path="thrifts/foo/bar",
name=None,
triggering_sources=["baz2.thrift", "baz3.thrift"],
),
]) == pts)
def test_find_putative_targets_subset(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"avro/foo/f.avsc": "",
"avro/foo/bar/bar.avsc": "",
"avro/foo/baz/baz.avsc": "",
"avro/foo/qux/qux.avsc": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeAvroTargetsRequest(("avro/foo/bar", "avro/foo/qux")),
AllOwnedSources([])
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
AvroSourcesGeneratorTarget,
path="avro/foo/bar",
name=None,
triggering_sources=["bar.avsc"],
),
PutativeTarget.for_target_type(
AvroSourcesGeneratorTarget,
path="avro/foo/qux",
name=None,
triggering_sources=["qux.avsc"],
),
]) == pts)
def test_find_go_package_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"unowned/f.go": "",
"unowned/f1.go": "",
"owned/f.go": "",
"owned/BUILD": "go_package()",
# Any `.go` files under a `testdata` or `vendor` folder should be ignored.
"unowned/testdata/f.go": "",
"unowned/testdata/subdir/f.go": "",
"unowned/vendor/example.com/foo/bar.go": "",
# Except if `vendor` is the last directory.
"unowned/cmd/vendor/main.go": "",
})
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeGoTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources(["owned/f.go"]),
],
)
assert putative_targets == PutativeTargets([
PutativeTarget.for_target_type(
GoPackageTarget,
path="unowned",
name=None,
triggering_sources=["f.go", "f1.go"],
),
PutativeTarget.for_target_type(
GoPackageTarget,
path="unowned/cmd/vendor",
name=None,
triggering_sources=["main.go"],
),
])
def test_find_putative_targets() -> None:
rule_runner = RuleRunner(
rules=[
*core_tailor_rules(),
*terraform_tailor_rules(),
QueryRule(PutativeTargets,
[PutativeTerraformTargetsRequest, AllOwnedSources]),
QueryRule(AllOwnedSources, ()),
],
target_types=[
TerraformModuleTarget,
],
)
rule_runner.write_files({
"prod/terraform/owned-module/BUILD": "terraform_module()",
"prod/terraform/owned-module/versions.tf": "",
"prod/terraform/unowned-module/versions.tf": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeTerraformTargetsRequest(("prod/terraform/owned-module",
"prod/terraform/unowned-module")),
AllOwnedSources(["prod/terraform/owned-module/versions.tf"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
TerraformModuleTarget,
"prod/terraform/unowned-module",
"unowned-module",
("versions.tf", ),
),
]) == pts)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"avro/foo/f.avsc": "",
"avro/foo/bar/baz1.avdl": "",
"avro/foo/bar/baz2.avpr": "",
"avro/foo/bar/baz3.avsc": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeAvroTargetsRequest(("avro/foo", "avro/foo/bar")),
AllOwnedSources(["avro/foo/bar/baz1.avdl"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
AvroSourcesGeneratorTarget,
path="avro/foo",
name=None,
triggering_sources=["f.avsc"],
),
PutativeTarget.for_target_type(
AvroSourcesGeneratorTarget,
path="avro/foo/bar",
name=None,
triggering_sources=["baz2.avpr", "baz3.avsc"],
),
]) == pts)
def test_ignore_solitary_init(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
f"src/python/foo/{fp}": ""
for fp in (
"__init__.py",
"bar/__init__.py",
"bar/bar.py",
"baz/__init__.py",
"qux/qux.py",
)
})
pts = rule_runner.request(
PutativeTargets,
[
PutativePythonTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources([]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(
PythonSourcesGeneratorTarget,
"src/python/foo/bar",
"bar",
["__init__.py", "bar.py"],
),
PutativeTarget.for_target_type(PythonSourcesGeneratorTarget,
"src/python/foo/qux", "qux",
["qux.py"]),
]) == pts)
def test_find_putative_targets() -> None:
rule_runner = RuleRunner(
rules=[
*tailor_rules(),
QueryRule(PutativeTargets,
(PutativeProtobufTargetsRequest, AllOwnedSources)),
],
target_types=[],
)
rule_runner.write_files({
"protos/foo/f.proto": "",
"protos/foo/bar/baz1.proto": "",
"protos/foo/bar/baz2.proto": "",
"protos/foo/bar/baz3.proto": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeProtobufTargetsRequest(),
AllOwnedSources(["protos/foo/bar/baz1.proto"])
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(ProtobufLibrary, "protos/foo", "foo",
["f.proto"]),
PutativeTarget.for_target_type(ProtobufLibrary, "protos/foo/bar",
"bar", ["baz2.proto", "baz3.proto"]),
]) == pts)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
"src/wsdl/simple.wsdl": "",
"src/wsdl/dir1/hello.wsdl": "",
"src/wsdl/dir1/world.wsdl": "",
}
)
pts = rule_runner.request(
PutativeTargets,
[
PutativeWsdlTargetsRequest(PutativeTargetsSearchPaths(("",))),
AllOwnedSources(["src/wsdl/simple.wsdl"]),
],
)
assert (
PutativeTargets(
[
PutativeTarget.for_target_type(
WsdlSourcesGeneratorTarget,
path="src/wsdl/dir1",
name=None,
triggering_sources=["hello.wsdl", "world.wsdl"],
),
]
)
== pts
)
def test_find_helm_charts(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"src/owned/Chart.yaml": "",
"src/foo/Chart.yaml": "",
"src/bar/Chart.yml": ""
})
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeHelmChartTargetsRequest(
("src/owned", "src/foo", "src/bar")),
AllOwnedSources(["src/owned/Chart.yaml"]),
],
)
def expected_target(path: str, triggering_source: str) -> PutativeTarget:
return PutativeTarget.for_target_type(
HelmChartTarget,
name=os.path.basename(path),
path=path,
triggering_sources=[triggering_source],
)
assert putative_targets == PutativeTargets([
expected_target("src/foo", "Chart.yaml"),
expected_target("src/bar", "Chart.yml")
])
def test_find_go_binary_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"missing_binary_tgt/go.mod": "",
"missing_binary_tgt/app.go": "package main",
"missing_binary_tgt/BUILD": "go_package()",
"tgt_already_exists/go.mod": "",
"tgt_already_exists/app.go": "package main",
"tgt_already_exists/BUILD": "go_binary(name='bin')\ngo_package()",
"missing_pkg_and_binary_tgt/go.mod": "",
"missing_pkg_and_binary_tgt/app.go": "package main",
"main_set_to_different_dir/go.mod": "",
"main_set_to_different_dir/subdir/app.go": "package main",
"main_set_to_different_dir/subdir/BUILD": "go_package()",
"main_set_to_different_dir/BUILD":
"go_binary(main='main_set_to_different_dir/subdir')",
"no_go_mod/app.go": "package main",
})
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeGoTargetsRequest((
"missing_binary_tgt",
"tgt_already_exists",
"missing_pkg_and_binary_tgt",
"main_set_to_different_dir",
"no_go_mod",
)),
AllOwnedSources([
"missing_binary_tgt/go.mod",
"missing_binary_tgt/app.go",
"tgt_already_exists/go.mod",
"tgt_already_exists/app.go",
"missing_pkg_and_binary_tgt/go.mod",
"main_set_to_different_dir/go.mod",
"main_set_to_different_dir/subdir/app.go",
]),
],
)
assert putative_targets == PutativeTargets([
PutativeTarget.for_target_type(
GoBinaryTarget,
path="missing_binary_tgt",
name="bin",
triggering_sources=[],
),
PutativeTarget.for_target_type(
GoPackageTarget,
path="missing_pkg_and_binary_tgt",
name="missing_pkg_and_binary_tgt",
triggering_sources=["app.go"],
kwargs={},
),
PutativeTarget.for_target_type(
GoBinaryTarget,
path="missing_pkg_and_binary_tgt",
name="bin",
triggering_sources=[],
),
])
def test_skip_invalid_requirements(rule_runner: RuleRunner) -> None:
rule_runner.set_options(["--no-python-tailor-ignore-solitary-init-files"])
rule_runner.write_files(
{
"3rdparty/requirements-valid.txt": b"FooProject >= 1.2",
"3rdparty/requirements-invalid.txt": b"FooProject LOLOLOLOL 1.2",
"pipfile-valid/Pipfile.lock": b"{}",
"pipfile-invalid/Pipfile.lock": b"FNARB",
"poetry-valid/pyproject.toml": b"[tool.poetry]",
"poetry-invalid/pyproject.toml": b"FNARB",
}
)
pts = rule_runner.request(
PutativeTargets,
[
PutativePythonTargetsRequest(
(
"3rdparty",
"pipfile-valid",
"pipfile-invalid",
"poetry-valid",
"poetry-invalid",
)
),
AllOwnedSources([]),
],
)
assert (
PutativeTargets(
[
PutativeTarget.for_target_type(
PythonRequirementsTargetGenerator,
path="3rdparty",
name="reqs",
triggering_sources=["3rdparty/requirements-valid.txt"],
kwargs={"source": "requirements-valid.txt"},
),
PutativeTarget.for_target_type(
PipenvRequirementsTargetGenerator,
path="pipfile-valid",
name="pipenv",
triggering_sources=["pipfile-valid/Pipfile.lock"],
),
PutativeTarget.for_target_type(
PoetryRequirementsTargetGenerator,
path="poetry-valid",
name="poetry",
triggering_sources=["poetry-valid/pyproject.toml"],
),
]
)
== pts
)
def test_all_owned_sources(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"dir/a.f90": "",
"dir/b.f90": "",
"dir/a_test.f90": "",
"dir/unowned.txt": "",
"dir/BUILD": "fortran_library()\nfortran_tests(name='tests')",
"unowned.txt": "",
"unowned.f90": "",
})
assert rule_runner.request(AllOwnedSources, []) == AllOwnedSources(
["dir/a.f90", "dir/b.f90", "dir/a_test.f90"])
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.set_options(
["--no-python-setup-tailor-ignore-solitary-init-files"])
rule_runner.write_files({
"3rdparty/requirements.txt": "",
"3rdparty/requirements-test.txt": "",
**{
f"src/python/foo/{fp}": ""
for fp in (
"__init__.py",
"bar/__init__.py",
"bar/baz1.py",
"bar/baz1_test.py",
"bar/baz2.py",
"bar/baz2_test.py",
"bar/baz3.py",
)
},
})
pts = rule_runner.request(
PutativeTargets,
[
PutativePythonTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources([
"3rdparty/requirements.txt",
"src/python/foo/bar/__init__.py",
"src/python/foo/bar/baz1.py",
]),
],
)
assert (PutativeTargets([
PutativeTarget(
"3rdparty",
"requirements-test.txt",
"python_requirements",
("3rdparty/requirements-test.txt", ),
("3rdparty/requirements-test.txt", ),
addressable=False,
kwargs={"requirements_relpath": "requirements-test.txt"},
),
PutativeTarget.for_target_type(PythonLibrary, "src/python/foo", "foo",
["__init__.py"]),
PutativeTarget.for_target_type(PythonLibrary, "src/python/foo/bar",
"bar", ["baz2.py", "baz3.py"]),
PutativeTarget.for_target_type(
PythonTests,
"src/python/foo/bar",
"tests",
["baz1_test.py", "baz2_test.py"],
kwargs={"name": "tests"},
),
]) == pts)
def test_all_owned_sources(rule_runner: RuleRunner) -> None:
for path in [
"dir/a.f90",
"dir/b.f90",
"dir/a_test.f90",
"dir/unowned.txt",
"unowned.txt",
"unowned.f90",
]:
rule_runner.create_file(path)
rule_runner.add_to_build_file("dir", "fortran_library()\nfortran_tests(name='tests')")
assert rule_runner.request(AllOwnedSources, []) == AllOwnedSources(
["dir/a.f90", "dir/b.f90", "dir/a_test.f90"]
)
def test_find_putative_go_module_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
"src/go/owned/BUILD": "go_module()\n",
"src/go/owned/go.mod": "module example.com/src/go/owned\n",
"src/go/unowned/go.mod": "module example.com/src/go/unowned\n",
}
)
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeGoModuleTargetsRequest(PutativeTargetsSearchPaths(("src/",))),
AllOwnedSources(["src/go/owned/go.mod"]),
],
)
assert putative_targets == PutativeTargets(
[PutativeTarget.for_target_type(GoModule, "src/go/unowned", "unowned", ["go.mod"])]
)
def test_find_putative_go_package_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
"src/go/owned/BUILD": "go_package()\n",
"src/go/owned/src.go": "package owned\n",
"src/go/unowned/src.go": "package unowned\n",
}
)
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeGoPackageTargetsRequest(PutativeTargetsSearchPaths(("src/",))),
AllOwnedSources(["src/go/owned/src.go"]),
],
)
assert putative_targets == PutativeTargets(
[PutativeTarget.for_target_type(GoPackage, "src/go/unowned", "unowned", ["src.go"])]
)
def test_find_putative_targets() -> None:
rule_runner = RuleRunner(
rules=[
*tailor.rules(),
QueryRule(PutativeTargets,
(PutativePythonTargetsRequest, AllOwnedSources)),
],
target_types=[],
)
rule_runner.write_files({
f"src/python/foo/{fp}": ""
for fp in (
"__init__.py",
"bar/__init__.py",
"bar/baz1.py",
"bar/baz1_test.py",
"bar/baz2.py",
"bar/baz2_test.py",
"bar/baz3.py",
)
})
pts = rule_runner.request(
PutativeTargets,
[
PutativePythonTargetsRequest(),
AllOwnedSources([
"src/python/foo/bar/__init__.py", "src/python/foo/bar/baz1.py"
]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(PythonLibrary, "src/python/foo", "foo",
["__init__.py"]),
PutativeTarget.for_target_type(PythonLibrary, "src/python/foo/bar",
"bar", ["baz2.py", "baz3.py"]),
PutativeTarget.for_target_type(
PythonTests,
"src/python/foo/bar",
"tests",
["baz1_test.py", "baz2_test.py"],
kwargs={"name": "tests"},
),
]) == pts)
def test_find_go_mod_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"unowned/go.mod": "",
"owned/go.mod": "",
"owned/BUILD": "go_mod()"
})
putative_targets = rule_runner.request(
PutativeTargets,
[
PutativeGoTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources(["owned/go.mod"]),
],
)
assert putative_targets == PutativeTargets([
PutativeTarget.for_target_type(GoModTarget,
path="unowned",
name=None,
triggering_sources=["go.mod"])
])
def test_find_putative_targets() -> None:
rule_runner = RuleRunner(
rules=[
*tailor.rules(),
QueryRule(PutativeTargets,
[PutativeShellTargetsRequest, AllOwnedSources]),
],
target_types=[],
)
rule_runner.write_files({
f"src/sh/foo/{fp}": ""
for fp in (
"f.sh",
"bar/baz1.sh",
"bar/baz1_test.sh",
"bar/baz2.sh",
"bar/baz2_test.sh",
"bar/baz3.sh",
)
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeShellTargetsRequest(),
AllOwnedSources(
["src/sh/foo/bar/baz1.sh", "src/sh/foo/bar/baz1_test.sh"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(ShellLibrary, "src/sh/foo", "foo",
["f.sh"]),
PutativeTarget.for_target_type(ShellLibrary, "src/sh/foo/bar", "bar",
["baz2.sh", "baz3.sh"]),
PutativeTarget.for_target_type(
Shunit2Tests,
"src/sh/foo/bar",
"tests",
["baz2_test.sh"],
kwargs={"name": "tests"},
),
]) == pts)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files(
{
f"src/sh/foo/{fp}": ""
for fp in (
"f.sh",
"bar/baz1.sh",
"bar/baz1_test.sh",
"bar/baz2.sh",
"bar/baz2_test.sh",
"bar/baz3.sh",
)
}
)
pts = rule_runner.request(
PutativeTargets,
[
PutativeShellTargetsRequest(PutativeTargetsSearchPaths(("",))),
AllOwnedSources(["src/sh/foo/bar/baz1.sh", "src/sh/foo/bar/baz1_test.sh"]),
],
)
assert (
PutativeTargets(
[
PutativeTarget.for_target_type(
ShellSourcesGeneratorTarget, "src/sh/foo", "foo", ["f.sh"]
),
PutativeTarget.for_target_type(
ShellSourcesGeneratorTarget, "src/sh/foo/bar", "bar", ["baz2.sh", "baz3.sh"]
),
PutativeTarget.for_target_type(
Shunit2TestsGeneratorTarget,
"src/sh/foo/bar",
"tests",
["baz2_test.sh"],
kwargs={"name": "tests"},
),
]
)
== pts
)
def test_find_putative_targets(rule_runner: RuleRunner) -> None:
rule_runner.write_files({
"protos/foo/f.proto": "",
"protos/foo/bar/baz1.proto": "",
"protos/foo/bar/baz2.proto": "",
"protos/foo/bar/baz3.proto": "",
})
pts = rule_runner.request(
PutativeTargets,
[
PutativeProtobufTargetsRequest(PutativeTargetsSearchPaths(("", ))),
AllOwnedSources(["protos/foo/bar/baz1.proto"]),
],
)
assert (PutativeTargets([
PutativeTarget.for_target_type(ProtobufLibrary, "protos/foo", "foo",
["f.proto"]),
PutativeTarget.for_target_type(ProtobufLibrary, "protos/foo/bar",
"bar", ["baz2.proto", "baz3.proto"]),
]) == pts)
