ios-app-review-plugin 1.0.0

package/tests/history/comparator.test.ts

@@ -0,0 +1,272 @@
+import { ScanComparator } from '../../src/history/comparator.js';
+import type { ScanRecord } from '../../src/history/types.js';
+import type { AnalysisReport, Issue } from '../../src/types/index.js';
+
+describe('ScanComparator', () => {
+  let comparator: ScanComparator;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    comparator = new ScanComparator();
+  });
+
+  const createIssue = (overrides: Partial<Issue> = {}): Issue => ({
+    id: 'test-issue',
+    title: 'Test Issue',
+    description: 'A test issue',
+    severity: 'warning',
+    category: 'code',
+    ...overrides,
+  });
+
+  const createScanRecord = (overrides: Partial<ScanRecord> = {}): ScanRecord => ({
+    id: 'scan-1',
+    timestamp: new Date().toISOString(),
+    projectPath: '/project',
+    score: 80,
+    report: {
+      projectPath: '/project',
+      timestamp: new Date().toISOString(),
+      results: [],
+      summary: { totalIssues: 0, errors: 0, warnings: 0, info: 0, passed: true, duration: 50 },
+    },
+    ...overrides,
+  });
+
+  describe('fingerprint()', () => {
+    it('should create stable fingerprint from issue', () => {
+      const issue = createIssue({
+        id: 'plist-missing-key',
+        category: 'info-plist',
+        filePath: '/project/src/Info.plist',
+      });
+
+      const fp1 = comparator.fingerprint(issue, '/project');
+      const fp2 = comparator.fingerprint(issue, '/project');
+      expect(fp1).toBe(fp2);
+      expect(fp1).toBe('plist-missing-key::info-plist::src/Info.plist');
+    });
+
+    it('should use relative path', () => {
+      const issue = createIssue({
+        id: 'code-issue',
+        category: 'code',
+        filePath: '/project/Sources/App/ViewController.swift',
+      });
+
+      const fp = comparator.fingerprint(issue, '/project');
+      expect(fp).toBe('code-issue::code::Sources/App/ViewController.swift');
+      expect(fp).not.toContain('/project/');
+    });
+
+    it('should handle missing filePath', () => {
+      const issue = createIssue({
+        id: 'general-issue',
+        category: 'privacy',
+        filePath: undefined,
+      });
+
+      const fp = comparator.fingerprint(issue, '/project');
+      expect(fp).toBe('general-issue::privacy::');
+    });
+  });
+
+  describe('compare()', () => {
+    it('should detect new issues', () => {
+      const previous = createScanRecord({
+        id: 'prev',
+        score: 90,
+        report: {
+          projectPath: '/project',
+          timestamp: new Date().toISOString(),
+          results: [],
+          summary: { totalIssues: 0, errors: 0, warnings: 0, info: 0, passed: true, duration: 50 },
+        },
+      });
+
+      const current = createScanRecord({
+        id: 'curr',
+        score: 70,
+        report: {
+          projectPath: '/project',
+          timestamp: new Date().toISOString(),
+          results: [
+            {
+              analyzer: 'Code Scanner',
+              passed: false,
+              issues: [
+                createIssue({ id: 'new-issue', category: 'code', filePath: '/project/src/file.swift' }),
+              ],
+              duration: 30,
+            },
+          ],
+          summary: { totalIssues: 1, errors: 0, warnings: 1, info: 0, passed: true, duration: 50 },
+        },
+      });
+
+      const result = comparator.compare(previous, current);
+      expect(result.newIssues).toHaveLength(1);
+      expect(result.resolvedIssues).toHaveLength(0);
+      expect(result.ongoingIssues).toHaveLength(0);
+    });
+
+    it('should detect resolved issues', () => {
+      const previous = createScanRecord({
+        id: 'prev',
+        score: 70,
+        report: {
+          projectPath: '/project',
+          timestamp: new Date().toISOString(),
+          results: [
+            {
+              analyzer: 'Code Scanner',
+              passed: false,
+              issues: [
+                createIssue({ id: 'old-issue', category: 'code', filePath: '/project/src/file.swift' }),
+              ],
+              duration: 30,
+            },
+          ],
+          summary: { totalIssues: 1, errors: 0, warnings: 1, info: 0, passed: true, duration: 50 },
+        },
+      });
+
+      const current = createScanRecord({
+        id: 'curr',
+        score: 95,
+        report: {
+          projectPath: '/project',
+          timestamp: new Date().toISOString(),
+          results: [],
+          summary: { totalIssues: 0, errors: 0, warnings: 0, info: 0, passed: true, duration: 50 },
+        },
+      });
+
+      const result = comparator.compare(previous, current);
+      expect(result.newIssues).toHaveLength(0);
+      expect(result.resolvedIssues).toHaveLength(1);
+      expect(result.ongoingIssues).toHaveLength(0);
+    });
+
+    it('should detect ongoing issues', () => {
+      const sharedIssue = createIssue({
+        id: 'ongoing-issue',
+        category: 'security',
+        filePath: '/project/src/Crypto.swift',
+      });
+
+      const previous = createScanRecord({
+        id: 'prev',
+        score: 75,
+        report: {
+          projectPath: '/project',
+          timestamp: new Date().toISOString(),
+          results: [
+            { analyzer: 'Security', passed: false, issues: [sharedIssue], duration: 30 },
+          ],
+          summary: { totalIssues: 1, errors: 0, warnings: 1, info: 0, passed: true, duration: 50 },
+        },
+      });
+
+      const current = createScanRecord({
+        id: 'curr',
+        score: 75,
+        report: {
+          projectPath: '/project',
+          timestamp: new Date().toISOString(),
+          results: [
+            { analyzer: 'Security', passed: false, issues: [sharedIssue], duration: 25 },
+          ],
+          summary: { totalIssues: 1, errors: 0, warnings: 1, info: 0, passed: true, duration: 50 },
+        },
+      });
+
+      const result = comparator.compare(previous, current);
+      expect(result.ongoingIssues).toHaveLength(1);
+      expect(result.newIssues).toHaveLength(0);
+      expect(result.resolvedIssues).toHaveLength(0);
+    });
+
+    it('should calculate score delta', () => {
+      const previous = createScanRecord({ id: 'prev', score: 60 });
+      const current = createScanRecord({ id: 'curr', score: 85 });
+
+      const result = comparator.compare(previous, current);
+      expect(result.scoreDelta).toBe(25);
+    });
+
+    it('should set trend to improving when score increases significantly', () => {
+      const previous = createScanRecord({ id: 'prev', score: 60 });
+      const current = createScanRecord({ id: 'curr', score: 80 });
+
+      const result = comparator.compare(previous, current);
+      expect(result.trend).toBe('improving');
+    });
+
+    it('should set trend to declining when score decreases significantly', () => {
+      const previous = createScanRecord({ id: 'prev', score: 90 });
+      const current = createScanRecord({ id: 'curr', score: 60 });
+
+      const result = comparator.compare(previous, current);
+      expect(result.trend).toBe('declining');
+    });
+
+    it('should set trend to stable for small changes', () => {
+      const previous = createScanRecord({ id: 'prev', score: 80 });
+      const current = createScanRecord({ id: 'curr', score: 81 });
+
+      const result = comparator.compare(previous, current);
+      expect(result.trend).toBe('stable');
+    });
+  });
+
+  describe('analyzeTrend()', () => {
+    it('should compute trend from multiple scans', () => {
+      const scans: ScanRecord[] = [
+        createScanRecord({ id: 'scan-1', timestamp: '2024-01-01T00:00:00Z', score: 50 }),
+        createScanRecord({ id: 'scan-2', timestamp: '2024-01-02T00:00:00Z', score: 60 }),
+        createScanRecord({ id: 'scan-3', timestamp: '2024-01-03T00:00:00Z', score: 70 }),
+        createScanRecord({ id: 'scan-4', timestamp: '2024-01-04T00:00:00Z', score: 80 }),
+      ];
+
+      const trend = comparator.analyzeTrend(scans);
+
+      expect(trend.scans).toHaveLength(4);
+      expect(trend.overallTrend).toBe('improving');
+      expect(trend.averageScore).toBe(65); // Math.round((50+60+70+80)/4) = 65
+      expect(trend.bestScore).toBe(80);
+      expect(trend.worstScore).toBe(50);
+    });
+
+    it('should detect declining trend', () => {
+      const scans: ScanRecord[] = [
+        createScanRecord({ id: 'scan-1', timestamp: '2024-01-01T00:00:00Z', score: 90 }),
+        createScanRecord({ id: 'scan-2', timestamp: '2024-01-02T00:00:00Z', score: 80 }),
+        createScanRecord({ id: 'scan-3', timestamp: '2024-01-03T00:00:00Z', score: 70 }),
+      ];
+
+      const trend = comparator.analyzeTrend(scans);
+      expect(trend.overallTrend).toBe('declining');
+    });
+
+    it('should detect stable trend', () => {
+      const scans: ScanRecord[] = [
+        createScanRecord({ id: 'scan-1', timestamp: '2024-01-01T00:00:00Z', score: 80 }),
+        createScanRecord({ id: 'scan-2', timestamp: '2024-01-02T00:00:00Z', score: 81 }),
+        createScanRecord({ id: 'scan-3', timestamp: '2024-01-03T00:00:00Z', score: 82 }),
+      ];
+
+      const trend = comparator.analyzeTrend(scans);
+      expect(trend.overallTrend).toBe('stable');
+    });
+
+    it('should handle empty scans array', () => {
+      const trend = comparator.analyzeTrend([]);
+      expect(trend.scans).toHaveLength(0);
+      expect(trend.overallTrend).toBe('stable');
+      expect(trend.averageScore).toBe(0);
+      expect(trend.bestScore).toBe(0);
+      expect(trend.worstScore).toBe(0);
+    });
+  });
+});

package/tests/history/store.test.ts

@@ -0,0 +1,200 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { HistoryStore } from '../../src/history/store.js';
+import type { AnalysisReport } from '../../src/types/index.js';
+
+jest.mock('child_process', () => ({
+  execSync: jest.fn().mockReturnValue('abc123\n'),
+}));
+
+describe('HistoryStore', () => {
+  let tempDir: string;
+  let store: HistoryStore;
+
+  beforeAll(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'history-store-test-'));
+  });
+
+  afterAll(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    store = new HistoryStore(tempDir);
+  });
+
+  const createMockReport = (): AnalysisReport => ({
+    projectPath: tempDir,
+    timestamp: new Date().toISOString(),
+    results: [],
+    summary: { totalIssues: 0, errors: 0, warnings: 0, info: 0, passed: true, duration: 50 },
+  });
+
+  describe('saveScan()', () => {
+    it('should save and return a scan record with an ID', async () => {
+      const mockReport = createMockReport();
+      const record = await store.saveScan(mockReport, 95);
+
+      expect(record).toBeDefined();
+      expect(record.id).toBeDefined();
+      expect(typeof record.id).toBe('string');
+      expect(record.id.length).toBeGreaterThan(0);
+      expect(record.projectPath).toBe(tempDir);
+      expect(record.score).toBe(95);
+      expect(record.report).toEqual(mockReport);
+      expect(record.gitCommit).toBe('abc123');
+      expect(record.gitBranch).toBe('abc123');
+    });
+  });
+
+  describe('getLatestScan()', () => {
+    it('should return the most recently saved scan', async () => {
+      // Use a fresh subdirectory so we start with clean state
+      const subDir = path.join(tempDir, 'latest-test');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      const report1 = createMockReport();
+      report1.projectPath = subDir;
+      await freshStore.saveScan(report1, 80);
+
+      const report2 = createMockReport();
+      report2.projectPath = subDir;
+      const secondRecord = await freshStore.saveScan(report2, 90);
+
+      const latest = await freshStore.getLatestScan();
+      expect(latest).not.toBeNull();
+      expect(latest!.id).toBe(secondRecord.id);
+      expect(latest!.score).toBe(90);
+    });
+
+    it('should return null when no scans exist', async () => {
+      const emptyDir = path.join(tempDir, 'empty-latest');
+      await fs.mkdir(emptyDir, { recursive: true });
+      const emptyStore = new HistoryStore(emptyDir);
+
+      const latest = await emptyStore.getLatestScan();
+      expect(latest).toBeNull();
+    });
+  });
+
+  describe('getScan()', () => {
+    it('should return a specific scan by ID', async () => {
+      const subDir = path.join(tempDir, 'get-scan-test');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      const report = createMockReport();
+      report.projectPath = subDir;
+      const saved = await freshStore.saveScan(report, 85);
+
+      const retrieved = await freshStore.getScan(saved.id);
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.id).toBe(saved.id);
+      expect(retrieved!.score).toBe(85);
+      expect(retrieved!.report).toEqual(report);
+    });
+
+    it('should return null for unknown ID', async () => {
+      const subDir = path.join(tempDir, 'get-scan-unknown');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      const result = await freshStore.getScan('non-existent-id');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('listScans()', () => {
+    it('should return scans in reverse chronological order (newest first)', async () => {
+      const subDir = path.join(tempDir, 'list-scans-order');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      const report1 = createMockReport();
+      report1.projectPath = subDir;
+      const first = await freshStore.saveScan(report1, 70);
+
+      const report2 = createMockReport();
+      report2.projectPath = subDir;
+      const second = await freshStore.saveScan(report2, 80);
+
+      const report3 = createMockReport();
+      report3.projectPath = subDir;
+      const third = await freshStore.saveScan(report3, 90);
+
+      const scans = await freshStore.listScans();
+      expect(scans).toHaveLength(3);
+      expect(scans[0]!.id).toBe(third.id);
+      expect(scans[1]!.id).toBe(second.id);
+      expect(scans[2]!.id).toBe(first.id);
+    });
+
+    it('should respect the limit parameter', async () => {
+      const subDir = path.join(tempDir, 'list-scans-limit');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      for (let i = 0; i < 5; i++) {
+        const report = createMockReport();
+        report.projectPath = subDir;
+        await freshStore.saveScan(report, 50 + i * 10);
+      }
+
+      const scans = await freshStore.listScans(2);
+      expect(scans).toHaveLength(2);
+      // Newest first, so the last saved (score 90) should be first
+      expect(scans[0]!.score).toBe(90);
+      expect(scans[1]!.score).toBe(80);
+    });
+  });
+
+  describe('pruneHistory()', () => {
+    it('should remove oldest scans and keep specified count', async () => {
+      const subDir = path.join(tempDir, 'prune-test');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      const ids: string[] = [];
+      for (let i = 0; i < 5; i++) {
+        const report = createMockReport();
+        report.projectPath = subDir;
+        const record = await freshStore.saveScan(report, 50 + i * 10);
+        ids.push(record.id);
+      }
+
+      const removed = await freshStore.pruneHistory(2);
+      expect(removed).toBe(3);
+
+      const scans = await freshStore.listScans();
+      expect(scans).toHaveLength(2);
+      // The two newest should remain (ids[3] and ids[4])
+      expect(scans[0]!.id).toBe(ids[4]);
+      expect(scans[1]!.id).toBe(ids[3]);
+
+      // Oldest should be gone
+      const oldScan = await freshStore.getScan(ids[0]!);
+      expect(oldScan).toBeNull();
+    });
+
+    it('should not remove anything if under limit', async () => {
+      const subDir = path.join(tempDir, 'prune-under-limit');
+      await fs.mkdir(subDir, { recursive: true });
+      const freshStore = new HistoryStore(subDir);
+
+      for (let i = 0; i < 3; i++) {
+        const report = createMockReport();
+        report.projectPath = subDir;
+        await freshStore.saveScan(report, 60 + i * 10);
+      }
+
+      const removed = await freshStore.pruneHistory(5);
+      expect(removed).toBe(0);
+
+      const scans = await freshStore.listScans();
+      expect(scans).toHaveLength(3);
+    });
+  });
+});

package/tests/integration/cli.test.ts

@@ -0,0 +1,95 @@
+import { execSync } from 'child_process';
+import * as path from 'path';
+
+const CLI_PATH = path.resolve(__dirname, '../../src/index.ts');
+const TSX = 'npx tsx';
+
+describe('CLI Integration', () => {
+  it('should print help with help command', () => {
+    const output = execSync(`${TSX} ${CLI_PATH} help`, {
+      encoding: 'utf-8',
+      timeout: 15000,
+    });
+    expect(output).toContain('ios-app-review');
+    expect(output).toContain('USAGE');
+    expect(output).toContain('scan');
+  });
+
+  it('should print help with --help flag', () => {
+    const output = execSync(`${TSX} ${CLI_PATH} --help`, {
+      encoding: 'utf-8',
+      timeout: 15000,
+    });
+    expect(output).toContain('USAGE');
+  });
+
+  it('should print version with version command', () => {
+    const output = execSync(`${TSX} ${CLI_PATH} version`, {
+      encoding: 'utf-8',
+      timeout: 15000,
+    });
+    expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+
+  it('should print version with --version flag', () => {
+    const output = execSync(`${TSX} ${CLI_PATH} --version`, {
+      encoding: 'utf-8',
+      timeout: 15000,
+    });
+    expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+
+  it('should exit with code 2 for unknown command', () => {
+    try {
+      execSync(`${TSX} ${CLI_PATH} unknown-command`, {
+        encoding: 'utf-8',
+        timeout: 15000,
+      });
+      fail('Should have thrown');
+    } catch (err) {
+      const error = err as { status: number; stderr: string };
+      expect(error.status).toBe(2);
+      expect(error.stderr).toContain('Unknown command');
+    }
+  });
+
+  it('should exit with code 2 when scan has no project path', () => {
+    try {
+      execSync(`${TSX} ${CLI_PATH} scan`, {
+        encoding: 'utf-8',
+        timeout: 15000,
+      });
+      fail('Should have thrown');
+    } catch (err) {
+      const error = err as { status: number; stderr: string };
+      expect(error.status).toBe(2);
+      expect(error.stderr).toContain('project path is required');
+    }
+  });
+
+  it('should exit with code 2 for invalid format', () => {
+    try {
+      execSync(`${TSX} ${CLI_PATH} scan /fake/path --format xml`, {
+        encoding: 'utf-8',
+        timeout: 15000,
+      });
+      fail('Should have thrown');
+    } catch (err) {
+      const error = err as { status: number; stderr: string };
+      expect(error.status).toBe(2);
+    }
+  });
+
+  it('should exit with code 2 for invalid project path', () => {
+    try {
+      execSync(`${TSX} ${CLI_PATH} scan /nonexistent/path.xcodeproj`, {
+        encoding: 'utf-8',
+        timeout: 15000,
+      });
+      fail('Should have thrown');
+    } catch (err) {
+      const error = err as { status: number };
+      expect(error.status).toBe(2);
+    }
+  });
+});

package/tests/integration/e2e.test.ts

@@ -0,0 +1,130 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { runAnalysis } from '../../src/analyzer.js';
+import { createFormatter } from '../../src/reports/index.js';
+
+let tempDir: string;
+
+beforeAll(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'e2e-test-'));
+
+  // Create a mock Xcode project structure
+  const xcodeproj = path.join(tempDir, 'TestApp.xcodeproj');
+  await fs.mkdir(xcodeproj, { recursive: true });
+
+  // Write a minimal pbxproj
+  await fs.writeFile(
+    path.join(xcodeproj, 'project.pbxproj'),
+    `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  classes = {};
+  objectVersion = 56;
+  objects = {
+    ROOT = { isa = PBXProject; buildConfigurationList = CONFIGLIST; mainGroup = MAINGROUP; targets = (TARGET1); };
+    CONFIGLIST = { isa = XCConfigurationList; buildConfigurations = (CONFIG1); };
+    CONFIG1 = { isa = XCBuildConfiguration; name = Release; buildSettings = { PRODUCT_BUNDLE_IDENTIFIER = "com.test.app"; IPHONEOS_DEPLOYMENT_TARGET = "15.0"; }; };
+    TARGET1 = { isa = PBXNativeTarget; name = TestApp; productType = "com.apple.product-type.application"; buildConfigurationList = CONFIGLIST; buildPhases = (); };
+    MAINGROUP = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+  };
+  rootObject = ROOT;
+}
+`
+  );
+
+  // Create source files with some detectable issues
+  await fs.writeFile(
+    path.join(tempDir, 'ViewController.swift'),
+    `import UIKit
+
+class ViewController: UIViewController {
+    let apiKey = "sk-test1234567890abcdef"
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        print("Debug: loaded")
+    }
+}
+`
+  );
+
+  // Create Info.plist
+  await fs.writeFile(
+    path.join(tempDir, 'Info.plist'),
+    `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleIdentifier</key>
+  <string>com.test.app</string>
+  <key>CFBundleName</key>
+  <string>TestApp</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0.0</string>
+</dict>
+</plist>
+`
+  );
+});
+
+afterAll(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+});
+
+describe('E2E: Full Analysis Pipeline', () => {
+  it('should analyze a mock Xcode project end-to-end', async () => {
+    const report = await runAnalysis({
+      projectPath: path.join(tempDir, 'TestApp.xcodeproj'),
+      analyzers: ['code', 'security'],
+    });
+
+    expect(report).toBeDefined();
+    expect(report.projectPath).toContain('TestApp.xcodeproj');
+    expect(report.results.length).toBeGreaterThan(0);
+    expect(report.summary).toBeDefined();
+    expect(typeof report.summary.totalIssues).toBe('number');
+    expect(typeof report.summary.duration).toBe('number');
+  });
+
+  it('should format report as markdown', async () => {
+    const report = await runAnalysis({
+      projectPath: path.join(tempDir, 'TestApp.xcodeproj'),
+      analyzers: ['code'],
+    });
+
+    const formatter = createFormatter('markdown');
+    const output = formatter.format(report);
+
+    expect(output).toContain('#');
+    expect(typeof output).toBe('string');
+    expect(output.length).toBeGreaterThan(0);
+  });
+
+  it('should format report as JSON', async () => {
+    const report = await runAnalysis({
+      projectPath: path.join(tempDir, 'TestApp.xcodeproj'),
+      analyzers: ['code'],
+    });
+
+    const formatter = createFormatter('json');
+    const output = formatter.format(report);
+
+    const parsed = JSON.parse(output);
+    expect(parsed).toBeDefined();
+  });
+
+  it('should format report as HTML', async () => {
+    const report = await runAnalysis({
+      projectPath: path.join(tempDir, 'TestApp.xcodeproj'),
+      analyzers: ['code'],
+    });
+
+    const formatter = createFormatter('html');
+    const output = formatter.format(report);
+
+    expect(output).toContain('<');
+  });
+});