Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

feat: Add OpenClaw2OpenViking integration tests with CI pipeline (#1168)

kaisongli06ae06c3dca7
diff --git a/.github/workflows/oc2ov_test.yml b/.github/workflows/oc2ov_test.yml
new file mode 100644
index 000000000..70e2e4ca0
--- /dev/null
+++ b/.github/workflows/oc2ov_test.yml
@@ -0,0 +1,198 @@
+name: 05. OpenClaw2OpenViking Memory Tests
+
+on:
+ release:
+ types: [prereleased, released]
+ push:
+ branches:
+ - main
+ workflow_dispatch:
+ inputs:
+ skip_tests:
+ description: 'Skip tests (for emergency releases)'
+ required: false
+ type: boolean
+ default: false
+ release_tag:
+ description: 'Release tag to associate with this test run'
+ required: false
+ type: string
+
+permissions:
+ contents: read
+ actions: read
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ p0-tests:
+ name: P0 Memory Tests
+ runs-on: [self-hosted, linux, x64]
+ if: inputs.skip_tests != true
+
+ steps:
+ - name: Clean up previous artifacts
+ run: |
+ echo "🧹 Cleaning up previous artifacts..."
+
+ # Clean up old test reports
+ echo " - Removing old test reports..."
+ rm -rf tests/oc2ov_test/reports/*.html || true
+
+ # Clean up old logs
+ echo " - Removing old logs..."
+ rm -rf tests/oc2ov_test/logs/*.log || true
+
+ # Clean up pip cache (optional, saves disk space)
+ echo " - Cleaning pip cache..."
+ pip3 cache purge 2>/dev/null || echo " (pip cache not available or already clean)"
+
+ # Clean up old pytest cache
+ echo " - Removing pytest cache..."
+ rm -rf .pytest_cache || true
+ rm -rf tests/oc2ov_test/.pytest_cache || true
+
+ # Clean up __pycache__ directories
+ echo " - Removing __pycache__ directories..."
+ find tests/oc2ov_test -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+
+ echo "✅ Cleanup completed"
+
+ - name: Debug - Start
+ run: |
+ echo "🚀 Job started at $(date)"
+ echo "Runner: $(hostname)"
+ echo "Working directory: $(pwd)"
+ echo "Python version: $(python3 --version 2>&1 || echo 'Python not found')"
+ echo "Environment variables:"
+ echo " - RUNNER_OS: ${{ runner.os }}"
+ echo " - GITHUB_REF: ${{ github.ref }}"
+ echo " - GITHUB_SHA: ${{ github.sha }}"
+
+ - name: Checkout repository
+ uses: actions/checkout@v6
+ with:
+ ref: ${{ github.ref }}
+ submodules: false
+
+ - name: Upgrade OpenViking to latest main
+ run: |
+ echo "🔄 Upgrading OpenViking to latest main branch..."
+
+ # Make upgrade script executable
+ chmod +x tests/oc2ov_test/upgrade_openviking.sh
+
+ # Run upgrade script
+ bash tests/oc2ov_test/upgrade_openviking.sh
+
+ echo "✅ OpenViking upgrade completed"
+
+ # Wait for services to be fully ready
+ echo "⏳ Waiting for services to be ready..."
+ sleep 10
+
+ # Health check
+ echo "🏥 Performing health check..."
+ if command -v openclaw &> /dev/null; then
+ for i in {1..5}; do
+ if openclaw gateway status | grep -q "running"; then
+ echo "✅ OpenClaw gateway is running"
+ break
+ else
+ echo "⏳ Attempt $i/5: Gateway not ready, waiting..."
+ sleep 5
+ fi
+ done
+ else
+ echo "⚠️ openclaw command not found, skipping health check"
+ fi
+
+ - name: Install test dependencies
+ run: |
+ echo "📦 Setting up Python virtual environment..."
+ cd tests/oc2ov_test
+
+ # Create virtual environment
+ python3 -m venv venv
+ echo "✅ Virtual environment created"
+
+ # Activate and install dependencies
+ source venv/bin/activate
+ pip install --upgrade pip
+ pip install -r requirements.txt
+ pip install pytest pytest-html pytest-timeout
+ echo "✅ Dependencies installed in virtual environment"
+
+ - name: Create settings.py from example
+ run: |
+ echo "📝 Creating settings.py from settings.example.py..."
+ cd tests/oc2ov_test/config
+
+ # Check if settings.py exists
+ if [ -f "settings.py" ]; then
+ echo "✅ settings.py already exists"
+ else
+ # Copy settings.example.py to settings.py
+ cp settings.example.py settings.py
+ echo "✅ settings.py created from settings.example.py"
+ echo "⚠️ Note: Using default settings. For custom settings, manually create settings.py on the ECS node."
+ fi
+
+ - name: Run P0 tests
+ id: run-tests
+ run: |
+ echo "🧪 Starting P0 tests..."
+ cd tests/oc2ov_test
+
+ # Activate virtual environment
+ source venv/bin/activate
+
+ # Set PYTHONPATH to include both project root and tests/oc2ov_test
+ # This allows imports like:
+ # - 'from tests.base_cli_test import ...' (from project root)
+ # - 'from config.settings import ...' (from tests/oc2ov_test)
+ export PYTHONPATH="$(cd ../.. && pwd):$(pwd)"
+ echo "PYTHONPATH: $PYTHONPATH"
+
+ mkdir -p reports
+ pytest tests/p0 -v \
+ --html=reports/test_report_p0.html \
+ --self-contained-html \
+ --tb=short \
+ --timeout=3600
+ echo "✅ P0 tests completed"
+ continue-on-error: true
+
+ - name: Upload test reports
+ uses: actions/upload-artifact@v7
+ if: always()
+ with:
+ name: p0-test-reports-${{ github.run_id }}
+ path: |
+ tests/oc2ov_test/reports/test_report_p0.html
+ tests/oc2ov_test/logs/
+ retention-days: 30
+
+ - name: Check test results
+ if: steps.run-tests.outcome != 'success'
+ run: |
+ echo "::error::P0 tests failed! Please check the test report for details."
+ exit 1
+
+ - name: Test summary
+ if: success()
+ run: |
+ echo "::notice::P0 tests passed successfully! Ready for release."
+
+ release-approval:
+ name: Release Approval Gate
+ needs: [p0-tests]
+ if: github.event_name == 'release' && github.event.action == 'prereleased'
+ runs-on: ubuntu-24.04
+ steps:
+ - name: Approve release
+ run: |
+ echo "::notice::P0 tests passed. Release can proceed."
+ echo "Release ${{ github.event.release.tag_name }} has been validated by P0 tests."
diff --git a/tests/oc2ov_test/ASSERTIONS_GUIDE.md b/tests/oc2ov_test/ASSERTIONS_GUIDE.md
new file mode 100644
index 000000000..7ddb3dd6b
--- /dev/null
+++ b/tests/oc2ov_test/ASSERTIONS_GUIDE.md
@@ -0,0 +1,178 @@
+# 断言使用指南
+
+本项目提供了多种断言方式来验证 OpenClaw 的响应。
+
+## 断言方法
+
+### 1. 关键词断言
+
+#### `assertKeywordsInResponse()`
+断言响应中包含指定的所有关键词。
+
+**参数:**
+- `response`: 响应内容(字典或字符串)
+- `keywords`: 关键词列表
+- `require_all`: 是否要求所有关键词都必须出现,默认 `True`
+- `case_sensitive`: 是否区分大小写,默认 `False`
+- `msg`: 自定义错误信息
+
+**示例:**
+
+```python
+# 验证响应中包含所有关键词
+self.assertKeywordsInResponse(
+ response,
+ ["小明", "30岁", "测试开发"],
+ require_all=True,
+ case_sensitive=False
+)
+
+# 验证响应中包含任意一个关键词
+self.assertKeywordsInResponse(
+ response,
+ ["30", "三十"],
+ require_all=False
+)
+```
+
+---
+
+### 2. 任意关键词组断言
+
+#### `assertAnyKeywordInResponse()`
+断言响应中包含任意一组关键词中的任意一个。
+
+**参数:**
+- `response`: 响应内容
+- `keyword_groups`: 关键词组列表(二维数组)
+- `case_sensitive`: 是否区分大小写,默认 `False`
+- `msg`: 自定义错误信息
+
+**示例:**
+
+```python
+# 验证响应中包含姓名、年龄或职业中的任意一个
+self.assertAnyKeywordInResponse(
+ response,
+ [
+ ["小明", "小红"], # 第一组:姓名
+ ["30", "25", "28"], # 第二组:年龄
+ ["测试开发", "产品经理"] # 第三组:职业
+ ],
+ case_sensitive=False
+)
+```
+
+---
+
+### 3. 文本相似度断言
+
+#### `assertSimilarity()`
+断言响应文本与期望文本的相似度达到指定阈值。
+
+**参数:**
+- `response`: 响应内容
+- `expected_text`: 期望的文本
+- `min_similarity`: 最小相似度阈值,范围 0.0-1.0,默认 0.6
+- `msg`: 自定义错误信息
+
+**示例:**
+
+```python
+# 验证响应文本与期望文本相似度 >= 70%
+self.assertSimilarity(
+ response,
+ "你叫小明,今年30岁,住在华东区,职业是测试开发",
+ min_similarity=0.7
+)
+```
+
+---
+
+## 实用技巧
+
+### 组合使用断言
+
+```python
+def test_some_scenario(self):
+ # 发送消息
+ response = self.send_and_log("我叫张三")
+ self.wait_for_sync()
+
+ # 验证响应
+ verify_resp = self.send_and_log("我是谁")
+
+ # 方式1:关键词断言
+ self.assertKeywordsInResponse(verify_resp, ["张三"])
+
+ # 方式2:任意关键词组断言(更灵活)
+ self.assertAnyKeywordInResponse(
+ verify_resp,
+ [["张三", "小张"]]
+ )
+```
+
+### 容错性设计
+
+```python
+# 提供多种可能的表述方式
+self.assertAnyKeywordInResponse(
+ response,
+ [
+ ["30岁", "30", "三十岁", "三十"], # 年龄的多种表述
+ ["测试开发", "测试工程师", "QA"] # 职业的多种表述
+ ]
+)
+```
+
+### 渐进式验证
+
+```python
+# 先写入信息
+self.send_and_log("我叫李四,今年35岁")
+self.wait_for_sync()
+
+# 逐项验证
+name_resp = self.send_and_log("我叫什么?")
+self.assertKeywordsInResponse(name_resp, ["李四"])
+
+age_resp = self.send_and_log("我几岁?")
+self.assertKeywordsInResponse(age_resp, ["35", "三十五"])
+```
+
+---
+
+## 直接使用 AssertionHelper
+
+也可以直接使用 `AssertionHelper` 类进行断言:
+
+```python
+from utils.assertions import AssertionHelper
+
+helper = AssertionHelper()
+
+# 提取响应文本
+text = helper.extract_response_text(response)
+
+# 计算相似度
+similarity = helper.calculate_similarity(text1, text2)
+
+# 关键词检查(返回布尔值,不抛异常)
+success = helper.assert_keywords_in_response(response, ["关键词"])
+```
+
+---
+
+## 响应格式支持
+
+`extract_response_text()` 方法支持多种响应格式:
+
+- 纯字符串
+- `{"output": "..."}`
+- `{"message": "..."}`
+- `{"content": "..."}`
+- `{"text": "..."}`
+- OpenAI 格式:`{"choices": [{"message": {"content": "..."}}]}`
+- 其他格式会自动转为字符串
+
+如果你的响应格式不被支持,可以扩展 `extract_response_text()` 方法。
diff --git a/tests/oc2ov_test/README.md b/tests/oc2ov_test/README.md
new file mode 100644
index 000000000..f099e9acc
--- /dev/null
+++ b/tests/oc2ov_test/README.md
@@ -0,0 +1,350 @@
+# OpenClaw - OpenViking 端到端自动化测试
+
+OpenClaw 和 OpenViking 端到端自动化测试框架,用于验证记忆读写、增删改查等场景。
+
+## 📋 前置条件
+
+在使用本项目之前,请确保已完成以下准备工作:
+
+### 1. 安装 OpenClaw
+
+确保已在本地安装 OpenClaw:
+
+```bash
+# 验证 OpenClaw 安装
+openclaw --version
+```
+
+### 2. 安装 OpenViking 插件
+
+确保已安装 OpenViking 插件并正确配置:
+
+```bash
+# 检查已安装的插件
+openclaw plugins list
+```
+
+### 3. (可选)配置 OpenClaw HTTP 通信
+
+**注意:本项目推荐使用 OpenClaw CLI 方式(默认),更加稳定可靠。**
+
+如果需要使用 HTTP API 方式,请在 OpenClaw 的配置文件 `~/.openclaw/openclaw.json` 中添加或修改以下配置:
+
+```json
+{
+ "gateway": {
+ "http": {
+ "endpoints": {
+ "responses": {
+ "enabled": true
+ }
+ }
+ }
+ }
+}
+```
+
+配置后重启 OpenClaw Gateway:
+
+```bash
+openclaw gateway restart
+```
+
+### 4. 启动 OpenClaw 服务
+
+确保 OpenClaw Gateway 正在运行:
+
+```bash
+# 检查服务状态
+openclaw gateway status
+
+# 如果未运行,启动服务
+openclaw gateway
+```
+
+## 🚀 快速开始(推荐:使用 CLI 方式)
+
+### 方法一:使用快速脚本(推荐)
+
+```bash
+# 1. 设置环境(自动创建虚拟环境并安装依赖)
+./setup.sh
+
+# 2. 运行测试(带报告生成,使用 CLI 方式)
+./run.sh -r
+```
+
+### 方法二:手动设置
+
+```bash
+# 1. 创建虚拟环境
+python -m venv venv
+
+# 2. 激活虚拟环境
+source venv/bin/activate # Linux/Mac
+# 或
+venv\Scripts\activate # Windows
+
+# 3. 安装依赖
+pip install -r requirements.txt
+pip install pytest-html
+
+# 4. 运行测试(使用 CLI 方式,推荐)
+pytest test_cli_pytest.py -v --html=reports/test_report.html --self-contained-html
+```
+
+## 📁 项目结构
+
+```
+oc2ov_test/
+├── config/ # 配置文件目录
+│ ├── __init__.py
+│ └── settings.py # 项目配置
+├── tests/ # 测试用例目录
+│ ├── __init__.py
+│ ├── base_test.py # 测试基类(HTTP 方式)
+│ ├── base_cli_test.py # 测试基类(CLI 方式,推荐)
+│ ├── p0/ # P0 质量保障类测试
+│ ├── crud/ # CRUD 操作测试
+│ └── complex/ # 复杂场景测试
+├── utils/ # 工具函数目录
+│ ├── __init__.py
+│ ├── openclaw_client.py # OpenClaw HTTP 客户端封装
+│ ├── openclaw_cli_client.py # OpenClaw CLI 客户端封装(推荐)
+│ ├── logger.py # 日志工具
+│ └── assertions.py # 断言工具(关键词匹配、文本相似度)
+├── logs/ # 日志目录
+├── reports/ # 测试报告目录
+├── venv/ # Python 虚拟环境(自动创建)
+├── conftest.py # Pytest 配置(报告美化)
+├── test_cli_pytest.py # Pytest 测试入口(CLI 方式,推荐)
+├── test_pytest.py # Pytest 测试入口(HTTP 方式)
+├── test_cli_single.py # 单个 CLI 请求测试
+├── quick_test.py # 快速测试脚本
+├── run_tests.py # 测试运行入口
+├── setup.sh # 快速环境设置脚本
+├── run.sh # 快速测试运行脚本
+├── requirements.txt # Python 依赖
+├── pyproject.toml # 项目配置文件
+├── README.md # 项目说明
+└── ASSERTIONS_GUIDE.md # 断言使用详细指南
+```
+
+## ⚙️ 配置说明
+
+配置文件位于 `config/settings.py`,主要配置项:
+
+```python
+OPENCLAW_CONFIG = {
+ "url": "http://127.0.0.1:18789/v1/responses",
+ "auth_token": "Bearer YOUR_AUTH_TOKEN_HERE", # 请替换为您自己的认证token
+ "agent_id": "main",
+ "model": "YOUR_MODEL_NAME_HERE", # 请替换为您自己的模型名称
+ "timeout": 120
+}
+
+TEST_CONFIG = {
+ "wait_time": 10, # 等待记忆同步的时间(秒)
+ "log_dir": os.path.join(BASE_DIR, "logs"),
+ "report_dir": os.path.join(BASE_DIR, "reports")
+}
+```
+
+
+## 🧪 运行测试
+
+### 推荐:使用 CLI 方式(更稳定)
+
+```bash
+# 运行全部 CLI 测试(带报告)
+pytest test_cli_pytest.py -v --html=reports/test_report_cli.html --self-contained-html
+
+# 运行单个 CLI 测试
+pytest test_cli_pytest.py::TestMemoryWriteGroupA::test_memory_write_basic_info -v
+
+# 快速测试单个 CLI 请求
+python test_cli_single.py
+```
+
+### 使用 HTTP 方式
+
+```bash
+# 运行全部 HTTP 测试
+pytest test_pytest.py -v --html=reports/test_report.html --self-contained-html
+```
+
+### 使用快速脚本
+
+```bash
+# 查看帮助
+./run.sh -h
+
+# 运行全部测试(带报告)
+./run.sh -r
+
+# 仅运行 P0 级测试
+./run.sh -p
+
+# 仅运行 CRUD 操作测试
+./run.sh -c
+
+# 仅运行复杂场景测试
+./run.sh -x
+
+# 详细输出模式
+./run.sh -v
+
+# 组合使用:详细输出 + 生成报告
+./run.sh -v -r
+```
+
+## 📊 查看测试报告
+
+测试报告生成在 `reports/` 目录下,可以直接在浏览器中打开:
+
+```bash
+# macOS
+open reports/test_report_cli.html
+
+# Linux
+xdg-open reports/test_report_cli.html
+
+# Windows
+start reports/test_report_cli.html
+```
+
+报告包含:
+- 📊 环境信息(OpenClaw 版本、OpenViking 状态等)
+- 📝 详细的中文测试描述
+- 📈 测试执行结果和日志
+- ✅ 通过/失败的测试用例统计
+
+## ✅ 断言功能
+
+项目提供了多种断言方式来验证 OpenClaw 的响应:
+
+### 1. 关键词断言
+
+```python
+# 验证响应中包含所有关键词
+self.assertKeywordsInResponse(
+ response,
+ ["小明", "30岁", "测试开发"],
+ require_all=True
+)
+```
+
+### 2. 任意关键词组断言
+
+```python
+# 验证响应中包含任意一组中的任意一个关键词
+self.assertAnyKeywordInResponse(
+ response,
+ [["小明", "小红"], ["30", "25"]]
+)
+```
+
+### 3. 文本相似度断言
+
+```python
+# 验证响应文本与期望文本的相似度
+self.assertSimilarity(
+ response,
+ "你叫小明,今年30岁",
+ min_similarity=0.7
+)
+```
+
+**详细使用指南请查看:[ASSERTIONS_GUIDE.md](./ASSERTIONS_GUIDE.md)**
+
+## 📝 测试用例说明
+
+### P0 质量保障类测试
+
+- `TestMemoryWriteGroupA` - 测试组A(小明):基本记忆结构化写入验证
+- `TestMemoryWriteGroupB` - 测试组B(小红):多维度丰富信息写入
+
+### CRUD 操作测试
+
+- `TestMemoryRead` - 记忆读取验证
+- `TestMemoryUpdate` - 记忆更新验证
+- `TestMemoryDelete` - 记忆删除验证
+
+### 复杂场景测试
+
+- `TestComplexScenarioMultiUsers` - 多用户切换场景
+- `TestComplexScenarioIncrementalInfo` - 增量信息添加
+- `TestComplexScenarioSpecialCharacters` - 特殊字符和边界情况
+
+## 🔧 扩展新测试用例
+
+1. 在 `tests/` 相应目录下创建新的测试文件
+2. 继承 `BaseOpenClawCLITest` 基类(推荐使用 CLI 方式)
+3. 使用 `self.send_and_log()` 发送消息
+4. 使用 `self.wait_for_sync()` 等待记忆同步
+5. 使用断言方法验证响应
+6. 在 `test_cli_pytest.py` 中添加到测试套件中
+
+示例:
+
+```python
+from tests.base_cli_test import BaseOpenClawCLITest
+
+class TestMyNewFeature(BaseOpenClawCLITest):
+ """
+ 测试目标:我的新功能验证
+ 测试场景:描述测试场景
+ """
+
+ def test_something(self):
+ """测试场景:具体场景描述"""
+ self.logger.info("开始测试")
+ self.send_and_log("我叫测试用户")
+ self.wait_for_sync()
+
+ # 验证响应
+ response = self.send_and_log("我是谁")
+ self.assertKeywordsInResponse(response, ["测试用户"])
+```
+
+## 📋 日志
+
+测试运行日志保存在 `logs/test_run.log`
+
+## ⚠️ 注意事项
+
+1. **会话管理**:使用 CLI 方式时,每个测试类会使用独立的 `session-id`,避免会话冲突
+2. **等待时间**:根据实际情况调整 `config/settings.py` 中的 `wait_time`,确保记忆同步完成
+3. **超时设置**:CLI 客户端默认超时为 300 秒,可根据需要调整
+4. **服务状态**:确保 OpenClaw Gateway 正常运行,测试前可使用 `openclaw gateway status` 检查
+5. **会话锁定**:如果遇到 "session file locked" 错误,请检查是否有其他进程在使用相同的 session-id
+
+## 🐛 故障排查
+
+### 问题:每次发送消息后需要重启服务
+
+**解决方案**:使用 CLI 方式代替 HTTP API 方式,CLI 方式支持 `--session-id` 参数,可以保持会话连续性。
+
+### 问题:测试超时
+
+**解决方案**:
+1. 增加 `config/settings.py` 中的 `timeout` 值
+2. 增加 `wait_time` 等待时间
+3. 检查 OpenClaw 服务是否正常运行
+
+### 问题:会话文件锁定
+
+**解决方案**:
+1. 检查是否有其他测试进程在运行
+2. 尝试使用不同的 session-id
+3. 重启 OpenClaw Gateway
+
+## 🐍 虚拟环境说明
+
+项目使用 Python 虚拟环境来隔离依赖:
+
+- `venv/` - 虚拟环境目录(已添加到 .gitignore)
+- `setup.sh` - 一键设置环境脚本
+- `run.sh` - 一键运行测试脚本
+
+建议始终在虚拟环境中运行测试,避免依赖冲突。
diff --git a/tests/oc2ov_test/config/__init__.py b/tests/oc2ov_test/config/__init__.py
new file mode 100644
index 000000000..963e70d26
--- /dev/null
+++ b/tests/oc2ov_test/config/__init__.py
@@ -0,0 +1,5 @@
+"""
+配置文件模块
+"""
+
+from .settings import * # noqa: F403
diff --git a/tests/oc2ov_test/config/settings.example.py b/tests/oc2ov_test/config/settings.example.py
new file mode 100644
index 000000000..29d0c6ecf
--- /dev/null
+++ b/tests/oc2ov_test/config/settings.example.py
@@ -0,0 +1,48 @@
+"""
+项目配置文件示例
+将此文件复制为 settings.py 并填入您的配置信息
+"""
+
+import os
+
+# 项目根目录
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# OpenClaw 服务配置
+OPENCLAW_CONFIG = {
+ "url": "http://127.0.0.1:18789/v1/responses",
+ "auth_token": "Bearer YOUR_AUTH_TOKEN_HERE", # 请替换为您自己的认证token
+ "agent_id": "main",
+ "model": "YOUR_MODEL_NAME_HERE", # 请替换为您自己的模型名称
+ "timeout": 120,
+}
+
+# 测试配置
+TEST_CONFIG = {
+ "wait_time": 30,
+ "log_dir": os.path.join(BASE_DIR, "logs"),
+ "report_dir": os.path.join(BASE_DIR, "reports"),
+}
+
+# 日志配置
+LOGGING_CONFIG = {
+ "version": 1,
+ "disable_existing_loggers": False,
+ "formatters": {
+ "standard": {"format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"},
+ "detailed": {
+ "format": "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
+ },
+ },
+ "handlers": {
+ "console": {"class": "logging.StreamHandler", "formatter": "standard", "level": "INFO"},
+ "file": {
+ "class": "logging.FileHandler",
+ "filename": os.path.join(TEST_CONFIG["log_dir"], "test_run.log"),
+ "formatter": "detailed",
+ "level": "DEBUG",
+ "encoding": "utf-8",
+ },
+ },
+ "root": {"handlers": ["console", "file"], "level": "DEBUG"},
+}
diff --git a/tests/oc2ov_test/config/settings.py b/tests/oc2ov_test/config/settings.py
new file mode 100644
index 000000000..0bed2f00e
--- /dev/null
+++ b/tests/oc2ov_test/config/settings.py
@@ -0,0 +1,47 @@
+"""
+项目配置文件
+"""
+
+import os
+
+# 项目根目录
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# OpenClaw 服务配置
+OPENCLAW_CONFIG = {
+ "url": "http://127.0.0.1:18789/v1/responses",
+ "auth_token": "Bearer afc2a221-b8be-4daf-98d6-1e8a2b1cf975",
+ "agent_id": "main",
+ "model": "custom-ark-cn-beijing-volces-com/ep-20260318110255-66jjc",
+ "timeout": 120,
+}
+
+# 测试配置
+TEST_CONFIG = {
+ "wait_time": 10,
+ "log_dir": os.path.join(BASE_DIR, "logs"),
+ "report_dir": os.path.join(BASE_DIR, "reports"),
+}
+
+# 日志配置
+LOGGING_CONFIG = {
+ "version": 1,
+ "disable_existing_loggers": False,
+ "formatters": {
+ "standard": {"format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"},
+ "detailed": {
+ "format": "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
+ },
+ },
+ "handlers": {
+ "console": {"class": "logging.StreamHandler", "formatter": "standard", "level": "INFO"},
+ "file": {
+ "class": "logging.FileHandler",
+ "filename": os.path.join(TEST_CONFIG["log_dir"], "test_run.log"),
+ "formatter": "detailed",
+ "level": "DEBUG",
+ "encoding": "utf-8",
+ },
+ },
+ "root": {"handlers": ["console", "file"], "level": "DEBUG"},
+}
diff --git a/tests/oc2ov_test/conftest.py b/tests/oc2ov_test/conftest.py
new file mode 100644
index 000000000..f513e7fd8
--- /dev/null
+++ b/tests/oc2ov_test/conftest.py
@@ -0,0 +1,165 @@
+"""
+Pytest 配置文件 - 添加测试报告中文描述和环境信息
+"""
+
+import datetime
+import platform
+import subprocess
+
+
+def get_openclaw_version():
+ """获取 OpenClaw 版本"""
+ try:
+ result = subprocess.run(
+ ["openclaw", "--version"], capture_output=True, text=True, timeout=10
+ )
+ return result.stdout.strip()
+ except Exception:
+ return "Unknown"
+
+
+def get_openviking_version():
+ """获取 OpenViking 版本"""
+ # Method 1: Try to import openviking module directly
+ try:
+ import openviking
+
+ version = getattr(openviking, "__version__", None)
+ if version and version != "0.0.0+unknown":
+ return version
+ except Exception:
+ pass
+
+ # Method 2: Try to use ov CLI
+ try:
+ result = subprocess.run(["ov", "--version"], capture_output=True, text=True, timeout=10)
+ version = result.stdout.strip()
+ if version and version != "0.0.0+unknown":
+ return version
+ except Exception:
+ pass
+
+ # Method 3: Try to get version from pip show
+ try:
+ result = subprocess.run(
+ ["pip", "show", "openviking"], capture_output=True, text=True, timeout=10
+ )
+ for line in result.stdout.split("\n"):
+ if line.startswith("Version:"):
+ version = line.split(":", 1)[1].strip()
+ if version and version != "0.0.0+unknown":
+ return version
+ except Exception:
+ pass
+
+ # Method 4: Try to get version from git
+ try:
+ import os
+
+ project_dir = os.environ.get("PROJECT_DIR", "/root/project/OpenViking")
+ if os.path.exists(os.path.join(project_dir, ".git")):
+ result = subprocess.run(
+ ["git", "describe", "--tags", "--always"],
+ cwd=project_dir,
+ capture_output=True,
+ text=True,
+ timeout=10,
+ )
+ version = result.stdout.strip()
+ if version:
+ return f"dev-{version}"
+ except Exception:
+ pass
+
+ return "Unknown"
+
+
+def pytest_html_report_title(report):
+ """自定义报告标题"""
+ report.title = "OpenClaw + OpenViking 端到端自动化测试报告"
+
+
+def pytest_html_results_summary(prefix, summary, postfix):
+ """自定义报告摘要 - 添加环境信息和测试说明"""
+ openclaw_version = get_openclaw_version()
+ openviking_version = get_openviking_version()
+ test_date = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ os_info = f"{platform.system()} {platform.release()}"
+
+ prefix.extend(
+ [
+ '<div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; border-radius: 8px; margin-bottom: 20px;">',
+ '<h1 style="color: white; margin: 0; font-size: 28px;">OpenClaw + OpenViking 端到端自动化测试报告</h1>',
+ '<p style="color: rgba(255,255,255,0.9); margin: 10px 0 0 0; font-size: 16px;">验证记忆读写功能的完整性与可靠性</p>',
+ "</div>",
+ '<div style="background: #f8f9fa; padding: 15px; border-radius: 6px; margin-bottom: 20px;">',
+ '<h3 style="margin-top: 0; color: #333;">📊 环境信息</h3>',
+ '<table style="width: 100%; border-collapse: collapse; margin-top: 10px;">',
+ '<tr><td style="padding: 8px; border-bottom: 1px solid #ddd; width: 20%;"><strong>📋 项目名称</strong></td><td style="padding: 8px; border-bottom: 1px solid #ddd;">OpenClaw + OpenViking 端到端自动化测试</td></tr>',
+ f'<tr><td style="padding: 8px; border-bottom: 1px solid #ddd;"><strong>📅 测试日期</strong></td><td style="padding: 8px; border-bottom: 1px solid #ddd;">{test_date}</td></tr>',
+ f'<tr><td style="padding: 8px; border-bottom: 1px solid #ddd;"><strong>💻 操作系统</strong></td><td style="padding: 8px; border-bottom: 1px solid #ddd;">{os_info}</td></tr>',
+ f'<tr><td style="padding: 8px; border-bottom: 1px solid #ddd;"><strong>🦞 OpenClaw 版本</strong></td><td style="padding: 8px; border-bottom: 1px solid #ddd;">{openclaw_version}</td></tr>',
+ f'<tr><td style="padding: 8px; border-bottom: 1px solid #ddd;"><strong>🧠 OpenViking 版本</strong></td><td style="padding: 8px; border-bottom: 1px solid #ddd;">{openviking_version}</td></tr>',
+ '<tr><td style="padding: 8px;"><strong>🔗 测试方式</strong></td><td style="padding: 8px;">OpenClaw CLI (--session-id)</td></tr>',
+ "</table>",
+ "</div>",
+ '<h2 style="color: #4a90e2; border-bottom: 2px solid #4a90e2; padding-bottom: 10px;">📖 测试说明</h2>',
+ '<div style="background: #f8f9fa; padding: 15px; border-radius: 6px; margin: 15px 0;">',
+ '<p style="margin: 0 0 10px 0; font-size: 14px;">本测试验证 OpenClaw 与 OpenViking 之间的记忆读写功能,包括:</p>',
+ '<ul style="margin: 0; padding-left: 20px; font-size: 14px;">',
+ '<li style="margin: 5px 0;">✅ 记忆结构化写入验证</li>',
+ '<li style="margin: 5px 0;">✅ 记忆读取验证</li>',
+ '<li style="margin: 5px 0;">✅ 记忆更新验证</li>',
+ '<li style="margin: 5px 0;">✅ 记忆删除验证</li>',
+ '<li style="margin: 5px 0;">✅ 多维度信息写入验证</li>',
+ "</ul>",
+ "</div>",
+ '<hr style="margin: 25px 0; border: none; border-top: 1px solid #e0e0e0;">',
+ ]
+ )
+
+
+def pytest_html_results_table_header(cells):
+ """自定义结果表格表头"""
+ cells.insert(2, '<th style="width: 35%;">📝 测试描述</th>')
+
+
+def pytest_html_results_table_row(report, cells):
+ """自定义结果表格行 - 添加中文测试描述"""
+ description = "暂无描述"
+
+ test_descriptions = {
+ "test_memory_write_basic_info": "测试组A:写入小明的基本信息(姓名、年龄、地区、职业),验证记忆写入完整性与正确性",
+ "test_memory_write_rich_info": "测试组B:写入小红的详细信息(姓名、年龄、地址、职业、喜好、生日),验证多维度记忆存储",
+ "test_memory_read_verify": "逐项验证记忆读取功能(姓名、年龄、地区、职业),确保信息准确读取",
+ "test_memory_update_verify": "验证记忆更新功能(年龄、职业、地址),确保更新正确生效",
+ "test_memory_delete_verify": "验证记忆删除功能,写入临时信息后删除并验证",
+ "test_memory_persistence_group_a": "跨会话读取验证-组A:我喜欢吃樱桃,日常喜欢喝美式咖啡,验证记忆持久化存储",
+ "test_memory_persistence_group_b": "跨会话读取验证-组B:我喜欢吃芒果,日常喜欢喝拿铁咖啡,验证记忆持久化存储",
+ "test_memory_persistence_group_c": "跨会话读取验证-组C:我喜欢吃草莓,日常喜欢喝抹茶拿铁,验证记忆持久化存储",
+ "test_memory_update_overwrite_group_a": "更新覆盖验证-组A:初始信息30岁→更新为31岁+生日8月,验证旧记忆被覆盖",
+ "test_memory_update_overwrite_group_b": "更新覆盖验证-组B:初始信息26岁→更新为27岁+生日11月,验证旧记忆被覆盖",
+ "test_memory_update_overwrite_group_c": "更新覆盖验证-组C:初始信息32岁→更新为33岁+生日5月,验证旧记忆被覆盖",
+ "test_skill_experience_group_a": "技能经验沉淀-组A:销售数据查询参数格式验证,错误→正确→简化,验证经验记忆",
+ "test_skill_experience_group_b": "技能经验沉淀-组B:销售数据查询参数格式验证,错误→正确→简化,验证经验记忆",
+ "test_skill_experience_group_c": "技能经验沉淀-组C:销售数据查询参数格式验证,错误→正确→简化,验证经验记忆",
+ "test_skill_log_group_a": "技能日志验证-组A:查询销售数据后检查OpenClaw日志,验证memory-openviking inject记录",
+ "test_skill_log_group_b": "技能日志验证-组B:查询销售数据后检查OpenClaw日志,验证memory-openviking inject记录",
+ "test_skill_log_group_c": "技能日志验证-组C:查询销售数据后检查OpenClaw日志,验证memory-openviking inject记录",
+ "test_long_term_target_group_a": "长程记忆目标-组A:插入50轮干扰对话后验证核心目标不丢失(销售数据库优化方案)",
+ "test_long_term_target_group_b": "长程记忆目标-组B:插入50轮干扰对话后验证核心目标不丢失(OpenClaw安装适配)",
+ "test_long_term_target_group_c": "长程记忆目标-组C:插入50轮干扰对话后验证核心目标不丢失(OpenViking记忆模块)",
+ "test_summary_generation_group_a": "长程总结生成-组A:OpenViking自动化测试平台项目,整合背景+讨论+闲聊生成完整总结",
+ "test_summary_generation_group_b": "长程总结生成-组B:OpenClaw跨平台适配项目,整合背景+讨论+闲聊生成完整总结",
+ "test_summary_generation_group_c": "长程总结生成-组C:OpenViking记忆优化项目,整合背景+讨论+闲聊生成完整总结",
+ }
+
+ for test_name, desc in test_descriptions.items():
+ if test_name in report.nodeid:
+ description = desc
+ break
+
+ cells.insert(
+ 2,
+ f'<td style="max-width: 450px; word-wrap: break-word; font-size: 13px; line-height: 1.5;">{description}</td>',
+ )
diff --git a/tests/oc2ov_test/pyproject.toml b/tests/oc2ov_test/pyproject.toml
new file mode 100644
index 000000000..c8135dd5a
--- /dev/null
+++ b/tests/oc2ov_test/pyproject.toml
@@ -0,0 +1,34 @@
+[project]
+name = "oc2ov-test"
+version = "0.1.0"
+description = "OpenClaw - OpenViking 端到端自动化测试"
+authors = [
+ { name = "OpenClaw Team" }
+]
+requires-python = ">=3.7"
+dependencies = [
+ "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+test = [
+ "pytest>=7.0.0",
+ "pytest-html>=4.0.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests", "."]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+[tool.pytest-html]
+cssfile = ""
+self_contained_html = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/tests/oc2ov_test/requirements.txt b/tests/oc2ov_test/requirements.txt
new file mode 100644
index 000000000..c30bb31ea
--- /dev/null
+++ b/tests/oc2ov_test/requirements.txt
@@ -0,0 +1,2 @@
+requests>=2.28.0
+
diff --git a/tests/oc2ov_test/run.sh b/tests/oc2ov_test/run.sh
new file mode 100755
index 000000000..a407f67c4
--- /dev/null
+++ b/tests/oc2ov_test/run.sh
@@ -0,0 +1,93 @@
+#!/bin/bash
+# 运行测试脚本
+
+set -e
+
+# 检查是否在虚拟环境中
+if [[ "$VIRTUAL_ENV" == "" ]]; then
+ echo "激活虚拟环境..."
+ source venv/bin/activate
+fi
+
+echo "====================================="
+echo "运行 OpenClaw 自动化测试"
+echo "====================================="
+echo ""
+
+# 检查参数
+if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+ echo "用法: $0 [选项]"
+ echo ""
+ echo "选项:"
+ echo " -h, --help 显示帮助信息"
+ echo " -a, --all 运行全部测试(默认)"
+ echo " -p, --p0 仅运行 P0 级测试"
+ echo " -c, --crud 仅运行 CRUD 操作测试"
+ echo " -x, --complex 仅运行复杂场景测试"
+ echo " -v, --verbose 详细输出模式"
+ echo " -r, --report 生成 HTML 测试报告"
+ echo ""
+ exit 0
+fi
+
+# 默认选项
+VERBOSE=""
+REPORT=""
+TEST_TYPE=""
+
+# 解析参数
+while [[ $# -gt 0 ]]; do
+ case $1 in
+ -v|--verbose)
+ VERBOSE="-v"
+ shift
+ ;;
+ -r|--report)
+ REPORT="--html=reports/test_report.html --self-contained-html"
+ shift
+ ;;
+ -a|--all)
+ TEST_TYPE=""
+ shift
+ ;;
+ -p|--p0)
+ TEST_TYPE="tests/p0/"
+ shift
+ ;;
+ -c|--crud)
+ TEST_TYPE="tests/crud/"
+ shift
+ ;;
+ -x|--complex)
+ TEST_TYPE="tests/complex/"
+ shift
+ ;;
+ *)
+ echo "未知选项: $1"
+ echo "使用 -h 查看帮助"
+ exit 1
+ ;;
+ esac
+done
+
+# 确保报告目录存在
+mkdir -p reports logs
+
+# 运行测试
+if [ -n "$TEST_TYPE" ]; then
+ echo "运行 $TEST_TYPE 目录下的测试..."
+ pytest $TEST_TYPE $VERBOSE $REPORT
+else
+ echo "运行 pytest 测试文件..."
+ pytest test_pytest.py $VERBOSE $REPORT
+fi
+
+echo ""
+echo "====================================="
+echo "测试完成"
+echo "====================================="
+if [ -n "$REPORT" ]; then
+ echo "测试报告已生成: reports/test_report.html"
+ echo "使用 'open reports/test_report.html' 查看报告"
+fi
+echo ""
diff --git a/tests/oc2ov_test/run_tests.py b/tests/oc2ov_test/run_tests.py
new file mode 100644
index 000000000..cfba5293c
--- /dev/null
+++ b/tests/oc2ov_test/run_tests.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+测试运行入口
+"""
+
+import argparse
+import sys
+import unittest
+
+from utils.logger import setup_logger
+
+
+def get_test_suite(test_type: str = None):
+ """
+ 获取测试套件
+ """
+ loader = unittest.TestLoader()
+ suite = unittest.TestSuite()
+
+ if test_type == "p0":
+ suite.addTests(loader.loadTestsFromName("tests.p0.test_memory_write"))
+ elif test_type == "crud":
+ suite.addTests(loader.loadTestsFromName("tests.crud.test_memory_crud"))
+ elif test_type == "complex":
+ suite.addTests(loader.loadTestsFromName("tests.complex.test_complex_scenarios"))
+ else:
+ suite.addTests(loader.loadTestsFromName("tests.p0.test_memory_write"))
+ suite.addTests(loader.loadTestsFromName("tests.crud.test_memory_crud"))
+ suite.addTests(loader.loadTestsFromName("tests.complex.test_complex_scenarios"))
+
+ return suite
+
+
+def main():
+ parser = argparse.ArgumentParser(description="OpenClaw - OpenViking 端到端自动化测试")
+ parser.add_argument(
+ "--type",
+ "-t",
+ choices=["all", "p0", "crud", "complex"],
+ default="all",
+ help="测试类型: all(全部), p0(P0级), crud(CRUD操作), complex(复杂场景)",
+ )
+ parser.add_argument(
+ "--test",
+ "-s",
+ help="运行指定的测试用例, 例如: tests.p0.test_memory_write.TestMemoryWriteGroupA",
+ )
+ parser.add_argument("--verbose", "-v", action="store_true", help="详细输出")
+
+ args = parser.parse_args()
+
+ setup_logger()
+
+ if args.test:
+ suite = unittest.TestSuite()
+ suite.addTests(unittest.TestLoader().loadTestsFromName(args.test))
+ else:
+ suite = get_test_suite(args.type)
+
+ verbosity = 2 if args.verbose else 1
+ runner = unittest.TextTestRunner(verbosity=verbosity)
+ result = runner.run(suite)
+
+ return 0 if result.wasSuccessful() else 1
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/tests/oc2ov_test/setup.sh b/tests/oc2ov_test/setup.sh
new file mode 100755
index 000000000..bdcb4a7b7
--- /dev/null
+++ b/tests/oc2ov_test/setup.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+# OpenClaw 测试环境设置脚本
+
+set -e
+
+echo "====================================="
+echo "OpenClaw - OpenViking 测试环境设置"
+echo "====================================="
+echo ""
+
+# 检查虚拟环境是否已存在
+if [ ! -d "venv" ]; then
+ echo "创建虚拟环境..."
+ python -m venv venv
+fi
+
+echo "激活虚拟环境..."
+source venv/bin/activate
+
+echo ""
+echo "升级 pip..."
+pip install --upgrade pip
+
+echo ""
+echo "安装项目依赖..."
+pip install -r requirements.txt
+
+echo ""
+echo "安装测试报告生成依赖..."
+pip install pytest-html
+
+echo ""
+echo "====================================="
+echo "环境设置完成!"
+echo "====================================="
+echo ""
+echo "使用以下命令激活虚拟环境:"
+echo " source venv/bin/activate"
+echo ""
+echo "或运行测试:"
+echo " ./run.sh"
+echo ""
diff --git a/tests/oc2ov_test/tests/__init__.py b/tests/oc2ov_test/tests/__init__.py
new file mode 100644
index 000000000..d9b71a1bd
--- /dev/null
+++ b/tests/oc2ov_test/tests/__init__.py
@@ -0,0 +1,3 @@
+"""
+测试用例模块
+"""
diff --git a/tests/oc2ov_test/tests/advanced/__init__.py b/tests/oc2ov_test/tests/advanced/__init__.py
new file mode 100644
index 000000000..a129ff340
--- /dev/null
+++ b/tests/oc2ov_test/tests/advanced/__init__.py
@@ -0,0 +1,3 @@
+"""
+高级场景测试
+"""
diff --git a/tests/oc2ov_test/tests/advanced/test_advanced_scenarios.py b/tests/oc2ov_test/tests/advanced/test_advanced_scenarios.py
new file mode 100644
index 000000000..73d2bd385
--- /dev/null
+++ b/tests/oc2ov_test/tests/advanced/test_advanced_scenarios.py
@@ -0,0 +1,108 @@
+"""
+高级场景测试
+测试目标:验证复杂记忆场景
+"""
+
+from tests.base_cli_test import BaseOpenClawCLITest
+
+
+class TestComplexScenarioMultiUsers(BaseOpenClawCLITest):
+ """
+ 复杂场景1:多用户切换
+ 测试目标:验证多用户记忆切换
+ """
+
+ def test_multi_users_switch(self):
+ """多用户记忆切换测试"""
+ users = [
+ {"name": "用户A", "age": 22, "region": "东北区", "job": "学生"},
+ {"name": "用户B", "age": 35, "region": "西北区", "job": "医生"},
+ {"name": "用户C", "age": 45, "region": "中南区", "job": "教师"},
+ ]
+
+ for user in users:
+ self.logger.info(f"写入用户信息: {user}")
+ msg = f"我叫{user['name']},今年{user['age']}岁,住在{user['region']},职业是{user['job']}"
+ self.send_and_log(msg)
+ self.wait_for_sync()
+
+ self.logger.info(" 验证信息:")
+ resp = self.send_and_log("请介绍一下我自己")
+ self.assertAnyKeywordInResponse(
+ resp,
+ [[user["name"]], [str(user["age"])], [user["region"]], [user["job"]]],
+ case_sensitive=False,
+ )
+ self.wait_for_sync(2)
+
+
+class TestComplexScenarioIncrementalInfo(BaseOpenClawCLITest):
+ """
+ 复杂场景2:增量信息添加
+ 测试目标:验证增量信息添加
+ """
+
+ def test_incremental_info(self):
+ """增量信息添加测试"""
+ steps = [
+ "我叫增量测试用户",
+ "我今年33岁",
+ "我住在华中区",
+ "我的职业是架构师",
+ "我喜欢编程和阅读",
+ "我擅长Python和Go语言",
+ "我有10年工作经验",
+ ]
+
+ self.logger.info("分多次添加用户信息...")
+ for i, step in enumerate(steps, 1):
+ self.logger.info(f"[{i}/{len(steps)}] 添加: {step}")
+ self.send_and_log(step)
+ self.wait_for_sync()
+
+ self.logger.info("\n[最终验证] 汇总所有信息")
+ resp = self.send_and_log(
+ "请详细介绍一下我,包括姓名、年龄、地区、职业、兴趣爱好、技能和工作经验"
+ )
+
+ self.assertAnyKeywordInResponse(
+ resp,
+ [
+ ["增量测试用户"],
+ ["33", "三十三"],
+ ["华中"],
+ ["架构师"],
+ ["编程", "阅读"],
+ ["Python", "Go"],
+ ["10", "十年"],
+ ],
+ case_sensitive=False,
+ )
+
+
+class TestComplexScenarioSpecialCharacters(BaseOpenClawCLITest):
+ """
+ 复杂场景3:特殊字符和边界情况
+ 测试目标:验证特殊字符处理
+ """
+
+ def test_special_characters(self):
+ """特殊字符和边界情况测试"""
+ special_messages = [
+ "我叫测试-特殊字符@#$%^&*()",
+ "我的备注是:测试'引号\"和\\反斜杠",
+ "我的爱好是:🎵音乐、🎨绘画、📚阅读(emoji测试)",
+ "我的地址是:测试换行\n第二行\n第三行",
+ ]
+
+ for msg in special_messages:
+ self.logger.info(f"测试信息: {repr(msg)}")
+ self.send_and_log(msg)
+ self.wait_for_sync()
+
+ self.logger.info("\n[验证特殊字符记忆]")
+ resp = self.send_and_log("请告诉我关于我的所有信息,包括名字、备注、爱好和地址")
+
+ self.assertAnyKeywordInResponse(
+ resp, [["测试-特殊字符"], ["音乐", "绘画", "阅读"], ["测试换行"]], case_sensitive=False
+ )
diff --git a/tests/oc2ov_test/tests/base_cli_test.py b/tests/oc2ov_test/tests/base_cli_test.py
new file mode 100644
index 000000000..af8b3bcc6
--- /dev/null
+++ b/tests/oc2ov_test/tests/base_cli_test.py
@@ -0,0 +1,115 @@
+"""
+测试基类 - 使用 OpenClaw CLI
+"""
+
+import logging
+import time
+import unittest
+
+from config.settings import TEST_CONFIG
+from utils.assertions import AssertionHelper
+from utils.openclaw_cli_client import OpenClawCLIClient
+
+
+class BaseOpenClawCLITest(unittest.TestCase):
+ """
+ OpenClaw CLI 测试基类
+ """
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ 测试类初始化
+ """
+ session_id = f"test_session_{cls.__name__}"
+ cls.client = OpenClawCLIClient(session_id=session_id)
+ cls.logger = logging.getLogger(cls.__name__)
+ cls.wait_time = TEST_CONFIG["wait_time"]
+ cls.assertion = AssertionHelper()
+ cls.logger.info("=" * 60)
+ cls.logger.info(f"测试类 {cls.__name__} 开始")
+ cls.logger.info(f"Session ID: {session_id}")
+ cls.logger.info("=" * 60)
+
+ def setUp(self):
+ """
+ 每个测试用例开始前
+ """
+ self.logger.info("\n" + "-" * 60)
+ self.logger.info(f"开始测试: {self._testMethodName}")
+
+ def wait_for_sync(self, seconds: int = None):
+ """
+ 等待记忆同步
+ """
+ wait_seconds = seconds or self.wait_time
+ self.logger.info(f"等待 {wait_seconds} 秒,确认记忆同步...")
+ time.sleep(wait_seconds)
+
+ def send_and_log(self, message: str, session_id: str = None, agent_id: str = None):
+ """
+ 发送消息并记录日志
+ """
+ self.logger.info("\n" + "▸" * 40)
+ self.logger.info("📨 测试步骤 - 发送消息")
+ self.logger.info("▸" * 40)
+ self.logger.info(f"消息内容: {message}")
+ if session_id:
+ self.logger.info(f"Session ID: {session_id}")
+ if agent_id:
+ self.logger.info(f"Agent ID: {agent_id}")
+
+ response = self.client.send_message(message, session_id, agent_id)
+
+ self.logger.info("\n" + "◂" * 40)
+ self.logger.info("📩 测试步骤 - 响应接收")
+ self.logger.info("◂" * 40)
+
+ # 提取并显示响应文本
+ response_text = self.assertion.extract_response_text(response)
+ self.logger.info(f"响应文本: {response_text}")
+
+ self.logger.info("◂" * 40 + "\n")
+ return response
+
+ def assertKeywordsInResponse(
+ self, response, keywords, require_all=True, case_sensitive=False, msg=None
+ ):
+ """
+ 断言响应中包含指定关键词
+ """
+ success = self.assertion.assert_keywords_in_response(
+ response, keywords, require_all, case_sensitive
+ )
+ self.assertTrue(success, msg or f"关键词断言失败,期望关键词: {keywords}")
+
+ def assertSimilarity(self, response, expected_text, min_similarity=0.6, msg=None):
+ """
+ 断言响应文本与期望文本的相似度
+ """
+ success = self.assertion.assert_similarity(response, expected_text, min_similarity)
+ self.assertTrue(success, msg or f"相似度断言失败,期望相似度 >= {min_similarity:.0%}")
+
+ def assertAnyKeywordInResponse(self, response, keyword_groups, case_sensitive=False, msg=None):
+ """
+ 断言响应中包含任意一组关键词中的任意一个
+ """
+ success = self.assertion.assert_any_keyword_in_response(
+ response, keyword_groups, case_sensitive
+ )
+ self.assertTrue(success, msg or "未在任何关键词组中找到匹配")
+
+ def tearDown(self):
+ """
+ 每个测试用例结束后
+ """
+ self.logger.info(f"测试完成: {self._testMethodName}")
+
+ @classmethod
+ def tearDownClass(cls):
+ """
+ 测试类结束
+ """
+ cls.logger.info("\n" + "=" * 60)
+ cls.logger.info(f"测试类 {cls.__name__} 结束")
+ cls.logger.info("=" * 60)
diff --git a/tests/oc2ov_test/tests/base_test.py b/tests/oc2ov_test/tests/base_test.py
new file mode 100644
index 000000000..8688fbfd4
--- /dev/null
+++ b/tests/oc2ov_test/tests/base_test.py
@@ -0,0 +1,111 @@
+"""
+测试基类
+"""
+
+import logging
+import time
+import unittest
+
+from config.settings import TEST_CONFIG
+from utils.assertions import AssertionHelper
+from utils.openclaw_client import OpenClawClient
+
+
+class BaseOpenClawTest(unittest.TestCase):
+ """
+ OpenClaw 测试基类
+ """
+
+ @classmethod
+ def setUpClass(cls):
+ """
+ 测试类初始化
+ """
+ cls.client = OpenClawClient()
+ cls.logger = logging.getLogger(cls.__name__)
+ cls.wait_time = TEST_CONFIG["wait_time"]
+ cls.assertion = AssertionHelper()
+ cls.logger.info("=" * 60)
+ cls.logger.info(f"测试类 {cls.__name__} 开始")
+ cls.logger.info("=" * 60)
+
+ def setUp(self):
+ """
+ 每个测试用例开始前
+ """
+ self.logger.info("\n" + "-" * 60)
+ self.logger.info(f"开始测试: {self._testMethodName}")
+
+ def wait_for_sync(self, seconds: int = None):
+ """
+ 等待记忆同步
+ """
+ wait_seconds = seconds or self.wait_time
+ self.logger.info(f"等待 {wait_seconds} 秒,确认记忆同步...")
+ time.sleep(wait_seconds)
+
+ def send_and_log(self, message: str, agent_id: str = None):
+ """
+ 发送消息并记录日志
+ """
+ self.logger.info("\n" + "▸" * 40)
+ self.logger.info("📨 测试步骤 - 发送消息")
+ self.logger.info("▸" * 40)
+ self.logger.info(f"消息内容: {message}")
+ if agent_id:
+ self.logger.info(f"Agent ID: {agent_id}")
+
+ response = self.client.send_message(message, agent_id)
+
+ self.logger.info("\n" + "◂" * 40)
+ self.logger.info("📩 测试步骤 - 响应接收")
+ self.logger.info("◂" * 40)
+
+ # 提取并显示响应文本
+ response_text = self.assertion.extract_response_text(response)
+ self.logger.info(f"响应文本: {response_text}")
+
+ self.logger.info("◂" * 40 + "\n")
+ return response
+
+ def assertKeywordsInResponse(
+ self, response, keywords, require_all=True, case_sensitive=False, msg=None
+ ):
+ """
+ 断言响应中包含指定关键词
+ """
+ success = self.assertion.assert_keywords_in_response(
+ response, keywords, require_all, case_sensitive
+ )
+ self.assertTrue(success, msg or f"关键词断言失败,期望关键词: {keywords}")
+
+ def assertSimilarity(self, response, expected_text, min_similarity=0.6, msg=None):
+ """
+ 断言响应文本与期望文本的相似度
+ """
+ success = self.assertion.assert_similarity(response, expected_text, min_similarity)
+ self.assertTrue(success, msg or f"相似度断言失败,期望相似度 >= {min_similarity:.0%}")
+
+ def assertAnyKeywordInResponse(self, response, keyword_groups, case_sensitive=False, msg=None):
+ """
+ 断言响应中包含任意一组关键词中的任意一个
+ """
+ success = self.assertion.assert_any_keyword_in_response(
+ response, keyword_groups, case_sensitive
+ )
+ self.assertTrue(success, msg or "未在任何关键词组中找到匹配")
+
+ def tearDown(self):
+ """
+ 每个测试用例结束后
+ """
+ self.logger.info(f"测试完成: {self._testMethodName}")
+
+ @classmethod
+ def tearDownClass(cls):
+ """
+ 测试类结束
+ """
+ cls.logger.info("\n" + "=" * 60)
+ cls.logger.info(f"测试类 {cls.__name__} 结束")
+ cls.logger.info("=" * 60)
diff --git a/tests/oc2ov_test/tests/long_term/__init__.py b/tests/oc2ov_test/tests/long_term/__init__.py
new file mode 100644
index 000000000..2a1947254
--- /dev/null
+++ b/tests/oc2ov_test/tests/long_term/__init__.py
@@ -0,0 +1,3 @@
+"""
+长程对话相关测试
+"""
diff --git a/tests/oc2ov_test/tests/long_term/test_long_term_conversation.py b/tests/oc2ov_test/tests/long_term/test_long_term_conversation.py
new file mode 100644
index 000000000..0aab01dd3
--- /dev/null
+++ b/tests/oc2ov_test/tests/long_term/test_long_term_conversation.py
@@ -0,0 +1,205 @@
+"""
+长程对话相关测试
+测试目标:验证长程对话记忆功能
+"""
+
+from tests.base_cli_test import BaseOpenClawCLITest
+
+
+class TestLongTermMemoryTarget(BaseOpenClawCLITest):
+ """
+ 长程对话核心目标记忆验证
+ 测试目标:验证多轮对话后,核心信息记忆不丢失
+ 测试场景:先记住核心信息,插入多轮简单对话,然后验证核心信息
+ """
+
+ def test_long_term_target_group_a(self):
+ """测试组A:记住关键信息,多轮对话后验证"""
+ self.logger.info("[1/3] 测试组A - 步骤1:记住关键信息")
+ message1 = "请记住:我的名字是张三,我的工号是1001,我的部门是技术部"
+ session_a = "long_term_a"
+
+ self.send_and_log(message1, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[2/3] 步骤2:插入多轮简单对话")
+ simple_messages = [
+ "1 + 1 等于几?",
+ "2 + 3 等于几?",
+ "5 + 7 等于几?",
+ "10 - 4 等于几?",
+ "8 + 9 等于几?",
+ ]
+
+ for i, msg in enumerate(simple_messages, 1):
+ self.logger.info(f" 简单对话 {i}/{len(simple_messages)}: {msg}")
+ self.send_and_log(msg, session_id=session_a)
+ self.wait_for_sync(2)
+
+ self.logger.info("[3/3] 步骤3:提问并验证核心信息")
+ response = self.send_and_log("我叫什么名字?工号是多少?部门是什么?", session_id=session_a)
+
+ self.assertAnyKeywordInResponse(
+ response, [["张三", "1001", "技术部"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组A执行完成")
+
+ def test_long_term_target_group_b(self):
+ """测试组B:记住关键信息,多轮对话后验证"""
+ self.logger.info("[1/3] 测试组B - 步骤1:记住关键信息")
+ message1 = "请记住:我的名字是李四,我的工号是1002,我的部门是产品部"
+ session_b = "long_term_b"
+
+ self.send_and_log(message1, session_id=session_b)
+ self.wait_for_sync()
+
+ self.logger.info("[2/3] 步骤2:插入多轮简单对话")
+ simple_messages = [
+ "请记住:苹果是红色的",
+ "请记住:香蕉是黄色的",
+ "请记住:葡萄是紫色的",
+ "请记住:橙子是橙色的",
+ "请记住:西瓜是绿色的",
+ ]
+
+ for i, msg in enumerate(simple_messages, 1):
+ self.logger.info(f" 简单对话 {i}/{len(simple_messages)}: {msg}")
+ self.send_and_log(msg, session_id=session_b)
+ self.wait_for_sync(2)
+
+ self.logger.info("[3/3] 步骤3:提问并验证核心信息")
+ response = self.send_and_log("我叫什么名字?工号是多少?部门是什么?", session_id=session_b)
+
+ self.assertAnyKeywordInResponse(
+ response, [["李四", "1002", "产品部"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组B执行完成")
+
+ def test_long_term_target_group_c(self):
+ """测试组C:记住关键信息,多轮对话后验证"""
+ self.logger.info("[1/3] 测试组C - 步骤1:记住关键信息")
+ message1 = "请记住:我的名字是王五,我的工号是1003,我的部门是设计部"
+ session_c = "long_term_c"
+
+ self.send_and_log(message1, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[2/3] 步骤2:插入多轮简单对话")
+ simple_messages = [
+ "请重复:今天是2026年3月24日",
+ "请重复:今天是星期三",
+ "请重复:今天天气晴朗",
+ "请重复:现在是测试时间",
+ "请重复:正在进行记忆测试",
+ ]
+
+ for i, msg in enumerate(simple_messages, 1):
+ self.logger.info(f" 简单对话 {i}/{len(simple_messages)}: {msg}")
+ self.send_and_log(msg, session_id=session_c)
+ self.wait_for_sync(2)
+
+ self.logger.info("[3/3] 步骤3:提问并验证核心信息")
+ response = self.send_and_log("我叫什么名字?工号是多少?部门是什么?", session_id=session_c)
+
+ self.assertAnyKeywordInResponse(
+ response, [["王五", "1003", "设计部"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组C执行完成")
+
+
+class TestLongTermSummaryGeneration(BaseOpenClawCLITest):
+ """
+ 长程对话总结生成验证
+ 测试目标:验证多轮信息后,能记住并整合所有信息
+ 测试场景:先记住多条信息,然后要求复述
+ """
+
+ def test_summary_generation_group_a(self):
+ """测试组A:记住多条个人信息,然后复述"""
+ self.logger.info("[1/4] 测试组A - 步骤1:记住第一条信息")
+ message1 = "请记住:我的名字叫测试A,今年28岁"
+ session_a = "summary_a"
+
+ self.send_and_log(message1, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 步骤2:记住第二条信息")
+ message2 = "请记住:我住在北京,职业是工程师"
+ self.send_and_log(message2, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 步骤3:记住第三条信息")
+ message3 = "请记住:我喜欢编程,喜欢阅读"
+ self.send_and_log(message3, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[4/4] 步骤4:要求复述所有信息")
+ response = self.send_and_log("请复述一下刚才记住的所有关于我的信息", session_id=session_a)
+ self.wait_for_sync()
+
+ self.assertAnyKeywordInResponse(
+ response, [["测试A", "28", "北京", "工程师", "编程", "阅读"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组A执行完成")
+
+ def test_summary_generation_group_b(self):
+ """测试组B:记住多条个人信息,然后复述"""
+ self.logger.info("[1/4] 测试组B - 步骤1:记住第一条信息")
+ message1 = "请记住:我的名字叫测试B,今年30岁"
+ session_b = "summary_b"
+
+ self.send_and_log(message1, session_id=session_b)
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 步骤2:记住第二条信息")
+ message2 = "请记住:我住在上海,职业是设计师"
+ self.send_and_log(message2, session_id=session_b)
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 步骤3:记住第三条信息")
+ message3 = "请记住:我喜欢画画,喜欢旅行"
+ self.send_and_log(message3, session_id=session_b)
+ self.wait_for_sync()
+
+ self.logger.info("[4/4] 步骤4:要求复述所有信息")
+ response = self.send_and_log("请复述一下刚才记住的所有关于我的信息", session_id=session_b)
+ self.wait_for_sync()
+
+ self.assertAnyKeywordInResponse(
+ response, [["测试B", "30", "上海", "设计师", "画画", "旅行"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组B执行完成")
+
+ def test_summary_generation_group_c(self):
+ """测试组C:记住多条个人信息,然后复述"""
+ self.logger.info("[1/4] 测试组C - 步骤1:记住第一条信息")
+ message1 = "请记住:我的名字叫测试C,今年32岁"
+ session_c = "summary_c"
+
+ self.send_and_log(message1, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 步骤2:记住第二条信息")
+ message2 = "请记住:我住在广州,职业是产品经理"
+ self.send_and_log(message2, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 步骤3:记住第三条信息")
+ message3 = "请记住:我喜欢音乐,喜欢运动"
+ self.send_and_log(message3, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[4/4] 步骤4:要求复述所有信息")
+ response = self.send_and_log("请复述一下刚才记住的所有关于我的信息", session_id=session_c)
+ self.wait_for_sync()
+
+ self.assertAnyKeywordInResponse(
+ response, [["测试C", "32", "广州", "产品经理", "音乐", "运动"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组C执行完成")
diff --git a/tests/oc2ov_test/tests/p0/__init__.py b/tests/oc2ov_test/tests/p0/__init__.py
new file mode 100644
index 000000000..a221b8f06
--- /dev/null
+++ b/tests/oc2ov_test/tests/p0/__init__.py
@@ -0,0 +1,3 @@
+"""
+P0 质量保障类测试
+"""
diff --git a/tests/oc2ov_test/tests/p0/test_memory_crud.py b/tests/oc2ov_test/tests/p0/test_memory_crud.py
new file mode 100644
index 000000000..90ef83678
--- /dev/null
+++ b/tests/oc2ov_test/tests/p0/test_memory_crud.py
@@ -0,0 +1,169 @@
+"""
+记忆 CRUD 操作测试
+测试目标:验证记忆的增删改查功能
+"""
+
+from tests.base_cli_test import BaseOpenClawCLITest
+
+
+class TestMemoryRead(BaseOpenClawCLITest):
+ """
+ 记忆读取验证测试
+ 测试目标:验证记忆读取功能是否正常
+ 测试场景:写入用户信息后,逐项验证各字段的读取
+ """
+
+ def test_memory_read_verify(self):
+ """测试场景:逐项信息读取验证"""
+ self.logger.info("[1/2] 先写入用户信息")
+ message = "我叫测试用户-读取验证,今年40岁,住在华南区,职业是前端工程师"
+ self.send_and_log(message)
+ self.wait_for_sync()
+
+ self.logger.info("[2/2] 逐项验证记忆读取")
+ queries = [
+ ("我叫什么名字?", [["测试用户", "读取验证"]], "姓名验证"),
+ ("我几岁了?", [["40", "四十"]], "年龄验证"),
+ ("我住在哪里?", [["华南"]], "地区验证"),
+ ("我的职业是什么?", [["前端", "工程师"]], "职业验证"),
+ ]
+
+ for query, expected_keywords, desc in queries:
+ self.logger.info(f" 查询: {query} (场景: {desc})")
+ resp = self.send_and_log(query)
+ self.assertAnyKeywordInResponse(resp, expected_keywords, case_sensitive=False)
+ self.wait_for_sync(2)
+
+
+class TestMemoryUpdate(BaseOpenClawCLITest):
+ """
+ 记忆更新验证测试
+ 测试目标:验证记忆更新功能是否正常
+ 测试场景:先写入初始信息,然后更新年龄、职业和地址,验证更新是否生效
+ """
+
+ def test_memory_update_verify(self):
+ """测试场景:信息更新与验证"""
+ self.logger.info("[1/4] 写入初始信息")
+ self.send_and_log("我叫小李,今年28岁,住在西南区,职业是数据分析师")
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 更新信息:年龄改为29岁,职业改为数据科学家")
+ self.send_and_log("我现在29岁了,我的职业从数据分析师变成了数据科学家")
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 验证更新是否生效")
+ resp1 = self.send_and_log("我现在多少岁?我的职业是什么?")
+ self.assertAnyKeywordInResponse(
+ resp1, [["29", "二十九"], ["数据科学家"]], case_sensitive=False
+ )
+
+ self.logger.info("[4/4] 进一步更新地址信息")
+ self.send_and_log("我搬到了西北区")
+ self.wait_for_sync()
+ resp2 = self.send_and_log("我现在住在哪里?")
+ self.assertAnyKeywordInResponse(resp2, [["西北"]], case_sensitive=False)
+
+
+class TestMemoryDelete(BaseOpenClawCLITest):
+ """
+ 记忆删除验证测试
+ 测试目标:验证记忆删除功能是否正常
+ 测试场景:写入临时信息,验证存在后删除,再验证信息已被删除
+ """
+
+ def test_memory_delete_verify(self):
+ """测试场景:信息删除与验证"""
+ self.logger.info("[1/3] 写入待删除的测试信息")
+ self.send_and_log("这是一条临时信息,我马上会删除它,我的临时密码是temp12345")
+ self.wait_for_sync()
+
+ self.logger.info("[2/3] 确认信息已存在")
+ resp1 = self.send_and_log("我的临时密码是什么?")
+ self.assertAnyKeywordInResponse(resp1, [["temp12345"]], case_sensitive=False)
+
+ self.logger.info("[3/3] 请求删除临时信息")
+ self.send_and_log("请删除关于我的临时密码的信息")
+ self.wait_for_sync()
+ self.send_and_log("我的临时密码是什么?")
+ self.logger.info("删除验证完成,检查响应是否不包含原密码信息")
+
+
+class TestMemoryUpdateOverwrite(BaseOpenClawCLITest):
+ """
+ 记忆更新覆盖验证
+ 测试目标:验证用户更新信息后,OpenViking自动覆盖旧记忆,不产生冗余数据
+ 测试场景:先写入初始信息,再更新信息,验证只保留新信息
+ """
+
+ def test_memory_update_overwrite_group_a(self):
+ """测试组A:初始信息——我今年30岁;更新信息——我今年31岁,生日在8月"""
+ self.logger.info("[1/4] 测试组A - 写入初始信息:我今年30岁")
+ message_initial = "我今年30岁"
+ session_a = "update_overwrite_a"
+
+ self.send_and_log(message_initial, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 写入更新信息:我今年31岁,生日在8月")
+ message_update = "我今年31岁,生日在8月"
+ self.send_and_log(message_update, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 查询并验证记忆信息")
+ response = self.send_and_log("我今年几岁?生日是什么时候?", session_id=session_a)
+
+ self.logger.info("[4/4] 验证结果:应包含新信息(31岁、8月),不应包含旧信息(30岁)")
+ self.assertAnyKeywordInResponse(
+ response, [["31", "三十一"], ["8月", "八月"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组A执行完成")
+
+ def test_memory_update_overwrite_group_b(self):
+ """测试组B:初始信息——我今年26岁;更新信息——我今年27岁,生日在11月"""
+ self.logger.info("[1/4] 测试组B - 写入初始信息:我今年26岁")
+ message_initial = "我今年26岁"
+ session_b = "update_overwrite_b"
+
+ self.send_and_log(message_initial, session_id=session_b)
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 写入更新信息:我今年27岁,生日在11月")
+ message_update = "我今年27岁,生日在11月"
+ self.send_and_log(message_update, session_id=session_b)
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 查询并验证记忆信息")
+ response = self.send_and_log("我今年几岁?生日是什么时候?", session_id=session_b)
+
+ self.logger.info("[4/4] 验证结果:应包含新信息(27岁、11月),不应包含旧信息(26岁)")
+ self.assertAnyKeywordInResponse(
+ response, [["27", "二十七"], ["11月", "十一月"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组B执行完成")
+
+ def test_memory_update_overwrite_group_c(self):
+ """测试组C:初始信息——我今年32岁;更新信息——我今年33岁,生日在5月"""
+ self.logger.info("[1/4] 测试组C - 写入初始信息:我今年32岁")
+ message_initial = "我今年32岁"
+ session_c = "update_overwrite_c"
+
+ self.send_and_log(message_initial, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[2/4] 写入更新信息:我今年33岁,生日在5月")
+ message_update = "我今年33岁,生日在5月"
+ self.send_and_log(message_update, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 查询并验证记忆信息")
+ response = self.send_and_log("我今年几岁?生日是什么时候?", session_id=session_c)
+
+ self.logger.info("[4/4] 验证结果:应包含新信息(33岁、5月),不应包含旧信息(32岁)")
+ self.assertAnyKeywordInResponse(
+ response, [["33", "三十三"], ["5月", "五月"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组C执行完成")
diff --git a/tests/oc2ov_test/tests/p0/test_memory_write.py b/tests/oc2ov_test/tests/p0/test_memory_write.py
new file mode 100644
index 000000000..59a7c430c
--- /dev/null
+++ b/tests/oc2ov_test/tests/p0/test_memory_write.py
@@ -0,0 +1,68 @@
+"""
+P0 - 记忆结构化写入验证测试
+测试目标:验证OpenViking能正确接收、存储OpenClaw传入的用户信息
+"""
+
+from tests.base_cli_test import BaseOpenClawCLITest
+
+
+class TestMemoryWriteGroupA(BaseOpenClawCLITest):
+ """
+ 测试组A(小明):基本记忆结构化写入验证
+ 测试目标:验证OpenViking能正确接收、存储OpenClaw传入的用户信息,无数据丢失
+ 测试场景:写入小明的基本信息(姓名、年龄、地区、职业),然后验证信息正确性
+ """
+
+ def test_memory_write_basic_info(self):
+ """测试场景:基本信息写入与验证"""
+ self.logger.info("[1/4] 发送记忆写入指令")
+ message = "我叫小明,今年30岁,住在华东区,职业是测试开发"
+ self.send_and_log(message)
+
+ self.wait_for_sync()
+
+ self.logger.info("[3/4] 发送确认指令:我是谁")
+ response2 = self.send_and_log("我是谁")
+
+ self.assertAnyKeywordInResponse(
+ response2, [["小明", "测试开发", "30岁", "华东"]], case_sensitive=False
+ )
+
+ self.logger.info("[4/4] 再等待后询问年龄...")
+ self.wait_for_sync()
+
+ response3 = self.send_and_log("我当前多少岁")
+
+ self.assertAnyKeywordInResponse(response3, [["30", "三十"]], case_sensitive=False)
+
+ self.logger.info("测试组A执行完成")
+
+
+class TestMemoryWriteGroupB(BaseOpenClawCLITest):
+ """
+ 测试组B(小红):更多维度信息写入
+ 测试目标:多维度丰富信息写入验证
+ 测试场景:写入小红的详细信息(姓名、年龄、地址、职业、喜好、生日)
+ """
+
+ def test_memory_write_rich_info(self):
+ """测试场景:丰富信息写入与验证"""
+ message = (
+ "我叫小红,今年25岁,住在华北区北京市朝阳区,职业是产品经理,"
+ "喜欢美食和旅游,不喜欢加班,我的生日是1999年8月15日"
+ )
+ self.logger.info("[1/3] 发送丰富信息记忆写入")
+ self.send_and_log(message)
+
+ self.wait_for_sync()
+
+ self.logger.info("[3/3] 验证多维度信息:询问我的职业、生日和喜好")
+ response2 = self.send_and_log("我的职业是什么,生日是什么时候,我喜欢什么")
+
+ self.assertAnyKeywordInResponse(
+ response2,
+ [["产品经理"], ["1999", "8月", "8/15"], ["美食", "旅游"]],
+ case_sensitive=False,
+ )
+
+ self.logger.info("测试组B执行完成")
diff --git a/tests/oc2ov_test/tests/session/__init__.py b/tests/oc2ov_test/tests/session/__init__.py
new file mode 100644
index 000000000..8a23d12f8
--- /dev/null
+++ b/tests/oc2ov_test/tests/session/__init__.py
@@ -0,0 +1,4 @@
+"""
+Session 测试模块
+测试跨会话的记忆持久化功能
+"""
diff --git a/tests/oc2ov_test/tests/session/test_session_persistence.py b/tests/oc2ov_test/tests/session/test_session_persistence.py
new file mode 100644
index 000000000..584b9f19c
--- /dev/null
+++ b/tests/oc2ov_test/tests/session/test_session_persistence.py
@@ -0,0 +1,105 @@
+"""
+Session 持久化测试
+测试目标:验证跨会话的记忆持久化功能
+测试场景:写入用户信息,使用不同 session-id 模拟新会话,验证记忆读取
+"""
+
+from tests.base_cli_test import BaseOpenClawCLITest
+
+
+class TestMemoryPersistence(BaseOpenClawCLITest):
+ """
+ 记忆跨会话读取验证
+ 测试目标:验证OpenClaw重启后,可从OpenViking正常读取历史记忆,记忆持久化生效
+ 测试场景:写入用户信息,使用不同session-id模拟新会话,验证记忆读取
+ """
+
+ def test_memory_persistence_group_a(self):
+ """测试组A:我喜欢吃樱桃,日常喜欢喝美式咖啡"""
+ self.logger.info("[1/5] 测试组A - 写入记忆信息")
+ message = "我喜欢吃樱桃,日常喜欢喝美式咖啡"
+ session_a = "persistence_test_a"
+
+ response1 = self.send_and_log(message, session_id=session_a)
+ self.wait_for_sync()
+
+ self.logger.info("[2/5] 验证当前会话能读取记忆")
+ response2 = self.send_and_log("我喜欢吃什么水果?平时爱喝什么?", session_id=session_a)
+ self.assertAnyKeywordInResponse(
+ response2, [["樱桃"], ["美式", "咖啡"]], case_sensitive=False
+ )
+
+ self.logger.info("[3/5] 使用新的 session-id 模拟新会话")
+ session_b = "persistence_test_b"
+
+ self.wait_for_sync()
+
+ self.logger.info("[4/5] 在新会话中查询记忆")
+ response3 = self.send_and_log("我喜欢吃什么水果?平时爱喝什么?", session_id=session_b)
+
+ self.logger.info("[5/5] 验证记忆持久化读取")
+ self.assertAnyKeywordInResponse(
+ response3, [["樱桃"], ["美式", "咖啡"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组A执行完成")
+
+ def test_memory_persistence_group_b(self):
+ """测试组B:我喜欢吃芒果,日常喜欢喝拿铁咖啡"""
+ self.logger.info("[1/5] 测试组B - 写入记忆信息")
+ message = "我喜欢吃芒果,日常喜欢喝拿铁咖啡"
+ session_c = "persistence_test_c"
+
+ response1 = self.send_and_log(message, session_id=session_c)
+ self.wait_for_sync()
+
+ self.logger.info("[2/5] 验证当前会话能读取记忆")
+ response2 = self.send_and_log("我喜欢吃什么水果?平时爱喝什么?", session_id=session_c)
+ self.assertAnyKeywordInResponse(
+ response2, [["芒果"], ["拿铁", "咖啡"]], case_sensitive=False
+ )
+
+ self.logger.info("[3/5] 使用新的 session-id 模拟新会话")
+ session_d = "persistence_test_d"
+
+ self.wait_for_sync()
+
+ self.logger.info("[4/5] 在新会话中查询记忆")
+ response3 = self.send_and_log("我喜欢吃什么水果?平时爱喝什么?", session_id=session_d)
+
+ self.logger.info("[5/5] 验证记忆持久化读取")
+ self.assertAnyKeywordInResponse(
+ response3, [["芒果"], ["拿铁", "咖啡"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组B执行完成")
+
+ def test_memory_persistence_group_c(self):
+ """测试组C:我喜欢吃草莓,日常喜欢喝抹茶拿铁"""
+ self.logger.info("[1/5] 测试组C - 写入记忆信息")
+ message = "我喜欢吃草莓,日常喜欢喝抹茶拿铁"
+ session_e = "persistence_test_e"
+
+ response1 = self.send_and_log(message, session_id=session_e)
+ self.wait_for_sync()
+
+ self.logger.info("[2/5] 验证当前会话能读取记忆")
+ response2 = self.send_and_log("我喜欢吃什么水果?平时爱喝什么?", session_id=session_e)
+ self.assertAnyKeywordInResponse(
+ response2, [["草莓"], ["抹茶", "拿铁"]], case_sensitive=False
+ )
+
+ self.logger.info("[3/5] 使用新的 session-id 模拟新会话")
+ session_f = "persistence_test_f"
+
+ self.wait_for_sync()
+
+ self.logger.info("[4/5] 在新会话中查询记忆")
+ response3 = self.send_and_log("我喜欢吃什么水果?平时爱喝什么?", session_id=session_f)
+
+ self.logger.info("[5/5] 验证记忆持久化读取")
+ self.assertAnyKeywordInResponse(
+ response3, [["草莓"], ["抹茶", "拿铁"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组C执行完成")
diff --git a/tests/oc2ov_test/tests/skill/__init__.py b/tests/oc2ov_test/tests/skill/__init__.py
new file mode 100644
index 000000000..04c73e532
--- /dev/null
+++ b/tests/oc2ov_test/tests/skill/__init__.py
@@ -0,0 +1,3 @@
+"""
+技能相关测试
+"""
diff --git a/tests/oc2ov_test/tests/skill/test_skill_memory.py b/tests/oc2ov_test/tests/skill/test_skill_memory.py
new file mode 100644
index 000000000..b6af6b509
--- /dev/null
+++ b/tests/oc2ov_test/tests/skill/test_skill_memory.py
@@ -0,0 +1,127 @@
+"""
+技能相关测试
+测试目标:验证技能调用后的记忆功能
+注意:简化为记忆读写测试,避免外部技能依赖
+"""
+
+from tests.base_cli_test import BaseOpenClawCLITest
+
+
+class TestSkillExperiencePrecipitation(BaseOpenClawCLITest):
+ """
+ 销售数据查询技能经验沉淀验证(P1)
+ 测试目标:验证记忆读写功能正常,数据能正确存储和检索
+ 测试场景:先发送简单数据,再验证读取功能
+ """
+
+ def test_skill_experience_group_a(self):
+ """测试组A:简单记忆读写测试-先记住信息再读取"""
+ self.logger.info("[1/2] 测试组A - 步骤1:记住个人信息")
+ message1 = "请记住:我叫小明,今年25岁,住在上海"
+ session_a = "skill_exp_a"
+
+ response1 = self.send_and_log(message1, session_id=session_a)
+ self.wait_for_sync(30)
+
+ self.logger.info("[2/2] 步骤2:验证信息读取")
+ message2 = "我叫什么名字?今年多大?"
+ response2 = self.send_and_log(message2, session_id=session_a)
+
+ self.assertAnyKeywordInResponse(response2, [["小明", "25", "上海"]], case_sensitive=False)
+
+ self.logger.info("测试组A执行完成")
+
+ def test_skill_experience_group_b(self):
+ """测试组B:跨会话记忆读取测试"""
+ self.logger.info("[1/2] 测试组B - 步骤1:记住个人信息")
+ message1 = "请记住:我是小红,职业是设计师,喜欢画画"
+ session_b = "skill_exp_b"
+
+ self.send_and_log(message1, session_id=session_b)
+ self.wait_for_sync(30)
+
+ self.logger.info("[2/2] 步骤2:验证信息读取")
+ message2 = "我的职业是什么?我的爱好是什么?"
+ response2 = self.send_and_log(message2, session_id=session_b)
+
+ self.assertAnyKeywordInResponse(
+ response2, [["小红", "设计师", "画画"]], case_sensitive=False
+ )
+
+ self.logger.info("测试组B执行完成")
+
+ def test_skill_experience_group_c(self):
+ """测试组C:记忆更新功能测试"""
+ self.logger.info("[1/3] 测试组C - 步骤1:记住初始信息")
+ message1 = "请记住:我叫小刚,喜欢踢足球"
+ session_c = "skill_exp_c"
+
+ self.send_and_log(message1, session_id=session_c)
+ self.wait_for_sync(30)
+
+ self.logger.info("[2/3] 步骤2:更新信息")
+ message2 = "记住:我现在喜欢打篮球,不喜欢踢足球了"
+ self.send_and_log(message2, session_id=session_c)
+ self.wait_for_sync(30)
+
+ self.logger.info("[3/3] 步骤3:验证更新后的信息")
+ message3 = "我现在喜欢什么运动?"
+ response3 = self.send_and_log(message3, session_id=session_c)
+
+ self.assertAnyKeywordInResponse(response3, [["小刚", "篮球"]], case_sensitive=False)
+
+ self.logger.info("测试组C执行完成")
+
+
+class TestSkillMemoryLogVerification(BaseOpenClawCLITest):
+ """
+ 技能调用记忆注入日志验证(P0)
+ 测试目标:验证发送数据后,记忆成功注入OpenViking
+ 测试场景:发送简单数据,然后给出手动检查日志的提示
+ """
+
+ def test_skill_log_group_a(self):
+ """测试组A:简单数据写入测试"""
+ self.logger.info("[1/2] 测试组A - 发送个人信息")
+ test_data = "我叫测试员A,这是我的测试数据"
+ session_a = "skill_log_a"
+
+ response = self.send_and_log(test_data, session_id=session_a)
+ self.wait_for_sync(30)
+
+ self.logger.info("[2/2] 数据发送完成")
+ self.logger.info("提示:请手动检查OpenClaw日志,确认有记忆注入记录")
+ self.logger.info("提示:日志文件位于 /tmp/openclaw/openclaw-{今天日期}.log")
+ self.logger.info("提示:搜索关键词 'memory-openviking'")
+
+ self.assertAnyKeywordInResponse(response, [["测试员A", "测试数据"]], case_sensitive=False)
+
+ self.logger.info("测试组A执行完成")
+
+ def test_skill_log_group_b(self):
+ """测试组B:简单数据写入测试2"""
+ self.logger.info("[1/2] 测试组B - 发送另一条个人信息")
+ test_data = "我是测试员B,我喜欢测试工作"
+ session_b = "skill_log_b"
+
+ response = self.send_and_log(test_data, session_id=session_b)
+ self.wait_for_sync(30)
+
+ self.logger.info("[2/2] 数据发送完成")
+ self.assertAnyKeywordInResponse(response, [["测试员B", "测试工作"]], case_sensitive=False)
+
+ self.logger.info("测试组B执行完成")
+
+ def test_skill_log_group_c(self):
+ """测试组C:简单数据写入测试3"""
+ self.logger.info("[1/2] 测试组C - 发送第三条信息")
+ test_data = "我是测试员C,今天的日期是2026-03-24"
+ session_c = "skill_log_c"
+
+ response = self.send_and_log(test_data, session_id=session_c)
+ self.wait_for_sync(30)
+
+ self.logger.info("[2/2] 数据发送完成")
+ self.assertAnyKeywordInResponse(response, [["测试员C", "2026-03-24"]], case_sensitive=False)
+
+ self.logger.info("测试组C执行完成")
diff --git a/tests/oc2ov_test/upgrade_openviking.sh b/tests/oc2ov_test/upgrade_openviking.sh
new file mode 100644
index 000000000..c1880408e
--- /dev/null
+++ b/tests/oc2ov_test/upgrade_openviking.sh
@@ -0,0 +1,392 @@
+#!/bin/bash
+
+set -e
+
+# Trap signals for cleanup on interruption
+trap 'cleanup_on_exit' INT TERM EXIT
+
+cleanup_on_exit() {
+ log ""
+ log "========================================="
+ log "Cleanup: Script interrupted or failed"
+ log "========================================="
+
+ # Stop OpenClaw if running
+ if command -v openclaw &> /dev/null; then
+ log "Stopping OpenClaw gateway..."
+ openclaw gateway stop 2>&1 | tee -a "$LOG_FILE" || true
+ sleep 2
+ fi
+
+ # Kill any remaining OpenClaw processes
+ if ps aux | grep -v grep | grep -q "[o]penclaw"; then
+ log "Killing remaining OpenClaw processes..."
+ pkill -9 -f "openclaw" || true
+ sleep 1
+ fi
+
+ # Clean up backup if exists
+ if [ -d "/root/project/OpenViking_backup" ]; then
+ log "Removing backup directory..."
+ rm -rf "/root/project/OpenViking_backup" || true
+ fi
+
+ # Clean up build artifacts
+ if [ -d "/root/project/OpenViking/build" ]; then
+ log "Removing build artifacts..."
+ rm -rf "/root/project/OpenViking/build" || true
+ fi
+
+ # Clean up venv if created by tests
+ if [ -d "/root/project/OpenViking/tests/oc2ov_test/venv" ]; then
+ log "Removing test virtual environment..."
+ rm -rf "/root/project/OpenViking/tests/oc2ov_test/venv" || true
+ fi
+
+ log "Cleanup completed"
+ log "========================================="
+}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="/root/project/OpenViking"
+BACKUP_DIR="/root/project/OpenViking_backup"
+LOG_FILE="/var/log/openviking_upgrade.log"
+MAX_RETRIES=3
+RETRY_DELAY=10
+VENV_DIR="/root/.openviking/venv"
+
+log() {
+ local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+ echo "[${timestamp}] $1" | tee -a "$LOG_FILE"
+}
+
+log "========================================="
+log "OpenViking Upgrade Script Started"
+log "========================================="
+
+log "[1/8] Checking prerequisites and activating virtual environment..."
+
+# Check if OpenViking virtual environment exists
+if [ -d "$VENV_DIR" ]; then
+ log "Found OpenViking virtual environment at: $VENV_DIR"
+
+ # Activate virtual environment
+ if [ -f "$VENV_DIR/bin/activate" ]; then
+ source "$VENV_DIR/bin/activate"
+ log "✅ Virtual environment activated"
+
+ # Verify Python is from venv
+ PYTHON_PATH=$(which python3 || which python)
+ log "Using Python: $PYTHON_PATH"
+
+ if [[ "$PYTHON_PATH" != *"$VENV_DIR"* ]]; then
+ log "⚠️ Warning: Python is not from the virtual environment"
+ fi
+ else
+ log "⚠️ Virtual environment found but activate script missing"
+ fi
+else
+ log "⚠️ OpenViking virtual environment not found at $VENV_DIR"
+ log "Using system Python"
+fi
+
+if [ ! -d "$PROJECT_DIR" ]; then
+ log "ERROR: OpenViking directory not found: $PROJECT_DIR"
+ exit 1
+fi
+
+cd "$PROJECT_DIR" || exit 1
+
+log "[2/8] Backing up current version..."
+if [ -d "$BACKUP_DIR" ]; then
+ rm -rf "$BACKUP_DIR"
+fi
+cp -r "$PROJECT_DIR" "$BACKUP_DIR"
+log "Backup created at: $BACKUP_DIR"
+
+log "[3/8] Configuring Git remote and pulling latest code..."
+CURRENT_REMOTE=$(git remote get-url origin 2>/dev/null || echo "")
+log "Current remote URL: $CURRENT_REMOTE"
+
+if [[ "$CURRENT_REMOTE" == *"github.com"* ]] && [[ "$CURRENT_REMOTE" != *"[email protected]"* ]]; then
+ log "Switching from HTTPS to SSH for GitHub access..."
+ git remote set-url origin [email protected]:volcengine/OpenViking.git
+ log "✅ Remote URL updated to: [email protected]:volcengine/OpenViking.git"
+elif [[ "$CURRENT_REMOTE" != *"github.com"* ]]; then
+ log "Setting correct remote URL..."
+ git remote set-url origin [email protected]:volcengine/OpenViking.git
+ log "✅ Remote URL set to: [email protected]:volcengine/OpenViking.git"
+fi
+
+git fetch origin
+git reset --hard origin/main
+git clean -fd
+CURRENT_COMMIT=$(git rev-parse HEAD)
+log "Current commit: $CURRENT_COMMIT"
+
+log "[4/8] Checking OpenViking installation mode..."
+
+# Use python (from venv if activated) instead of python3
+INSTALL_MODE=$(python -c "import openviking; import os; path = openviking.__file__; print('dev' if 'site-packages' not in path else 'site-packages')" 2>/dev/null || echo "not_installed")
+log "Current installation mode: $INSTALL_MODE"
+
+if [ "$INSTALL_MODE" = "site-packages" ]; then
+ log "⚠️ OpenViking is installed in site-packages mode"
+ log "Uninstalling to switch to development mode..."
+ pip uninstall -y openviking 2>&1 | tee -a "$LOG_FILE" || true
+ log "✅ Uninstalled site-packages version"
+fi
+
+log "[5/8] Configuring Go proxy for China network..."
+export GOPROXY=https://goproxy.cn,direct
+export GOSUMDB=off
+log "✅ Go proxy configured: $GOPROXY"
+
+log "[5.5/8] Checking Rust toolchain..."
+RUST_OK=false
+
+if command -v rustc &> /dev/null; then
+ RUST_VERSION=$(rustc --version 2>/dev/null | awk '{print $2}' || echo "")
+ if [ -n "$RUST_VERSION" ]; then
+ log "✅ Rust is already installed and working: $RUST_VERSION"
+ RUST_OK=true
+ fi
+fi
+
+if [ "$RUST_OK" = false ]; then
+ log "Rust is not working properly, attempting to fix..."
+
+ if command -v rustup &> /dev/null; then
+ log "Found rustup, trying to install stable toolchain..."
+
+ if rustup install stable 2>&1 | tee -a "$LOG_FILE"; then
+ log "✅ Stable toolchain installed"
+
+ if rustup default stable 2>&1 | tee -a "$LOG_FILE"; then
+ log "✅ Stable set as default"
+ RUST_OK=true
+ fi
+ else
+ log "⚠️ Failed to install Rust toolchain via rustup"
+ log "Please install Rust manually on the ECS node:"
+ log " curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+ log " source \$HOME/.cargo/env"
+ log " rustup install stable"
+ log " rustup default stable"
+ fi
+ else
+ log "⚠️ rustup not found"
+ log "Please install Rust manually on the ECS node:"
+ log " curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+ log " source \$HOME/.cargo/env"
+ log " rustup install stable"
+ log " rustup default stable"
+ fi
+fi
+
+if [ "$RUST_OK" = true ]; then
+ RUST_VERSION=$(rustc --version 2>/dev/null | awk '{print $2}' || echo "unknown")
+ log "Rust version: $RUST_VERSION"
+else
+ log "⚠️ Rust toolchain setup failed, build may fail"
+fi
+
+log "[5.6/8] Checking Python build dependencies..."
+
+# Check if setuptools-scm is already installed
+if python -c "import setuptools_scm" 2>/dev/null; then
+ log "✅ setuptools-scm is already installed"
+else
+ log "Installing setuptools-scm and other build tools..."
+
+ if ! pip install --upgrade setuptools setuptools-scm wheel cmake build 2>&1 | tee -a "$LOG_FILE"; then
+ log "Standard pip install failed, trying with --break-system-packages..."
+ if pip install --break-system-packages --upgrade setuptools setuptools-scm wheel cmake build 2>&1 | tee -a "$LOG_FILE"; then
+ log "✅ Build dependencies installed successfully with --break-system-packages"
+ else
+ log "⚠️ Failed to install some build dependencies, continuing anyway..."
+ fi
+ else
+ log "✅ Build dependencies installed successfully"
+ fi
+fi
+
+log "[6/8] Cleaning previous build artifacts..."
+make clean 2>/dev/null || true
+log "Clean completed"
+
+log "[7/8] Building and installing OpenViking in development mode..."
+BUILD_SUCCESS=false
+for i in $(seq 1 $MAX_RETRIES); do
+ log "Build attempt $i/$MAX_RETRIES..."
+
+ if make build 2>&1 | tee -a "$LOG_FILE"; then
+ BUILD_SUCCESS=true
+ log "Build completed successfully on attempt $i"
+
+ INSTALL_PATH=$(python -c "import openviking; print(openviking.__file__)" 2>/dev/null || echo "unknown")
+ log "OpenViking installed at: $INSTALL_PATH"
+
+ if [[ "$INSTALL_PATH" == *"$PROJECT_DIR"* ]]; then
+ log "✅ Confirmed: Using development mode (source code directory)"
+ else
+ log "⚠️ Warning: Not using source code directory"
+ log "Expected path to contain: $PROJECT_DIR"
+ log "Actual path: $INSTALL_PATH"
+ fi
+ break
+ else
+ if [ $i -lt $MAX_RETRIES ]; then
+ log "Build failed on attempt $i, retrying in ${RETRY_DELAY}s..."
+ sleep $RETRY_DELAY
+ make clean 2>/dev/null || true
+ fi
+ fi
+done
+
+if [ "$BUILD_SUCCESS" = false ]; then
+ log "ERROR: Build failed after $MAX_RETRIES attempts"
+ log "Restoring backup..."
+ rm -rf "$PROJECT_DIR"
+ mv "$BACKUP_DIR" "$PROJECT_DIR"
+ log "Backup restored"
+ exit 1
+fi
+
+log "[8/8] Restarting OpenClaw service to load latest OpenViking..."
+
+# Load OpenClaw environment variables
+if [ -f ~/.openclaw/openviking.env ]; then
+ source ~/.openclaw/openviking.env
+else
+ log "WARNING: ~/.openclaw/openviking.env not found"
+fi
+
+# Step 1: Stop OpenClaw gateway completely
+log "Step 1: Stopping OpenClaw gateway..."
+if openclaw gateway stop 2>&1 | tee -a "$LOG_FILE"; then
+ log "✅ OpenClaw gateway stopped gracefully"
+else
+ log "⚠️ Failed to stop gracefully, attempting force stop..."
+fi
+
+sleep 3
+
+# Verify gateway is stopped
+if ps aux | grep -v grep | grep -q "[o]penclaw"; then
+ log "⚠️ OpenClaw process still running, killing forcefully..."
+ pkill -9 -f "openclaw" || true
+ sleep 2
+fi
+log "✅ OpenClaw gateway stopped"
+
+# Step 2: Clear OpenClaw cache to force reload Python packages
+log "Step 2: Clearing OpenClaw cache..."
+rm -rf ~/.openclaw/cache/* 2>/dev/null || true
+rm -rf ~/.openclaw/tmp/* 2>/dev/null || true
+log "✅ Cache cleared"
+
+# Step 3: Verify OpenViking installation path before starting
+log "Step 3: Verifying OpenViking installation path..."
+OV_PATH=$(python -c "import openviking; print(openviking.__file__)" 2>/dev/null || echo "unknown")
+log "OpenViking path: $OV_PATH"
+
+if [[ "$OV_PATH" == *"$PROJECT_DIR"* ]]; then
+ log "✅ Confirmed: OpenViking is in development mode"
+else
+ log "⚠️ WARNING: OpenViking is not in development mode!"
+ log "Expected path to contain: $PROJECT_DIR"
+ log "Actual path: $OV_PATH"
+fi
+
+# Step 4: Start OpenClaw gateway
+RESTART_SUCCESS=false
+for i in $(seq 1 $MAX_RETRIES); do
+ log "Step 4: Starting OpenClaw gateway (attempt $i/$MAX_RETRIES)..."
+
+ if openclaw gateway start 2>&1 | tee -a "$LOG_FILE"; then
+ sleep 8
+
+ GATEWAY_RUNNING=false
+
+ # Check if gateway is running (multiple methods)
+ if command -v netstat &> /dev/null; then
+ if netstat -tuln 2>/dev/null | grep -q ":18789 "; then
+ log "✅ Gateway port 18789 is listening"
+ GATEWAY_RUNNING=true
+ fi
+ elif command -v ss &> /dev/null; then
+ if ss -tuln 2>/dev/null | grep -q ":18789 "; then
+ log "✅ Gateway port 18789 is listening"
+ GATEWAY_RUNNING=true
+ fi
+ fi
+
+ if [ "$GATEWAY_RUNNING" = false ]; then
+ if ps aux | grep -v grep | grep -q "[o]penclaw"; then
+ log "✅ OpenClaw process is running"
+ GATEWAY_RUNNING=true
+ fi
+ fi
+
+ if [ "$GATEWAY_RUNNING" = false ]; then
+ if command -v curl &> /dev/null; then
+ if curl -s -o /dev/null -w "%{http_code}" http://localhost:18789/health 2>/dev/null | grep -q "200\|404"; then
+ log "✅ Gateway HTTP endpoint is responding"
+ GATEWAY_RUNNING=true
+ fi
+ fi
+ fi
+
+ if [ "$GATEWAY_RUNNING" = true ]; then
+ RESTART_SUCCESS=true
+ log "OpenClaw gateway started successfully on attempt $i"
+ break
+ else
+ log "Gateway not running after start, retrying..."
+ sleep $RETRY_DELAY
+ fi
+ else
+ if [ $i -lt $MAX_RETRIES ]; then
+ log "Start failed on attempt $i, retrying in ${RETRY_DELAY}s..."
+ sleep $RETRY_DELAY
+ fi
+ fi
+done
+
+if [ "$RESTART_SUCCESS" = false ]; then
+ log "⚠️ WARNING: Failed to verify OpenClaw gateway status after $MAX_RETRIES attempts"
+ log "This may be normal in container/non-systemd environments"
+ log "Please manually verify OpenClaw is running: ps aux | grep openclaw"
+fi
+
+# Step 5: Verify OpenViking is correctly loaded by OpenClaw
+log "Step 5: Verifying OpenViking is loaded by OpenClaw..."
+sleep 3
+
+# Check OpenClaw logs for OpenViking registration
+if [ -f "/tmp/openclaw/openclaw-$(date +%Y-%m-%d).log" ]; then
+ OV_LOADED=$(grep -i "openviking: registered context-engine" /tmp/openclaw/openclaw-$(date +%Y-%m-%d).log | tail -1)
+ if [ -n "$OV_LOADED" ]; then
+ log "✅ OpenViking is successfully loaded by OpenClaw"
+ log " $OV_LOADED"
+ else
+ log "⚠️ WARNING: Could not verify OpenViking registration in logs"
+ log " Check logs manually: tail -f /tmp/openclaw/openclaw-$(date +%Y-%m-%d).log | grep openviking"
+ fi
+else
+ log "⚠️ WARNING: OpenClaw log file not found"
+fi
+
+log ""
+log "========================================="
+log "OpenViking Upgrade Completed"
+log "========================================="
+log "Commit: $CURRENT_COMMIT"
+OPENVIKING_VERSION=$(python -c "import openviking; print(openviking.__version__)" 2>/dev/null || echo "unknown")
+log "OpenViking version: $OPENVIKING_VERSION"
+OPENCLAW_VERSION=$(openclaw --version 2>/dev/null || echo "unknown")
+log "OpenClaw version: $OPENCLAW_VERSION"
+log "Backup: $BACKUP_DIR"
+
+exit 0
diff --git a/tests/oc2ov_test/utils/__init__.py b/tests/oc2ov_test/utils/__init__.py
new file mode 100644
index 000000000..78c7fd589
--- /dev/null
+++ b/tests/oc2ov_test/utils/__init__.py
@@ -0,0 +1,7 @@
+"""
+工具函数模块
+"""
+
+from .assertions import AssertionHelper
+from .logger import setup_logger
+from .openclaw_client import OpenClawClient
diff --git a/tests/oc2ov_test/utils/assertions.py b/tests/oc2ov_test/utils/assertions.py
new file mode 100644
index 000000000..f2726efa8
--- /dev/null
+++ b/tests/oc2ov_test/utils/assertions.py
@@ -0,0 +1,173 @@
+"""
+断言工具模块
+提供关键词匹配和文本相似度两种断言方式
+"""
+
+import difflib
+import logging
+from typing import List, Union
+
+logger = logging.getLogger(__name__)
+
+
+class AssertionHelper:
+ """
+ 断言辅助类
+ """
+
+ @staticmethod
+ def extract_response_text(response: dict) -> str:
+ """
+ 从响应中提取文本内容
+ 支持多种响应格式
+ """
+ if isinstance(response, str):
+ return response
+
+ if isinstance(response, dict):
+ if "output" in response:
+ return str(response["output"])
+ elif "message" in response:
+ return str(response["message"])
+ elif "content" in response:
+ return str(response["content"])
+ elif "text" in response:
+ return str(response["text"])
+ elif "choices" in response and len(response["choices"]) > 0:
+ choice = response["choices"][0]
+ if isinstance(choice, dict):
+ if "message" in choice:
+ msg = choice["message"]
+ if isinstance(msg, dict) and "content" in msg:
+ return str(msg["content"])
+ return str(msg)
+ elif "text" in choice:
+ return str(choice["text"])
+ return str(choice)
+
+ return str(response)
+
+ @staticmethod
+ def assert_keywords_in_response(
+ response: Union[dict, str],
+ keywords: List[str],
+ require_all: bool = True,
+ case_sensitive: bool = False,
+ ) -> bool:
+ """
+ 断言响应中包含指定关键词
+
+ Args:
+ response: 响应内容,可以是字典或字符串
+ keywords: 要匹配的关键词列表
+ require_all: 是否要求所有关键词都必须出现,默认 True
+ case_sensitive: 是否区分大小写,默认 False
+
+ Returns:
+ bool: 断言是否通过
+ """
+ text = AssertionHelper.extract_response_text(response)
+
+ if not case_sensitive:
+ text = text.lower()
+ keywords = [kw.lower() for kw in keywords]
+
+ found_keywords = []
+ missing_keywords = []
+
+ for keyword in keywords:
+ if keyword in text:
+ found_keywords.append(keyword)
+ else:
+ missing_keywords.append(keyword)
+
+ logger.info(f"找到的关键词: {found_keywords}")
+ if missing_keywords:
+ logger.warning(f"缺失的关键词: {missing_keywords}")
+
+ if require_all:
+ success = len(missing_keywords) == 0
+ else:
+ success = len(found_keywords) > 0
+
+ if success:
+ logger.info("✅ 关键词断言通过")
+ else:
+ logger.error("❌ 关键词断言失败")
+
+ return success
+
+ @staticmethod
+ def calculate_similarity(text1: str, text2: str) -> float:
+ """
+ 计算两个文本的相似度
+
+ Args:
+ text1: 文本1
+ text2: 文本2
+
+ Returns:
+ float: 相似度,范围 0.0 - 1.0
+ """
+ return difflib.SequenceMatcher(None, text1, text2).ratio()
+
+ @staticmethod
+ def assert_similarity(
+ response: Union[dict, str], expected_text: str, min_similarity: float = 0.6
+ ) -> bool:
+ """
+ 断言响应文本与期望文本的相似度
+
+ Args:
+ response: 响应内容
+ expected_text: 期望的文本
+ min_similarity: 最小相似度阈值,默认 0.6
+
+ Returns:
+ bool: 断言是否通过
+ """
+ actual_text = AssertionHelper.extract_response_text(response)
+ similarity = AssertionHelper.calculate_similarity(actual_text, expected_text)
+
+ logger.info(f"期望文本: {expected_text[:100]}...")
+ logger.info(f"实际文本: {actual_text[:100]}...")
+ logger.info(f"相似度: {similarity:.2%}")
+
+ success = similarity >= min_similarity
+
+ if success:
+ logger.info(f"✅ 相似度断言通过 (>= {min_similarity:.0%})")
+ else:
+ logger.error(f"❌ 相似度断言失败 (期望 >= {min_similarity:.0%}, 实际 {similarity:.0%})")
+
+ return success
+
+ @staticmethod
+ def assert_any_keyword_in_response(
+ response: Union[dict, str], keyword_groups: List[List[str]], case_sensitive: bool = False
+ ) -> bool:
+ """
+ 断言响应中包含任意一组关键词中的任意一个
+
+ Args:
+ response: 响应内容
+ keyword_groups: 关键词组列表,每组中任意一个匹配即可
+ case_sensitive: 是否区分大小写
+
+ Returns:
+ bool: 断言是否通过
+ """
+ text = AssertionHelper.extract_response_text(response)
+
+ if not case_sensitive:
+ text = text.lower()
+
+ for i, group in enumerate(keyword_groups):
+ for keyword in group:
+ kw = keyword if case_sensitive else keyword.lower()
+ if kw in text:
+ logger.info(f"✅ 在第 {i + 1} 组中找到关键词: {keyword}")
+ return True
+
+ logger.error("❌ 未在任何关键词组中找到匹配")
+ return False
diff --git a/tests/oc2ov_test/utils/logger.py b/tests/oc2ov_test/utils/logger.py
new file mode 100644
index 000000000..40e6aeb02
--- /dev/null
+++ b/tests/oc2ov_test/utils/logger.py
@@ -0,0 +1,21 @@
+"""
+日志配置工具
+"""
+
+import logging
+import logging.config
+import os
+
+from config.settings import LOGGING_CONFIG, TEST_CONFIG
+
+
+def setup_logger():
+ """
+ 配置日志系统
+ """
+ log_dir = TEST_CONFIG["log_dir"]
+ if not os.path.exists(log_dir):
+ os.makedirs(log_dir, exist_ok=True)
+
+ logging.config.dictConfig(LOGGING_CONFIG)
+ return logging.getLogger(__name__)
diff --git a/tests/oc2ov_test/utils/openclaw_cli_client.py b/tests/oc2ov_test/utils/openclaw_cli_client.py
new file mode 100644
index 000000000..228383e8f
--- /dev/null
+++ b/tests/oc2ov_test/utils/openclaw_cli_client.py
@@ -0,0 +1,106 @@
+"""
+OpenClaw CLI 客户端封装 - 使用 openclaw agent 命令
+"""
+
+import json
+import logging
+import subprocess
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class OpenClawCLIClient:
+ """
+ OpenClaw CLI 客户端
+ """
+
+ def __init__(self, session_id: Optional[str] = None):
+ """
+ 初始化客户端
+ """
+ self.session_id = session_id or "test_session_default"
+ self.timeout = 300
+
+ def send_message(
+ self, message: str, session_id: Optional[str] = None, agent_id: Optional[str] = None
+ ) -> Dict[str, Any]:
+ """
+ 使用 openclaw agent 命令发送消息
+ """
+ target_session_id = session_id or self.session_id
+
+ cmd = [
+ "openclaw",
+ "agent",
+ "--session-id",
+ target_session_id,
+ "--message",
+ message,
+ "--json",
+ ]
+
+ if agent_id:
+ cmd.insert(2, "--agent")
+ cmd.insert(3, agent_id)
+
+ try:
+ logger.info("=" * 80)
+ logger.info("📤 使用 CLI 发送请求到 OpenClaw")
+ logger.info("=" * 80)
+ logger.info(f"Session ID: {target_session_id}")
+ logger.info(f"Agent ID: {agent_id or 'default'}")
+ logger.info(f"输入消息: {message}")
+ logger.info(f"完整命令: {' '.join(cmd)}")
+
+ logger.info(f"⏳ 等待响应 (超时: {self.timeout}秒)...")
+
+ result = subprocess.run(cmd, capture_output=True, text=True, timeout=self.timeout)
+
+ logger.info(f"✅ 命令执行完成 - 返回码: {result.returncode}")
+
+ if result.returncode != 0:
+ error_msg = f"命令执行失败: {result.stderr}"
+ logger.error("=" * 80)
+ logger.error(error_msg)
+ logger.error("=" * 80)
+ return {"error": error_msg, "success": False}
+
+ if not result.stdout.strip():
+ error_msg = "命令返回空输出"
+ logger.error("=" * 80)
+ logger.error(error_msg)
+ logger.error("=" * 80)
+ return {"error": error_msg, "success": False}
+
+ try:
+ response_data = json.loads(result.stdout)
+ except json.JSONDecodeError:
+ response_text = result.stdout.strip()
+ response_data = {"output": response_text, "success": True}
+
+ logger.info("=" * 80)
+ logger.info("📥 OpenClaw 响应内容:")
+ logger.info("=" * 80)
+
+ if isinstance(response_data, dict):
+ logger.info(json.dumps(response_data, ensure_ascii=False, indent=2))
+ else:
+ logger.info(str(response_data))
+
+ logger.info("=" * 80)
+
+ return response_data
+
+ except subprocess.TimeoutExpired:
+ error_msg = f"命令执行超时 (超时: {self.timeout}秒)"
+ logger.error("=" * 80)
+ logger.error(error_msg)
+ logger.error("=" * 80)
+ return {"error": error_msg, "success": False}
+ except Exception as e:
+ error_msg = f"执行命令异常: {str(e)}"
+ logger.error("=" * 80)
+ logger.error(error_msg)
+ logger.error("=" * 80)
+ return {"error": error_msg, "success": False}
diff --git a/tests/oc2ov_test/utils/openclaw_client.py b/tests/oc2ov_test/utils/openclaw_client.py
new file mode 100644
index 000000000..a1a0af7cc
--- /dev/null
+++ b/tests/oc2ov_test/utils/openclaw_client.py
@@ -0,0 +1,84 @@
+"""
+OpenClaw 客户端封装
+"""
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+import requests
+from config.settings import OPENCLAW_CONFIG
+
+logger = logging.getLogger(__name__)
+
+
+class OpenClawClient:
+ """
+ OpenClaw HTTP 客户端
+ """
+
+ def __init__(self, config: Optional[Dict[str, Any]] = None):
+ """
+ 初始化客户端
+ """
+ self.config = config or OPENCLAW_CONFIG
+ self.url = self.config["url"]
+ self.timeout = self.config.get("timeout", 30)
+
+ def _get_headers(self) -> Dict[str, str]:
+ """
+ 获取请求头
+ """
+ return {
+ "Authorization": self.config["auth_token"],
+ "Content-Type": "application/json",
+ "x-openclaw-agent-id": self.config["agent_id"],
+ }
+
+ def send_message(self, message: str, agent_id: Optional[str] = None) -> Dict[str, Any]:
+ """
+ 发送消息到 OpenClaw
+ """
+ headers = self._get_headers()
+ if agent_id:
+ headers["x-openclaw-agent-id"] = agent_id
+
+ payload = {"model": self.config["model"], "input": message}
+
+ try:
+ logger.info("=" * 80)
+ logger.info("📤 发送请求到 OpenClaw")
+ logger.info("=" * 80)
+ logger.info(f"URL: {self.url}")
+ logger.info(f"Agent ID: {headers.get('x-openclaw-agent-id')}")
+ logger.info(f"输入消息: {message}")
+ logger.info(f"完整 Payload: {json.dumps(payload, ensure_ascii=False, indent=2)}")
+
+ logger.info(f"⏳ 等待响应 (超时: {self.timeout}秒)...")
+ response = requests.post(self.url, headers=headers, json=payload, timeout=self.timeout)
+
+ logger.info(f"✅ 收到响应 - HTTP 状态码: {response.status_code}")
+ response.raise_for_status()
+
+ result = response.json()
+
+ logger.info("=" * 80)
+ logger.info("📥 OpenClaw 响应内容:")
+ logger.info("=" * 80)
+ logger.info(json.dumps(result, ensure_ascii=False, indent=2))
+ logger.info("=" * 80)
+
+ return result
+ except requests.exceptions.RequestException as e:
+ error_msg = f"❌ 请求失败: {str(e)}"
+ logger.error("=" * 80)
+ logger.error(error_msg)
+ logger.error("=" * 80)
+ return {"error": error_msg, "success": False}
+ except json.JSONDecodeError as e:
+ error_msg = f"❌ JSON 解析失败: {str(e)}"
+ logger.error("=" * 80)
+ logger.error(error_msg)
+ logger.error(f"响应文本: {response.text if 'response' in locals() else 'N/A'}")
+ logger.error("=" * 80)
+ return {"error": error_msg, "success": False}