def test_report_file(rule_runner: RuleRunner) -> None:
    target = make_target(rule_runner, [BAD_SOURCE])
    result = run_bandit(rule_runner, [target],
                        additional_args=["--lint-reports-dir='.'"])
    assert len(result) == 1
    assert result[0].exit_code == 1
    assert result[0].stdout.strip() == ""
    assert result[0].report is not None
    report_files = rule_runner.request(DigestContents,
                                       [result[0].report.digest])
    assert len(report_files) == 1
    assert ("Issue: [B303:blacklist] Use of insecure MD2, MD4, MD5"
            in report_files[0].content.decode())
Exemple #2
0
def test_gather_scalafmt_config_files(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({
        SCALAFMT_CONF_FILENAME: "",
        f"foo/bar/{SCALAFMT_CONF_FILENAME}": "",
        f"hello/{SCALAFMT_CONF_FILENAME}": "",
        "hello/Foo.scala": "",
        "hello/world/Foo.scala": "",
        "foo/bar/Foo.scala": "",
        "foo/bar/xyyzzy/Foo.scala": "",
        "foo/blah/Foo.scala": "",
    })

    snapshot = rule_runner.request(Snapshot, [PathGlobs(["**/*.scala"])])
    request = rule_runner.request(ScalafmtConfigFiles,
                                  [GatherScalafmtConfigFilesRequest(snapshot)])
    assert sorted(request.source_dir_to_config_file.items()) == [
        ("foo/bar", "foo/bar/.scalafmt.conf"),
        ("foo/bar/xyyzzy", "foo/bar/.scalafmt.conf"),
        ("foo/blah", ".scalafmt.conf"),
        ("hello", "hello/.scalafmt.conf"),
        ("hello/world", "hello/.scalafmt.conf"),
    ]
Exemple #3
0
def _run_setup_py(
    rule_runner: RuleRunner,
    plugin: str,
    version: Optional[str],
    setup_py_args: Iterable[str],
    install_dir: str,
) -> None:
    pex_obj = _create_pex(rule_runner)
    setup_py_file = FileContent(
        "setup.py",
        dedent(
            f"""
                from setuptools import setup

                setup(name="{plugin}", version="{version or DEFAULT_VERSION}")
            """
        ).encode(),
    )
    source_digest = rule_runner.request(
        Digest,
        [CreateDigest([setup_py_file])],
    )
    merged_digest = rule_runner.request(Digest, [MergeDigests([pex_obj.digest, source_digest])])

    process = Process(
        argv=("python", "setup-py-runner.pex", "setup.py") + tuple(setup_py_args),
        # We reasonably expect there to be a python interpreter on the test-running
        # process's path.
        env={"PATH": os.getenv("PATH", "")},
        input_digest=merged_digest,
        description="Run setup.py",
        output_directories=("dist/",),
    )
    result = rule_runner.request(ProcessResult, [process])
    result_snapshot = rule_runner.request(Snapshot, [result.output_digest])
    rule_runner.scheduler.write_digest(result.output_digest, path_prefix="output")
    safe_mkdir(install_dir)
    for path in result_snapshot.files:
        shutil.copy(PurePath(rule_runner.build_root, "output", path), install_dir)
Exemple #4
0
def assert_files_generated(
    rule_runner: RuleRunner,
    address: Address,
    *,
    expected_files: list[str],
    source_roots: list[str],
    mypy: bool = False,
    extra_args: list[str] | None = None,
) -> None:
    args = [f"--source-root-patterns={repr(source_roots)}", *(extra_args or ())]
    if mypy:
        args.append("--python-protobuf-mypy-plugin")
    rule_runner.set_options(args, env_inherit={"PATH", "PYENV_ROOT", "HOME"})
    tgt = rule_runner.get_target(address)
    protocol_sources = rule_runner.request(
        HydratedSources, [HydrateSourcesRequest(tgt[ProtobufSourceField])]
    )
    generated_sources = rule_runner.request(
        GeneratedSources,
        [GeneratePythonFromProtobufRequest(protocol_sources.snapshot, tgt)],
    )
    assert set(generated_sources.snapshot.files) == set(expected_files)
Exemple #5
0
def parse(content: str) -> ParsedThrift:
    rule_runner = RuleRunner(rules=[
        *thrift_parser.rules(),
        QueryRule(ParsedThrift, [ParsedThriftRequest])
    ])
    rule_runner.write_files({"f.thrift": content})
    return rule_runner.request(
        ParsedThrift,
        [
            ParsedThriftRequest(
                ThriftSourceField("f.thrift", Address("", target_name="t")))
        ],
    )
Exemple #6
0
def _run_setup_py(
    rule_runner: RuleRunner,
    plugin: str,
    interpreter_constraints: InterpreterConstraints,
    version: Optional[str],
    setup_py_args: Iterable[str],
    install_dir: str,
) -> None:
    pex_obj = _create_pex(rule_runner, interpreter_constraints)
    setup_py_file = FileContent(
        "setup.py",
        dedent(f"""
                from setuptools import setup

                setup(name="{plugin}", version="{version or DEFAULT_VERSION}")
            """).encode(),
    )
    source_digest = rule_runner.request(
        Digest,
        [CreateDigest([setup_py_file])],
    )
    merged_digest = rule_runner.request(
        Digest, [MergeDigests([pex_obj.digest, source_digest])])

    process = PexProcess(
        pex=pex_obj,
        argv=("setup.py", *setup_py_args),
        input_digest=merged_digest,
        description="Run setup.py",
        output_directories=("dist/", ),
    )
    result = rule_runner.request(ProcessResult, [process])
    result_snapshot = rule_runner.request(Snapshot, [result.output_digest])
    rule_runner.scheduler.write_digest(result.output_digest,
                                       path_prefix="output")
    safe_mkdir(install_dir)
    for path in result_snapshot.files:
        shutil.copy(PurePath(rule_runner.build_root, "output", path),
                    install_dir)
Exemple #7
0
def test_npx_process(rule_runner: RuleRunner):
    result = rule_runner.request(
        ProcessResult,
        [
            nodejs.NpxProcess(
                npm_package="",
                args=("--version", ),
                description="Testing NpxProcess",
            )
        ],
    )

    assert result.stdout.strip() == b"8.5.5"
Exemple #8
0
def _analyze(rule_runner: RuleRunner, source: str) -> ScalaSourceDependencyAnalysis:
    rule_runner.write_files(
        {
            "BUILD": """scala_source(name="source", source="Source.scala")""",
            "Source.scala": source,
        }
    )

    target = rule_runner.get_target(address=Address("", target_name="source"))

    source_files = rule_runner.request(
        SourceFiles,
        [
            SourceFilesRequest(
                (target.get(SourcesField),),
                for_sources_types=(ScalaSourceField,),
                enable_codegen=True,
            )
        ],
    )

    return rule_runner.request(ScalaSourceDependencyAnalysis, [source_files])
Exemple #9
0
def test_infer_java_imports_same_target_with_cycle(
        rule_runner: RuleRunner) -> None:
    rule_runner.write_files({
        "BUILD":
        dedent("""\
                java_sources(name = 't')
                """),
        "A.java":
        dedent("""\
                package org.pantsbuild.a;

                import org.pantsbuild.b.B;

                public class A {}
                """),
        "B.java":
        dedent("""\
                package org.pantsbuild.b;

                import org.pantsbuild.a.A;

                public class B {}
                """),
    })

    target_a = rule_runner.get_target(
        Address("", target_name="t", relative_file_path="A.java"))
    target_b = rule_runner.get_target(
        Address("", target_name="t", relative_file_path="B.java"))

    assert rule_runner.request(
        InferredDependencies,
        [InferJavaImportDependencies(target_a[JavaSourceField])
         ]) == InferredDependencies(dependencies=[target_b.address])

    assert rule_runner.request(
        InferredDependencies,
        [InferJavaImportDependencies(target_b[JavaSourceField])
         ]) == InferredDependencies(dependencies=[target_a.address])
Exemple #10
0
def assert_files_generated(
    rule_runner: RuleRunner,
    address: Address,
    *,
    expected_files: list[str],
    source_roots: list[str],
    extra_args: Iterable[str] = (),
) -> None:
    args = [f"--source-root-patterns={repr(source_roots)}", *extra_args]
    rule_runner.set_options(args, env_inherit=PYTHON_BOOTSTRAP_ENV)
    tgt = rule_runner.get_target(address)
    protocol_sources = rule_runner.request(
        HydratedSources, [HydrateSourcesRequest(tgt[ProtobufSourceField])]
    )
    generated_sources = rule_runner.request(
        GeneratedSources,
        [GenerateScalaFromProtobufRequest(protocol_sources.snapshot, tgt)],
    )
    sources_contents = rule_runner.request(DigestContents, [generated_sources.snapshot.digest])
    for sc in sources_contents:
        print(f"{sc.path}:\n{sc.content.decode()}")
    assert set(generated_sources.snapshot.files) == set(expected_files)
Exemple #11
0
def test_find_go_binary_targets(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({
        "missing_binary_tgt/app.go":
        "package main",
        "missing_binary_tgt/BUILD":
        "go_package()",
        "tgt_already_exists/app.go":
        "package main",
        "tgt_already_exists/BUILD":
        "go_binary(name='bin')\ngo_package()",
        "missing_pkg_and_binary_tgt/app.go":
        "package main",
        "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')",
    })
    putative_targets = rule_runner.request(
        PutativeTargets,
        [
            PutativeGoTargetsRequest(PutativeTargetsSearchPaths(("", ))),
            AllOwnedSources([
                "missing_binary_tgt/app.go",
                "tgt_already_exists/app.go",
                "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=[],
        ),
    ])
Exemple #12
0
def test_download_artifacts(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({
        "3rdparty/helm/BUILD":
        dedent("""\
                helm_artifact(
                  name="cert-manager",
                  repository="https://charts.jetstack.io/",
                  artifact="cert-manager",
                  version="v1.7.1"
                )

                helm_artifact(
                    name="prometheus-stack",
                    repository="https://prometheus-community.github.io/helm-charts",
                    artifact="kube-prometheus-stack",
                    version="^27.2.0"
                )
                """),
    })

    targets = rule_runner.request(AllHelmArtifactTargets, [])
    fetched_artifacts = rule_runner.request(
        FetchedHelmArtifacts,
        [
            FetchHelmArfifactsRequest.for_targets(
                targets, description_of_origin="test_download_artifacts")
        ],
    )

    expected_artifacts = [
        rule_runner.request(ResolvedHelmArtifact,
                            [HelmArtifact.from_target(tgt)]) for tgt in targets
    ]

    assert len(fetched_artifacts) == len(expected_artifacts)
    for fetched, expected in zip(fetched_artifacts, expected_artifacts):
        assert fetched.artifact == expected
        assert f"{expected.name}/Chart.yaml" in fetched.snapshot.files
Exemple #13
0
def test_internal_test_fails_to_compile(rule_runner: RuleRunner) -> None:
    """A compilation failure should not cause Pants to error, only the test to fail."""
    rule_runner.write_files({
        "foo/BUILD":
        "go_mod()",
        "foo/go.mod":
        "module foo",
        # Test itself is bad.
        "foo/bad_test.go":
        "invalid!!!",
        # A dependency of the test is bad.
        "foo/dep/f.go":
        "invalid!!!",
        "foo/uses_dep/f_test.go":
        textwrap.dedent("""
                package uses_dep

                import (
                  "foo/dep"
                  "testing"
                )

                func TestAdd(t *testing.T) {
                  if add(2, 3) != 5 {
                    t.Fail()
                  }
                }
                """),
    })
    tgt = rule_runner.get_target(Address("foo", generated_name="./"))
    result = rule_runner.request(TestResult, [GoTestFieldSet.create(tgt)])
    assert result.exit_code == 1
    assert "bad_test.go:1:1: expected 'package', found invalid\n" in result.stderr

    tgt = rule_runner.get_target(Address("foo", generated_name="./uses_dep"))
    result = rule_runner.request(TestResult, [GoTestFieldSet.create(tgt)])
    assert result.exit_code == 1
    assert "dep/f.go:1:1: expected 'package', found invalid\n" in result.stderr
def run_pytest(
    rule_runner: RuleRunner,
    test_target: PythonTests,
    *,
    passthrough_args: Optional[str] = None,
    junit_xml_dir: Optional[str] = None,
    use_coverage: bool = False,
    execution_slot_var: Optional[str] = None,
    extra_env_vars: Optional[str] = None,
    env: Optional[Mapping[str, str]] = None,
) -> TestResult:
    args = [
        "--backend-packages=pants.backend.python",
        f"--source-root-patterns={SOURCE_ROOT}",
        # pin to lower versions so that we can run Python 2 tests
        "--pytest-version=pytest>=4.6.6,<4.7",
        "--pytest-pytest-plugins=['zipp==1.0.0', 'pytest-cov>=2.8.1,<2.9']",
    ]
    if passthrough_args:
        args.append(f"--pytest-args='{passthrough_args}'")
    if extra_env_vars:
        args.append(f"--test-extra-env-vars={extra_env_vars}")
    if junit_xml_dir:
        args.append(f"--pytest-junit-xml-dir={junit_xml_dir}")
    if use_coverage:
        args.append("--test-use-coverage")
    if execution_slot_var:
        args.append(f"--pytest-execution-slot-var={execution_slot_var}")
    rule_runner.set_options(args, env=env)

    inputs = [PythonTestFieldSet.create(test_target)]
    test_result = rule_runner.request(TestResult, inputs)
    debug_request = rule_runner.request(TestDebugRequest, inputs)
    if debug_request.process is not None:
        debug_result = InteractiveRunner(rule_runner.scheduler).run(
            debug_request.process)
        assert test_result.exit_code == debug_result.exit_code
    return test_result
def run_gofmt(
    rule_runner: RuleRunner,
    targets: list[Target],
    *,
    extra_args: list[str] | None = None,
) -> tuple[tuple[LintResult, ...], FmtResult]:
    rule_runner.set_options(extra_args or (), env_inherit={"PATH"})
    field_sets = [GofmtFieldSet.create(tgt) for tgt in targets]
    lint_results = rule_runner.request(LintResults, [GofmtRequest(field_sets)])
    input_sources = rule_runner.request(
        SourceFiles,
        [
            SourceFilesRequest(field_set.sources for field_set in field_sets),
        ],
    )
    fmt_result = rule_runner.request(
        FmtResult,
        [
            GofmtRequest(field_sets,
                         prior_formatter_result=input_sources.snapshot),
        ],
    )
    return lint_results.results, fmt_result
Exemple #16
0
def create_mock_run_request(rule_runner: RuleRunner,
                            program_text: bytes) -> RunRequest:
    digest = rule_runner.request(
        Digest,
        [
            CreateDigest([
                FileContent(path="program.py",
                            content=program_text,
                            is_executable=True)
            ])
        ],
    )
    return RunRequest(digest=digest,
                      args=(os.path.join("{chroot}", "program.py"), ))
Exemple #17
0
def test_compile_jdk_12_file_fails_with_jdk_11(
        rule_runner: RuleRunner) -> None:
    rule_runner.write_files({
        "BUILD":
        dedent("""\
                java_sources(
                    name = 'lib',
                    jdk = 'adopt:1.11',
                )
                """),
        "3rdparty/jvm/default.lock":
        TestCoursierWrapper.new(entries=()).serialize(),
        "ExampleLib.java":
        JAVA_LIB_JDK12_SOURCE,
    })

    request = CompileJavaSourceRequest(
        component=expect_single_expanded_coarsened_target(
            rule_runner, Address(spec_path="", target_name="lib")),
        resolve=make_resolve(rule_runner),
    )
    with pytest.raises(ExecutionError):
        rule_runner.request(RenderedClasspath, [request])
Exemple #18
0
def run_hadolint(
        rule_runner: RuleRunner,
        targets: list[Target],
        *,
        extra_args: list[str] | None = None) -> tuple[LintResult, ...]:
    rule_runner.set_options(
        extra_args or (),
        env_inherit={"PATH"},
    )
    results = rule_runner.request(
        LintResults,
        [HadolintRequest(HadolintFieldSet.create(tgt) for tgt in targets)],
    )
    return results.results
Exemple #19
0
def assert_files_generated(
    rule_runner: RuleRunner,
    address: Address,
    *,
    expected_files: list[str],
    source_roots: list[str],
    extra_args: list[str] | None = None,
) -> None:
    args = [
        f"--source-root-patterns={repr(source_roots)}",
        "--no-python-thrift-infer-runtime-dependency",
        *(extra_args or ()),
    ]
    rule_runner.set_options(args, env_inherit={"PATH", "PYENV_ROOT", "HOME"})
    tgt = rule_runner.get_target(address)
    thrift_sources = rule_runner.request(
        HydratedSources, [HydrateSourcesRequest(tgt[ThriftSourceField])]
    )
    generated_sources = rule_runner.request(
        GeneratedSources,
        [GeneratePythonFromThriftRequest(thrift_sources.snapshot, tgt)],
    )
    assert set(generated_sources.snapshot.files) == set(expected_files)
def assert_sources_resolved(
        rule_runner: RuleRunner,
        sources_fields: Iterable[SourcesField],
        *,
        expected: Iterable[TargetSources],
        expected_unrooted: Iterable[str] = (),
) -> None:
    result = rule_runner.request(SourceFiles,
                                 [SourceFilesRequest(sources_fields)])
    assert list(result.snapshot.files) == sorted(
        set(
            itertools.chain.from_iterable(sources.full_paths
                                          for sources in expected)))
    assert list(result.unrooted_files) == sorted(expected_unrooted)
Exemple #21
0
def test_report_file(rule_runner: RuleRunner) -> None:
    rule_runner.write_files({
        f"{PACKAGE}/f.py": GOOD_FILE,
        f"{PACKAGE}/BUILD": "python_sources()"
    })
    tgt = rule_runner.get_target(Address(PACKAGE, relative_file_path="f.py"))
    result = run_mypy(rule_runner, [tgt],
                      extra_args=["--mypy-args='--linecount-report=reports'"])
    assert len(result) == 1
    assert result[0].exit_code == 0
    assert "Success: no issues found" in result[0].stdout.strip()
    report_files = rule_runner.request(DigestContents, [result[0].report])
    assert len(report_files) == 1
    assert "4       4      1      1 f" in report_files[0].content.decode()
Exemple #22
0
def _deploy_jar_test(rule_runner: RuleRunner, target_name: str) -> None:
    tgt = rule_runner.get_target(Address("", target_name=target_name))
    jdk = rule_runner.request(InternalJdk, [])
    fat_jar = rule_runner.request(
        BuiltPackage,
        [DeployJarFieldSet.create(tgt)],
    )

    process_result = rule_runner.request(
        ProcessResult,
        [
            JvmProcess(
                jdk=jdk,
                argv=("-jar", "dave.jar"),
                classpath_entries=[],
                description="Run that test jar",
                input_digest=fat_jar.digest,
                use_nailgun=False,
            )
        ],
    )

    assert process_result.stdout.decode("utf-8").strip() == "Hello, World!"
Exemple #23
0
def test_generate_source_targets() -> None:
    rule_runner = RuleRunner(
        rules=[
            *target_types.rules(),
            QueryRule(_TargetParametrizations,
                      [_TargetParametrizationsRequest]),
        ],
        target_types=[AvroSourcesGeneratorTarget],
    )
    rule_runner.write_files({
        "src/avro/BUILD":
        dedent("""\
                avro_sources(
                    name='lib',
                    sources=['**/*.avsc', '**/*.avpr'],
                    overrides={'f1.avsc': {'tags': ['overridden']}},
                )
                """),
        "src/avro/f1.avsc":
        "",
        "src/avro/f2.avpr":
        "",
        "src/avro/subdir/f.avsc":
        "",
    })

    def gen_tgt(rel_fp: str,
                tags: list[str] | None = None) -> AvroSourceTarget:
        return AvroSourceTarget(
            {
                SingleSourceField.alias: rel_fp,
                Tags.alias: tags
            },
            Address("src/avro", target_name="lib", relative_file_path=rel_fp),
            residence_dir=os.path.dirname(os.path.join("src/avro", rel_fp)),
        )

    generated = rule_runner.request(
        _TargetParametrizations,
        [
            _TargetParametrizationsRequest(Address("src/avro",
                                                   target_name="lib"),
                                           description_of_origin="tests")
        ],
    ).parametrizations
    assert set(generated.values()) == {
        gen_tgt("f1.avsc", tags=["overridden"]),
        gen_tgt("f2.avpr"),
        gen_tgt("subdir/f.avsc"),
    }
def test_import_path(rule_runner: RuleRunner, mod_dir: str) -> None:
    rule_runner.write_files(
        {
            f"{mod_dir}BUILD": "go_mod(name='mod')\ngo_package(name='pkg')",
            f"{mod_dir}go.mod": "module go.example.com/foo",
            f"{mod_dir}f.go": "",
            f"{mod_dir}dir/f.go": "",
            f"{mod_dir}dir/BUILD": "go_package()",
        }
    )
    info = rule_runner.request(
        FirstPartyPkgImportPath,
        [FirstPartyPkgImportPathRequest(Address(mod_dir, target_name="pkg"))],
    )
    assert info.import_path == "go.example.com/foo"
    assert info.dir_path_rel_to_gomod == ""

    info = rule_runner.request(
        FirstPartyPkgImportPath,
        [FirstPartyPkgImportPathRequest(Address(os.path.join(mod_dir, "dir")))],
    )
    assert info.import_path == "go.example.com/foo/dir"
    assert info.dir_path_rel_to_gomod == "dir"
Exemple #25
0
def assert_path_globs(
    rule_runner: RuleRunner,
    globs: Iterable[str],
    *,
    expected_files: Iterable[str],
    expected_dirs: Iterable[str],
) -> None:
    snapshot = rule_runner.request(Snapshot, [PathGlobs(globs)])
    assert snapshot.files == tuple(sorted(expected_files))
    assert snapshot.dirs == tuple(sorted(expected_dirs))
    if expected_files or expected_dirs:
        assert snapshot.digest != EMPTY_DIGEST
    else:
        assert snapshot.digest == EMPTY_DIGEST
Exemple #26
0
def test_map_third_party_modules_to_addresses(rule_runner: RuleRunner) -> None:
    rule_runner.add_to_build_file(
        "3rdparty/python",
        dedent(
            """\
            python_requirement_library(
              name='ansicolors',
              requirements=['ansicolors==1.21'],
              module_mapping={'ansicolors': ['colors']},
            )

            python_requirement_library(
              name='req1',
              requirements=['req1', 'two_owners'],
            )

            python_requirement_library(
              name='un_normalized',
              requirements=['Un-Normalized-Project>3', 'two_owners'],
            )

            python_requirement_library(
              name='direct_references',
              requirements=[
                'pip@ git+https://github.com/pypa/pip.git', 'local_dist@ file:///path/to/dist.whl',
              ],
            )
            """
        ),
    )
    result = rule_runner.request(ThirdPartyPythonModuleMapping, [])
    assert result == ThirdPartyPythonModuleMapping(
        mapping=FrozenDict(
            {
                "colors": Address("3rdparty/python", target_name="ansicolors"),
                "local_dist": Address("3rdparty/python", target_name="direct_references"),
                "pip": Address("3rdparty/python", target_name="direct_references"),
                "req1": Address("3rdparty/python", target_name="req1"),
                "un_normalized_project": Address("3rdparty/python", target_name="un_normalized"),
            }
        ),
        ambiguous_modules=FrozenDict(
            {
                "two_owners": (
                    Address("3rdparty/python", target_name="req1"),
                    Address("3rdparty/python", target_name="un_normalized"),
                ),
            }
        ),
    )
Exemple #27
0
def test_venv_pex_resolve_info(rule_runner: RuleRunner, pex_type: type[Pex | VenvPex]) -> None:
    venv_pex = create_pex_and_get_all_data(
        rule_runner, pex_type=pex_type, requirements=PexRequirements(["requests==2.23.0"])
    )["pex"]
    dists = rule_runner.request(PexResolveInfo, [venv_pex])
    assert dists[0] == PexDistributionInfo("certifi", Version("2020.12.5"), None, ())
    assert dists[1] == PexDistributionInfo("chardet", Version("3.0.4"), None, ())
    assert dists[2] == PexDistributionInfo(
        "idna", Version("2.10"), SpecifierSet("!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7"), ()
    )
    assert dists[3].project_name == "requests"
    assert dists[3].version == Version("2.23.0")
    assert Requirement.parse('PySocks!=1.5.7,>=1.5.6; extra == "socks"') in dists[3].requires_dists
    assert dists[4].project_name == "urllib3"
def build_package(
    rule_runner: RuleRunner,
    main_target: Target,
) -> BuiltPackage:
    args = ["--backend-packages=pants.backend.go"]
    rule_runner.set_options(args)
    rule_runner.add_to_build_file(
        "",
        f"go_binary(name='bin', binary_name='foo', main='{main_target.address.spec}')\n"
    )
    go_binary_target = rule_runner.get_target(Address("", target_name="bin"))
    built_package = rule_runner.request(
        BuiltPackage, (GoBinaryFieldSet.create(go_binary_target), ))
    return built_package
Exemple #29
0
def _assert_build_package(rule_runner: RuleRunner, *, chart_name: str,
                          chart_version: str) -> None:
    rule_runner.set_options(["--source-root-patterns=['src/*']"])

    target = rule_runner.get_target(
        Address(f"src/{chart_name}", target_name=chart_name))
    field_set = HelmPackageFieldSet.create(target)

    dest_dir = field_set.output_path.value_or_default(file_ending=None)
    result = rule_runner.request(BuiltPackage, [field_set])

    assert len(result.artifacts) == 1
    assert result.artifacts[0].relpath == os.path.join(
        dest_dir, f"{chart_name}-{chart_version}.tgz")
Exemple #30
0
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"]
    )