appstash.test.ts

import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import { appstash, ensure, resolve } from '../src';

describe('appstash', () => {
  let tempBase: string;

  beforeEach(() => {
    tempBase = fs.mkdtempSync(path.join(os.tmpdir(), 'appstash-test-'));
  });

  afterEach(() => {
    if (fs.existsSync(tempBase)) {
      fs.rmSync(tempBase, { recursive: true, force: true });
    }
  });

  describe('Basic functionality', () => {
    it('should return correct directory paths for a tool', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      
      expect(dirs.root).toBe(path.join(tempBase, '.pgpm'));
      expect(dirs.config).toBe(path.join(tempBase, '.pgpm', 'config'));
      expect(dirs.cache).toBe(path.join(tempBase, '.pgpm', 'cache'));
      expect(dirs.data).toBe(path.join(tempBase, '.pgpm', 'data'));
      expect(dirs.logs).toBe(path.join(tempBase, '.pgpm', 'logs'));
      expect(dirs.tmp).toBe(path.join(os.tmpdir(), 'pgpm'));
      expect(dirs.usedFallback).toBeUndefined();
    });

    it('should work with different tool names', () => {
      const dirs1 = appstash('lql', { baseDir: tempBase });
      const dirs2 = appstash('myapp', { baseDir: tempBase });
      
      expect(dirs1.root).toBe(path.join(tempBase, '.lql'));
      expect(dirs2.root).toBe(path.join(tempBase, '.myapp'));
    });

    it('should use custom tmpRoot when provided', () => {
      const customTmp = path.join(tempBase, 'tmp');
      const dirs = appstash('pgpm', { baseDir: tempBase, tmpRoot: customTmp });
      
      expect(dirs.tmp).toBe(path.join(customTmp, 'pgpm'));
    });
  });

  describe('ensure option', () => {
    it('should create directories when ensure is true', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase, ensure: true });
      
      expect(fs.existsSync(dirs.root)).toBe(true);
      expect(fs.existsSync(dirs.config)).toBe(true);
      expect(fs.existsSync(dirs.cache)).toBe(true);
      expect(fs.existsSync(dirs.data)).toBe(true);
      expect(fs.existsSync(dirs.logs)).toBe(true);
      expect(dirs.usedFallback).toBeFalsy();
    });

    it('should not create directories when ensure is false', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase, ensure: false });
      
      expect(fs.existsSync(dirs.root)).toBe(false);
      expect(fs.existsSync(dirs.config)).toBe(false);
    });

    it('should not create tmp directory', () => {
      const customTmp = path.join(tempBase, 'tmp');
      const dirs = appstash('pgpm', { baseDir: tempBase, ensure: true, tmpRoot: customTmp });
      
      expect(fs.existsSync(dirs.tmp)).toBe(false);
    });
  });

  describe('ensure function', () => {
    it('should create directories that do not exist', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      const result = ensure(dirs);
      
      expect(result.created.length).toBeGreaterThan(0);
      expect(result.created).toContain(dirs.root);
      expect(result.created).toContain(dirs.config);
      expect(result.usedFallback).toBe(false);
      
      expect(fs.existsSync(dirs.root)).toBe(true);
      expect(fs.existsSync(dirs.config)).toBe(true);
    });

    it('should not recreate existing directories', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase, ensure: true });
      const result = ensure(dirs);
      
      expect(result.created.length).toBe(0);
      expect(result.usedFallback).toBe(false);
    });
  });

  describe('resolve function', () => {
    it('should resolve paths within config directory', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      const configPath = resolve(dirs, 'config', 'settings.json');
      
      expect(configPath).toBe(path.join(dirs.config, 'settings.json'));
    });

    it('should resolve paths within cache directory', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      const cachePath = resolve(dirs, 'cache', 'repos', 'my-repo');
      
      expect(cachePath).toBe(path.join(dirs.cache, 'repos', 'my-repo'));
    });

    it('should resolve paths within data directory', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      const dataPath = resolve(dirs, 'data', 'db.json');
      
      expect(dataPath).toBe(path.join(dirs.data, 'db.json'));
    });

    it('should resolve paths within logs directory', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      const logPath = resolve(dirs, 'logs', 'app.log');
      
      expect(logPath).toBe(path.join(dirs.logs, 'app.log'));
    });

    it('should resolve paths within tmp directory', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      const tmpPath = resolve(dirs, 'tmp', 'temp-file.txt');
      
      expect(tmpPath).toBe(path.join(dirs.tmp, 'temp-file.txt'));
    });
  });

  describe('APPSTASH_BASE_DIR env var', () => {
    const originalEnv = process.env.APPSTASH_BASE_DIR;

    afterEach(() => {
      if (originalEnv === undefined) {
        delete process.env.APPSTASH_BASE_DIR;
      } else {
        process.env.APPSTASH_BASE_DIR = originalEnv;
      }
    });

    it('should use APPSTASH_BASE_DIR when no baseDir option is provided', () => {
      process.env.APPSTASH_BASE_DIR = tempBase;
      const dirs = appstash('pgpm');

      expect(dirs.root).toBe(path.join(tempBase, '.pgpm'));
      expect(dirs.config).toBe(path.join(tempBase, '.pgpm', 'config'));
    });

    it('should prefer baseDir option over APPSTASH_BASE_DIR env var', () => {
      const otherBase = fs.mkdtempSync(path.join(os.tmpdir(), 'appstash-other-'));
      process.env.APPSTASH_BASE_DIR = otherBase;

      const dirs = appstash('pgpm', { baseDir: tempBase });

      expect(dirs.root).toBe(path.join(tempBase, '.pgpm'));
      fs.rmSync(otherBase, { recursive: true, force: true });
    });
  });

  describe('Edge cases', () => {
    it('should handle tool names with special characters', () => {
      const dirs = appstash('my-app', { baseDir: tempBase });
      
      expect(dirs.root).toBe(path.join(tempBase, '.my-app'));
    });

    it('should be consistent across multiple calls', () => {
      const dirs1 = appstash('pgpm', { baseDir: tempBase });
      const dirs2 = appstash('pgpm', { baseDir: tempBase });
      
      expect(dirs1.root).toBe(dirs2.root);
      expect(dirs1.config).toBe(dirs2.config);
      expect(dirs1.cache).toBe(dirs2.cache);
    });
  });

  describe('Integration tests', () => {
    it('should support full workflow: resolve, ensure, use', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase });
      
      const ensureResult = ensure(dirs);
      expect(ensureResult.usedFallback).toBe(false);
      
      const configFile = resolve(dirs, 'config', 'settings.json');
      
      fs.writeFileSync(configFile, JSON.stringify({ test: 'value' }));
      
      const content = JSON.parse(fs.readFileSync(configFile, 'utf8'));
      expect(content.test).toBe('value');
    });

    it('should work with ensure option', () => {
      const dirs = appstash('pgpm', { baseDir: tempBase, ensure: true });
      
      expect(fs.existsSync(dirs.root)).toBe(true);
      expect(fs.existsSync(dirs.config)).toBe(true);
      expect(dirs.root).toBe(path.join(tempBase, '.pgpm'));
    });
  });
});