.pex

.pex

.zip

We've made a pretty good dent in this with our current approach. But today, we tried using

register_plugin_field

as well as extending

PythonTestTarget

and in both cases we ran into issues where our tests ran twice--once for the built-in pytest runners and once for our remote pytest runner (which isn't what we want). Any tips on what we're potentially doing wrong here would also be appreciated

from dataclasses import dataclass
from typing import Any
from pants.backend.python.goals.pytest_runner import PyTestRequest
from pants.backend.python.target_types import PythonTestTarget, PythonTestsGeneratorTarget, PythonTestsGeneratingSourcesField, PythonTestsOverrideField, PythonFilesGeneratorSettingsRequest, SkipPythonTestsField
from pants.backend.python.subsystems.pytest import PythonTestFieldSet, PyTest
from pants.backend.python.subsystems.setup import PythonSetup
from pants.backend.python.subsystems.python_tool_base import PythonToolBase
from pants.backend.python.target_types import PythonTestSourceField, PythonTestsDependenciesField, _PYTHON_TEST_MOVED_FIELDS
from pants.core.goals.test import Partitions, TestFieldSet, TestRequest, TestResult, TestSubsystem, ShowOutput, TestDebugAdapterRequest, TestDebugRequest
from pants.engine.fs import EMPTY_FILE_DIGEST
from pants.engine.rules import rule, collect_rules
from pants.engine.target import (
    COMMON_TARGET_FIELDS,
    Dependencies,
    BoolField,
    IntField,
    SingleSourceField,
    Target,
    TargetFilesGenerator
)
from pants.engine.unions import UnionRule

from pants.option.option_types import SkipOption
from pants.option.subsystem import Subsystem

# adding one field to differentiate our target from the python_test and python_tests target
class RunOnRemoteField(BoolField):
     alias = "run_on_remote"
     help = "Whether to run the test on remote."
     default = False
     required = True

# extending target instead of PythonTestTarget as a step to try and elminate issues
class RemotePythonTestTarget(Target):
    alias = "remote_python_test"
    help = "Tests run on remote."
    core_fields = (
        *COMMON_TARGET_FIELDS,
        *_PYTHON_TEST_MOVED_FIELDS,
        PythonTestsDependenciesField,
        PythonTestSourceField,
        RunOnRemoteField
    )

class RemotePythonTestsGeneratorTarget(TargetFilesGenerator):
    alias = "remote_python_tests"
    core_fields = (
        *COMMON_TARGET_FIELDS,
        PythonTestsGeneratingSourcesField,
        PythonTestsOverrideField,
        RunOnRemoteField
    )
    generated_target_cls = RemotePythonTestTarget
    copied_fields = (*COMMON_TARGET_FIELDS,RunOnRemoteField,)
    moved_fields = _PYTHON_TEST_MOVED_FIELDS
    settings_request_cls = PythonFilesGeneratorSettingsRequest
    help = "Generate a `remote_python_test` target for each file in the `sources` field."

# Our field set is the same as PythonTestFieldSet, but with one additional field.
@dataclass(frozen=True)
class RemotePythonTestFieldSet(PythonTestFieldSet):
    required_fields = (PythonTestSourceField, RunOnRemoteField)
    run_on_remote: RunOnRemoteField

    @classmethod
    def opt_out(cls, tgt: Target) -> bool:
        return tgt.get(SkipPythonTestsField).value or not tgt.get(RunOnRemoteField).value

# We're not going to be running pytest locally, so we extend the default Subsystem instead of the Pytest subsystem (although we tried that and it too didn't make a difference)
class RemotePythonTestSubsystem(Subsystem):
    name = "Remote Python Tests"
    options_scope = "example-test"
    help = "Tests run on remote."
    skip = SkipOption("skip_remote_tests")


# Define our test request
@dataclass(frozen=True)
class RemotePythonTestRequest(TestRequest):
    field_set_type = RemotePythonTestFieldSet
    tool_subsystem = RemotePythonTestSubsystem

# somehow, this gets called twice
# It gets called once with our valid RemotePythonTestFieldSet
# but it also gets called a second time with a PythonTestFieldSet entry. This shouldn't happen because RemotePythonTestFieldSet doesn't
# inherit from PythonTestFieldSet
@rule
async def run_remote_tests(
    batch: RemotePythonTestRequest.Batch[RemotePythonTestFieldSet, Any],
) -> TestResult:

    print(f"batch is: {batch}")

    return TestResult(
        exit_code=None,
        stdout="",
        stderr="",
        stdout_digest=EMPTY_FILE_DIGEST,
        stderr_digest=EMPTY_FILE_DIGEST,
        addresses=tuple(field_set.address for field_set in batch.elements),
        output_setting=ShowOutput.ALL,
        result_metadata=None,
        partition_description=batch.partition_metadata.description,
    )


def rules():
    return [
        # Originally, we tried just re-using the existing targets by adding a field, but abandoned that approach
        # when we saw run_remote_tests was getting called twice
        # PythonTestTarget.register_plugin_field(RunOnRemoteField),
        # PythonTestsGeneratorTarget.register_plugin_field(RunOnRemoteField),
        # UnionRule(TestFieldSet, RemotePythonTestFieldSet),
        *RemotePythonTestRequest.rules(),
        *collect_rules(),
    ]

stuff.py

register.py

from remote_cluster_plugin.remote_integration_test import stuff


def rules():
    return [ *stuff.rules()]


def target_types():
    return [stuff.RemotePythonTestTarget, stuff.RemotePythonTestsGeneratorTarget]

remote_python_tests

BUILD

integration_tests

run_remote_tests

RemotePythonTestFieldSet

PythonTestFieldSet

2.16.0rc4

Hmm that is strange, even if this were purely duck-typed, that

RunOnRemoteField

is not available on

PythonTestFieldSet

, so it shouldn't trigger