def run_all_tests()

in dev/archery/archery/integration/runner.py [0:0]
146 lines of code
20 McCabe index (conditional complexity)

def run_all_tests(with_cpp=True, with_java=True, with_js=True,
                  with_csharp=True, with_go=True, with_rust=False,
                  with_nanoarrow=False, run_ipc=False, run_flight=False,
                  run_c_data=False, tempdir=None, target_implementations="",
                  **kwargs):
    tempdir = tempdir or tempfile.mkdtemp(prefix='arrow-integration-')
    target_implementations = \
        target_implementations.split(",") if target_implementations else []

    testers: List[Tester] = []
    other_testers: List[Tester] = []

    def append_tester(implementation, tester):
        if len(target_implementations) == 0 or implementation in target_implementations:
            testers.append(tester)
        else:
            other_testers.append(tester)

    if with_cpp:
        from .tester_cpp import CppTester
        append_tester("cpp", CppTester(**kwargs))

    if with_java:
        from .tester_java import JavaTester
        append_tester("java", JavaTester(**kwargs))

    if with_js:
        from .tester_js import JSTester
        append_tester("js", JSTester(**kwargs))

    if with_csharp:
        from .tester_csharp import CSharpTester
        append_tester("csharp", CSharpTester(**kwargs))

    if with_go:
        from .tester_go import GoTester
        append_tester("go", GoTester(**kwargs))

    if with_nanoarrow:
        from .tester_nanoarrow import NanoarrowTester
        append_tester("nanoarrow", NanoarrowTester(**kwargs))

    if with_rust:
        from .tester_rust import RustTester
        append_tester("rust", RustTester(**kwargs))

    static_json_files = get_static_json_files()
    generated_json_files = datagen.get_generated_json_files(tempdir=tempdir)
    json_files = static_json_files + generated_json_files

    # Additional integration test cases for Arrow Flight.
    flight_scenarios = [
        Scenario(
            "auth:basic_proto",
            description="Authenticate using the BasicAuth protobuf.",
            skip_testers={"C#"},
        ),
        Scenario(
            "middleware",
            description="Ensure headers are propagated via middleware.",
            skip_testers={"C#"},
        ),
        Scenario(
            "ordered",
            description="Ensure FlightInfo.ordered is supported.",
            skip_testers={"JS", "C#", "Rust"},
        ),
        Scenario(
            "expiration_time:do_get",
            description=("Ensure FlightEndpoint.expiration_time with "
                         "DoGet is working as expected."),
            skip_testers={"JS", "C#", "Rust"},
        ),
        Scenario(
            "expiration_time:list_actions",
            description=("Ensure FlightEndpoint.expiration_time related "
                         "pre-defined actions is working with ListActions "
                         "as expected."),
            skip_testers={"JS", "C#", "Rust"},
        ),
        Scenario(
            "expiration_time:cancel_flight_info",
            description=("Ensure FlightEndpoint.expiration_time and "
                         "CancelFlightInfo are working as expected."),
            skip_testers={"JS", "C#", "Rust"},
        ),
        Scenario(
            "expiration_time:renew_flight_endpoint",
            description=("Ensure FlightEndpoint.expiration_time and "
                         "RenewFlightEndpoint are working as expected."),
            skip_testers={"JS", "C#", "Rust"},
        ),
        Scenario(
            "do_exchange:echo",
            description=("Test the do_exchange method by "
                         "echoing data back to the client."),
            skip_testers={"Go", "JS", "Rust"},
        ),
        Scenario(
            "location:reuse_connection",
            description="Ensure arrow-flight-reuse-connection is accepted.",
            skip_testers={"JS", "C#", "Rust"},
        ),
        Scenario(
            "session_options",
            description="Ensure Flight SQL Sessions work as expected.",
            skip_testers={"JS", "C#", "Rust"}
        ),
        Scenario(
            "poll_flight_info",
            description="Ensure PollFlightInfo is supported.",
            skip_testers={"JS", "C#", "Rust"}
        ),
        Scenario(
            "app_metadata_flight_info_endpoint",
            description="Ensure support FlightInfo and Endpoint app_metadata",
            skip_testers={"JS", "C#", "Rust"}
        ),
        Scenario(
            "flight_sql",
            description="Ensure Flight SQL protocol is working as expected.",
            skip_testers={"Rust", "C#"}
        ),
        Scenario(
            "flight_sql:extension",
            description="Ensure Flight SQL extensions work as expected.",
            skip_testers={"Rust", "C#"}
        ),
        Scenario(
            "flight_sql:ingestion",
            description="Ensure Flight SQL ingestion works as expected.",
            skip_testers={"JS", "C#", "Rust"}
        ),
    ]

    runner = IntegrationRunner(json_files, flight_scenarios, testers,
                               other_testers, **kwargs)
    if run_ipc:
        runner.run_ipc()
    if run_flight:
        runner.run_flight()
    if run_c_data:
        runner.run_c_data()

    with group("Integration: Test: Result"):
        fail_count = 0
        if runner.failures:
            log("################# FAILURES #################")
            for test_case, producer, consumer, exc_info in runner.failures:
                fail_count += 1
                log("FAILED TEST:", end=" ")
                log(test_case.name, producer.name, "producing, ",
                    consumer.name, "consuming")
                if exc_info:
                    exc_type, exc_value, exc_tb = exc_info
                    log(f'{exc_type}: {exc_value}')
                log()

        log(f"{fail_count} failures, {len(runner.skips)} skips")
        if fail_count > 0:
            sys.exit(1)