@harmonyos-arkts/d2h 0.1.2 → 0.1.5

package/skills/d2h-hypium-forge/scripts/run_direct.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+"""
+run_direct.py — 裸 hypium 直跑器（无 devicetest/xdevice 依赖）+ 前置条件分组编排。
+
+编排规则（TD-004 修正：共用前置条件，防交错破坏）：
+  用例文件可声明模块级常量 PRECOND（缺省 'anonymous'）：
+    - 'anonymous'    无状态要求（软启动即可）
+    - 'logged_in'    需登录态（组内软隔离保持 preferences，ensure_login 幂等复用）
+    - 'first_launch' 需首启态（bm clean 破坏性最大，强制排尾，不再破坏后续）
+  执行顺序 = 组序（anonymous → logged_in → first_launch）→ 组内文件名序。
+  组切换打印分隔；results.json 每条附 group 字段（可分组统计）。
+  组首条置 os.environ['FORGE_GROUP_FIRST']='1'（用例可选做完整冷启验证），执行后清除。
+
+用法:
+  单条:  python3 run_direct.py --case F01_func_normal_001 [--dir testcases]
+  批量:  python3 run_direct.py --all [--dir testcases]
+
+要求: 用例 .py 文件含 process_case(d) 顶层函数；或兼容 devicetest 风格（反射 process 方法）。
+结果: 逐条打印 PASS/FAIL + 汇总，写 results.json
+"""
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+import time
+import traceback
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from hypium import UiDriver
+
+# 前置组执行序：破坏性递增（first_launch 会 bm clean，必须排尾）
+GROUP_ORDER = {'anonymous': 0, 'logged_in': 1, 'first_launch': 2}
+
+
+def load_case(path):
+    spec = importlib.util.spec_from_file_location('case_mod', path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def case_group(mod):
+    g = str(getattr(mod, 'PRECOND', 'anonymous') or 'anonymous')
+    return g if g in GROUP_ORDER else 'anonymous'
+
+
+def order_files(dir_):
+    """返回 [(filename, group)]，按 组序→文件名 排序；只 import 一次读 PRECOND。"""
+    files = sorted(f for f in os.listdir(dir_) if f.endswith('.py') and not f.startswith('_'))
+    tagged = []
+    for f in files:
+        try:
+            mod = load_case(os.path.join(dir_, f))
+            tagged.append((f, case_group(mod)))
+        except Exception:
+            tagged.append((f, 'anonymous'))  # import 失败留给 run_one 报 FAIL，不在此拦截
+    tagged.sort(key=lambda x: (GROUP_ORDER[x[1]], x[0]))
+    return tagged
+
+
+def _scene_evidence(d, n=8):
+    # FAIL 现场证据: 当前页面 Text 摘要(进 results.msg, 供下轮 LLM 直读省重取证)
+    try:
+        ts = [(c.getText() or '')[:12] for c in (d.find_all_components(BY.type('Text')) or [])]
+        ts = [t for t in ts if t][:n]
+        return ' | 现场Text: ' + '/'.join(ts) if ts else ' | 现场Text: (空)'
+    except Exception:
+        return ''
+
+
+def run_one(d, mod_path, name):
+    mod = load_case(mod_path)
+    t0 = time.time()
+    try:
+        if hasattr(mod, 'process_case'):
+            sampler = None
+            _sample_state = None
+            try:
+                os.environ['FORGE_CASE'] = name
+                if SHOT_DIR:  # 过程采样：每 2.5s 一帧（<case>_pNN.jpeg），执行过程关键画面自动留存
+                    import threading
+                    state = {'n': 0, 'stop': False}
+                    _sample_state = state
+
+                    def _sample():
+                        import time as _t
+                        while not state['stop']:
+                            _t.sleep(2.5)
+                            if state['stop']:
+                                break
+                            state['n'] += 1
+                            try:
+                                _shot(d, os.path.join(SHOT_DIR, f"{name}_p{state['n']:02d}.jpeg"), f'proc{state["n"]:02d}')
+                            except Exception:
+                                pass
+                    sampler = threading.Thread(target=_sample, daemon=True)
+                    sampler.start()
+                mod.process_case(d)
+                if SHOT_DIR:
+                    _shot(d, os.path.join(SHOT_DIR, name + '_end.jpeg'), 'end-shot')
+            except Exception as _ex:
+                if SHOT_DIR:
+                    _shot(d, os.path.join(SHOT_DIR, name + '_fail.jpeg'), 'fail-shot')
+                raise type(_ex)(str(_ex) + _scene_evidence(d)) from None
+            finally:
+                _sample_state and _sample_state.__setitem__('stop', True)
+                os.environ.pop('FORGE_CASE', None)
+        else:  # devicetest 风格兜底：实例化伪 TestCase
+            cls = None
+            for attr in dir(mod):
+                obj = getattr(mod, attr)
+                if isinstance(obj, type) and hasattr(obj, 'process') and attr != 'TestCase':
+                    cls = obj
+                    break
+            if cls is None:
+                return name, 'SKIP', 'no process func', 0
+
+            # devicetest TestCase.__init__(TAG, controllers) —— 直跑时跳过基类构造
+            inst = object.__new__(cls)
+            inst.driver = d
+            inst.device1 = d.device if hasattr(d, 'device') else None
+            inst.TAG = name
+            # 直跑跳过 __init__：软断言收集器等实例属性需补默认值
+            if hasattr(cls, '_soft_check') and not hasattr(inst, '_errors'):
+                inst._errors = []
+            # setup 也在 try/finally 内：setup 抛异常时 teardown 仍执行
+            try:
+                if hasattr(cls, 'setup'):
+                    cls.setup(inst)
+                try:
+                    os.environ['FORGE_CASE'] = name  # 分步截图命名用
+                    cls.process(inst)
+                    if SHOT_DIR:
+                        _shot(d, os.path.join(SHOT_DIR, f'{name}_end.jpeg'), 'end-shot')
+                except Exception:
+                    if SHOT_DIR:
+                        _shot(d, os.path.join(SHOT_DIR, f'{name}_fail.jpeg'), 'fail-shot')
+                    raise
+            finally:
+                os.environ.pop('FORGE_CASE', None)
+                if hasattr(cls, 'teardown'):
+                    try:
+                        cls.teardown(inst)
+                    except Exception:
+                        pass
+        return name, 'PASS', '', round(time.time() - t0, 1)
+    except Exception as e:
+        tb = traceback.format_exc().strip().split('\n')
+        msg = f'{e} | {tb[-1][:120] if len(tb) > 1 else ""}'
+        return name, 'FAIL', msg, round(time.time() - t0, 1)
+
+
+SHOT_DIR = None  # 本次运行的截图目录（main 里初始化）
+
+
+# ---------------- 产品代码变更检测（增量重试回归门禁） ----------------
+# 背景：--retry-failed 只重跑 FAIL/SKIP，PASS 保留原结果；若上一轮之后修改了产品代码
+# （entry/src/main/ets），旧 PASS 可能已回归（实证：Profiles TC09/TC14 PASS→FAIL 靠全量重跑才抓到）。
+# 门禁：结果侧车 results.meta.json 记录 srcHash；增量重试前重算，不一致 → 自动升级为全量重跑。
+
+def _find_src_root():
+    """定位被测工程 entry/src/main/ets：FORGE_SRC_DIR 优先；否则在父/祖父目录的
+    *Ohos|ohos 兄弟工程中，按 forge 目录名令牌匹配（timer-hypium→TimerOhos）；
+    匹配失败且候选不唯一时返回 None（门禁将保守全量，宁可多跑不漏回归）。"""
+    env = os.environ.get('FORGE_SRC_DIR')
+    if env and os.path.isdir(env):
+        return env
+    import re as _re
+    here = os.path.abspath(os.getcwd())
+
+    def _norm(s):
+        s = s.lower()
+        changed = True
+        while changed:
+            changed = False
+            for suf in ('-ohos', 'ohos', '-hypium', 'hypium', '-forge', 'forge', '-migration', 'migration'):
+                if s.endswith(suf) and len(s) > len(suf):
+                    s = s[:-len(suf)]
+                    changed = True
+        return s
+
+    token = _norm(_re.split(r'[-_.]', os.path.basename(here))[0])
+    if token in ('hypium', 'tmp', 'testcases', 'forge', ''):  # <X>-migration/hypium_forge → 用父目录令牌
+        token = _norm(_re.split(r'[-_.]', os.path.basename(os.path.dirname(here)))[0])
+    cands = []  # (src_root, 归一化工程名)
+    for base in (os.path.dirname(here), os.path.dirname(os.path.dirname(here))):
+        if not base or not os.path.isdir(base):
+            continue
+        for d in sorted(os.listdir(base)):
+            if d.endswith('Ohos') or d == 'ohos':
+                cand = os.path.join(base, d, 'entry', 'src', 'main', 'ets')
+                if os.path.isdir(cand):
+                    cands.append((cand, _norm(d)))
+    if not cands:
+        return None
+    if len(cands) == 1:
+        return cands[0][0]
+    for cand, dn in cands:
+        if dn == token or dn.startswith(token) or token.startswith(dn):
+            return cand
+    return None
+
+
+def src_tree_hash():
+    """entry/src/main/ets 下全部 .ets/.ts 内容哈希（排序后串联），产品代码指纹。"""
+    root = _find_src_root()
+    if not root:
+        return None
+    h = hashlib.sha256()
+    for dirpath, dirs, files in os.walk(root):
+        dirs[:] = sorted(d for d in dirs if d not in ('build', 'oh_modules', '.preview'))
+        for fn in sorted(files):
+            if not fn.endswith(('.ets', '.ts')):
+                continue
+            p = os.path.join(dirpath, fn)
+            h.update(os.path.relpath(p, root).encode())
+            try:
+                h.update(open(p, 'rb').read())
+            except OSError:
+                return None
+    return h.hexdigest()[:16]
+
+
+def _meta_path(result_path):
+    return os.path.join(os.path.dirname(os.path.abspath(result_path)) or '.',
+                        'results.meta.json')
+
+
+def _read_prev_src_hash(result_path):
+    mp = _meta_path(result_path)
+    if os.path.exists(mp):
+        try:
+            return json.load(open(mp, encoding='utf-8')).get('srcHash')
+        except Exception:
+            return None
+    return None
+
+
+def _write_src_meta(result_path, src_hash, mode):
+    if not src_hash:
+        return
+    try:
+        mp = _meta_path(result_path)
+        json.dump({'srcHash': src_hash, 'ts': time.time(), 'mode': mode},
+                  open(mp, 'w', encoding='utf-8'), indent=1)
+    except Exception:
+        pass
+
+
+
+def _init_shot_dir():
+    global SHOT_DIR
+    import datetime
+    SHOT_DIR = os.path.join('reports', datetime.datetime.now().strftime('%Y-%m-%d'),
+                            datetime.datetime.now().strftime('%H-%M-%S'))
+    os.makedirs(SHOT_DIR, exist_ok=True)
+    os.environ['FORGE_SHOT_DIR'] = SHOT_DIR  # 分步截图（step_shot）读取
+
+
+HDC_BIN = '/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony/toolchains/hdc'
+DEVICE_SN = None  # main() 里从 args.device 赋值
+
+
+def _shot(d, path, label='shot'):
+    """截图（尽力而为，绝不影响结果记录）：d.screenshot 优先，失败走 hdc snapshot_display。"""
+    os.makedirs(os.path.dirname(path) if os.path.dirname(path) else '.', exist_ok=True)
+    try:
+        d.screenshot(path)
+        print(f'  [{label}] {path}')
+        return
+    except Exception:
+        pass
+    try:
+        import subprocess as _sp
+        dev = DEVICE_SN or os.environ.get('FORGE_DEVICE', '127.0.0.1:5555')
+        remote = f'/data/local/tmp/_forge_shot.jpeg'
+        _sp.run([HDC_BIN, '-t', dev, 'shell', 'snapshot_display', '-f', remote],
+                capture_output=True, timeout=10)
+        _sp.run([HDC_BIN, '-t', dev, 'file', 'recv', remote, path],
+                capture_output=True, timeout=15)
+        _sp.run([HDC_BIN, '-t', dev, 'shell', 'rm', '-f', remote],
+                capture_output=True, timeout=5)
+        print(f'  [{label}] {path} (hdc)')
+    except Exception as exc:
+        print(f'  [{label}] 不可用: {exc}')
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--case', default=None)
+    ap.add_argument('--all', action='store_true')
+    ap.add_argument('--dir', default='testcases')
+    ap.add_argument('--device', default='127.0.0.1:5555')
+    ap.add_argument('--retry-failed', action='store_true',
+                    help='增量重试：只重跑 results.json 中 FAIL/SKIP 条（PASS 保留原结果，合并写出）；'
+                         '产品代码(entry/src/main/ets)较上轮有变更时自动升级为全量重跑')
+    ap.add_argument('--force-incremental', action='store_true',
+                    help='跳过产品代码变更门禁，强制增量（仅测试脚本变更时使用）')
+    args = ap.parse_args()
+    global DEVICE_SN
+    DEVICE_SN = args.device
+    sys.path.insert(0, os.path.abspath(args.dir))
+
+    if args.case:
+        ordered = [(f'{args.case}.py', 'anonymous')]
+    elif args.retry_failed:
+        prev = os.path.join(os.path.abspath(args.dir), '..', 'results.json')
+        if not os.path.exists(prev):
+            print('--retry-failed 需要 results.json'); sys.exit(1)
+        # ---- 回归门禁：产品代码变更 → 自动全量（TD-019）----
+        cur_hash = src_tree_hash()
+        if not args.force_incremental:
+            prev_hash = _read_prev_src_hash(prev)
+            if cur_hash is None:
+                print('⚠ 未定位到 entry/src/main/ets（可用 FORGE_SRC_DIR 指定），无法判定产品代码变更 → 保守全量重跑')
+                args.all = True
+            elif prev_hash is None:
+                print('⚠ results.meta.json 无上轮 srcHash 记录（旧版产物）→ 保守全量重跑（本轮后建立指纹）')
+                args.all = True
+            elif cur_hash != prev_hash:
+                print(f'⚠ 产品代码已变更（srcHash {prev_hash} → {cur_hash}）：旧 PASS 可能回归 → 自动升级为全量重跑')
+                print('  （确认仅测试脚本变更可加 --force-incremental 强制增量）')
+                args.all = True
+        prev_res = {str(r.get('case')).split('_')[0]: r
+                    for r in json.load(open(prev, encoding='utf-8'))}
+        all_ordered = order_files(args.dir)
+        if args.all:  # 门禁升级为全量：不保留旧 PASS
+            ordered = all_ordered
+            print(f'全量重跑（产品代码变更门禁）: {len(ordered)} 条')
+        else:
+            ordered = [(f, g) for f, g in all_ordered
+                       if f[:-3].split('_')[0] not in prev_res
+                       or prev_res[f[:-3].split('_')[0]].get('status') != 'PASS']
+            keep = [prev_res[f[:-3].split('_')[0]] for f, g in all_ordered
+                    if f[:-3].split('_')[0] in prev_res
+                    and prev_res[f[:-3].split('_')[0]].get('status') == 'PASS']
+            print(f'增量重试: 重跑 {len(ordered)} 条 / 保留 PASS {len(keep)} 条（srcHash 未变: {cur_hash}）')
+            globals()['_RETRY_KEEP'] = keep
+    elif args.all:
+        ordered = order_files(args.dir)
+    else:
+        print('指定 --case X 或 --all（或 --retry-failed）'); sys.exit(1)
+
+    _init_shot_dir()
+    os.environ['FORGE_DEVICE'] = args.device   # launch(want/reset) 的 hdc 透传用
+
+    d = UiDriver.connect(device_sn=args.device)
+    results = []
+    cur_group = None
+    for f, grp in ordered:
+        name = f[:-3]
+        if grp != cur_group:  # 组切换：首启组排尾，此前组状态不被回头破坏
+            cur_group = grp
+            print(f'\n────── 前置组 [{grp}] 开始（{grp} 组内软隔离共享前置）──────', flush=True)
+            os.environ['FORGE_GROUP_FIRST'] = '1'
+        print(f'▶ {name} ...', flush=True)
+        n, status, msg, dur = run_one(d, os.path.join(args.dir, f), name)
+        os.environ.pop('FORGE_GROUP_FIRST', None)
+        print(f'  {status} ({dur}s) {msg[:110]}', flush=True)
+        results.append({'case': n, 'status': status, 'msg': msg, 'dur': dur, 'group': grp})
+        time.sleep(2)
+
+    results = globals().get('_RETRY_KEEP', []) + results
+    p = sum(1 for r in results if r['status'] == 'PASS')
+    f_ = sum(1 for r in results if r['status'] == 'FAIL')
+    print(f'\n══════ 直跑汇总: PASS={p} FAIL={f_} SKIP={len(results)-p-f_} / {len(results)} ══════')
+    from collections import Counter
+    print('分组: ' + ', '.join(f'{g}={c}' for g, c in Counter(r['group'] for r in results).items()))
+    # 同族错误聚类（分诊三律①：同消息视为同族，一次定案禁逐条实验）
+    fails = [r for r in results if r['status'] == 'FAIL']
+    if fails:
+        import re as _re
+        def _sig(m):
+            head = (m or '').split(' | ')[0]
+            return _re.sub(r'[:：].+', ': X', head)[:60]
+        clus = Counter(_sig(r.get('msg')) for r in fails)
+        print('同族聚类: ' + ' ; '.join(f'{c}×[{k}]' for k, c in clus.most_common(4)))
+    out = 'results.json' if (args.all or args.retry_failed) else 'results-%s.json' % (args.case or 'single').split('_')[0]
+    if os.path.exists(out):  # 修复轮重跑前保留上一轮原始记录（自愈边界：修≠覆盖历史）
+        import shutil as _sh
+        _sh.copy(out, out.replace('.json', '.prev.json'))
+    json.dump(results, open(out, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)
+    if args.all or args.retry_failed:  # 全量/合并结果写入后记录产品代码指纹（供下轮增量门禁比对）
+        _write_src_meta(out, src_tree_hash(), 'full' if args.all else 'retry')
+    print('明细: ' + out)
+
+
+if __name__ == '__main__':
+    main()

package/skills/d2h-hypium-forge/scripts/run_parallel.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+run_parallel.py — 多设备并发直跑器（N 设备 × 1 线程/设备）。
+
+用法:
+  python3 run_parallel.py --dir testcases --devices 127.0.0.1:5555,127.0.0.1:5556,127.0.0.1:5557
+  可选: --filter-prefix F01（只跑某前缀）/ --results results.json
+
+设计: 每设备一个常驻线程 + 独立 UiDriver（hypium 驱动线程安全边界内），
+     用例按 round-robin 分发；单例失败不中断；汇总 per-case 耗时与总时长。
+"""
+import argparse
+import importlib.util
+import json
+import os
+import queue
+import sys
+import threading
+import time
+import traceback
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from hypium import UiDriver
+
+
+def load_case(path):
+    spec = importlib.util.spec_from_file_location(os.path.basename(path)[:-3], path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def run_case_on(d, mod_path, name):
+    mod = load_case(mod_path)
+    t0 = time.time()
+    try:
+        cls = None
+        for attr in dir(mod):
+            obj = getattr(mod, attr)
+            if isinstance(obj, type) and hasattr(obj, 'process') and attr != 'TestCase':
+                cls = obj
+                break
+        inst = object.__new__(cls)
+        inst.driver = d
+        inst.device1 = None
+        inst.TAG = name
+        if hasattr(cls, 'setup'):
+            cls.setup(inst)
+        try:
+            cls.process(inst)
+        finally:
+            if hasattr(cls, 'teardown'):
+                try:
+                    cls.teardown(inst)
+                except Exception:
+                    pass
+        return 'PASS', '', round(time.time() - t0, 1)
+    except Exception as e:
+        tb = traceback.format_exc().strip().split('\n')
+        return 'FAIL', f'{e} | {tb[-1][:100] if len(tb) > 1 else ""}', round(time.time() - t0, 1)
+
+
+def worker(dev_sn, case_q, results, lock):
+    try:
+        d = UiDriver.connect(device_sn=dev_sn)
+    except Exception as e:
+        with lock:
+            results.append({'case': f'WORKER-{dev_sn}', 'status': 'ERROR', 'msg': str(e)[:100], 'dur': 0})
+        return
+    while True:
+        try:
+            name, path = case_q.get_nowait()
+        except queue.Empty:
+            return
+        status, msg, dur = run_case_on(d, path, name)
+        with lock:
+            results.append({'case': name, 'status': status, 'msg': msg, 'dur': dur, 'device': dev_sn})
+            print(f'[{dev_sn}] {name}: {status} ({dur}s) {msg[:60]}', flush=True)
+        case_q.task_done()
+        time.sleep(2)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--dir', default='testcases')
+    ap.add_argument('--devices', required=True, help='逗号分隔设备 SN')
+    ap.add_argument('--filter-prefix', default=None)
+    ap.add_argument('--results', default='results_parallel.json')
+    args = ap.parse_args()
+
+    sys.path.insert(0, os.path.abspath(args.dir))
+    files = sorted(f for f in os.listdir(args.dir) if f.endswith('.py') and not f.startswith('_'))
+    if args.filter_prefix:
+        files = [f for f in files if f.startswith(args.filter_prefix)]
+    if not files:
+        print('无用例'); sys.exit(1)
+
+    case_q = queue.Queue()
+    for f in files:
+        case_q.put((f[:-3], os.path.join(args.dir, f)))
+
+    devices = [d.strip() for d in args.devices.split(',') if d.strip()]
+    results, lock = [], threading.Lock()
+    t0 = time.time()
+    threads = [threading.Thread(target=worker, args=(dsn, case_q, results, lock)) for dsn in devices]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    total = round(time.time() - t0, 1)
+
+    p = sum(1 for r in results if r['status'] == 'PASS')
+    f_ = sum(1 for r in results if r['status'] == 'FAIL')
+    durs = [r['dur'] for r in results if r['status'] in ('PASS', 'FAIL')]
+    print(f'\n══════ 并发汇总: PASS={p} FAIL={f_} / {len(results)} | 总时长 {total}s '
+          f'| 单例均值 {sum(durs)/len(durs):.1f}s | {len(devices)} 设备并发 ══════')
+    json.dump(results, open(args.results, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)
+
+
+if __name__ == '__main__':
+    main()