android-midscene-automation 0.1.0

package/server/test-case-import/parsers/txt.ts

@@ -0,0 +1,11 @@
+import { normalizeExtractedText } from '../text-normalizer';
+
+// 优先按 UTF-8 解码；出现大量替换字符时兼容常见的 GB18030 中文文本。
+export function parseTxt(buffer: Buffer) {
+  let text = buffer.toString('utf8');
+  const replacementCount = (text.match(/\uFFFD/g) || []).length;
+  if (replacementCount > 2) {
+    text = new TextDecoder('gb18030').decode(buffer);
+  }
+  return normalizeExtractedText(text);
+}

package/server/test-case-import/parsers/word.ts

@@ -0,0 +1,9 @@
+import WordExtractor from 'word-extractor';
+import { normalizeExtractedText } from '../text-normalizer';
+
+// word-extractor 同时支持 OLE .doc 与 OOXML .docx，并直接从 Buffer 提取正文。
+export async function parseWord(buffer: Buffer) {
+  const extractor = new WordExtractor();
+  const document = await extractor.extract(buffer);
+  return normalizeExtractedText(document.getBody());
+}

package/server/test-case-import/service.ts

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { formatTestCases } from './formatter';
+import { parseExcel } from './parsers/excel';
+import { parseTxt } from './parsers/txt';
+import { parseWord } from './parsers/word';
+import { parseTextCases } from './text-normalizer';
+import type { ParsedTestCaseDocument, TestCaseImportResult, TestCaseSourceFormat } from './types';
+import { validateTestCaseDocument } from './validator';
+
+export const MAX_TEST_CASE_FILE_SIZE = 10 * 1024 * 1024;
+
+const formatByExtension: Record<string, TestCaseSourceFormat> = {
+  '.txt': 'txt',
+  '.xls': 'excel',
+  '.xlsx': 'excel',
+  '.doc': 'word',
+  '.docx': 'word',
+};
+
+// 文件扩展名决定解析器；所有解析结果随后统一校验并格式化为 Prompt。
+export async function importTestCaseFile(input: { fileName: string; buffer: Buffer }): Promise<TestCaseImportResult> {
+  const fileName = path.basename(input.fileName || '').trim();
+  const extension = path.extname(fileName).toLowerCase();
+  const format = formatByExtension[extension];
+
+  if (!fileName || !format) {
+    throw new Error('仅支持 txt、xls、xlsx、doc、docx 格式的测试用例文件');
+  }
+  if (!input.buffer.length) {
+    throw new Error('上传文件为空');
+  }
+  if (input.buffer.length > MAX_TEST_CASE_FILE_SIZE) {
+    throw new Error('文件大小不能超过 10MB');
+  }
+
+  let document: ParsedTestCaseDocument;
+  if (format === 'excel') {
+    const parsed = parseExcel(input.buffer);
+    document = { format, ...parsed };
+  } else {
+    const rawText = format === 'txt' ? parseTxt(input.buffer) : await parseWord(input.buffer);
+    document = {
+      format,
+      rawText,
+      cases: parseTextCases(rawText, fileName),
+    };
+  }
+
+  validateTestCaseDocument(document);
+  const cases = document.cases.length ? document.cases : parseTextCases(document.rawText, fileName);
+
+  return {
+    fileName,
+    format,
+    caseCount: cases.length,
+    prompt: formatTestCases(fileName, cases),
+  };
+}

package/server/test-case-import/text-normalizer.ts

@@ -0,0 +1,98 @@
+import path from 'node:path';
+import type { ImportedTestCase } from './types';
+
+type SectionName = 'preconditions' | 'steps' | 'expectedResults' | 'testData' | 'description';
+
+const sectionPatterns: Array<{ section: SectionName; pattern: RegExp }> = [
+  { section: 'preconditions', pattern: /^(?:前置条件|前提条件|准备条件)\s*[:：]?\s*(.*)$/i },
+  { section: 'steps', pattern: /^(?:测试步骤|操作步骤|执行步骤|步骤)\s*[:：]?\s*(.*)$/i },
+  { section: 'expectedResults', pattern: /^(?:预期结果|期望结果|预期|expected\s*results?)\s*[:：]?\s*(.*)$/i },
+  { section: 'testData', pattern: /^(?:测试数据|输入数据|数据)\s*[:：]?\s*(.*)$/i },
+];
+
+const caseTitlePattern = /^(?:#{1,3}\s*)?(?:测试)?(?:用例名称|用例标题|用例|场景标题|测试场景)\s*[:：]\s*(.+)$/i;
+const priorityPattern = /^(?:优先级|priority)\s*[:：]\s*(.+)$/i;
+
+export function normalizeExtractedText(value: string) {
+  return value
+    .replace(/^\uFEFF/, '')
+    .replace(/\r\n?/g, '\n')
+    .replace(/[\t\u00a0]+/g, ' ')
+    .replace(/[ ]{2,}/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function cleanListItem(value: string) {
+  return value.replace(/^\s*(?:[-*•]|\d+[.)、])\s*/, '').trim();
+}
+
+function createCase(title: string): ImportedTestCase {
+  return {
+    title,
+    preconditions: [],
+    steps: [],
+    expectedResults: [],
+    testData: [],
+    description: [],
+    priority: '',
+  };
+}
+
+// 将 TXT/Word 中常见的“字段标题 + 内容”结构转换为统一测试用例对象。
+export function parseTextCases(rawText: string, fileName: string) {
+  const text = normalizeExtractedText(rawText);
+  const fallbackTitle = path.basename(fileName, path.extname(fileName)) || '导入测试用例';
+  const lines = text.split('\n').map((line) => line.trim()).filter(Boolean);
+  const cases: ImportedTestCase[] = [];
+  let currentCase = createCase(fallbackTitle);
+  let activeSection: SectionName = 'description';
+
+  const pushCurrentCase = () => {
+    const hasContent = [
+      ...currentCase.preconditions,
+      ...currentCase.steps,
+      ...currentCase.expectedResults,
+      ...currentCase.testData,
+      ...currentCase.description,
+    ].some(Boolean);
+    if (hasContent) cases.push(currentCase);
+  };
+
+  for (const line of lines) {
+    const titleMatch = line.match(caseTitlePattern);
+    if (titleMatch) {
+      pushCurrentCase();
+      currentCase = createCase(titleMatch[1]?.trim() || fallbackTitle);
+      activeSection = 'description';
+      continue;
+    }
+
+    const priorityMatch = line.match(priorityPattern);
+    if (priorityMatch) {
+      currentCase.priority = priorityMatch[1]?.trim() || '';
+      continue;
+    }
+
+    const sectionMatch = sectionPatterns.find(({ pattern }) => pattern.test(line));
+    if (sectionMatch) {
+      const match = line.match(sectionMatch.pattern);
+      activeSection = sectionMatch.section;
+      const inlineValue = cleanListItem(match?.[1] || '');
+      if (inlineValue) currentCase[activeSection].push(inlineValue);
+      continue;
+    }
+
+    const item = cleanListItem(line);
+    if (item) currentCase[activeSection].push(item);
+  }
+
+  pushCurrentCase();
+  return cases.length ? cases : [createCase(fallbackTitle)];
+}
+
+export function splitCellItems(value: unknown) {
+  const text = normalizeExtractedText(String(value ?? ''));
+  if (!text) return [];
+  return text.split('\n').map(cleanListItem).filter(Boolean);
+}

package/server/test-case-import/types.ts

@@ -0,0 +1,24 @@
+export type TestCaseSourceFormat = 'txt' | 'excel' | 'word';
+
+export type ImportedTestCase = {
+  title: string;
+  preconditions: string[];
+  steps: string[];
+  expectedResults: string[];
+  testData: string[];
+  description: string[];
+  priority: string;
+};
+
+export type ParsedTestCaseDocument = {
+  format: TestCaseSourceFormat;
+  rawText: string;
+  cases: ImportedTestCase[];
+};
+
+export type TestCaseImportResult = {
+  fileName: string;
+  format: TestCaseSourceFormat;
+  caseCount: number;
+  prompt: string;
+};

package/server/test-case-import/validator.ts

@@ -0,0 +1,34 @@
+import type { ParsedTestCaseDocument } from './types';
+
+const MAX_EXTRACTED_TEXT_LENGTH = 100_000;
+const structurePattern = /测试用例|用例名称|用例标题|测试场景|前置条件|测试步骤|操作步骤|预期结果|期望结果|test\s*case|precondition|expected/i;
+const actionPattern = /打开|启动|进入|点击|选择|输入|填写|提交|登录|注册|搜索|切换|滑动|等待|关闭|允许|同意|检查|验证|操作|执行/i;
+const assertionPattern = /预期|期望|结果|成功|失败|显示|出现|跳转|进入首页|提示|返回|应当|应该|不存在|可见/i;
+
+function countMatches(text: string, pattern: RegExp) {
+  const globalPattern = new RegExp(pattern.source, `${pattern.flags.replace('g', '')}g`);
+  return (text.match(globalPattern) || []).length;
+}
+
+// 结构化用例优先通过；非结构化文本必须同时具备操作和结果语义，避免导入普通文章。
+export function validateTestCaseDocument(document: ParsedTestCaseDocument) {
+  if (!document.rawText.trim()) {
+    throw new Error('文件内容为空，未读取到测试用例');
+  }
+  if (document.rawText.length > MAX_EXTRACTED_TEXT_LENGTH) {
+    throw new Error('测试用例内容过长，请控制在 10 万个字符以内');
+  }
+
+  const hasCanonicalCase = document.cases.some(
+    (item) => item.steps.length > 0 && item.expectedResults.length > 0,
+  );
+  const structureCount = countMatches(document.rawText, structurePattern);
+  const actionCount = countMatches(document.rawText, actionPattern);
+  const assertionCount = countMatches(document.rawText, assertionPattern);
+  const hasStructuredTestText = structureCount >= 2 && actionCount >= 1;
+  const hasBehaviorTestText = actionCount >= 2 && assertionCount >= 1 && document.rawText.length >= 20;
+
+  if (!hasCanonicalCase && !hasStructuredTestText && !hasBehaviorTestText) {
+    throw new Error('文件内容与测试用例无关，请上传包含测试步骤、操作动作和预期结果的用例文件');
+  }
+}