onbuzz 3.4.0 → 3.6.2

package/src/utilities/__tests__/directoryAccessManager.test.js

@@ -0,0 +1,388 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import path from 'path';
+import os from 'os';
+import DirectoryAccessManager from '../directoryAccessManager.js';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+describe('DirectoryAccessManager', () => {
+  let dam;
+  let logger;
+  const projectDir = path.resolve('/tmp/test-project');
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    dam = new DirectoryAccessManager({}, logger);
+  });
+
+  test('createDirectoryAccess returns config with working directory', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir
+    });
+    expect(access).toHaveProperty('workingDirectory');
+    expect(access.workingDirectory).toBe(projectDir);
+    expect(access).toHaveProperty('readOnlyDirectories');
+    expect(access).toHaveProperty('writeEnabledDirectories');
+    expect(access).toHaveProperty('restrictToProject');
+    expect(access).toHaveProperty('version', '1.0');
+    expect(access).toHaveProperty('createdAt');
+  });
+
+  test('createDirectoryAccess includes workingDir in readOnly when restrictToProject', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      restrictToProject: true
+    });
+    expect(access.readOnlyDirectories).toContain(projectDir);
+  });
+
+  test('createDirectoryAccess filters writeEnabled dirs outside project when restricted', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      restrictToProject: true,
+      writeEnabledDirectories: ['/tmp/other-project']
+    });
+    // /tmp/other-project is outside projectDir, should be filtered
+    expect(access.writeEnabledDirectories).not.toContain(path.resolve('/tmp/other-project'));
+  });
+
+  test('createDirectoryAccess resolves custom restrictions to absolute paths', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      customRestrictions: ['sensitive']
+    });
+    expect(access.customRestrictions[0]).toBe(path.resolve('sensitive'));
+  });
+
+  // ─── validateReadAccess ────────────────────────────────────────
+
+  test('validateReadAccess allows path within project', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir
+    });
+    const filePath = path.join(projectDir, 'src', 'index.js');
+    const result = dam.validateReadAccess(filePath, access);
+    expect(result.allowed).toBe(true);
+    expect(result.category).toBe('allowed');
+  });
+
+  test('validateReadAccess denies system paths', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir
+    });
+    const systemPath = process.platform === 'win32'
+      ? 'C:\\Windows\\System32\\config'
+      : '/etc/passwd';
+    const result = dam.validateReadAccess(systemPath, access);
+    expect(result.allowed).toBe(false);
+    expect(result.category).toBe('system_restricted');
+  });
+
+  test('validateReadAccess allows system paths when allowSystemAccess is true', () => {
+    const sshPath = path.join(os.homedir(), '.ssh', 'known_hosts');
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      allowSystemAccess: true,
+      restrictToProject: false,
+      readOnlyDirectories: [os.homedir()]
+    });
+    const result = dam.validateReadAccess(sshPath, access);
+    expect(result.allowed).toBe(true);
+  });
+
+  test('validateReadAccess denies custom restricted paths', () => {
+    const restrictedDir = path.join(projectDir, 'secrets');
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      customRestrictions: [restrictedDir]
+    });
+    const result = dam.validateReadAccess(path.join(restrictedDir, 'key.pem'), access);
+    expect(result.allowed).toBe(false);
+    expect(result.category).toBe('custom_restricted');
+  });
+
+  test('validateReadAccess denies path outside project scope', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      restrictToProject: true
+    });
+    const result = dam.validateReadAccess('/tmp/other-project/file.js', access);
+    expect(result.allowed).toBe(false);
+    expect(result.category).toBe('project_restricted');
+  });
+
+  test('validateReadAccess handles validation errors gracefully', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir
+    });
+    // Pass an object instead of string to trigger error
+    const result = dam.validateReadAccess(null, access);
+    expect(result.allowed).toBe(false);
+    expect(result.category).toBe('validation_error');
+  });
+
+  // ─── validateWriteAccess ───────────────────────────────────────
+
+  test('validateWriteAccess allows within write-enabled directory', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      writeEnabledDirectories: [projectDir]
+    });
+    const filePath = path.join(projectDir, 'output.txt');
+    const result = dam.validateWriteAccess(filePath, access);
+    expect(result.allowed).toBe(true);
+    expect(result.writeAllowed).toBe(true);
+    expect(result.category).toBe('write_allowed');
+  });
+
+  test('validateWriteAccess denies write to read-only directory', () => {
+    const readOnlyDir = path.join(projectDir, 'readonly');
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      readOnlyDirectories: [readOnlyDir],
+      writeEnabledDirectories: [path.join(projectDir, 'writable')],
+      restrictToProject: false
+    });
+    const result = dam.validateWriteAccess(path.join(readOnlyDir, 'file.txt'), access);
+    expect(result.allowed).toBe(false);
+    expect(result.writeAllowed).toBe(false);
+    expect(result.category).toBe('read_only_restricted');
+  });
+
+  test('validateWriteAccess denies write outside write-enabled directories', () => {
+    const writeDir = path.join(projectDir, 'output');
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      writeEnabledDirectories: [writeDir],
+      restrictToProject: false
+    });
+    const otherPath = path.join(projectDir, 'src', 'file.js');
+    const result = dam.validateWriteAccess(otherPath, access);
+    expect(result.allowed).toBe(false);
+    expect(result.writeAllowed).toBe(false);
+    expect(result.category).toBe('write_restricted');
+  });
+
+  test('validateWriteAccess falls back to workingDirectory when no writeEnabled dirs', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      writeEnabledDirectories: [],
+      restrictToProject: true
+    });
+    // Manually clear writeEnabledDirectories that createDirectoryAccess may have filtered
+    access.writeEnabledDirectories = [];
+    const filePath = path.join(projectDir, 'output.txt');
+    const result = dam.validateWriteAccess(filePath, access);
+    expect(result.allowed).toBe(true);
+    expect(result.writeAllowed).toBe(true);
+  });
+
+  test('validateWriteAccess propagates read-access denial', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir
+    });
+    const systemPath = process.platform === 'win32'
+      ? 'C:\\Windows\\System32\\config\\test.txt'
+      : '/etc/shadow';
+    const result = dam.validateWriteAccess(systemPath, access);
+    expect(result.allowed).toBe(false);
+    expect(result.writeAllowed).toBe(false);
+  });
+
+  // ─── getWorkingDirectory ───────────────────────────────────────
+
+  test('getWorkingDirectory returns workingDirectory from config', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    expect(dam.getWorkingDirectory(access)).toBe(projectDir);
+  });
+
+  test('getWorkingDirectory falls back to cwd when no workingDirectory', () => {
+    expect(dam.getWorkingDirectory({})).toBe(process.cwd());
+  });
+
+  // ─── getAccessibleDirectories ──────────────────────────────────
+
+  test('getAccessibleDirectories returns directory listing', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      readOnlyDirectories: [path.join(projectDir, 'docs')],
+      writeEnabledDirectories: [path.join(projectDir, 'src')]
+    });
+    const result = dam.getAccessibleDirectories(access);
+    expect(result.workingDirectory).toBe(projectDir);
+    expect(result.readOnly).toContain(projectDir); // workingDir added
+    expect(result.projectRestricted).toBe(true);
+    expect(result.systemAccessAllowed).toBe(false);
+    expect(typeof result.totalDirectories).toBe('number');
+  });
+
+  // ─── updateDirectoryAccess ─────────────────────────────────────
+
+  test('updateDirectoryAccess updates working directory', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    const updated = dam.updateDirectoryAccess(access, {
+      workingDirectory: '/tmp/new-project'
+    });
+    expect(updated.workingDirectory).toBe(path.resolve('/tmp/new-project'));
+    expect(updated.updatedAt).toBeDefined();
+  });
+
+  test('updateDirectoryAccess updates readOnlyDirectories', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    const updated = dam.updateDirectoryAccess(access, {
+      readOnlyDirectories: ['/tmp/docs']
+    });
+    // The stored path may be normalized differently per platform
+    const hasDocsPath = updated.readOnlyDirectories.some(d => d.includes('tmp') && d.includes('docs'));
+    expect(hasDocsPath).toBe(true);
+  });
+
+  test('updateDirectoryAccess updates writeEnabledDirectories', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    const updated = dam.updateDirectoryAccess(access, {
+      writeEnabledDirectories: [projectDir]
+    });
+    expect(updated.writeEnabledDirectories).toContain(projectDir);
+  });
+
+  test('updateDirectoryAccess updates boolean flags', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    const updated = dam.updateDirectoryAccess(access, {
+      restrictToProject: false,
+      allowSystemAccess: true
+    });
+    expect(updated.restrictToProject).toBe(false);
+    expect(updated.allowSystemAccess).toBe(true);
+  });
+
+  test('updateDirectoryAccess updates customRestrictions', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    const updated = dam.updateDirectoryAccess(access, {
+      customRestrictions: ['/tmp/restricted']
+    });
+    expect(updated.customRestrictions).toContain(path.resolve('/tmp/restricted'));
+  });
+
+  test('updateDirectoryAccess preserves version', () => {
+    const access = dam.createDirectoryAccess({ workingDirectory: projectDir });
+    const updated = dam.updateDirectoryAccess(access, {});
+    expect(updated.version).toBe('1.0');
+  });
+
+  // ─── validateAccessConfiguration ──────────────────────────────
+
+  test('validateAccessConfiguration validates valid config', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      writeEnabledDirectories: [projectDir]
+    });
+    const result = dam.validateAccessConfiguration(access);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.summary).toBeDefined();
+  });
+
+  test('validateAccessConfiguration errors on missing workingDirectory', () => {
+    const config = {
+      readOnlyDirectories: [],
+      writeEnabledDirectories: []
+    };
+    const result = dam.validateAccessConfiguration(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('Working directory'))).toBe(true);
+  });
+
+  test('validateAccessConfiguration errors on non-array directories', () => {
+    const result = dam.validateAccessConfiguration({
+      workingDirectory: projectDir,
+      readOnlyDirectories: 'not-array',
+      writeEnabledDirectories: 'not-array'
+    });
+    expect(result.errors.some(e => e.includes('readOnlyDirectories must be an array'))).toBe(true);
+    expect(result.errors.some(e => e.includes('writeEnabledDirectories must be an array'))).toBe(true);
+  });
+
+  test('validateAccessConfiguration warns on overlapping directories', () => {
+    const result = dam.validateAccessConfiguration({
+      workingDirectory: projectDir,
+      readOnlyDirectories: [projectDir],
+      writeEnabledDirectories: [projectDir],
+      allowSystemAccess: false,
+      restrictToProject: true
+    });
+    expect(result.warnings.some(w => w.includes('Overlapping'))).toBe(true);
+  });
+
+  test('validateAccessConfiguration warns on system access enabled', () => {
+    const result = dam.validateAccessConfiguration({
+      workingDirectory: projectDir,
+      readOnlyDirectories: [],
+      writeEnabledDirectories: [],
+      allowSystemAccess: true
+    });
+    expect(result.warnings.some(w => w.includes('System path access'))).toBe(true);
+  });
+
+  // ─── createRelativePath ────────────────────────────────────────
+
+  test('createRelativePath converts absolute to relative', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      writeEnabledDirectories: [projectDir]
+    });
+    const absPath = path.join(projectDir, 'src', 'index.js');
+    const result = dam.createRelativePath(absPath, access);
+    expect(result).toBe(path.join('src', 'index.js'));
+  });
+
+  test('createRelativePath returns original when not within any directory', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      readOnlyDirectories: [],
+      writeEnabledDirectories: []
+    });
+    // Clear auto-added dirs
+    access.readOnlyDirectories = [];
+    access.writeEnabledDirectories = [];
+    access.workingDirectory = '/nonexistent';
+    const absPath = '/completely/different/path.js';
+    const result = dam.createRelativePath(absPath, access);
+    expect(result).toBe(absPath);
+  });
+
+  // ─── getAccessSummary ──────────────────────────────────────────
+
+  test('getAccessSummary returns summary object', () => {
+    const access = dam.createDirectoryAccess({
+      workingDirectory: projectDir,
+      writeEnabledDirectories: [projectDir]
+    });
+    const summary = dam.getAccessSummary(access);
+    expect(summary.workingDirectory).toBe(projectDir);
+    expect(typeof summary.readOnlyCount).toBe('number');
+    expect(typeof summary.writeEnabledCount).toBe('number');
+    expect(typeof summary.projectRestricted).toBe('boolean');
+    expect(typeof summary.systemAccessAllowed).toBe('boolean');
+    expect(typeof summary.customRestrictionsCount).toBe('number');
+    expect(summary.configVersion).toBe('1.0');
+    expect(summary.lastUpdated).toBeDefined();
+  });
+
+  // ─── Static methods ───────────────────────────────────────────
+
+  test('createProjectDefaults returns config for given directory', () => {
+    const defaults = DirectoryAccessManager.createProjectDefaults(projectDir);
+    expect(defaults.workingDirectory).toBe(projectDir);
+    expect(defaults.readOnlyDirectories).toContain(projectDir);
+    expect(defaults.writeEnabledDirectories).toContain(projectDir);
+    expect(defaults.restrictToProject).toBe(true);
+    expect(defaults.allowSystemAccess).toBe(false);
+  });
+
+  test('createPermissiveDefaults returns permissive config', () => {
+    const defaults = DirectoryAccessManager.createPermissiveDefaults(projectDir);
+    expect(defaults.workingDirectory).toBe(projectDir);
+    expect(defaults.restrictToProject).toBe(false);
+    expect(defaults.allowSystemAccess).toBe(false);
+    expect(defaults.writeEnabledDirectories).toContain(projectDir);
+  });
+});

package/src/utilities/__tests__/fileProcessor.test.js

@@ -0,0 +1,104 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+const fsMock = {
+  readFile: jest.fn(),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  unlink: jest.fn().mockResolvedValue(undefined),
+  mkdir: jest.fn().mockResolvedValue(undefined),
+  stat: jest.fn(),
+  access: jest.fn(),
+  copyFile: jest.fn().mockResolvedValue(undefined),
+  readdir: jest.fn().mockResolvedValue(['a.js', 'b.txt']),
+  rm: jest.fn().mockResolvedValue(undefined),
+  rename: jest.fn().mockResolvedValue(undefined)
+};
+
+jest.unstable_mockModule('fs/promises', () => ({ default: fsMock, ...fsMock }));
+
+const { default: FileProcessor } = await import('../fileProcessor.js');
+
+describe('FileProcessor', () => {
+  let fp;
+  let logger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    fp = new FileProcessor({}, logger);
+  });
+
+  test('readFile calls fs.readFile and returns content', async () => {
+    fsMock.readFile.mockResolvedValue('hello world');
+    const result = await fp.readFile('/tmp/test.txt');
+    expect(fsMock.readFile).toHaveBeenCalledWith('/tmp/test.txt', 'utf8');
+    expect(result).toBe('hello world');
+  });
+
+  test('readFile propagates errors', async () => {
+    fsMock.readFile.mockRejectedValue(new Error('ENOENT'));
+    await expect(fp.readFile('/missing.txt')).rejects.toThrow('Failed to read file');
+  });
+
+  test('imageToBase64 returns data URI string starting with data:image/', async () => {
+    const buf = Buffer.from('fakepng');
+    fsMock.readFile.mockResolvedValue(buf);
+    const result = await fp.imageToBase64('/tmp/photo.png');
+    expect(result).toMatch(/^data:image\//);
+    expect(result).toContain(';base64,');
+  });
+
+  test('imageToBase64 maps .png to image/png and .jpg to image/jpeg', async () => {
+    const buf = Buffer.from('img');
+    fsMock.readFile.mockResolvedValue(buf);
+
+    const png = await fp.imageToBase64('/tmp/a.png');
+    expect(png).toMatch(/^data:image\/png;base64,/);
+
+    const jpg = await fp.imageToBase64('/tmp/b.jpg');
+    expect(jpg).toMatch(/^data:image\/jpeg;base64,/);
+  });
+
+  test('estimateTokens returns ~length/4 for regular text', () => {
+    const text = 'a'.repeat(100);
+    const tokens = fp.estimateTokens(text);
+    expect(tokens).toBe(Math.ceil(100 / 4));
+  });
+
+  test('estimateTokens returns ~length/1.5 for base64 images', () => {
+    const base64Part = 'A'.repeat(300);
+    const dataUri = `data:image/png;base64,${base64Part}`;
+    const tokens = fp.estimateTokens(dataUri);
+    expect(tokens).toBe(Math.ceil(300 / 1.5));
+  });
+
+  test('estimateTokens returns 0 for empty/null input', () => {
+    expect(fp.estimateTokens(null)).toBe(0);
+    expect(fp.estimateTokens('')).toBe(0);
+    expect(fp.estimateTokens(undefined)).toBe(0);
+  });
+
+  test('fileExists returns true when access succeeds', async () => {
+    fsMock.access.mockResolvedValue(undefined);
+    const result = await fp.fileExists('/tmp/exists.txt');
+    expect(result).toBe(true);
+  });
+
+  test('fileExists returns false when access throws', async () => {
+    fsMock.access.mockRejectedValue(new Error('ENOENT'));
+    const result = await fp.fileExists('/tmp/nope.txt');
+    expect(result).toBe(false);
+  });
+
+  test('writeFile creates parent directory before writing', async () => {
+    await fp.writeFile('/tmp/sub/dir/file.txt', 'content');
+
+    // mkdir should be called before writeFile
+    expect(fsMock.mkdir).toHaveBeenCalled();
+    expect(fsMock.writeFile).toHaveBeenCalled();
+
+    const mkdirCall = fsMock.mkdir.mock.invocationCallOrder[0];
+    const writeCall = fsMock.writeFile.mock.invocationCallOrder[0];
+    expect(mkdirCall).toBeLessThan(writeCall);
+  });
+});

package/src/utilities/__tests__/jsonRepair.test.js

@@ -0,0 +1,104 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import {
+  parseJSONWithRepair,
+  looksLikeTruncatedJSON,
+  createTruncationNotice,
+  getFileExtension
+} from '../jsonRepair.js';
+import {
+  validJson,
+  trailingCommaObject,
+  truncatedObject,
+  truncatedString,
+  plainText,
+  emptyString
+} from '../../__test-utils__/fixtures/malformedJson.js';
+
+describe('jsonRepair', () => {
+  beforeEach(() => {
+    jest.spyOn(console, 'warn').mockImplementation(() => {});
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  describe('parseJSONWithRepair', () => {
+    test('valid JSON returns data with wasRepaired=false', () => {
+      const result = parseJSONWithRepair(validJson);
+      expect(result.data).toEqual({ name: 'test', value: 42 });
+      expect(result.wasRepaired).toBe(false);
+      expect(result.wasTruncated).toBe(false);
+      expect(result.error).toBeNull();
+    });
+
+    test('trailing comma repairs successfully with wasRepaired=true', () => {
+      const result = parseJSONWithRepair(trailingCommaObject, { silent: true });
+      expect(result.data).toEqual({ a: 1, b: 2 });
+      expect(result.wasRepaired).toBe(true);
+      expect(result.error).toBeNull();
+    });
+
+    test('truncated JSON sets wasTruncated=true', () => {
+      const result = parseJSONWithRepair(truncatedObject, { silent: true });
+      expect(result.wasRepaired).toBe(true);
+      expect(result.wasTruncated).toBe(true);
+      expect(result.data).not.toBeNull();
+      expect(result.error).toBeNull();
+    });
+
+    test('completely invalid input returns error or repaired result', () => {
+      // jsonrepair may be able to "repair" some plain text by treating it as a value
+      const result = parseJSONWithRepair(plainText, { silent: true });
+      // Either it was repaired successfully or it returned an error
+      if (result.error) {
+        expect(result.data).toBeNull();
+        expect(result.error).toHaveProperty('originalError');
+      } else {
+        // jsonrepair managed to parse it somehow
+        expect(result.data).not.toBeUndefined();
+      }
+    });
+
+    test('null/undefined input handles gracefully', () => {
+      // JSON.parse(null) returns null, so parseJSONWithRepair(null) succeeds with data=null
+      const nullResult = parseJSONWithRepair(null, { silent: true });
+      // Should not throw — returns a result object
+      expect(nullResult).toHaveProperty('wasRepaired');
+      expect(nullResult).toHaveProperty('error');
+    });
+  });
+
+  describe('looksLikeTruncatedJSON', () => {
+    test('unclosed bracket returns true', () => {
+      expect(looksLikeTruncatedJSON('{"key": "value"')).toBe(true);
+      expect(looksLikeTruncatedJSON('[1, 2, 3')).toBe(true);
+      expect(looksLikeTruncatedJSON(truncatedString)).toBe(true);
+    });
+
+    test('complete JSON returns false', () => {
+      expect(looksLikeTruncatedJSON('{"key": "value"}')).toBe(false);
+      expect(looksLikeTruncatedJSON('[1, 2, 3]')).toBe(false);
+      expect(looksLikeTruncatedJSON('{}')).toBe(false);
+    });
+  });
+
+  describe('createTruncationNotice', () => {
+    test('returns appropriate comment for each file type', () => {
+      expect(createTruncationNotice('js')).toContain('//');
+      expect(createTruncationNotice('css')).toContain('/*');
+      expect(createTruncationNotice('html')).toContain('<!--');
+      expect(createTruncationNotice('py')).toContain('#');
+      // Note: json returns '' which is falsy, so || falls through to default
+      expect(createTruncationNotice('json')).toContain('[CONTENT TRUNCATED]');
+      expect(createTruncationNotice('unknown')).toContain('[CONTENT TRUNCATED]');
+    });
+  });
+
+  describe('getFileExtension', () => {
+    test('extracts extension correctly for various paths', () => {
+      expect(getFileExtension('file.js')).toBe('js');
+      expect(getFileExtension('path/to/file.test.ts')).toBe('ts');
+      expect(getFileExtension('document.PDF')).toBe('pdf');
+      expect(getFileExtension('noext')).toBe('');
+      expect(getFileExtension('/some/path/file.json')).toBe('json');
+    });
+  });
+});