testit-cli 2.11.1__tar.gz → 2.12.0__tar.gz

{testit_cli-2.11.1 → testit_cli-2.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testit-cli
-Version: 2.11.1
+Version: 2.12.0
 Summary: This tool is the command line wrapper of Test IT allowing you to upload the test results in real time to Test IT
 Home-page: https://pypi.org/project/testit-cli/
 Author: Integration team
@@ -65,6 +65,68 @@ You can see more information in [official documentation](https://docs.testit.sof
 2. Starting with 5.2, we have added a TMS postscript, which means that the utility is compatible with a specific enterprise version.
 3. If you are in doubt about which version to use, check with the support staff. support@yoonion.ru
 
+## Launch a filled test run (`testrun create launch`)
+
+Unlike `testrun create` (empty run), `testrun create launch` creates a **filled** test run.
+
+Provide **exactly one** source:
+
+| Source            | Flag                                   | Behaviour                                         |
+|-------------------|----------------------------------------|---------------------------------------------------|
+| Test plan         | `--test-plan-id` / `-tpi`              | Search automated test points in the TMS test plan |
+| Tags              | `--filter tags=smoke,nightly`          | Search autotests in TMS                           |
+| External IDs file | `--autotest-external-ids-file` / `-af` | One external ID per line in file                  |
+
+Required: `--url`, `--token`, `--project-id`, `--configuration-id`. Optional: `--testrun-name`, `--output` (also write ID to a file).
+
+The command prints `testRunId` to **stdout** (suitable for `export TMS_TEST_RUN_ID=$(...)`).
+
+```bash
+export TMS_TEST_RUN_ID=$(testit testrun create launch \
+  --url "$TMS_URL" \
+  --token "$TMS_TOKEN" \
+  --project-id "$TMS_PROJECT_ID" \
+  --configuration-id "$TMS_CONFIGURATION_ID" \
+  --filter tags=smoke \
+  --testrun-name "CI smoke")
+```
+
+From a test plan:
+
+```bash
+testit testrun create launch \
+  -u "$TMS_URL" -t "$TMS_TOKEN" \
+  -pi "$TMS_PROJECT_ID" -ci "$TMS_CONFIGURATION_ID" \
+  --test-plan-id "$TMS_TEST_PLAN_ID" \
+  -o ./testrun.id
+```
+
+### Autotest external IDs file
+
+`--autotest-external-ids-file` / `-af` expects a plain-text file of **autotest external IDs** (the same values as in TMS / `autoTestExternalIds`, not internal UUIDs or global IDs):
+
+- one external ID per line;
+- empty lines are ignored;
+- lines starting with `#` are comments;
+- duplicate IDs are ignored.
+
+Example `autotest-external-ids.txt`:
+
+```text
+# smoke suite
+login-test-ext-id
+checkout-test-ext-id
+
+payment-test-ext-id
+```
+
+```bash
+testit testrun create launch \
+  -u "$TMS_URL" -t "$TMS_TOKEN" \
+  -pi "$TMS_PROJECT_ID" -ci "$TMS_CONFIGURATION_ID" \
+  -af ./autotest-external-ids.txt
+```
+
 ## Test run tags and links
 
 You can attach **test run** tags and links (for example a CI job URL) via CLI flags or environment variables.  

{testit_cli-2.11.1 → testit_cli-2.12.0}/README.md

@@ -31,6 +31,68 @@ You can see more information in [official documentation](https://docs.testit.sof
 2. Starting with 5.2, we have added a TMS postscript, which means that the utility is compatible with a specific enterprise version.
 3. If you are in doubt about which version to use, check with the support staff. support@yoonion.ru
 
+## Launch a filled test run (`testrun create launch`)
+
+Unlike `testrun create` (empty run), `testrun create launch` creates a **filled** test run.
+
+Provide **exactly one** source:
+
+| Source            | Flag                                   | Behaviour                                         |
+|-------------------|----------------------------------------|---------------------------------------------------|
+| Test plan         | `--test-plan-id` / `-tpi`              | Search automated test points in the TMS test plan |
+| Tags              | `--filter tags=smoke,nightly`          | Search autotests in TMS                           |
+| External IDs file | `--autotest-external-ids-file` / `-af` | One external ID per line in file                  |
+
+Required: `--url`, `--token`, `--project-id`, `--configuration-id`. Optional: `--testrun-name`, `--output` (also write ID to a file).
+
+The command prints `testRunId` to **stdout** (suitable for `export TMS_TEST_RUN_ID=$(...)`).
+
+```bash
+export TMS_TEST_RUN_ID=$(testit testrun create launch \
+  --url "$TMS_URL" \
+  --token "$TMS_TOKEN" \
+  --project-id "$TMS_PROJECT_ID" \
+  --configuration-id "$TMS_CONFIGURATION_ID" \
+  --filter tags=smoke \
+  --testrun-name "CI smoke")
+```
+
+From a test plan:
+
+```bash
+testit testrun create launch \
+  -u "$TMS_URL" -t "$TMS_TOKEN" \
+  -pi "$TMS_PROJECT_ID" -ci "$TMS_CONFIGURATION_ID" \
+  --test-plan-id "$TMS_TEST_PLAN_ID" \
+  -o ./testrun.id
+```
+
+### Autotest external IDs file
+
+`--autotest-external-ids-file` / `-af` expects a plain-text file of **autotest external IDs** (the same values as in TMS / `autoTestExternalIds`, not internal UUIDs or global IDs):
+
+- one external ID per line;
+- empty lines are ignored;
+- lines starting with `#` are comments;
+- duplicate IDs are ignored.
+
+Example `autotest-external-ids.txt`:
+
+```text
+# smoke suite
+login-test-ext-id
+checkout-test-ext-id
+
+payment-test-ext-id
+```
+
+```bash
+testit testrun create launch \
+  -u "$TMS_URL" -t "$TMS_TOKEN" \
+  -pi "$TMS_PROJECT_ID" -ci "$TMS_CONFIGURATION_ID" \
+  -af ./autotest-external-ids.txt
+```
+
 ## Test run tags and links
 
 You can attach **test run** tags and links (for example a CI job URL) via CLI flags or environment variables.  

{testit_cli-2.11.1 → testit_cli-2.12.0}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import find_packages, setup
 
-VERSION = "2.11.1"
+VERSION = "2.12.0"
 
 ADAPTERS_ROOT = "src/testit_cli/adapters_api"
 ADAPTERS_PACKAGES = ["adapters_api"] + [

{testit_cli-2.11.1 → testit_cli-2.12.0}/src/testit_cli/click_commands.py

@@ -3,10 +3,11 @@ from itertools import chain
 
 import click
 
+from .launch_filter import LaunchFilterError, parse_launch_filter, read_autotest_external_ids_file
 from .models.config import Config
 from .service_factory import ServiceFactory
 from .testrun_metadata import parse_testrun_links, parse_testrun_tags
-from .validation import validate_url, validate_uuid
+from .validation import validate_url, validate_url_optional, validate_uuid
 
 
 @click.group()
@@ -178,19 +179,71 @@ def testrun():
     pass
 
 
-@testrun.command("create")
-@click.option("-u", "--url", type=str, envvar='TMS_URL', required=True, help="Set url address of the Test IT instance (https://demo.testit.software)", callback=validate_url)
-@click.option("-t", "--token", type=str, envvar='TMS_TOKEN', required=True, help="Set API token (T2lKd2pLZGI4WHRhaVZUejNl)")
-@click.option("-pi", "--project-id", type=str, envvar='TMS_PROJECT_ID', required=True, help="Set project id (5236eb3f-7c05-46f9-a609-dc0278896464)", callback=validate_uuid)
-@click.option("-tn", "--testrun-name", type=str, envvar='TMS_TEST_RUN_NAME', help="Set test run name (TestRun01)", default=None)
+def _require_create_options(**required_options):
+    """Validate empty-create required options when no subcommand is invoked."""
+    for flag, value in required_options.items():
+        if value is None or value == "":
+            raise click.UsageError(f"Missing option '{flag}'.")
+
+
+def _require_exactly_one_launch_source(
+    test_plan_id: typing.Optional[str],
+    launch_filter: typing.Optional[str],
+    autotest_external_ids_file: typing.Optional[str],
+) -> None:
+    sources = [
+        bool(test_plan_id),
+        bool(launch_filter),
+        bool(autotest_external_ids_file),
+    ]
+    if sum(sources) != 1:
+        raise click.UsageError(
+            "Provide exactly one of: --test-plan-id, --filter, or --autotest-external-ids-file"
+        )
+
+
+def _parse_launch_tags(launch_filter: typing.Optional[str]) -> typing.Optional[typing.List[str]]:
+    if not launch_filter:
+        return None
+    try:
+        return parse_launch_filter(launch_filter)
+    except LaunchFilterError as exc:
+        raise click.BadParameter(str(exc), param_hint="--filter") from exc
+
+
+def _load_autotest_external_ids(path: typing.Optional[str]) -> typing.Optional[typing.List[str]]:
+    if not path:
+        return None
+    autotest_external_ids = read_autotest_external_ids_file(path)
+    if not autotest_external_ids:
+        raise click.BadParameter(
+            "Autotest external ids file is empty (no external IDs)",
+            param_hint="--autotest-external-ids-file",
+        )
+    return autotest_external_ids
+
+
+@testrun.group("create", invoke_without_command=True)
+@click.pass_context
+@click.option("-u", "--url", type=str, envvar='TMS_URL', default=None, help="Set url address of the Test IT instance (https://demo.testit.software)", callback=validate_url_optional)
+@click.option("-t", "--token", type=str, envvar='TMS_TOKEN', default=None, help="Set API token (T2lKd2pLZGI4WHRhaVZUejNl)")
+@click.option("-pi", "--project-id", type=str, envvar='TMS_PROJECT_ID', default=None, help="Set project id (5236eb3f-7c05-46f9-a609-dc0278896464)", callback=validate_uuid)
+@click.option("-tn", "--testrun-name", type=str, envvar='TMS_TEST_RUN_NAME', default=None, help="Set test run name (TestRun01)")
 @click.option("-trt", "--testruntags", type=str, envvar='TMS_TEST_RUN_TAGS', default=None, help=_TESTRUN_TAGS_HELP)
 @click.option("-trl", "--testrunlinks", type=str, envvar='TMS_TEST_RUN_LINKS', default=None, help=_TESTRUN_LINKS_HELP)
-@click.option("-o", "--output", type=str, required=True, help="Set file path for output (FILE)")
+@click.option("-o", "--output", type=str, default=None, help="Set file path for output (FILE)")
 @click.option("-a", "--attachments", multiple=True, type=list, help="Path to attachments for test run (multiple)", default=[], cls=ExtraArgsForOption)
 @click.option("-d", "--debug", is_flag=True, help="Set debug logs")
 @click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
-def create_test_run(url, token, project_id, testrun_name, testruntags, testrunlinks, output, debug, attachments, disable_cert_validation):
+def create_test_run(ctx, url, token, project_id, testrun_name, testruntags, testrunlinks, output, debug, attachments, disable_cert_validation):
     """Creating a new test run"""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    _require_create_options(
+        **{"--url": url, "--token": token, "--project-id": project_id, "--output": output}
+    )
+
     config = Config(
         url=url,
         token=token,
@@ -208,6 +261,41 @@ def create_test_run(url, token, project_id, testrun_name, testruntags, testrunli
     service.create_test_run()
 
 
+@create_test_run.command("launch")
+@click.option("-u", "--url", type=str, envvar='TMS_URL', required=True, help="Set url address of the Test IT instance (https://demo.testit.software)", callback=validate_url)
+@click.option("-t", "--token", type=str, envvar='TMS_TOKEN', required=True, help="Set API token (T2lKd2pLZGI4WHRhaVZUejNl)")
+@click.option("-pi", "--project-id", type=str, envvar='TMS_PROJECT_ID', required=True, help="Set project id (5236eb3f-7c05-46f9-a609-dc0278896464)", callback=validate_uuid)
+@click.option("-ci", "--configuration-id", type=str, envvar='TMS_CONFIGURATION_ID', required=True, help="Set configuration id (15dbb164-c1aa-4cbf-830c-8c01ae14f4fb)", callback=validate_uuid)
+@click.option("-tpi", "--test-plan-id", type=str, envvar='TMS_TEST_PLAN_ID', default=None, help="Create run from test plan (UUID)", callback=validate_uuid)
+@click.option("-f", "--filter", "launch_filter", type=str, default=None, help="TMS filter, e.g. tags=smoke,nightly")
+@click.option("-af", "--autotest-external-ids-file", type=click.Path(exists=True, dir_okay=False, readable=True), default=None, help="File with autotest external IDs (one per line)")
+@click.option("-tn", "--testrun-name", type=str, envvar='TMS_TEST_RUN_NAME', help="Set test run name (TestRun01)", default=None)
+@click.option("-o", "--output", type=str, default=None, help="Optional file path to write test run id")
+@click.option("-d", "--debug", is_flag=True, help="Set debug logs")
+@click.option("-dcv", "--disable-cert-validation", is_flag=True, help="Disables certificate validation")
+def create_launch(url, token, project_id, configuration_id, test_plan_id, launch_filter, autotest_external_ids_file, testrun_name, output, debug, disable_cert_validation):
+    """Create and fill a test run (by plan, tags, or external IDs)"""
+    _require_exactly_one_launch_source(test_plan_id, launch_filter, autotest_external_ids_file)
+    launch_tags = _parse_launch_tags(launch_filter)
+    autotest_external_ids = _load_autotest_external_ids(autotest_external_ids_file)
+
+    config = Config(
+        url=url,
+        token=token,
+        project_id=project_id,
+        configuration_id=configuration_id,
+        test_plan_id=test_plan_id,
+        launch_tags=launch_tags,
+        autotest_external_ids=autotest_external_ids,
+        testrun_name=testrun_name,
+        is_debug=debug,
+        output=output or "",
+        disable_cert_validation=disable_cert_validation,
+    )
+    service = ServiceFactory().get(config)
+    service.launch_test_run()
+
+
 @testrun.command("complete")
 @click.option("-u", "--url", type=str, envvar='TMS_URL', required=True, help="Set url address of the Test IT instance (https://demo.testit.software)", callback=validate_url)
 @click.option("-t", "--token", type=str, envvar='TMS_TOKEN', required=True, help="Set API token (T2lKd2pLZGI4WHRhaVZUejNl)")

testit_cli-2.12.0/src/testit_cli/launch_filter.py

@@ -0,0 +1,57 @@
+"""Parsers for `testrun create launch` filter and autotest external ids file."""
+import typing
+
+
+class LaunchFilterError(ValueError):
+    """Invalid --filter or external ids file content."""
+
+
+def parse_launch_filter(raw: str) -> typing.List[str]:
+    """
+    Parse `--filter tags=tag1,tag2` into a list of tags.
+
+    Only the `tags=` key is supported.
+    """
+    if raw is None:
+        raise LaunchFilterError("Filter value is required")
+
+    value = str(raw).strip()
+    if not value:
+        raise LaunchFilterError("Filter value is empty")
+
+    if "=" not in value:
+        raise LaunchFilterError(
+            f'Unsupported filter "{value}". Expected format: tags=tag1,tag2'
+        )
+
+    key, _, rest = value.partition("=")
+    key = key.strip().lower()
+    if key != "tags":
+        raise LaunchFilterError(
+            f'Unsupported filter key "{key}". Only tags=... is supported'
+        )
+
+    tags = [t.strip() for t in rest.split(",") if t.strip()]
+    if not tags:
+        raise LaunchFilterError("Filter tags=... must list at least one tag")
+    return tags
+
+
+def read_autotest_external_ids_file(path: str) -> typing.List[str]:
+    """
+    Read autotest external IDs from a file: one ID per line.
+    Empty lines and lines starting with # are ignored.
+    """
+    ids: typing.List[str] = []
+    seen = set()
+
+    with open(path, "r", encoding="utf-8") as handle:
+        for line in handle:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#"):
+                continue
+            if stripped not in seen:
+                seen.add(stripped)
+                ids.append(stripped)
+
+    return ids

{testit_cli-2.11.1 → testit_cli-2.12.0}/src/testit_cli/models/config.py

@@ -38,3 +38,6 @@ class Config:
     framework: str = ""
     ignore_flaky_failure: bool = False
     autotest_layer: typing.Optional[str] = None
+    test_plan_id: typing.Optional[str] = None
+    launch_tags: typing.Optional[list[str]] = None
+    autotest_external_ids: typing.Optional[list[str]] = None

{testit_cli-2.11.1 → testit_cli-2.12.0}/src/testit_cli/service.py

@@ -1,6 +1,7 @@
 import logging
 import typing
 
+import click
 from adapters_api.model.assign_attachment_api_model import AssignAttachmentApiModel
 from adapters_api.model.attachment_put_model import AttachmentPutModel
 from .apiclient import ApiClient
@@ -13,6 +14,7 @@ from .models.config import Config
 from .models.testrun import TestRun
 from .parser import Parser
 from .testrun_metadata import merge_links, merge_tags, to_create_link_models, to_update_link_models
+from .v2_client import V2Client
 
 
 class Service:
@@ -22,13 +24,15 @@ class Service:
         api_client: ApiClient,
         parser: Parser,
         importer: Importer,
-        autotests_filter: AutotestsFilter
+        autotests_filter: AutotestsFilter,
+        v2_client: typing.Optional[V2Client] = None,
     ):
         self.__config = config
         self.__api_client = api_client
         self.__parser = parser
         self.__importer = importer
         self.__autotests_filter = autotests_filter
+        self.__v2_client = v2_client
 
     def import_results(self):
         self.__upload_results()
@@ -43,6 +47,49 @@ class Service:
 
         self.__write_to_output(test_run.id)
 
+    def launch_test_run(self) -> None:
+        if self.__v2_client is None:
+            raise RuntimeError("V2Client is required for testrun create launch")
+
+        if self.__config.test_plan_id:
+            work_item_ids = self.__v2_client.search_test_point_work_item_ids(
+                self.__config.test_plan_id,
+                self.__config.configuration_id,
+            )
+            if not work_item_ids:
+                raise ValueError(
+                    "No automated work items found for the given test plan and configuration"
+                )
+            test_run_id = self.__v2_client.create_run_by_work_items(
+                self.__config.project_id,
+                self.__config.test_plan_id,
+                self.__config.configuration_id,
+                work_item_ids,
+                name=self.__config.testrun_name,
+            )
+        else:
+            external_ids = self.__config.autotest_external_ids
+            if external_ids is None and self.__config.launch_tags:
+                external_ids = self.__v2_client.search_autotest_external_ids(
+                    self.__config.project_id,
+                    self.__config.launch_tags,
+                )
+            if not external_ids:
+                raise ValueError(
+                    "No autotest external IDs resolved for launch "
+                    "(empty search result or empty ids file)"
+                )
+            test_run_id = self.__v2_client.create_run_by_auto_tests(
+                self.__config.project_id,
+                self.__config.configuration_id,
+                external_ids,
+                name=self.__config.testrun_name,
+            )
+
+        click.echo(test_run_id)
+        if self.__config.output:
+            self.__write_to_output(test_run_id)
+
     def rerun_test_run(self) -> None:
         self.__api_client.rerun_test_run(
             self.__config.testrun_id,

{testit_cli-2.11.1 → testit_cli-2.12.0}/src/testit_cli/service_factory.py

@@ -5,6 +5,7 @@ from .logger import Logger
 from .models.config import Config
 from .parser import Parser
 from .service import Service
+from .v2_client import V2Client
 
 
 class ServiceFactory:
@@ -13,8 +14,9 @@ class ServiceFactory:
         Logger.register_logger(config.is_debug)
 
         api_client = ApiClient(config.url, config.token, config.disable_cert_validation)
+        v2_client = V2Client(config.url, config.token, config.disable_cert_validation)
         parser = Parser(config)
         importer = Importer(api_client, config)
         autotests_filter = AutotestsFilter(api_client, config)
 
-        return Service(config, api_client, parser, importer, autotests_filter)
+        return Service(config, api_client, parser, importer, autotests_filter, v2_client)

testit_cli-2.12.0/src/testit_cli/v2_client.py

@@ -0,0 +1,207 @@
+"""Thin public v2 API client for testrun create launch (urllib3, no testit-api-client)."""
+import json
+import logging
+import typing
+from urllib.parse import urljoin
+
+import urllib3
+
+from .http_retry import with_http_retries
+
+_PAGE_SIZE = 100
+_LAUNCH_SOURCE = "testit-cli"
+
+
+class V2ApiError(Exception):
+    """Raised when a v2 API call returns a non-success status."""
+
+    def __init__(self, status: int, body: str, path: str):
+        self.status = status
+        self.body = body
+        self.path = path
+        super().__init__(f"v2 {path} failed with HTTP {status}: {body}")
+
+
+class V2Client:
+    """HTTP client for selected /api/v2 endpoints used by `testrun create launch`."""
+
+    def __init__(self, url: str, token: str, disable_cert_validation: bool = False):
+        base = url.rstrip("/") + "/"
+        self.__base_url = base
+        self.__headers = {
+            "Authorization": f"PrivateToken {token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        self.__http = urllib3.PoolManager(
+            cert_reqs="CERT_NONE" if disable_cert_validation else "CERT_REQUIRED",
+        )
+
+    def search_autotest_external_ids(
+        self,
+        project_id: str,
+        tags: typing.List[str],
+    ) -> typing.List[str]:
+        """Paginate POST /api/v2/autoTests/search; return unique externalIds."""
+        filter_body = {
+            "filter": {
+                "projectIds": [project_id],
+                "tags": tags,
+                "isDeleted": False,
+            }
+        }
+        external_ids: typing.List[str] = []
+        seen = set()
+        skip = 0
+
+        while True:
+            page = self.__post_json(
+                "/api/v2/autoTests/search",
+                filter_body,
+                query={"skip": skip, "take": _PAGE_SIZE},
+                label="Search autotests",
+            )
+            if not isinstance(page, list) or not page:
+                break
+            for item in page:
+                external_id = item.get("externalId") if isinstance(item, dict) else None
+                if external_id and external_id not in seen:
+                    seen.add(external_id)
+                    external_ids.append(external_id)
+            if len(page) < _PAGE_SIZE:
+                break
+            skip += _PAGE_SIZE
+
+        logging.info("Found %s autotest external id(s) by tags=%s", len(external_ids), tags)
+        return external_ids
+
+    def search_test_point_work_item_ids(
+        self,
+        test_plan_id: str,
+        configuration_id: str,
+    ) -> typing.List[str]:
+        """Paginate POST /api/v2/testPoints/search; return unique workItemIds."""
+        # Body is TestPointFilterModel fields at the top level (not nested under "filter").
+        filter_body = {
+            "testPlanIds": [test_plan_id],
+            "configurationIds": [configuration_id],
+            "isAutomated": True,
+        }
+        work_item_ids: typing.List[str] = []
+        seen = set()
+        skip = 0
+
+        while True:
+            page = self.__post_json(
+                "/api/v2/testPoints/search",
+                filter_body,
+                query={"skip": skip, "take": _PAGE_SIZE},
+                label="Search test points",
+            )
+            if not isinstance(page, list) or not page:
+                break
+            for item in page:
+                work_item_id = item.get("workItemId") if isinstance(item, dict) else None
+                if work_item_id and work_item_id not in seen:
+                    seen.add(work_item_id)
+                    work_item_ids.append(work_item_id)
+            if len(page) < _PAGE_SIZE:
+                break
+            skip += _PAGE_SIZE
+
+        logging.info(
+            "Found %s work item id(s) for test plan %s / configuration %s",
+            len(work_item_ids),
+            test_plan_id,
+            configuration_id,
+        )
+        return work_item_ids
+
+    def create_run_by_auto_tests(
+        self,
+        project_id: str,
+        configuration_id: str,
+        auto_test_external_ids: typing.List[str],
+        name: typing.Optional[str] = None,
+    ) -> str:
+        """POST /api/v2/testRuns/byAutoTests; return test run id."""
+        body: typing.Dict[str, typing.Any] = {
+            "projectId": project_id,
+            "configurationIds": [configuration_id],
+            "autoTestExternalIds": auto_test_external_ids,
+            "launchSource": _LAUNCH_SOURCE,
+        }
+        if name:
+            body["name"] = name
+
+        result = self.__post_json(
+            "/api/v2/testRuns/byAutoTests",
+            body,
+            label="Create test run by auto tests",
+        )
+        run_id = result.get("id") if isinstance(result, dict) else None
+        if not run_id:
+            raise V2ApiError(200, str(result), "/api/v2/testRuns/byAutoTests")
+        logging.info("Created testrun by auto tests (ID: %s)", run_id)
+        return run_id
+
+    def create_run_by_work_items(
+        self,
+        project_id: str,
+        test_plan_id: str,
+        configuration_id: str,
+        work_item_ids: typing.List[str],
+        name: typing.Optional[str] = None,
+    ) -> str:
+        """POST /api/v2/testRuns/byWorkItems; return test run id."""
+        body: typing.Dict[str, typing.Any] = {
+            "projectId": project_id,
+            "testPlanId": test_plan_id,
+            "configurationIds": [configuration_id],
+            "workItemIds": work_item_ids,
+            "launchSource": _LAUNCH_SOURCE,
+        }
+        if name:
+            body["name"] = name
+
+        result = self.__post_json(
+            "/api/v2/testRuns/byWorkItems",
+            body,
+            label="Create test run by work items",
+        )
+        run_id = result.get("id") if isinstance(result, dict) else None
+        if not run_id:
+            raise V2ApiError(200, str(result), "/api/v2/testRuns/byWorkItems")
+        logging.info("Created testrun by work items (ID: %s)", run_id)
+        return run_id
+
+    def __post_json(
+        self,
+        path: str,
+        body: typing.Dict[str, typing.Any],
+        query: typing.Optional[typing.Dict[str, typing.Any]] = None,
+        label: str = "v2 request",
+    ) -> typing.Any:
+        url = urljoin(self.__base_url, path.lstrip("/"))
+        if query:
+            qs = "&".join(f"{k}={v}" for k, v in query.items())
+            url = f"{url}?{qs}"
+
+        encoded = json.dumps(body).encode("utf-8")
+        logging.debug("%s POST %s body=%s", label, url, body)
+
+        def _do_request():
+            response = self.__http.request(
+                "POST",
+                url,
+                body=encoded,
+                headers=self.__headers,
+            )
+            raw = response.data.decode("utf-8") if response.data else ""
+            if response.status < 200 or response.status >= 300:
+                raise V2ApiError(response.status, raw, path)
+            if not raw:
+                return None
+            return json.loads(raw)
+
+        return with_http_retries(_do_request, label=label)

{testit_cli-2.11.1 → testit_cli-2.12.0}/src/testit_cli/validation.py

@@ -27,3 +27,10 @@ def validate_url(ctx, param, value):
         return value[:-1]
 
     return value
+
+
+def validate_url_optional(ctx, param, value):
+    """Like validate_url, but allows missing value (optional group options)."""
+    if value is None:
+        return value
+    return validate_url(ctx, param, value)