trcli 1.13.3__tar.gz → 1.13.4__tar.gz

{trcli-1.13.3 → trcli-1.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcli
-Version: 1.13.3
+Version: 1.13.4
 License-File: LICENSE.md
 Requires-Dist: click<8.2.2,>=8.1.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0

{trcli-1.13.3 → trcli-1.13.4}/README.md

@@ -33,7 +33,7 @@ trcli
 ```
 You should get something like this:
 ```
-TestRail CLI v1.13.3
+TestRail CLI v1.13.4
 Copyright 2025 Gurock Software GmbH - www.gurock.com
 Supported and loaded modules:
     - parse_junit: JUnit XML Files (& Similar)
@@ -51,7 +51,7 @@ CLI general reference
 --------
 ```shell
 $ trcli --help
-TestRail CLI v1.13.3
+TestRail CLI v1.13.4
 Copyright 2025 Gurock Software GmbH - www.gurock.com
 Usage: trcli [OPTIONS] COMMAND [ARGS]...
 
@@ -196,7 +196,7 @@ For further detail, please refer to the
 
 ### Using Glob Patterns for Multiple Files
 
-TRCLI supports glob patterns to process multiple report files in a single command. This feature is available for **JUnit XML** and **Cucumber JSON** parsers.
+TRCLI supports glob patterns to process multiple report files in a single command. This feature is available for **JUnit XML**, **Robot Framework**, and **Cucumber JSON** parsers.
 
 #### Important: Shell Quoting Requirement
 
@@ -239,6 +239,7 @@ When a glob pattern matches **multiple files**, TRCLI automatically:
 3. **Merges test results** into a single combined report
 4. **Writes merged file** to current directory:
    - JUnit: `Merged-JUnit-report.xml`
+   - Robot Framework: `Merged-Robot-report.xml`
    - Cucumber: `merged_cucumber.json`
 5. **Processes the merged file** as a single test run upload
 
@@ -263,6 +264,23 @@ trcli parse_junit \
   --case-matcher auto
 ```
 
+**Robot Framework - Multiple output files:**
+```bash
+# Merge multiple Robot Framework test runs
+trcli -y \
+  -h https://example.testrail.com \
+  --project "My Project" \
+  parse_robot \
+  -f "reports/robot-*.xml" \
+  --title "Merged Robot Tests"
+
+# Recursive search for all Robot outputs
+trcli parse_robot \
+  -f "test-results/**/output.xml" \
+  --title "All Robot Results" \
+  --case-matcher property
+```
+
 **Cucumber JSON - Multiple test runs:**
 ```bash
 # Merge multiple Cucumber JSON reports
@@ -1623,7 +1641,7 @@ Options:
 ### Reference
 ```shell
 $ trcli add_run --help
-TestRail CLI v1.13.3
+TestRail CLI v1.13.4
 Copyright 2025 Gurock Software GmbH - www.gurock.com
 Usage: trcli add_run [OPTIONS]
 
@@ -1640,6 +1658,8 @@ Options:
   --run-end-date         The expected or scheduled end date of this test run in MM/DD/YYYY format
   --run-assigned-to-id   The ID of the user the test run should be assigned
                          to.  [x>=1]
+  --clear-run-assigned-to-id  Clear the assignee of the test run (only valid
+                         when updating with --run-id).
   --run-include-all      Use this option to include all test cases in this test run.
   --auto-close-run       Use this option to automatically close the created run.
   --run-case-ids         Comma separated list of test case IDs to include in
@@ -1712,6 +1732,39 @@ trcli -y -h https://example.testrail.io/ --project "My Project" \
 - **Action Requirements**: `update` and `delete` actions require an existing run (--run-id must be provided)
 - **Validation**: Invalid reference formats are rejected with clear error messages
 
+### Managing Assignees in Test Runs
+
+The `add_run` command supports comprehensive assignee management for test runs. You can assign runs to users when creating or updating them, and clear assignees when needed.
+
+#### Assigning Runs to Users
+
+When creating a new test run or updating an existing one, you can assign it to a user using the `--run-assigned-to-id` option:
+
+```bash
+# Create a new run and assign to user ID 5
+trcli -y -h https://example.testrail.io/ --project "My Project" \
+  add_run --title "My Test Run" --run-assigned-to-id 5
+
+# Update an existing run and change the assignee
+trcli -y -h https://example.testrail.io/ --project "My Project" \
+  add_run --run-id 123 --title "My Test Run" --run-assigned-to-id 10
+```
+
+#### Clearing Assignees from Test Runs
+
+To remove the assignee from an existing test run, use the `--clear-run-assigned-to-id` flag:
+
+```bash
+# Clear the assignee from an existing run
+trcli -y -h https://example.testrail.io/ --project "My Project" \
+  add_run --run-id 123 --title "My Test Run" --clear-run-assigned-to-id
+```
+
+#### Assignee Management Rules
+
+- **Update Mode Only**: The `--clear-run-assigned-to-id` flag can only be used when updating an existing run (requires `--run-id`)
+- **Mutually Exclusive**: You cannot use both `--run-assigned-to-id` and `--clear-run-assigned-to-id` in the same command
+
 #### Examples
 
 **Complete Workflow Example:**
@@ -1747,7 +1800,7 @@ providing you with a solid base of test cases, which you can further expand on T
 ### Reference
 ```shell
 $ trcli parse_openapi --help
-TestRail CLI v1.13.3
+TestRail CLI v1.13.4
 Copyright 2025 Gurock Software GmbH - www.gurock.com
 Usage: trcli parse_openapi [OPTIONS]
 

{trcli-1.13.3 → trcli-1.13.4}/tests/test_cmd_add_run.py

@@ -42,9 +42,11 @@ class TestCmdAddRun:
         environment.run_assigned_to_id = assigned_to_id
         environment.run_case_ids = case_ids
         environment.run_include_all = True
-        expected_string = (f"run_assigned_to_id: {assigned_to_id}\nrun_case_ids: '{case_ids}'\n"
-                           f"run_description: {description}\nrun_id: {run_id}\n"
-                           f"run_include_all: true\nrun_refs: {refs}\ntitle: {title}\n")
+        expected_string = (
+            f"run_assigned_to_id: {assigned_to_id}\nrun_case_ids: '{case_ids}'\n"
+            f"run_description: {description}\nrun_id: {run_id}\n"
+            f"run_include_all: true\nrun_refs: {refs}\ntitle: {title}\n"
+        )
         cmd_add_run.write_run_to_file(environment, run_id)
         mock_open_file.assert_called_with(file, "a")
         mock_open_file.return_value.__enter__().write.assert_called_once_with(expected_string)
@@ -52,35 +54,31 @@ class TestCmdAddRun:
     def test_cli_validation_refs_too_long(self):
         """Test that references validation fails when exceeding 250 characters"""
         from trcli.cli import Environment
-        
+
         environment = Environment()
         environment.run_refs = "A" * 251  # 251 characters, exceeds limit
-        
+
         assert len(environment.run_refs) > 250
-        
+
         runner = CliRunner()
         long_refs = "A" * 251
-        
-        result = runner.invoke(cmd_add_run.cli, [
-            '--title', 'Test Run',
-            '--run-refs', long_refs
-        ], catch_exceptions=False)
-        
+
+        result = runner.invoke(
+            cmd_add_run.cli, ["--title", "Test Run", "--run-refs", long_refs], catch_exceptions=False
+        )
+
         # Should exit with error code 1 due to missing required parameters or validation
         assert result.exit_code == 1
 
     def test_cli_validation_refs_exactly_250_chars(self):
         """Test that references validation passes with exactly 250 characters"""
         from trcli.cli import Environment
-        
+
         runner = CliRunner()
         refs_250 = "A" * 250  # Exactly 250 characters, should pass validation
-        
-        result = runner.invoke(cmd_add_run.cli, [
-            '--title', 'Test Run',
-            '--run-refs', refs_250
-        ], catch_exceptions=False)
-        
+
+        result = runner.invoke(cmd_add_run.cli, ["--title", "Test Run", "--run-refs", refs_250], catch_exceptions=False)
+
         # Should not fail due to refs validation (will fail due to missing required parameters)
         # But the important thing is that it doesn't fail with the character limit error
         assert "References field cannot exceed 250 characters" not in result.output
@@ -88,18 +86,18 @@ class TestCmdAddRun:
     def test_validation_logic_refs_action_without_run_id(self):
         """Test validation logic for refs action without run_id"""
         from trcli.cli import Environment
-        
+
         # Update action validation
         environment = Environment()
         environment.run_refs_action = "update"
         environment.run_id = None
         environment.run_refs = "JIRA-123"
-        
+
         # This should be invalid
         assert environment.run_refs_action == "update"
         assert environment.run_id is None
-        
-        # Delete action validation  
+
+        # Delete action validation
         environment.run_refs_action = "delete"
         assert environment.run_refs_action == "delete"
         assert environment.run_id is None
@@ -107,37 +105,72 @@ class TestCmdAddRun:
     def test_refs_action_parameter_parsing(self):
         """Test that refs action parameter is parsed correctly"""
         runner = CliRunner()
-        
+
         # Test that the CLI accepts new param without crashing! :) - acuanico
-        result = runner.invoke(cmd_add_run.cli, ['--help'])
+        result = runner.invoke(cmd_add_run.cli, ["--help"])
         assert result.exit_code == 0
         assert "--run-refs-action" in result.output
         assert "Action to perform on references" in result.output
 
+    def test_clear_assigned_to_id_parameter_exists(self):
+        """Test that --clear-run-assigned-to-id parameter is available"""
+        runner = CliRunner()
+
+        result = runner.invoke(cmd_add_run.cli, ["--help"])
+        assert result.exit_code == 0
+        assert "--clear-run-assigned-to-id" in result.output
+        assert "Clear the assignee" in result.output
+
+    @mock.patch("trcli.cli.Environment.check_for_required_parameters")
+    def test_clear_assigned_to_id_requires_run_id(self, mock_check):
+        """Test that --clear-run-assigned-to-id requires --run-id"""
+        runner = CliRunner()
+
+        result = runner.invoke(cmd_add_run.cli, ["--title", "Test Run", "--clear-run-assigned-to-id"])
+
+        assert result.exit_code == 1
+        assert (
+            "--clear-run-assigned-to-id can only be used when updating" in result.output
+            or "--run-id required" in result.output
+        )
+
+    @mock.patch("trcli.cli.Environment.check_for_required_parameters")
+    def test_clear_assigned_to_id_mutually_exclusive_with_assigned_to_id(self, mock_check):
+        """Test that --clear-run-assigned-to-id and --run-assigned-to-id are mutually exclusive"""
+        runner = CliRunner()
+
+        result = runner.invoke(
+            cmd_add_run.cli,
+            ["--title", "Test Run", "--run-id", "123", "--run-assigned-to-id", "42", "--clear-run-assigned-to-id"],
+        )
+
+        assert result.exit_code == 1
+        assert "cannot be used together" in result.output
+
 
 class TestApiRequestHandlerReferences:
     """Test class for reference management functionality"""
-    
+
     def test_manage_references_add(self):
         """Test adding references to existing ones"""
         from trcli.api.api_request_handler import ApiRequestHandler
         from trcli.cli import Environment
         from trcli.api.api_client import APIClient
         from trcli.data_classes.dataclass_testrail import TestRailSuite
-        
+
         environment = Environment()
         api_client = APIClient("https://test.testrail.com")
         suite = TestRailSuite(name="Test Suite")
         handler = ApiRequestHandler(environment, api_client, suite)
-        
+
         # Adding new references
         result = handler._manage_references("JIRA-100,JIRA-200", "JIRA-300,JIRA-400", "add")
         assert result == "JIRA-100,JIRA-200,JIRA-300,JIRA-400"
-        
+
         # Adding duplicate references (should not duplicate)
         result = handler._manage_references("JIRA-100,JIRA-200", "JIRA-200,JIRA-300", "add")
         assert result == "JIRA-100,JIRA-200,JIRA-300"
-        
+
         # Adding to empty existing references
         result = handler._manage_references("", "JIRA-100,JIRA-200", "add")
         assert result == "JIRA-100,JIRA-200"
@@ -148,16 +181,16 @@ class TestApiRequestHandlerReferences:
         from trcli.cli import Environment
         from trcli.api.api_client import APIClient
         from trcli.data_classes.dataclass_testrail import TestRailSuite
-        
+
         environment = Environment()
         api_client = APIClient("https://test.testrail.com")
         suite = TestRailSuite(name="Test Suite")
         handler = ApiRequestHandler(environment, api_client, suite)
-        
+
         # Test replacing all references
         result = handler._manage_references("JIRA-100,JIRA-200", "JIRA-300,JIRA-400", "update")
         assert result == "JIRA-300,JIRA-400"
-        
+
         # Test replacing with empty references
         result = handler._manage_references("JIRA-100,JIRA-200", "", "update")
         assert result == ""
@@ -168,24 +201,24 @@ class TestApiRequestHandlerReferences:
         from trcli.cli import Environment
         from trcli.api.api_client import APIClient
         from trcli.data_classes.dataclass_testrail import TestRailSuite
-        
+
         environment = Environment()
         api_client = APIClient("https://test.testrail.com")
         suite = TestRailSuite(name="Test Suite")
         handler = ApiRequestHandler(environment, api_client, suite)
-        
+
         # Deleting specific references
         result = handler._manage_references("JIRA-100,JIRA-200,JIRA-300", "JIRA-200", "delete")
         assert result == "JIRA-100,JIRA-300"
-        
+
         # Deleting multiple specific references
         result = handler._manage_references("JIRA-100,JIRA-200,JIRA-300,JIRA-400", "JIRA-200,JIRA-400", "delete")
         assert result == "JIRA-100,JIRA-300"
-        
+
         # Deleting all references (empty new_refs)
         result = handler._manage_references("JIRA-100,JIRA-200", "", "delete")
         assert result == ""
-        
+
         # Deleting non-existent references
         result = handler._manage_references("JIRA-100,JIRA-200", "JIRA-999", "delete")
         assert result == "JIRA-100,JIRA-200"

{trcli-1.13.3 → trcli-1.13.4}/tests/test_glob_integration.py

@@ -146,6 +146,37 @@ class TestGlobIntegration:
         if merged_file.exists():
             merged_file.unlink()
 
+    @pytest.mark.parse_robot
+    def test_glob_robot_duplicate_automation_ids(self):
+        """Test Robot Framework glob pattern with duplicate automation_ids."""
+        env = Environment()
+        env.case_matcher = MatchersParser.AUTO
+        env.file = Path(__file__).parent / "test_data/XML/testglob_robot/*.xml"
+
+        # Check if test files exist
+        if not list(Path(__file__).parent.glob("test_data/XML/testglob_robot/*.xml")):
+            pytest.skip("Robot test data not available")
+
+        parser = RobotParser(env)
+        parsed_suites = parser.parse_file()
+        suite = parsed_suites[0]
+
+        # Similar verification as JUnit tests
+        data_provider = ApiDataProvider(suite)
+        cases_to_add = data_provider.add_cases()
+
+        # Verify deduplication occurred if there were duplicates
+        total_cases = sum(len(section.testcases) for section in suite.testsections)
+        automation_ids = [c.custom_automation_id for c in cases_to_add if c.custom_automation_id]
+
+        # Cases to add should have unique automation_ids
+        assert len(automation_ids) == len(set(automation_ids)), "Cases to add should have unique automation_ids"
+
+        # Clean up merged file
+        merged_file = Path.cwd() / "Merged-Robot-report.xml"
+        if merged_file.exists():
+            merged_file.unlink()
+
     @pytest.mark.parse_cucumber
     def test_cucumber_glob_filepath_not_pattern(self):
         """Test Scenario 3: Cucumber glob pattern uses correct filepath (not pattern string).

trcli-1.13.4/tests/test_robot_parser.py

@@ -0,0 +1,186 @@
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Union
+
+import pytest
+from deepdiff import DeepDiff
+
+from trcli.cli import Environment
+from trcli.data_classes.data_parsers import MatchersParser
+from trcli.data_classes.dataclass_testrail import TestRailSuite
+from trcli.readers.robot_xml import RobotParser
+
+
+class TestRobotParser:
+
+    @pytest.mark.parse_robot
+    @pytest.mark.parametrize(
+        "matcher, input_xml_path, expected_path",
+        [
+            # RF 5.0 format
+            (
+                MatchersParser.AUTO,
+                Path(__file__).parent / "test_data/XML/robotframework_simple_RF50.xml",
+                Path(__file__).parent / "test_data/json/robotframework_simple_RF50.json",
+            ),
+            (
+                MatchersParser.NAME,
+                Path(__file__).parent / "test_data/XML/robotframework_id_in_name_RF50.xml",
+                Path(__file__).parent / "test_data/json/robotframework_id_in_name_RF50.json",
+            ),
+            # RF 7.0 format
+            (
+                MatchersParser.AUTO,
+                Path(__file__).parent / "test_data/XML/robotframework_simple_RF70.xml",
+                Path(__file__).parent / "test_data/json/robotframework_simple_RF70.json",
+            ),
+            (
+                MatchersParser.NAME,
+                Path(__file__).parent / "test_data/XML/robotframework_id_in_name_RF70.xml",
+                Path(__file__).parent / "test_data/json/robotframework_id_in_name_RF70.json",
+            ),
+        ],
+        ids=["Case Matcher Auto", "Case Matcher Name", "Case Matcher Auto", "Case Matcher Name"],
+    )
+    @pytest.mark.parse_robot
+    def test_robot_xml_parser_id_matcher_name(
+        self, matcher: str, input_xml_path: Union[str, Path], expected_path: str, freezer
+    ):
+        freezer.move_to("2020-05-20 01:00:00")
+        env = Environment()
+        env.case_matcher = matcher
+        env.file = input_xml_path
+        file_reader = RobotParser(env)
+        read_junit = self.__clear_unparsable_junit_elements(file_reader.parse_file()[0])
+        parsing_result_json = asdict(read_junit)
+        file_json = open(expected_path)
+        expected_json = json.load(file_json)
+        assert (
+            DeepDiff(parsing_result_json, expected_json) == {}
+        ), f"Result of parsing XML is different than expected \n{DeepDiff(parsing_result_json, expected_json)}"
+
+    def __clear_unparsable_junit_elements(self, test_rail_suite: TestRailSuite) -> TestRailSuite:
+        """helper method to delete temporary junit_case_refs attribute,
+        which asdict() method of dataclass can't handle"""
+        for section in test_rail_suite.testsections:
+            for case in section.testcases:
+                # Remove temporary junit_case_refs attribute if it exists
+                if hasattr(case, "_junit_case_refs"):
+                    delattr(case, "_junit_case_refs")
+        return test_rail_suite
+
+    @pytest.mark.parse_robot
+    def test_robot_xml_parser_file_not_found(self):
+        with pytest.raises(FileNotFoundError):
+            env = Environment()
+            env.file = Path(__file__).parent / "not_found.xml"
+            RobotParser(env)
+
+    @pytest.mark.parse_robot
+    def test_robot_xml_parser_glob_pattern_single_file(self):
+        """Test glob pattern that matches single file"""
+        env = Environment()
+        env.case_matcher = MatchersParser.AUTO
+        # Use glob pattern that matches only one file
+        env.file = Path(__file__).parent / "test_data/XML/robotframework_simple_RF50.xml"
+
+        # This should work just like a regular file path
+        file_reader = RobotParser(env)
+        result = file_reader.parse_file()
+
+        assert len(result) == 1
+        assert isinstance(result[0], TestRailSuite)
+        # Verify it has test sections and cases
+        assert len(result[0].testsections) > 0
+
+    @pytest.mark.parse_robot
+    def test_robot_xml_parser_glob_pattern_multiple_files(self):
+        """Test glob pattern that matches multiple files and merges them"""
+        env = Environment()
+        env.case_matcher = MatchersParser.AUTO
+        # Use glob pattern that matches multiple Robot XML files
+        env.file = Path(__file__).parent / "test_data/XML/testglob_robot/*.xml"
+
+        file_reader = RobotParser(env)
+        result = file_reader.parse_file()
+
+        # Should return a merged result
+        assert len(result) == 1
+        assert isinstance(result[0], TestRailSuite)
+
+        # Verify merged file was created
+        merged_file = Path.cwd() / "Merged-Robot-report.xml"
+        assert merged_file.exists(), "Merged Robot report should be created"
+
+        # Verify the merged result contains test cases from both files
+        total_cases = sum(len(section.testcases) for section in result[0].testsections)
+        assert total_cases > 0, "Merged result should contain test cases"
+
+        # Clean up merged file
+        if merged_file.exists():
+            merged_file.unlink()
+
+    @pytest.mark.parse_robot
+    def test_robot_xml_parser_glob_pattern_no_matches(self):
+        """Test glob pattern that matches no files"""
+        with pytest.raises(FileNotFoundError):
+            env = Environment()
+            env.case_matcher = MatchersParser.AUTO
+            # Use glob pattern that matches no files
+            env.file = Path(__file__).parent / "test_data/XML/nonexistent_*.xml"
+            RobotParser(env)
+
+    @pytest.mark.parse_robot
+    def test_robot_check_file_glob_returns_path(self):
+        """Test that check_file method returns valid Path for glob pattern"""
+        # Test single file match
+        single_file_glob = Path(__file__).parent / "test_data/XML/robotframework_simple_RF50.xml"
+        result = RobotParser.check_file(single_file_glob)
+        assert isinstance(result, Path)
+        assert result.exists()
+
+        # Test multiple file match (returns merged file path)
+        multi_file_glob = Path(__file__).parent / "test_data/XML/testglob_robot/*.xml"
+        result = RobotParser.check_file(multi_file_glob)
+        assert isinstance(result, Path)
+        assert result.name == "Merged-Robot-report.xml"
+        assert result.exists()
+
+        # Clean up
+        if result.exists() and result.name == "Merged-Robot-report.xml":
+            result.unlink()
+
+    @pytest.mark.parse_robot
+    def test_robot_xml_parser_glob_merges_duplicate_sections(self):
+        """Test that glob pattern merging handles duplicate section names correctly.
+
+        When multiple Robot XML files have the same suite structure, sections with
+        the same name should be merged into one section with all test cases combined.
+        This prevents the "Section duplicates detected" error.
+        """
+        env = Environment()
+        env.case_matcher = MatchersParser.AUTO
+        env.file = Path(__file__).parent / "test_data/XML/testglob_robot/*.xml"
+
+        file_reader = RobotParser(env)
+        result = file_reader.parse_file()
+
+        assert len(result) == 1
+        suite = result[0]
+
+        # Verify no duplicate section names
+        section_names = [section.name for section in suite.testsections]
+        unique_section_names = set(section_names)
+
+        assert len(section_names) == len(unique_section_names), f"Duplicate section names detected: {section_names}"
+
+        # Verify sections have combined test cases from both files
+        # Both robot-1.xml and robot-2.xml have same structure, so sections should have tests from both
+        total_cases = sum(len(section.testcases) for section in suite.testsections)
+        assert total_cases > 4, "Sections should contain test cases from both merged files"
+
+        # Clean up merged file
+        merged_file = Path.cwd() / "Merged-Robot-report.xml"
+        if merged_file.exists():
+            merged_file.unlink()

trcli-1.13.4/trcli/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.13.4"

{trcli-1.13.3 → trcli-1.13.4}/trcli/api/api_request_handler.py

@@ -256,8 +256,11 @@ class ApiRequestHandler:
         milestone_id: int = None,
         refs: str = None,
         refs_action: str = "add",
+        assigned_to_id: Union[int, None] = ...,
     ) -> Tuple[dict, str]:
-        return self.run_handler.update_run(run_id, run_name, start_date, end_date, milestone_id, refs, refs_action)
+        return self.run_handler.update_run(
+            run_id, run_name, start_date, end_date, milestone_id, refs, refs_action, assigned_to_id
+        )
 
     def _manage_references(self, existing_refs: str, new_refs: str, action: str) -> str:
         return self.run_handler._manage_references(existing_refs, new_refs, action)

{trcli-1.13.3 → trcli-1.13.4}/trcli/api/project_based_client.py

@@ -213,6 +213,15 @@ class ProjectBasedClient:
         else:
             self.environment.log(f"Updating test run. ", new_line=False)
             run_id = self.environment.run_id
+
+            # Determine assigned_to_id value based on flags
+            if hasattr(self.environment, "clear_run_assigned_to_id") and self.environment.clear_run_assigned_to_id:
+                assigned_to_id = None  # Clear the assignee
+            elif self.environment.run_assigned_to_id:
+                assigned_to_id = self.environment.run_assigned_to_id  # Set new assignee
+            else:
+                assigned_to_id = ...  # Don't change (sentinel value)
+
             run, error_message = self.api_request_handler.update_run(
                 run_id,
                 self.run_name,
@@ -221,6 +230,7 @@ class ProjectBasedClient:
                 milestone_id=self.environment.milestone_id,
                 refs=self.environment.run_refs,
                 refs_action=getattr(self.environment, "run_refs_action", "add"),
+                assigned_to_id=assigned_to_id,
             )
         if self.environment.auto_close_run:
             self.environment.log("Closing run. ", new_line=False)

{trcli-1.13.3 → trcli-1.13.4}/trcli/api/run_handler.py

@@ -8,7 +8,7 @@ It manages all test run operations including:
 - Closing and deleting runs
 """
 
-from beartype.typing import List, Tuple, Dict
+from beartype.typing import List, Tuple, Dict, Union
 
 from trcli.api.api_client import APIClient
 from trcli.api.api_utils import (
@@ -89,8 +89,14 @@ class RunHandler:
         )
 
         # Validate that we have test cases to include in the run
-        # Empty runs are not allowed unless include_all is True
-        if not include_all and (not add_run_data.get("case_ids") or len(add_run_data["case_ids"]) == 0):
+        # Empty runs are not allowed for parse commands unless include_all is True
+        # However, add_run command explicitly allows empty runs for later result uploads
+        is_add_run_command = self.environment.cmd == "add_run"
+        if (
+            not is_add_run_command
+            and not include_all
+            and (not add_run_data.get("case_ids") or len(add_run_data["case_ids"]) == 0)
+        ):
             error_msg = (
                 "Cannot create test run: No test cases were matched.\n"
                 "  - For parse_junit: Ensure tests have automation_id/test ids that matches existing cases in TestRail\n"
@@ -129,6 +135,7 @@ class RunHandler:
         milestone_id: int = None,
         refs: str = None,
         refs_action: str = "add",
+        assigned_to_id: Union[int, None] = ...,
     ) -> Tuple[dict, str]:
         """
         Updates an existing run
@@ -136,10 +143,11 @@ class RunHandler:
         :param run_id: run id
         :param run_name: run name
         :param start_date: start date
-        :param end_date: end date
+        :param end_date: end_date: end date
         :param milestone_id: milestone id
         :param refs: references to manage
         :param refs_action: action to perform ('add', 'update', 'delete')
+        :param assigned_to_id: user ID to assign (int), None to clear, or ... to leave unchanged
         :returns: Tuple with run and error string.
         """
         run_response = self.client.send_get(f"get_run/{run_id}")
@@ -161,6 +169,11 @@ class RunHandler:
         else:
             add_run_data["refs"] = existing_refs  # Keep existing refs if none provided
 
+        # Handle assigned_to_id - only add to payload if explicitly provided
+        if assigned_to_id is not ...:
+            add_run_data["assignedto_id"] = assigned_to_id  # Can be None (clears) or int (sets)
+        # else: Don't include assignedto_id in payload (no change to existing assignee)
+
         existing_include_all = run_response.response_text.get("include_all", False)
         add_run_data["include_all"] = existing_include_all