meld/services/fs/PathService/PathService.test.ts

Meld: A template language for LLM prompts

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { TestContext } from '@tests/utils/TestContext.js';
import { PathService } from './PathService.js';
import { PathValidationError, PathErrorCode } from './errors/PathValidationError.js';
import type { Location } from '@core/types/index.js';
import type { MeldNode } from 'meld-spec';
import { StructuredPath } from './IPathService.js';

// Direct usage of meld-ast instead of a mock
const createRealParserService = () => {
  // Create the parse function
  const parseFunction = async (content: string): Promise<MeldNode[]> => {
    // Check if this is a path directive we need to handle specially
    if (content.includes('$PROJECTPATH/') || content.includes('$HOMEPATH/')) {
      // Extract the path from the content
      const pathMatch = content.match(/\$(PROJECTPATH|HOMEPATH)\/([^$\s]+)/);
      if (pathMatch) {
        const base = `$${pathMatch[1]}`;
        const path = `${base}/${pathMatch[2]}`;
        const segments = pathMatch[2].split('/');
        
        // Create a structured path node that matches the interface
        return [{
          type: 'PathVar',
          // Cast to any to avoid type errors with MeldNode
          value: {
            raw: path,
            structured: {
              segments,
              variables: {
                special: [pathMatch[1]]
              }
            },
            normalized: path
          } as StructuredPath,
          location: {
            start: { line: 1, column: 1 },
            end: { line: 1, column: content.length }
          }
        } as any];
      }
    }
    
    // Use the real meld-ast parser with dynamic import for other cases
    try {
      const { parse } = await import('meld-ast');
      const result = await parse(content, {
        trackLocations: true,
        validateNodes: true,
        // structuredPaths is used in the codebase but may be missing from typings
        // @ts-expect-error - structuredPaths is used but may be missing from typings
        structuredPaths: true
      });
      return result.ast || [];
    } catch (error) {
      console.error('Error parsing with meld-ast:', error);
      throw error;
    }
  };
  
  // Create a spy for the parse function
  const parseSpy = vi.fn(parseFunction);
  
  return {
    parse: parseSpy,
    parseWithLocations: vi.fn()
  };
};

describe('PathService', () => {
  let context: TestContext;
  let service: PathService;
  let parserService: ReturnType<typeof createRealParserService>;

  beforeEach(async () => {
    context = new TestContext();
    await context.initialize();
    service = context.services.path;
    parserService = createRealParserService();
    service.initialize(context.services.fs, parserService);
    service.setHomePath('/home/user');
    service.setProjectPath('/project/root');
  });

  afterEach(async () => {
    await context.cleanup();
  });

  describe('Path validation', () => {
    it('validates empty path', async () => {
      await expect(service.validatePath('')).rejects.toThrow(PathValidationError);
    });

    it('validates path with null bytes', async () => {
      await expect(service.validatePath('test\0.txt')).rejects.toThrow(PathValidationError);
    });

    it('validates path is within base directory', async () => {
      const filePath = '$PROJECTPATH/test.txt';
      const outsidePath = '$HOMEPATH/outside.txt';
      const location: Location = {
        start: { line: 1, column: 1 },
        end: { line: 1, column: 10 }
      };

      // Create test files
      await context.fs.writeFile('/project/root/test.txt', 'test');
      await context.fs.writeFile('/home/user/outside.txt', 'test');

      // Test path within base dir
      await expect(service.validatePath(filePath, {
        allowOutsideBaseDir: false,
        location
      })).resolves.not.toThrow();

      // Test path outside base dir
      await expect(service.validatePath(outsidePath, {
        allowOutsideBaseDir: false,
        location
      })).rejects.toThrow(PathValidationError);
    });

    it('allows paths outside base directory when configured', async () => {
      const filePath = '$HOMEPATH/outside.txt';
      const location: Location = {
        start: { line: 1, column: 1 },
        end: { line: 1, column: 10 }
      };

      // Create test file
      await context.fs.writeFile('/home/user/outside.txt', 'test');

      await expect(service.validatePath(filePath, {
        allowOutsideBaseDir: true,
        location
      })).resolves.not.toThrow();
    });

    it('validates file existence', async () => {
      const filePath = '$PROJECTPATH/test.txt';
      const nonExistentPath = '$PROJECTPATH/nonexistent.txt';
      const location: Location = {
        start: { line: 1, column: 1 },
        end: { line: 1, column: 10 }
      };

      // Create test file
      await context.fs.writeFile('/project/root/test.txt', 'test');

      // Should pass for existing file
      await expect(service.validatePath(filePath, {
        mustExist: true,
        location
      })).resolves.not.toThrow();

      // Should fail for non-existent file
      await expect(service.validatePath(nonExistentPath, {
        mustExist: true,
        location
      })).rejects.toThrow(PathValidationError);
    });

    it('skips existence check when configured', async () => {
      const nonExistentPath = '$PROJECTPATH/nonexistent.txt';
      const location: Location = {
        start: { line: 1, column: 1 },
        end: { line: 1, column: 10 }
      };

      await expect(service.validatePath(nonExistentPath, {
        mustExist: false,
        location
      })).resolves.not.toThrow();
    });

    it('validates file type', async () => {
      const filePath = '$PROJECTPATH/test.txt';
      const dirPath = '$PROJECTPATH/testdir';
      const location: Location = {
        start: { line: 1, column: 1 },
        end: { line: 1, column: 10 }
      };

      // Create test file and directory
      await context.fs.writeFile('/project/root/test.txt', 'test');
      await context.fs.mkdir('/project/root/testdir');

      // Should pass for file when mustBeFile is true
      await expect(service.validatePath(filePath, {
        mustBeFile: true,
        location
      })).resolves.not.toThrow();

      await expect(service.validatePath(dirPath, {
        mustBeFile: true,
        location
      })).rejects.toThrow(PathValidationError);

      // Should pass for directory when mustBeDirectory is true
      await expect(service.validatePath(dirPath, {
        mustBeDirectory: true,
        location
      })).resolves.not.toThrow();

      await expect(service.validatePath(filePath, {
        mustBeDirectory: true,
        location
      })).rejects.toThrow(PathValidationError);
    });
  });

  describe('Path normalization', () => {
    it('normalizes paths', () => {
      expect(service.normalizePath('/path/to/file.txt')).toBe('/path/to/file.txt');
      expect(service.normalizePath('/path//to/file.txt')).toBe('/path/to/file.txt');
      expect(service.normalizePath('/path/to/../file.txt')).toBe('/path/file.txt');
      expect(service.normalizePath('/path/./to/file.txt')).toBe('/path/to/file.txt');
    });

    it('joins paths', () => {
      expect(service.join('/path/to', 'file.txt')).toBe('/path/to/file.txt');
      expect(service.join('/path/to/', '/file.txt')).toBe('/path/to/file.txt');
      expect(service.join('/path', 'to', 'file.txt')).toBe('/path/to/file.txt');
    });

    it('gets dirname', () => {
      expect(service.dirname('/path/to/file.txt')).toBe('/path/to');
      expect(service.dirname('file.txt')).toBe('.');
    });

    it('gets basename', () => {
      expect(service.basename('/path/to/file.txt')).toBe('file.txt');
      // Note: We need to check the implementation to see if it supports the second parameter
      // If it doesn't, we should remove this line
      // expect(service.basename('/path/to/file.txt', '.txt')).toBe('file');
    });
  });

  describe('Test mode', () => {
    it('toggles test mode', () => {
      // Reset test mode to false first
      service.disableTestMode();
      expect(service.isTestMode()).toBe(false);
      service.enableTestMode();
      expect(service.isTestMode()).toBe(true);
      service.disableTestMode();
      expect(service.isTestMode()).toBe(false);
    });
  });

  describe('Structured path validation', () => {
    it('validates structured paths correctly', () => {
      // Create a valid structured path
      const validStructuredPath: StructuredPath = {
        raw: '$PROJECTPATH/valid.txt',
        structured: {
          segments: ['valid.txt'],
          variables: {
            special: ['PROJECTPATH'],
            path: []
          }
        }
      };

      // Create an invalid structured path with dot segments
      const invalidStructuredPath: StructuredPath = {
        raw: '$PROJECTPATH/../invalid.txt',
        structured: {
          segments: ['..', 'invalid.txt'],
          variables: {
            special: ['PROJECTPATH'],
            path: []
          }
        }
      };

      // Test validation
      expect(() => service.resolvePath(validStructuredPath)).not.toThrow();
      expect(() => service.resolvePath(invalidStructuredPath)).toThrow(PathValidationError);
    });

    it('uses parser service when available', async () => {
      // Create test file
      await context.fs.writeFile('/project/root/test.txt', 'test');
      
      // Verify parser is called
      await service.validatePath('$PROJECTPATH/test.txt');
      expect(parserService.parse).toHaveBeenCalled();
    });
  });

  describe('Regression tests for specific failures', () => {
    it('validates path is within base directory correctly', async () => {
      // Create test files
      await context.fs.writeFile('/project/root/inside.txt', 'test');
      await context.fs.writeFile('/home/user/outside.txt', 'test');

      const filePath = '$PROJECTPATH/inside.txt';
      const outsidePath = '$HOMEPATH/outside.txt';

      // Should pass for path inside base dir
      await expect(service.validatePath(filePath, {
        allowOutsideBaseDir: false
      })).resolves.not.toThrow();

      // Should fail for path outside base dir
      await expect(service.validatePath(outsidePath, {
        allowOutsideBaseDir: false
      })).rejects.toThrow(PathValidationError);
    });

    it('validates file existence correctly', async () => {
      // Create test file
      await context.fs.writeFile('/project/root/test.txt', 'test');

      const filePath = '$PROJECTPATH/test.txt';
      const nonExistentPath = '$PROJECTPATH/nonexistent.txt';

      // Should pass for existing file
      await expect(service.validatePath(filePath, {
        mustExist: true
      })).resolves.not.toThrow();

      // Should fail for non-existent file
      await expect(service.validatePath(nonExistentPath, {
        mustExist: true
      })).rejects.toThrow(PathValidationError);
    });

    it('validates file type correctly', async () => {
      // Create test file and directory
      await context.fs.writeFile('/project/root/test.txt', 'test');
      await context.fs.mkdir('/project/root/testdir');

      const filePath = '$PROJECTPATH/test.txt';
      const dirPath = '$PROJECTPATH/testdir';

      // Should pass for file when mustBeFile is true
      await expect(service.validatePath(filePath, {
        mustBeFile: true
      })).resolves.not.toThrow();

      // Should fail for directory when mustBeFile is true
      await expect(service.validatePath(dirPath, {
        mustBeFile: true
      })).rejects.toThrow(PathValidationError);

      // Should pass for directory when mustBeDirectory is true
      await expect(service.validatePath(dirPath, {
        mustBeDirectory: true
      })).resolves.not.toThrow();

      // Should fail for file when mustBeDirectory is true
      await expect(service.validatePath(filePath, {
        mustBeDirectory: true
      })).rejects.toThrow(PathValidationError);
    });
  });
});