def rules():
return [
*java_protobuf_rules.rules(),
*protobuf_target_types.rules(),
*protobuf_dependency_inference.rules(),
*export_codegen_goal.rules(),
]
def test_inject_dependencies() -> None:
rule_runner = RuleRunner(
rules=[
*python_protobuf_subsystem.rules(),
*target_types.rules(),
QueryRule(InjectedDependencies,
(InjectPythonProtobufDependencies, )),
],
target_types=[ProtobufSourcesGeneratorTarget, GenericTarget],
)
rule_runner.set_options(
["--python-protobuf-runtime-dependencies=protos:injected_dep"])
# Note that injected deps can be any target type for `--python-protobuf-runtime-dependencies`.
rule_runner.write_files({
"protos/BUILD": "protobuf_sources()\ntarget(name='injected_dep')",
"protos/f.proto": "",
})
def assert_injected(addr: Address) -> None:
tgt = rule_runner.get_target(addr)
injected = rule_runner.request(
InjectedDependencies,
[InjectPythonProtobufDependencies(tgt[ProtobufDependenciesField])])
assert injected == InjectedDependencies(
[Address("protos", target_name="injected_dep")])
assert_injected(Address("protos"))
assert_injected(Address("protos", relative_file_path="f.proto"))
def test_generate_source_targets() -> None:
rule_runner = RuleRunner(
rules=[
*target_types.rules(),
QueryRule(_TargetParametrizations,
[_TargetParametrizationsRequest]),
],
target_types=[ProtobufSourcesGeneratorTarget],
)
rule_runner.write_files({
"src/proto/BUILD":
dedent("""\
protobuf_sources(
name='lib',
sources=['**/*.proto'],
overrides={'f1.proto': {'tags': ['overridden']}},
)
"""),
"src/proto/f1.proto":
"",
"src/proto/f2.proto":
"",
"src/proto/subdir/f.proto":
"",
})
def gen_tgt(rel_fp: str,
tags: list[str] | None = None) -> ProtobufSourceTarget:
return ProtobufSourceTarget(
{
SingleSourceField.alias: rel_fp,
Tags.alias: tags
},
Address("src/proto", target_name="lib", relative_file_path=rel_fp),
residence_dir=os.path.dirname(os.path.join("src/proto", rel_fp)),
)
generated = rule_runner.request(
_TargetParametrizations,
[
_TargetParametrizationsRequest(Address("src/proto",
target_name="lib"),
description_of_origin="tests")
],
).parametrizations
assert set(generated.values()) == {
gen_tgt("f1.proto", tags=["overridden"]),
gen_tgt("f2.proto"),
gen_tgt("subdir/f.proto"),
}
def test_generate_source_targets() -> None:
rule_runner = RuleRunner(
rules=[
*target_types.rules(),
QueryRule(GeneratedTargets, [GenerateTargetsFromProtobufSources]),
],
target_types=[ProtobufSourcesGeneratorTarget],
)
rule_runner.write_files({
"src/proto/BUILD":
dedent("""\
protobuf_sources(
name='lib',
sources=['**/*.proto'],
overrides={'f1.proto': {'tags': ['overridden']}},
)
"""),
"src/proto/f1.proto":
"",
"src/proto/f2.proto":
"",
"src/proto/subdir/f.proto":
"",
})
generator = rule_runner.get_target(Address("src/proto", target_name="lib"))
def gen_tgt(rel_fp: str,
tags: list[str] | None = None) -> ProtobufSourceTarget:
return ProtobufSourceTarget(
{
SingleSourceField.alias: rel_fp,
Tags.alias: tags
},
Address("src/proto", target_name="lib", relative_file_path=rel_fp),
residence_dir=os.path.dirname(os.path.join("src/proto", rel_fp)),
)
generated = rule_runner.request(
GeneratedTargets, [GenerateTargetsFromProtobufSources(generator)])
assert generated == GeneratedTargets(
generator,
{
gen_tgt("f1.proto", tags=["overridden"]),
gen_tgt("f2.proto"),
gen_tgt("subdir/f.proto"),
},
)
def rules():
return [
*scala_protobuf_rules.rules(),
*protobuf_target_types.rules(),
*protobuf_dependency_inference.rules(),
# Re-export rules necessary to avoid rule graph errors.
*config_files.rules(),
*classpath.rules(),
*coursier_fetch_rules(),
*coursier_setup_rules(),
*external_tool_rules(),
*source_files.rules(),
*scalac_rules(),
*util_rules(),
*jdk_rules(),
*scala_target_types.rules(),
*stripped_source_files.rules(),
]
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*config_files.rules(),
*external_tool_rules(),
*source_files.rules(),
*protobuf_target_types_rules(),
*protobuf_dependency_inference.rules(),
*stripped_source_files.rules(),
*go_protobuf_rules(),
*sdk.rules(),
*target_types.rules(),
# Rules needed to run Go unit test.
*test.rules(),
*assembly.rules(),
*build_pkg.rules(),
*build_pkg_target.rules(),
*first_party_pkg.rules(),
*go_mod.rules(),
*link.rules(),
*sdk.rules(),
*target_type_rules.rules(),
*tests_analysis.rules(),
*third_party_pkg.rules(),
QueryRule(HydratedSources, [HydrateSourcesRequest]),
QueryRule(GeneratedSources, [GenerateGoFromProtobufRequest]),
QueryRule(DigestContents, (Digest, )),
QueryRule(TestResult, (GoTestFieldSet, )),
],
target_types=[
GoModTarget,
GoPackageTarget,
ProtobufSourceTarget,
ProtobufSourcesGeneratorTarget,
],
)
rule_runner.set_options(
[],
env_inherit=PYTHON_BOOTSTRAP_ENV,
)
return rule_runner
def rules():
return [
*java_protobuf_rules.rules(),
*protobuf_target_types.rules(),
*protobuf_dependency_inference.rules(),
]
def test_find_protobuf_python_requirement() -> None:
rule_runner = RuleRunner(
rules=[
*python_protobuf_subsystem.rules(),
*target_types.rules(),
*module_mapper.rules(),
*stripped_source_files.rules(),
QueryRule(InjectedDependencies,
(InjectPythonProtobufDependencies, )),
],
target_types=[ProtobufSourcesGeneratorTarget, PythonRequirementTarget],
)
rule_runner.write_files({
"codegen/dir/f.proto": "",
"codegen/dir/BUILD": "protobuf_sources(grpc=True)"
})
rule_runner.set_options([
"--python-resolves={'python-default': '', 'another': ''}",
"--python-enable-resolves"
])
proto_tgt = rule_runner.get_target(
Address("codegen/dir", relative_file_path="f.proto"))
request = InjectPythonProtobufDependencies(proto_tgt[Dependencies])
# Start with no relevant requirements.
with engine_error(MissingPythonCodegenRuntimeLibrary, contains="protobuf"):
rule_runner.request(InjectedDependencies, [request])
rule_runner.write_files(
{"proto1/BUILD": "python_requirement(requirements=['protobuf'])"})
with engine_error(MissingPythonCodegenRuntimeLibrary, contains="grpcio"):
rule_runner.request(InjectedDependencies, [request])
# If exactly one, match it.
rule_runner.write_files(
{"grpc1/BUILD": "python_requirement(requirements=['grpc'])"})
assert rule_runner.request(InjectedDependencies,
[request]) == InjectedDependencies(
[Address("proto1"),
Address("grpc1")])
# Multiple is fine if from other resolve.
rule_runner.write_files({
"another_resolve/BUILD":
("python_requirement(name='r1', requirements=['protobuf'], resolve='another')\n"
"python_requirement(name='r2', requirements=['grpc'], resolve='another')\n"
)
})
assert rule_runner.request(InjectedDependencies,
[request]) == InjectedDependencies(
[Address("proto1"),
Address("grpc1")])
# If multiple from the same resolve, error.
rule_runner.write_files(
{"grpc2/BUILD": "python_requirement(requirements=['grpc'])"})
with engine_error(AmbiguousPythonCodegenRuntimeLibrary,
contains="['grpc1:grpc1', 'grpc2:grpc2']"):
rule_runner.request(InjectedDependencies, [request])
rule_runner.write_files(
{"proto2/BUILD": "python_requirement(requirements=['protobuf'])"})
with engine_error(AmbiguousPythonCodegenRuntimeLibrary,
contains="['proto1:proto1', 'proto2:proto2']"):
rule_runner.request(InjectedDependencies, [request])
