opencode-conductor-cdd-plugin 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/utils/planParser.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { addPhaseDelimiters, extractActivePhase, extractPhaseByName } from "./planParser.js";
+describe("planParser", () => {
+    const samplePlan = `# Implementation Plan: Sample Track
+
+This is the introduction.
+
+## Phase 1: Setup
+*Goal: Set up the project infrastructure.*
+
+- [x] Task: Initialize repository (abc1234)
+- [x] Task: Configure tools (def5678)
+- [x] Task: Orchestrator - User Manual Verification 'Phase 1: Setup' [checkpoint: aaa1111]
+
+## Phase 2: Implementation
+*Goal: Implement core features.*
+
+- [~] Task: Design API
+- [ ] Task: Implement endpoints
+- [ ] Task: Orchestrator - User Manual Verification 'Phase 2: Implementation'
+
+## Phase 3: Testing
+*Goal: Write and run tests.*
+
+- [ ] Task: Unit tests
+- [ ] Task: Integration tests
+- [ ] Task: Orchestrator - User Manual Verification 'Phase 3: Testing'
+`;
+    describe("addPhaseDelimiters", () => {
+        it("should add XML-style phase delimiters to plan.md content", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            expect(delimited).toContain("<!-- PHASE_START:phase1 -->");
+            expect(delimited).toContain("<!-- PHASE_END:phase1 -->");
+            expect(delimited).toContain("<!-- PHASE_START:phase2 -->");
+            expect(delimited).toContain("<!-- PHASE_END:phase2 -->");
+            expect(delimited).toContain("<!-- PHASE_START:phase3 -->");
+            expect(delimited).toContain("<!-- PHASE_END:phase3 -->");
+        });
+        it("should preserve all original content", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            expect(delimited).toContain("# Implementation Plan: Sample Track");
+            expect(delimited).toContain("## Phase 1: Setup");
+            expect(delimited).toContain("- [x] Task: Initialize repository");
+            expect(delimited).toContain("## Phase 2: Implementation");
+            expect(delimited).toContain("## Phase 3: Testing");
+        });
+        it("should handle plan with no phases", () => {
+            const noPhasePlan = "# Plan\n\nJust some intro text.";
+            const delimited = addPhaseDelimiters(noPhasePlan);
+            expect(delimited).toBe(noPhasePlan);
+        });
+    });
+    describe("extractActivePhase", () => {
+        it("should extract the first in-progress phase", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const activePhase = extractActivePhase(delimited);
+            expect(activePhase).not.toBeNull();
+            expect(activePhase?.phaseId).toBe("phase2");
+            expect(activePhase?.content).toContain("## Phase 2: Implementation");
+            expect(activePhase?.content).toContain("- [~] Task: Design API");
+        });
+        it("should extract the first pending phase if no in-progress phase", () => {
+            const allCompletedPlan = `# Plan
+
+<!-- PHASE_START:phase1 -->
+## Phase 1: Setup
+- [x] Task: Done [checkpoint: xxx]
+<!-- PHASE_END:phase1 -->
+
+<!-- PHASE_START:phase2 -->
+## Phase 2: Testing
+- [ ] Task: Todo
+<!-- PHASE_END:phase2 -->`;
+            const activePhase = extractActivePhase(allCompletedPlan);
+            expect(activePhase).not.toBeNull();
+            expect(activePhase?.phaseId).toBe("phase2");
+        });
+        it("should return null if all phases are completed", () => {
+            const allCompletedPlan = `# Plan
+
+<!-- PHASE_START:phase1 -->
+## Phase 1: Setup
+- [x] Task: Done [checkpoint: xxx]
+<!-- PHASE_END:phase1 -->
+
+<!-- PHASE_START:phase2 -->
+## Phase 2: Testing
+- [x] Task: Done [checkpoint: yyy]
+<!-- PHASE_END:phase2 -->`;
+            const activePhase = extractActivePhase(allCompletedPlan);
+            expect(activePhase).toBeNull();
+        });
+        it("should return null if no delimiters found", () => {
+            const activePhase = extractActivePhase(samplePlan);
+            expect(activePhase).toBeNull();
+        });
+    });
+    describe("extractPhaseByName", () => {
+        it("should extract a specific phase by name", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const phase = extractPhaseByName(delimited, "Phase 1: Setup");
+            expect(phase).not.toBeNull();
+            expect(phase?.phaseId).toBe("phase1");
+            expect(phase?.content).toContain("## Phase 1: Setup");
+            expect(phase?.content).toContain("- [x] Task: Initialize repository");
+        });
+        it("should return null if phase name not found", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const phase = extractPhaseByName(delimited, "Phase 99: Nonexistent");
+            expect(phase).toBeNull();
+        });
+        it("should handle partial name matches", () => {
+            const delimited = addPhaseDelimiters(samplePlan);
+            const phase = extractPhaseByName(delimited, "Implementation");
+            expect(phase).not.toBeNull();
+            expect(phase?.phaseId).toBe("phase2");
+        });
+    });
+});

package/dist/utils/projectMaturity.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Project Maturity Detection Module
+ *
+ * Determines whether a project is brownfield (existing) or greenfield (new).
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export type ProjectMaturity = 'brownfield' | 'greenfield';
+/**
+ * Detect project maturity (brownfield vs greenfield)
+ *
+ * A project is considered BROWNFIELD if ANY of:
+ * - Version control directory exists (.git, .svn, .hg)
+ * - Git repository is dirty (uncommitted changes)
+ * - Dependency manifests exist
+ * - Source directories contain code files
+ *
+ * A project is considered GREENFIELD only if NONE of the above are true.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns 'brownfield' or 'greenfield'
+ */
+export declare function detectProjectMaturity(projectPath: string): ProjectMaturity;
+/**
+ * Check if git repository has uncommitted changes
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns true if repository is dirty, false otherwise
+ */
+export declare function checkGitStatus(projectPath: string): boolean;
+/**
+ * Check for dependency manifest files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found manifest file names
+ */
+export declare function checkManifestFiles(projectPath: string): string[];
+/**
+ * Check for source directories containing code files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found source directory names
+ */
+export declare function checkSourceDirectories(projectPath: string): string[];
+/**
+ * Check for version control system directories
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Name of VCS directory found, or null if none found
+ */
+export declare function checkVersionControl(projectPath: string): string | null;

package/dist/utils/projectMaturity.js

@@ -0,0 +1,179 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+/**
+ * Manifest files that indicate a brownfield project
+ */
+const MANIFEST_FILES = [
+    'package.json',
+    'pom.xml',
+    'requirements.txt',
+    'go.mod',
+    'Cargo.toml',
+    'Gemfile',
+];
+/**
+ * Source directory names to check for code
+ */
+const SOURCE_DIRECTORIES = ['src', 'app', 'lib'];
+/**
+ * Code file extensions to detect
+ */
+const CODE_EXTENSIONS = ['.ts', '.js', '.py', '.go', '.rs', '.rb', '.java', '.kt', '.swift'];
+/**
+ * Version control system directories
+ */
+const VCS_DIRECTORIES = ['.git', '.svn', '.hg'];
+/**
+ * Detect project maturity (brownfield vs greenfield)
+ *
+ * A project is considered BROWNFIELD if ANY of:
+ * - Version control directory exists (.git, .svn, .hg)
+ * - Git repository is dirty (uncommitted changes)
+ * - Dependency manifests exist
+ * - Source directories contain code files
+ *
+ * A project is considered GREENFIELD only if NONE of the above are true.
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns 'brownfield' or 'greenfield'
+ */
+export function detectProjectMaturity(projectPath) {
+    // Check version control
+    const vcs = checkVersionControl(projectPath);
+    if (vcs) {
+        return 'brownfield';
+    }
+    // Check git status (dirty repository)
+    const isDirty = checkGitStatus(projectPath);
+    if (isDirty) {
+        return 'brownfield';
+    }
+    // Check for dependency manifests
+    const manifests = checkManifestFiles(projectPath);
+    if (manifests.length > 0) {
+        return 'brownfield';
+    }
+    // Check for source directories with code
+    const sourceDirs = checkSourceDirectories(projectPath);
+    if (sourceDirs.length > 0) {
+        return 'brownfield';
+    }
+    // No brownfield indicators found
+    return 'greenfield';
+}
+/**
+ * Check if git repository has uncommitted changes
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns true if repository is dirty, false otherwise
+ */
+export function checkGitStatus(projectPath) {
+    try {
+        const gitDir = path.join(projectPath, '.git');
+        if (!fs.existsSync(gitDir)) {
+            return false;
+        }
+        const output = execSync('git status --porcelain', {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'], // Suppress stderr
+        });
+        return output.trim().length > 0;
+    }
+    catch (error) {
+        // Git command failed or not a git repository
+        return false;
+    }
+}
+/**
+ * Check for dependency manifest files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found manifest file names
+ */
+export function checkManifestFiles(projectPath) {
+    const found = [];
+    for (const manifest of MANIFEST_FILES) {
+        const manifestPath = path.join(projectPath, manifest);
+        if (fs.existsSync(manifestPath)) {
+            found.push(manifest);
+        }
+    }
+    return found;
+}
+/**
+ * Check for source directories containing code files
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Array of found source directory names
+ */
+export function checkSourceDirectories(projectPath) {
+    const found = [];
+    for (const dirName of SOURCE_DIRECTORIES) {
+        const dirPath = path.join(projectPath, dirName);
+        if (!fs.existsSync(dirPath)) {
+            continue;
+        }
+        const stat = fs.statSync(dirPath);
+        if (!stat.isDirectory()) {
+            continue;
+        }
+        // Check if directory contains code files
+        if (containsCodeFiles(dirPath)) {
+            found.push(dirName);
+        }
+    }
+    return found;
+}
+/**
+ * Check if directory contains code files (recursive, depth-limited)
+ *
+ * @param dirPath - Absolute path to directory
+ * @param maxDepth - Maximum recursion depth (default: 3)
+ * @param currentDepth - Current recursion depth
+ * @returns true if code files found
+ */
+function containsCodeFiles(dirPath, maxDepth = 3, currentDepth = 0) {
+    if (currentDepth > maxDepth) {
+        return false;
+    }
+    try {
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(dirPath, entry.name);
+            if (entry.isFile()) {
+                const ext = path.extname(entry.name);
+                if (CODE_EXTENSIONS.includes(ext)) {
+                    return true;
+                }
+            }
+            else if (entry.isDirectory()) {
+                // Recursively check subdirectories
+                if (containsCodeFiles(entryPath, maxDepth, currentDepth + 1)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        // Permission error or other issue
+        return false;
+    }
+}
+/**
+ * Check for version control system directories
+ *
+ * @param projectPath - Absolute path to project directory
+ * @returns Name of VCS directory found, or null if none found
+ */
+export function checkVersionControl(projectPath) {
+    for (const vcs of VCS_DIRECTORIES) {
+        const vcsPath = path.join(projectPath, vcs);
+        if (fs.existsSync(vcsPath)) {
+            return vcs;
+        }
+    }
+    return null;
+}

package/dist/utils/projectMaturity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/projectMaturity.test.js

@@ -0,0 +1,298 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { detectProjectMaturity, checkGitStatus, checkManifestFiles, checkSourceDirectories, checkVersionControl, } from './projectMaturity.js';
+/**
+ * Project Maturity Detection Module Tests
+ *
+ * This module is responsible for determining whether a project is:
+ * - Brownfield (existing project with code/configuration)
+ * - Greenfield (new/empty project)
+ *
+ * Based on reference implementations from:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+// Mock file system and child_process
+vi.mock('fs');
+vi.mock('child_process');
+describe('Project Maturity Detection', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('detectProjectMaturity', () => {
+        it('should detect brownfield project with .git directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with dirty git repository', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            vi.mocked(execSync).mockReturnValue('M file.txt\n');
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with package.json manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with pom.xml manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('pom.xml');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with requirements.txt manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('requirements.txt');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with go.mod manifest', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('go.mod');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with src/ directory containing code', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with app/ directory containing code', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/app');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with lib/ directory containing code', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/lib');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'utils.js', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with .svn directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.svn');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect brownfield project with .hg directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.hg');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+        it('should detect greenfield project when directory is empty', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('greenfield');
+        });
+        it('should detect greenfield project with only README.md', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('greenfield');
+        });
+        it('should detect greenfield when no brownfield indicators present', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('greenfield');
+        });
+        it('should prioritize brownfield if ANY indicator is present', () => {
+            // Only .git exists, nothing else
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            const result = detectProjectMaturity('/test/project');
+            expect(result).toBe('brownfield');
+        });
+    });
+    describe('checkGitStatus', () => {
+        it('should return true for dirty repository', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(execSync).mockReturnValue('M file.txt\n');
+            const result = checkGitStatus('/test/project');
+            expect(result).toBe(true);
+        });
+        it('should return false for clean repository', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(execSync).mockReturnValue('');
+            const result = checkGitStatus('/test/project');
+            expect(result).toBe(false);
+        });
+        it('should handle missing .git directory gracefully', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = checkGitStatus('/test/project');
+            expect(result).toBe(false);
+        });
+    });
+    describe('checkManifestFiles', () => {
+        it('should detect package.json', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('package.json');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('package.json');
+        });
+        it('should detect pom.xml', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('pom.xml');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('pom.xml');
+        });
+        it('should detect requirements.txt', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('requirements.txt');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('requirements.txt');
+        });
+        it('should detect go.mod', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('go.mod');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('go.mod');
+        });
+        it('should detect Cargo.toml', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Cargo.toml');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('Cargo.toml');
+        });
+        it('should detect Gemfile', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('Gemfile');
+            });
+            const result = checkManifestFiles('/test/project');
+            expect(result).toContain('Gemfile');
+        });
+        it('should return empty array when no manifests found', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = checkManifestFiles('/test/project');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('checkSourceDirectories', () => {
+        it('should detect src/ directory with .ts files', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'index.ts', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toContain('src');
+        });
+        it('should detect app/ directory with .py files', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/app');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'main.py', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toContain('app');
+        });
+        it('should detect lib/ directory with .js files', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().includes('/lib');
+            });
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'utils.js', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toContain('lib');
+        });
+        it('should ignore empty source directories', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toEqual([]);
+        });
+        it('should ignore directories with only non-code files', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.statSync).mockReturnValue({
+                isDirectory: () => true,
+            });
+            vi.mocked(fs.readdirSync).mockReturnValue([
+                { name: 'README.md', isFile: () => true, isDirectory: () => false },
+                { name: 'notes.txt', isFile: () => true, isDirectory: () => false },
+            ]);
+            const result = checkSourceDirectories('/test/project');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('checkVersionControl', () => {
+        it('should detect .git directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.git');
+            });
+            const result = checkVersionControl('/test/project');
+            expect(result).toBe('.git');
+        });
+        it('should detect .svn directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.svn');
+            });
+            const result = checkVersionControl('/test/project');
+            expect(result).toBe('.svn');
+        });
+        it('should detect .hg directory', () => {
+            vi.mocked(fs.existsSync).mockImplementation((p) => {
+                return p.toString().endsWith('.hg');
+            });
+            const result = checkVersionControl('/test/project');
+            expect(result).toBe('.hg');
+        });
+        it('should return null when no VCS found', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = checkVersionControl('/test/project');
+            expect(result).toBeNull();
+        });
+    });
+});