pytest-testkit 1.0.0__tar.gz → 1.0.1__tar.gz

{pytest_testkit-1.0.0/pytest_testkit.egg-info → pytest_testkit-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest_testkit
-Version: 1.0.0
+Version: 1.0.1
 Summary: Pytest plugin for Infra logging framework and environment management
 Author: Huawei
 License: MIT License
@@ -430,6 +430,49 @@ pytest --quiet-stdout --testbed=testbed.json testcase/
 quiet_stdout = true
 ```
 
+### CI 运行元数据（ci_env_info）
+
+执行器（pytest-executor）在调度用例时，会把 CI 流水线的运行元数据序列化成**单个**
+`ci_env_info` 环境变量注入用例进程，覆盖 runner / remote / local 三种执行模式。
+用例侧统一通过读取该环境变量获取当前流水线上下文，无需关心运行在哪种模式。
+
+#### 字段说明
+
+环境变量 `ci_env_info` 的值是一个 JSON 字符串，固定包含以下白名单字段（值均为字符串）：
+
+| 字段名          | 含义               | 示例                |
+|:-------------|:-----------------|:------------------|
+| project_name | CI 项目名称          | "openlibing/demo" |
+| workflow_name| 工作流名称            | "nightly"         |
+| job_name     | 任务（job）名称       | "run-pytest"      |
+| run_number   | 流水线运行序号          | "128"             |
+| step_name    | 当前步骤名称           | "pytest-orch"     |
+
+#### 读取方式
+
+```python
+import json
+import os
+
+def test_use_ci_metadata():
+    raw = os.environ.get("ci_env_info", "")
+    info = json.loads(raw) if raw else {}
+    job_name = info.get("job_name", "")
+    run_number = info.get("run_number", "")
+    # 例如按流水线序号归档产物、按 job 名分支断言逻辑
+    assert isinstance(job_name, str)
+```
+
+#### 取值约定
+
+- **白名单字段恒在**：无论入参是否提供，解析后的 JSON 一定包含上表 5 个字段，缺省值为 `""`。
+- **值经过清洗**：单个字段值会剔除 NUL、换行等控制字符，并按 128 字符截断；
+  非字符串标量（如数字）转为字符串，非标量（字典/列表）降级为 `""`。
+- **非法输入不阻断用例**：入参结构不合法、缺失或类型错误时一律降级为空串并告警，
+  不会中断用例调度；未注入时 `ci_env_info` 为 `""`。
+- **纯 ASCII 安全**：JSON 以 `ensure_ascii` 序列化，含中文等非 ASCII 值时以 `\uXXXX`
+  转义，避免经 SSH 传输后乱码。
+- 该变量由执行器注入，本地直接 `pytest` 调试时通常为空，用例代码应对空值做好兜底。
 
 ### 支持的 fixture
 

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/README.md

@@ -372,6 +372,49 @@ pytest --quiet-stdout --testbed=testbed.json testcase/
 quiet_stdout = true
 ```
 
+### CI 运行元数据（ci_env_info）
+
+执行器（pytest-executor）在调度用例时，会把 CI 流水线的运行元数据序列化成**单个**
+`ci_env_info` 环境变量注入用例进程，覆盖 runner / remote / local 三种执行模式。
+用例侧统一通过读取该环境变量获取当前流水线上下文，无需关心运行在哪种模式。
+
+#### 字段说明
+
+环境变量 `ci_env_info` 的值是一个 JSON 字符串，固定包含以下白名单字段（值均为字符串）：
+
+| 字段名          | 含义               | 示例                |
+|:-------------|:-----------------|:------------------|
+| project_name | CI 项目名称          | "openlibing/demo" |
+| workflow_name| 工作流名称            | "nightly"         |
+| job_name     | 任务（job）名称       | "run-pytest"      |
+| run_number   | 流水线运行序号          | "128"             |
+| step_name    | 当前步骤名称           | "pytest-orch"     |
+
+#### 读取方式
+
+```python
+import json
+import os
+
+def test_use_ci_metadata():
+    raw = os.environ.get("ci_env_info", "")
+    info = json.loads(raw) if raw else {}
+    job_name = info.get("job_name", "")
+    run_number = info.get("run_number", "")
+    # 例如按流水线序号归档产物、按 job 名分支断言逻辑
+    assert isinstance(job_name, str)
+```
+
+#### 取值约定
+
+- **白名单字段恒在**：无论入参是否提供，解析后的 JSON 一定包含上表 5 个字段，缺省值为 `""`。
+- **值经过清洗**：单个字段值会剔除 NUL、换行等控制字符，并按 128 字符截断；
+  非字符串标量（如数字）转为字符串，非标量（字典/列表）降级为 `""`。
+- **非法输入不阻断用例**：入参结构不合法、缺失或类型错误时一律降级为空串并告警，
+  不会中断用例调度；未注入时 `ci_env_info` 为 `""`。
+- **纯 ASCII 安全**：JSON 以 `ensure_ascii` 序列化，含中文等非 ASCII 值时以 `\uXXXX`
+  转义，避免经 SSH 传输后乱码。
+- 该变量由执行器注入，本地直接 `pytest` 调试时通常为空，用例代码应对空值做好兜底。
 
 ### 支持的 fixture
 

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytest_testkit"
-version = "1.0.0"
+version = "1.0.1"
 description = "Pytest plugin for Infra logging framework and environment management"
 readme = "README.md"
 license = { file = "LICENSE" }

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/pytest_testkit/lib/base/ssh.py

@@ -245,8 +245,8 @@ class Ssh:
         stdin, stdout, stderr = self.target_client.exec_command(
             cmd_prefix, timeout=param.timeout, environment=param.environment
         )
-        stdout_content = stdout.read().decode("utf-8").strip()
-        stderr_content = stderr.read().decode("utf-8").strip()
+        stdout_content = stdout.read().decode("utf-8", errors="replace").strip()
+        stderr_content = stderr.read().decode("utf-8", errors="replace").strip()
         exit_code = stdout.channel.recv_exit_status()
         self.logger.debug(
             f"[Ssh._jump_exec_command] executed: {cmd}, exit_code={exit_code}"
@@ -394,7 +394,7 @@ class Ssh:
                     while (
                         channel.recv_ready() and recv_iterations < max_recv_iterations
                     ):
-                        chunk = channel.recv(4096).decode("utf-8")
+                        chunk = channel.recv(4096).decode("utf-8", errors="replace")
                         if not chunk:
                             break  # recv返回空数据，防止死循环
                         echo_output += chunk
@@ -505,8 +505,8 @@ class Ssh:
         stdin, stdout, stderr = self.client.exec_command(
             cmd_prefix, timeout=param.timeout, environment=param.environment
         )
-        stdout_content = stdout.read().decode("utf-8").strip()
-        stderr_content = stderr.read().decode("utf-8").strip()
+        stdout_content = stdout.read().decode("utf-8", errors="replace").strip()
+        stderr_content = stderr.read().decode("utf-8", errors="replace").strip()
         exit_code = stdout.channel.recv_exit_status()
         self.logger.debug(
             f"[Ssh._direct_exec_cmd] executed: {cmd}, exit_code={exit_code}"

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/pytest_testkit/lib/common/environment/device.py

@@ -647,8 +647,9 @@ class Device:
         if isinstance(timeout, str):
             timeout = int(timeout)
 
-        # 第 1 行: 总是打印执行的命令
-        logger.info(f"[Device.sendcmd] $ {LogColor.CYAN}{cmd}{LogColor.RESET}")
+        # 第 1 行: 默认打印执行的命令, 受 echo_output 和 _SESSION_QUIET_STDOUT 控制
+        if echo_output and not _SESSION_QUIET_STDOUT:
+            logger.info(f"[Device.sendcmd] $ {LogColor.CYAN}{cmd}{LogColor.RESET}")
 
         if self.local_exec:
             logger.debug(f"[Device.sendcmd] local_exec=True, executing locally: {cmd}")
@@ -708,14 +709,17 @@ class Device:
         # ignore_err=True 时即使底层 success=False 也按成功处理(不打 ERROR)
         is_failure = (not success) and (not ignore_err)
 
+        # echo_output=False 或 全局静默开关开启时, 任何返回值都不打印
+        if not echo_output or _SESSION_QUIET_STDOUT:
+            return
+
         parts = []
         if matched_prompt is not None:
             parts.append(f"prompt={matched_prompt}")
         if exit_code is not None:
             suffix = " (ignored)" if ignore_err and exit_code != 0 else ""
             parts.append(f"exit={exit_code}{suffix}")
-        # 全局静默开关一旦开启, 即使用户传了 echo_output=True 也不打印 stdout
-        if echo_output and stdout and not _SESSION_QUIET_STDOUT:
+        if stdout:
             parts.append(f"stdout={stdout}")
         if stderr:
             parts.append(f"stderr={stderr}")
@@ -769,10 +773,11 @@ class Device:
         if isinstance(timeout, str):
             timeout = int(timeout)
 
-        # 第 1 行: 总是打印执行的命令
-        logger.info(
-            f"[Device.sendcmd_interactive] $ {LogColor.CYAN}{cmd}{LogColor.RESET}"
-        )
+        # 第 1 行: 默认打印执行的命令, 受 echo_output 和 _SESSION_QUIET_STDOUT 控制
+        if echo_output and not _SESSION_QUIET_STDOUT:
+            logger.info(
+                f"[Device.sendcmd_interactive] $ {LogColor.CYAN}{cmd}{LogColor.RESET}"
+            )
 
         if self.local_exec:
             if not self._get_logged_in():

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/pytest_testkit/lib/common/log/manager.py

@@ -2,6 +2,7 @@ import logging
 import os
 import re
 import threading
+import unicodedata
 from datetime import datetime, timezone
 from typing import Dict, Optional
 
@@ -117,16 +118,19 @@ class LogFileManager:
             return ""
         try:
             if b"\xc3" in text.encode("utf-8", errors="replace"):
-                text = text.encode("latin-1", errors="replace").decode(
-                    "utf-8", errors="replace"
-                )
+                # 严格 latin-1 编码：遇到中文(>U+00FF)会抛错被跳过，避免误伤
+                text = text.encode("latin-1").decode("utf-8", errors="replace")
         except (UnicodeEncodeError, UnicodeDecodeError):
             logger.debug("latin-1/utf-8 re-decode skipped due to encoding error")
-        text = "".join(c for c in text if ord(c) < 128 or c in "\n\r\t")
+        # 只过滤控制字符，保留中文等合法非 ASCII 字符
+        text = "".join(
+            c for c in text if c in "\n\r\t" or unicodedata.category(c)[0] != "C"
+        )
         try:
-            text = text.encode("windows-1252", errors="replace").decode(
-                "utf-8", errors="replace"
-            )
+            encoded = text.encode("windows-1252")
+            # 仅当存在高位字节(疑似 mojibake)时才尝试二次还原
+            if any(0x80 <= b <= 0xFF for b in encoded):
+                text = encoded.decode("utf-8", errors="replace")
         except (UnicodeEncodeError, UnicodeDecodeError):
             logger.debug("windows-1252/utf-8 re-decode skipped due to encoding error")
         return text

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/pytest_testkit/plugin.py

@@ -501,28 +501,28 @@ def _get_inifile_info(config):
         cfg = configparser.ConfigParser()
         cfg.read(config.inifile, encoding="utf-8")
 
+        # Split a raw value into tokens. Accept comma, whitespace, or
+        # comma+whitespace as separators, e.g. "a,b", "a b", "a, b", "a , b".
+        # Empty tokens are dropped.
+        def _split_tokens(raw):
+            if not raw:
+                return []
+            return [tok.strip() for tok in re.split(r"[,\s]+", raw) if tok.strip()]
+
         # Read all attributes from [case_info] section
-        # Split values by comma to support multiple values per attribute
+        # Split values to support multiple values per attribute (comma/space separated)
         aim_attrs = {}
         if cfg.has_section("case_info"):
             for key, value in cfg.items("case_info"):
-                # Split by comma and strip whitespace, filter empty strings
-                values = [v.strip() for v in value.split(",") if v.strip()]
-                aim_attrs[key] = values
+                aim_attrs[key] = _split_tokens(value)
 
         # Read test_ids include/exclude/pre_test
-        include_ids = cfg.get("test_ids", "include", fallback="")
-        exclude_ids = cfg.get("test_ids", "exclude", fallback="")
-        pre_test_ids = cfg.get("pre_test", "pre_test", fallback="")
-        include_ids = dict.fromkeys(include_ids.split(","), 1)
-        exclude_ids = dict.fromkeys(exclude_ids.split(","), 1)
-        pre_test_ids = dict.fromkeys(pre_test_ids.split(","), 1)
-        include_ids.pop("", None)
-        exclude_ids.pop("", None)
-        pre_test_ids.pop("", None)
-        include_ids = {tid.strip(): 1 for tid in include_ids if tid.strip()}
-        exclude_ids = {tid.strip(): 1 for tid in exclude_ids if tid.strip()}
-        pre_test_ids = {tid.strip(): 1 for tid in pre_test_ids if tid.strip()}
+        include_raw = cfg.get("test_ids", "include", fallback="")
+        exclude_raw = cfg.get("test_ids", "exclude", fallback="")
+        pre_test_raw = cfg.get("pre_test", "pre_test", fallback="")
+        include_ids = {tid: 1 for tid in _split_tokens(include_raw)}
+        exclude_ids = {tid: 1 for tid in _split_tokens(exclude_raw)}
+        pre_test_ids = {tid: 1 for tid in _split_tokens(pre_test_raw)}
     except Exception as e:
         logger.info(f"get inifile err: {e}, return default val")
         return {}, {}, {}, {}
@@ -576,10 +576,13 @@ def _collect_case_with_inifile(config, items):
     """
     Filter test cases based on pytest.ini configuration.
 
-    Filtering logic:
-    1. test_ids include/exclude have highest priority
-    2. case_info attributes: case must contain all attributes configured in ini with matching values (subset match)
-    3. Attributes not configured in ini match all cases
+    Filtering logic (priority high -> low):
+    1. include_ids: if configured, only keep matching items (ordered by ini) and return
+    2. case_info attributes: subset match if configured
+    3. exclude_ids: drop matching items from whatever was kept above (or from all items)
+    4. Otherwise keep all items
+
+    All branches finally reorder by pre_test_ids.
     """
     # Get ini file filtering criteria
     aim_attrs, include_ids, exclude_ids, pre_test_ids = _get_inifile_info(config)
@@ -657,56 +660,69 @@ def _collect_case_with_inifile(config, items):
         _apply_pre_test_order(items, pre_test_ids)
         return
 
-    if exclude_ids:
-        items[:] = exclude_list
-        deselected = [item for item in original_items if item not in exclude_list]
-        if deselected:
-            config.hook.pytest_deselected(items=deselected)
-        logger.info(
-            f"filter case with exclude id: exclude id list: [{exclude_ids}]\n"
-            f"final id list: {exclude_list}"
-        )
-        _apply_pre_test_order(items, pre_test_ids)
-        return
+    # Step 2: filter by case_info attributes if configured (subset match)
+    # If aim_attrs is empty, keep all items for now and let exclude_ids handle removal.
+    if aim_attrs:
+        attr_filtered_items = []
+        for item in items:
+            case_info_marker = item.get_closest_marker("case_info")
+            if not case_info_marker:
+                logger.info(f"item: {item}, match no case_info case")
+                continue
 
-    # If no attributes configured, match all cases
-    if not aim_attrs:
-        logger.info("inifile no case_info attributes, match all case")
-        _apply_pre_test_order(items, pre_test_ids)
-        return
+            case_attrs = _get_item_case_info(case_info_marker)
 
-    # Filter by case_info attributes
-    # Match if case contains all attributes configured in ini with matching values
-    filtered_items = []
-    for item in items:
-        case_info_marker = item.get_closest_marker("case_info")
-        if not case_info_marker:
-            logger.info(f"item: {item}, match no case_info case")
-            continue
+            # Check if all aim_attrs are present in case_attrs with matching values
+            # aim_attrs values are lists, case must match one of the values
+            all_match = True
+            for attr_k, aim_values in aim_attrs.items():
+                case_value = case_attrs.get(attr_k)
+                if case_value is None or case_value not in aim_values:
+                    all_match = False
+                    break
 
-        case_attrs = _get_item_case_info(case_info_marker)
+            logger.info(f"item: match[{all_match}]{item}[{case_attrs}]")
 
-        # Check if all aim_attrs are present in case_attrs with matching values
-        # aim_attrs values are lists, case must match one of the values
-        all_match = True
-        for attr_k, aim_values in aim_attrs.items():
-            case_value = case_attrs.get(attr_k)
-            if case_value is None or case_value not in aim_values:
-                all_match = False
-                break
+            if all_match:
+                attr_filtered_items.append(item)
 
-        logger.info(f"item: match[{all_match}]{item}[{case_attrs}]")
+        items[:] = attr_filtered_items
+        deselected = [
+            item for item in original_items if item not in attr_filtered_items
+        ]
+        if deselected:
+            config.hook.pytest_deselected(items=deselected)
+        logger.info(
+            f"filter case with inifile: attributes[{aim_attrs}]\nfiltered cases: {items}"
+        )
 
-        if all_match:
-            filtered_items.append(item)
+    # Step 3: apply exclude_ids if configured (drop matching items)
+    if exclude_ids:
+        # Build set of items currently kept, then drop any whose id is in exclude_ids.
+        kept_items = []
+        excluded_items = []
+        for item in items:
+            nodeid_parts = item.nodeid.split("::")
+            if len(nodeid_parts) >= 2:
+                item_full_id = "::".join(nodeid_parts[1:])
+                item_method_id = nodeid_parts[-1]
+                if exclude_ids.get(item_full_id, None) or exclude_ids.get(
+                    item_method_id, None
+                ):
+                    excluded_items.append(item)
+                    continue
+            kept_items.append(item)
+
+        items[:] = kept_items
+        if excluded_items:
+            config.hook.pytest_deselected(items=excluded_items)
+            logger.info(
+                f"filter case with exclude id: exclude id list: [{list(exclude_ids.keys())}]\n"
+                f"excluded items: {[item.nodeid for item in excluded_items]}"
+            )
+        logger.info(f"final id list: {kept_items}")
 
-    items[:] = filtered_items
-    deselected = [item for item in original_items if item not in filtered_items]
-    if deselected:
-        config.hook.pytest_deselected(items=deselected)
-    logger.info(
-        f"filter case with inifile: attributes[{aim_attrs}]\nfiltered cases: {items}"
-    )
+    # Final: reorder by pre_test_ids
     _apply_pre_test_order(items, pre_test_ids)
 
 
@@ -729,12 +745,118 @@ def _get_item_env_info(env_marker):
         raise Exception("get None template")
 
 
+def _parse_env_nodes_config(config):
+    """
+    Parse env_nodes from [env_info] section of pytest.ini.
+
+    The env_nodes key is declared under [env_info] (a user-defined section,
+    not recognized by pytest.getini), so we read it directly via configparser
+    from the ini file pytest is using.
+
+    Format: '<template_type>.<node_name>' entries, comma-separated.
+    Example: 't1.n1, t1.n2, t2.n3' -> {t1: {n1, n2}, t2: {n3}}.
+
+    Returns:
+        dict[str, set[str]]: template_type -> set of node_names to keep.
+        Empty dict when not configured or section missing.
+    """
+    inifile = getattr(config, "inifile", None)
+    if not inifile:
+        return {}
+
+    parser = configparser.ConfigParser()
+    try:
+        parser.read(inifile, encoding="utf-8")
+    except configparser.Error as e:
+        logger.info(f"parse inifile for env_info err: {e}, return default val")
+        return {}
+
+    if not parser.has_section("env_info"):
+        return {}
+
+    raw = parser.get("env_info", "env_nodes", fallback="").strip()
+    if not raw:
+        return {}
+
+    result: dict = {}
+    for entry in raw.split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+        if "." not in entry:
+            logger.warning(
+                f"env_nodes entry ignored (missing '.'): {entry!r}, "
+                f"expected format '<template_type>.<node_name>'"
+            )
+            continue
+        ttype, node_name = entry.split(".", 1)
+        ttype = ttype.strip()
+        node_name = node_name.strip()
+        if not ttype or not node_name:
+            logger.warning(f"env_nodes entry ignored (empty parts): {entry!r}")
+            continue
+        result.setdefault(ttype, set()).add(node_name)
+
+    return result
+
+
+def _apply_env_nodes_filter(env_info: dict, env_nodes_cfg: dict) -> dict:
+    """
+    Filter env_info according to env_nodes_cfg.
+
+    Rules:
+      - template_type not in cfg: leave env_info unchanged (no processing).
+      - template_type in cfg:
+          * Keep only nodes listed in cfg[template_type]; discard others.
+          * If any configured node name is missing from env_definition -> raise.
+          * After filtering, env_definition must still contain at least one machine
+            (sum of machines across kept nodes > 0); otherwise raise.
+
+    Returns the (possibly mutated) env_info dict.
+    """
+    if not env_nodes_cfg:
+        return env_info
+
+    ttype = env_info.get("template_type")
+    if ttype not in env_nodes_cfg:
+        return env_info
+
+    allowed = env_nodes_cfg[ttype]
+    env_def: dict = env_info.get("env_definition", {}) or {}
+
+    missing = sorted(n for n in allowed if n not in env_def)
+    if missing:
+        raise ValueError(
+            f"env_nodes filter for template_type={ttype!r} expects {sorted(allowed)}, "
+            f"but env_definition has nodes {sorted(env_def.keys())}; "
+            f"missing: {missing}"
+        )
+
+    filtered_def = {n: env_def[n] for n in env_def if n in allowed}
+
+    total_machines = sum(
+        len(machines)
+        for machines in filtered_def.values()
+        if isinstance(machines, list)
+    )
+    if total_machines == 0:
+        raise ValueError(
+            f"env_nodes filter for template_type={ttype!r} kept {sorted(filtered_def)}, "
+            f"but the resulting env_definition contains zero machines. "
+            f"Check env_nodes config and template definitions."
+        )
+
+    env_info["env_definition"] = filtered_def
+    return env_info
+
+
 def _collect_env_and_remote_for_testcase(config, items):
     """
     收集过滤后的用例的环境信息
     """
     try:
         env_var_name = config.getoption("--env-var", "COLLECTED_INFO")
+        env_nodes_cfg = _parse_env_nodes_config(config)
 
         if not hasattr(config, "collected_infos"):
             config.collected_infos = {}  # 用于报错收集后的信息
@@ -744,6 +866,7 @@ def _collect_env_and_remote_for_testcase(config, items):
             if env_marker:
                 try:
                     env_info = _get_item_env_info(env_marker)
+                    env_info = _apply_env_nodes_filter(env_info, env_nodes_cfg)
                     remote_marker = item.get_closest_marker("remote_run")
                     env_info.update({"remote_run": bool(remote_marker)})
                     config.collected_infos[item.nodeid] = env_info

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1/pytest_testkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest_testkit
-Version: 1.0.0
+Version: 1.0.1
 Summary: Pytest plugin for Infra logging framework and environment management
 Author: Huawei
 License: MIT License
@@ -430,6 +430,49 @@ pytest --quiet-stdout --testbed=testbed.json testcase/
 quiet_stdout = true
 ```
 
+### CI 运行元数据（ci_env_info）
+
+执行器（pytest-executor）在调度用例时，会把 CI 流水线的运行元数据序列化成**单个**
+`ci_env_info` 环境变量注入用例进程，覆盖 runner / remote / local 三种执行模式。
+用例侧统一通过读取该环境变量获取当前流水线上下文，无需关心运行在哪种模式。
+
+#### 字段说明
+
+环境变量 `ci_env_info` 的值是一个 JSON 字符串，固定包含以下白名单字段（值均为字符串）：
+
+| 字段名          | 含义               | 示例                |
+|:-------------|:-----------------|:------------------|
+| project_name | CI 项目名称          | "openlibing/demo" |
+| workflow_name| 工作流名称            | "nightly"         |
+| job_name     | 任务（job）名称       | "run-pytest"      |
+| run_number   | 流水线运行序号          | "128"             |
+| step_name    | 当前步骤名称           | "pytest-orch"     |
+
+#### 读取方式
+
+```python
+import json
+import os
+
+def test_use_ci_metadata():
+    raw = os.environ.get("ci_env_info", "")
+    info = json.loads(raw) if raw else {}
+    job_name = info.get("job_name", "")
+    run_number = info.get("run_number", "")
+    # 例如按流水线序号归档产物、按 job 名分支断言逻辑
+    assert isinstance(job_name, str)
+```
+
+#### 取值约定
+
+- **白名单字段恒在**：无论入参是否提供，解析后的 JSON 一定包含上表 5 个字段，缺省值为 `""`。
+- **值经过清洗**：单个字段值会剔除 NUL、换行等控制字符，并按 128 字符截断；
+  非字符串标量（如数字）转为字符串，非标量（字典/列表）降级为 `""`。
+- **非法输入不阻断用例**：入参结构不合法、缺失或类型错误时一律降级为空串并告警，
+  不会中断用例调度；未注入时 `ci_env_info` 为 `""`。
+- **纯 ASCII 安全**：JSON 以 `ensure_ascii` 序列化，含中文等非 ASCII 值时以 `\uXXXX`
+  转义，避免经 SSH 传输后乱码。
+- 该变量由执行器注入，本地直接 `pytest` 调试时通常为空，用例代码应对空值做好兜底。
 
 ### 支持的 fixture
 

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/pytest_testkit.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ tests/test_docker_proxy_is_interactive_shell.py
 tests/test_docker_proxy_non_shell_commands.py
 tests/test_docker_proxy_sendcmd.py
 tests/test_docker_proxy_sendcmd_interactive.py
+tests/test_env_nodes_filter.py
 tests/test_get_inifile_info.py
 tests/test_get_item_case_info.py
 tests/test_local_exec.py

{pytest_testkit-1.0.0 → pytest_testkit-1.0.1}/requirements.txt

@@ -1,4 +1,5 @@
 pytest==8.3.2
+pytest-timeout>=2.3.1,<3.0
 requests
 paramiko
 xlrd>=2.0.0

pytest_testkit-1.0.1/tests/test_env_nodes_filter.py

@@ -0,0 +1,349 @@
+"""
+Tests for env_nodes filter applied during pytest_collection_modifyitems.
+
+env_nodes is configured in pytest.ini under [env_info] section (a user-defined
+section that pytest.getini does NOT expose, so the plugin reads it via
+configparser from config.inifile).
+
+Format:
+
+    env_nodes = <template_type>.<node_name>[, <template_type>.<node_name>...]
+
+Behavior:
+- template_type not in cfg: env_info unchanged
+- template_type in cfg:
+    * only keep listed nodes in env_definition
+    * if any configured node missing from env_definition -> ValueError
+    * after filtering, env_definition must contain >=1 machine total -> ValueError
+"""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+from pytest_testkit.plugin import (
+    _apply_env_nodes_filter,
+    _parse_env_nodes_config,
+)
+
+
+def _write_ini(content):
+    """Write a temp ini file and return its path."""
+    fd, path = tempfile.mkstemp(suffix=".ini")
+    try:
+        with open(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+    except Exception:
+        Path(path).unlink(missing_ok=True)
+        raise
+    return path
+
+
+class MockConfig:
+    """Minimal pytest Config mock that exposes inifile and getini (any key)."""
+
+    def __init__(self, inifile=""):
+        self.inifile = inifile
+
+    def getini(self, key):
+        # The plugin no longer relies on getini for env_nodes, but keep it
+        # so it behaves like a real pytest Config when the plugin calls it.
+        return ""
+
+
+# -----------------------------_parse_env_nodes_config----------------------------
+
+
+def test_parse_returns_empty_when_no_inifile():
+    cfg = MockConfig(inifile="")
+    assert _parse_env_nodes_config(cfg) == {}
+
+
+def test_parse_returns_empty_when_inifile_missing():
+    cfg = MockConfig(inifile="/nonexistent/path/to.ini")
+    assert _parse_env_nodes_config(cfg) == {}
+
+
+def test_parse_returns_empty_when_no_env_info_section():
+    path = _write_ini("[other_section]\nfoo = bar\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_returns_empty_when_env_info_section_has_no_env_nodes_key():
+    path = _write_ini("[env_info]\nother_key = value\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_single_entry():
+    path = _write_ini(
+        "[pytest]\nfoo = bar\n\n[env_info]\nenv_nodes = single_device.nodes_A2\n"
+    )
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"single_device": {"nodes_A2"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_multiple_entries_same_template():
+    path = _write_ini("[env_info]\nenv_nodes = t1.n1, t1.n2, t1.n3\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"t1": {"n1", "n2", "n3"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_multiple_template_types():
+    path = _write_ini("[env_info]\nenv_nodes = t1.n1, t1.n2, t2.n3\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"t1": {"n1", "n2"}, "t2": {"n3"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_extra_whitespace_tolerated():
+    path = _write_ini("[env_info]\nenv_nodes =   t1.n1  ,  t2.n2  \n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"t1": {"n1"}, "t2": {"n2"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_malformed_entry_ignored_but_valid_kept():
+    # 'no_dot', 'empty.', '.empty' are ignored; only 't1.n1' is kept.
+    path = _write_ini("[env_info]\nenv_nodes = no_dot, t1.n1, empty., .empty\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"t1": {"n1"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_node_name_can_contain_dot():
+    # split with maxsplit=1, so 't1.foo.bar' -> ('t1', 'foo.bar').
+    path = _write_ini("[env_info]\nenv_nodes = t1.foo.bar\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"t1": {"foo.bar"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_strips_whitespace_inside_entries():
+    path = _write_ini("[env_info]\nenv_nodes = t1.  n1  , t2.n2\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {"t1": {"n1"}, "t2": {"n2"}}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_env_nodes_in_other_section_ignored():
+    # env_nodes written under [pytest] should NOT be picked up: the plugin
+    # only reads [env_info] section.
+    path = _write_ini("[pytest]\nenv_nodes = t1.n1\n")
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {}
+    finally:
+        Path(path).unlink()
+
+
+def test_parse_full_pytest_ini_layout():
+    # Realistic pytest.ini: [pytest] for builtins + [env_info] for ours.
+    path = _write_ini(
+        "[pytest]\n"
+        "infra_log_dir = logs\n"
+        "infra_log_level = INFO\n"
+        "error_log_fail = true\n"
+        "\n"
+        "[env_info]\n"
+        "env_nodes = single_device.nodes_1, multi_device.nodes_main\n"
+    )
+    try:
+        cfg = MockConfig(inifile=path)
+        assert _parse_env_nodes_config(cfg) == {
+            "single_device": {"nodes_1"},
+            "multi_device": {"nodes_main"},
+        }
+    finally:
+        Path(path).unlink()
+
+
+# ---------------------------_apply_env_nodes_filter----------------------------
+
+
+def _make_env_info(template_type, env_definition):
+    return {"template_type": template_type, "env_definition": env_definition}
+
+
+def test_filter_skipped_when_template_type_not_in_cfg():
+    env_info = _make_env_info(
+        "other_type",
+        {"nodes_A": [{"name": "device_a"}]},
+    )
+    cfg = {"single_device": {"nodes_A2"}}
+    out = _apply_env_nodes_filter(env_info, cfg)
+    assert out is env_info
+    assert out["env_definition"] == {"nodes_A": [{"name": "device_a"}]}
+
+
+def test_filter_skipped_when_cfg_empty():
+    env_info = _make_env_info(
+        "single_device",
+        {"nodes_A": [{"name": "device_a"}]},
+    )
+    out = _apply_env_nodes_filter(env_info, {})
+    assert out is env_info
+    assert out["env_definition"] == {"nodes_A": [{"name": "device_a"}]}
+
+
+def test_filter_keeps_only_configured_nodes():
+    env_info = _make_env_info(
+        "single_device",
+        {
+            "nodes_A1": [{"name": "device_a1"}],
+            "nodes_A2": [{"name": "device_a2"}],
+            "nodes_A3": [{"name": "device_a3"}],
+        },
+    )
+    cfg = {"single_device": {"nodes_A2"}}
+    out = _apply_env_nodes_filter(env_info, cfg)
+    assert "env_definition" in out
+    assert set(out["env_definition"].keys()) == {"nodes_A2"}
+    assert out["env_definition"]["nodes_A2"] == [{"name": "device_a2"}]
+
+
+def test_filter_keeps_multiple_nodes_for_same_template():
+    env_info = _make_env_info(
+        "t1",
+        {
+            "n1": [{"name": "d1"}],
+            "n2": [{"name": "d2"}],
+            "n3": [{"name": "d3"}],
+        },
+    )
+    cfg = {"t1": {"n1", "n3"}}
+    out = _apply_env_nodes_filter(env_info, cfg)
+    assert set(out["env_definition"].keys()) == {"n1", "n3"}
+
+
+def test_filter_raises_when_configured_node_missing():
+    env_info = _make_env_info(
+        "single_device",
+        {"nodes_A1": [{"name": "device_a1"}]},
+    )
+    cfg = {"single_device": {"nodes_A2"}}
+    with pytest.raises(ValueError, match="nodes_A2"):
+        _apply_env_nodes_filter(env_info, cfg)
+
+
+def test_filter_raises_when_one_of_many_configured_nodes_missing():
+    env_info = _make_env_info(
+        "t1",
+        {"n1": [{"name": "d1"}]},
+    )
+    cfg = {"t1": {"n1", "n2"}}
+    with pytest.raises(ValueError, match="n2"):
+        _apply_env_nodes_filter(env_info, cfg)
+
+
+def test_filter_raises_when_all_kept_nodes_empty_machine_list():
+    env_info = _make_env_info("t1", {"n1": []})
+    cfg = {"t1": {"n1"}}
+    with pytest.raises(ValueError, match="zero machines"):
+        _apply_env_nodes_filter(env_info, cfg)
+
+
+def test_filter_raises_when_no_node_kept_at_all():
+    env_info = _make_env_info("t1", {"other": [{"name": "d"}]})
+    cfg = {"t1": {"n1"}}
+    with pytest.raises(ValueError, match="missing"):
+        _apply_env_nodes_filter(env_info, cfg)
+
+
+def test_filter_preserves_machine_payload_after_filter():
+    env_info = _make_env_info(
+        "t1",
+        {
+            "n1": [{"name": "d1", "pool": "default"}],
+            "n2": [{"name": "d2", "pool": "default"}],
+        },
+    )
+    cfg = {"t1": {"n2"}}
+    out = _apply_env_nodes_filter(env_info, cfg)
+    assert out["env_definition"]["n2"] == [{"name": "d2", "pool": "default"}]
+    assert "n1" not in out["env_definition"]
+
+
+def test_filter_does_not_affect_other_template_types_in_cfg():
+    env_info_a = _make_env_info(
+        "t1",
+        {"n1": [{"name": "d1"}], "n2": [{"name": "d2"}]},
+    )
+    env_info_b = _make_env_info("t2", {"x": [{"name": "dx"}]})
+    cfg = {"t1": {"n1"}, "t2": {"x"}}
+    out_a = _apply_env_nodes_filter(env_info_a, cfg)
+    out_b = _apply_env_nodes_filter(env_info_b, cfg)
+    assert set(out_a["env_definition"].keys()) == {"n1"}
+    assert set(out_b["env_definition"].keys()) == {"x"}
+
+
+def test_filter_with_unrelated_cfg_keys_returns_unchanged():
+    env_info = _make_env_info(
+        "completely_different",
+        {"nodes_A": [{"name": "device_a"}]},
+    )
+    cfg = {"single_device": {"nodes_A2"}, "multi_device": {"nodes_B1"}}
+    out = _apply_env_nodes_filter(env_info, cfg)
+    assert out is env_info
+    assert out["env_definition"] == {"nodes_A": [{"name": "device_a"}]}
+
+
+# ---------------------------integration: parse + filter--------------------------
+
+
+def test_integration_single_template_match():
+    path = _write_ini(
+        "[env_info]\nenv_nodes = single_device.nodes_1, multi_device.nodes_main\n"
+    )
+    try:
+        cfg = MockConfig(inifile=path)
+        parsed = _parse_env_nodes_config(cfg)
+
+        env_info_single = _make_env_info(
+            "single_device",
+            {
+                "nodes_1": [{"name": "device"}],
+                "nodes_2": [{"name": "other"}],
+            },
+        )
+        env_info_multi = _make_env_info(
+            "multi_device",
+            {
+                "nodes_main": [{"name": "m1"}, {"name": "m2"}],
+                "nodes_extra": [{"name": "extra"}],
+            },
+        )
+        env_info_other = _make_env_info("local_exec", {"nodes_x": [{"name": "x"}]})
+
+        out_single = _apply_env_nodes_filter(env_info_single, parsed)
+        out_multi = _apply_env_nodes_filter(env_info_multi, parsed)
+        out_other = _apply_env_nodes_filter(env_info_other, parsed)
+
+        assert set(out_single["env_definition"].keys()) == {"nodes_1"}
+        assert set(out_multi["env_definition"].keys()) == {"nodes_main"}
+        assert out_other["env_definition"] == {"nodes_x": [{"name": "x"}]}
+    finally:
+        Path(path).unlink()