chore: implement read via config rules

Author: junners

src/providers/config-provider.ts

@@ -5,7 +5,6 @@ import {
   IRuleDefinition,
 } from 'lightning-flow-scanner-core';
 import * as vsce from 'vscode';
-
 import { Document, parse } from 'yaml';
 
 type Configuration = {
@@ -14,10 +13,7 @@ type Configuration = {
 };
 
 export class ConfigProvider {
-  public async discover(configPath: string): Promise<{
-    fspath: string;
-    config: unknown;
-  }> {
+  public async discover(configPath: string): Promise<Configuration> {
     const configurationName = 'flow-scanner';
 
     const findInJson = [`.${configPath}.json`, `${configurationName}.json`];
@@ -51,10 +47,7 @@ export class ConfigProvider {
   private async writeConfigFile(
     configurationName: string,
     configPath: string
-  ): Promise<{
-    fspath: string;
-    config: unknown;
-  }> {
+  ): Promise<Configuration> {
     const allRules: Record<string, { severity: string }> = [
       ...getRules(),
       ...getBetaRules(),
@@ -87,8 +80,8 @@ export class ConfigProvider {
     basePath: string,
     potentialFileNames: string[],
     parser: Function
-  ): Promise<{ fspath: string; config: unknown } | null> {
-    let foundConfig: { fspath: string; config: unknown };
+  ): Promise<Configuration | null> {
+    let foundConfig: Configuration;
     await Promise.all(
       potentialFileNames.map(async (fileName) => {
         if (foundConfig) return;

tests/providers/config-provider.spec.ts

@@ -1,86 +1,116 @@
-import { describe, it, expect, jest } from '@jest/globals';
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
 
 import { ConfigProvider } from '../../src/providers/config-provider';
-import * as cosmi from 'cosmiconfig';
 
-jest.mock('cosmiconfig');
+import * as yml from 'yaml';
+import * as vsce from 'vscode';
+
+jest.mock('yaml');
+jest.mock('vscode');
 
 describe('Config-Provider', () => {
+  let provider: ConfigProvider;
+  const mockFs: any = {};
+  const mockWorkspace: any = {};
+  const mockUri = (path: string) => ({ fsPath: path, path });
+
+  beforeEach(() => {
+    provider = new ConfigProvider();
+    jest.clearAllMocks();
+    // Mock VSCE
+    mockFs.stat = jest.fn();
+    mockFs.readFile = jest.fn();
+    mockFs.writeFile = jest.fn();
+    (vsce.workspace.fs as any).stat = mockFs.stat;
+    (vsce.workspace.fs as any).readFile = mockFs.readFile;
+    (vsce.workspace.fs as any).writeFile = mockFs.writeFile;
+    if (vsce.Uri) {
+      (vsce.Uri as any).file = mockUri;
+    }
+    // Mock YAML
+    jest.spyOn(yml, 'parse').mockImplementation(() => jest.fn());
+    jest.spyOn(yml, 'Document').mockImplementation((c: any) => c);
+    // TextEncoder
+    (global as any).TextEncoder = class {
+      encode(str: string) {
+        return Buffer.from(str);
+      }
+    };
+  });
+
   it('should be defined', () => {
     expect(ConfigProvider).toBeDefined();
   });
 
-  it('should not error when no config', async () => {
-    const cosmiMock = {
-      load: jest.fn(),
-      search: jest.fn(),
-    };
-    const cosmiSpy = jest.spyOn(cosmi, 'cosmiconfig');
-    cosmiSpy.mockReturnValue(cosmiMock as any);
+  it('discover: finds JSON config', async () => {
+    mockFs.stat.mockResolvedValueOnce(true);
+    mockFs.readFile.mockResolvedValueOnce(Buffer.from('{"foo":1}'));
+    (yml as any).parse.mockReturnValue({ foo: 1 });
+    const config = await provider.discover('/path');
+    expect(config).toBeDefined();
+    expect(config.config).toEqual({ foo: 1 });
+  });
 
-    const configProvider = new ConfigProvider();
-    await expect(configProvider.loadConfig()).resolves.toStrictEqual({});
+  it('discover: finds YAML config', async () => {
+    mockFs.stat.mockRejectedValueOnce(new Error('not found'));
+    mockFs.stat.mockRejectedValueOnce(new Error('not found'));
+    mockFs.stat.mockResolvedValueOnce(true);
+    mockFs.readFile.mockResolvedValueOnce(Buffer.from('bar: 2'));
+    (yml as any).parse.mockReturnValue({ bar: 2 });
+    const config = await provider.discover('/path');
+    expect(config).toBeDefined();
+    expect(config.config).toEqual({ bar: 2 });
   });
 
-  it('should load config when directly passed from settings', async () => {
-    const cosmiMock = {
-      load: jest.fn().mockImplementation(() => ({
-        config: {
-          rules: {
-            FlowName: {
-              severity: 'error',
-            },
-          },
-          exceptions: {},
-        },
-        filepath: '',
-      })),
-      search: jest.fn(),
-    };
-    const cosmiSpy = jest.spyOn(cosmi, 'cosmiconfig');
-    cosmiSpy.mockReturnValue(cosmiMock as any);
+  it('discover: creates new config if not found', async () => {
+    mockFs.stat.mockRejectedValue(new Error('not found'));
+    mockFs.writeFile.mockResolvedValueOnce(undefined);
+    const config = await provider.discover('/path');
+    expect(config).toBeDefined();
+    expect(config.fspath).toContain('/path/.flow-scanner.yml');
+    expect(mockFs.writeFile).toHaveBeenCalled();
+  });
 
-    const configProvider = new ConfigProvider();
-    await expect(
-      configProvider.loadConfig('some config')
-    ).resolves.toStrictEqual({
-      rules: {
-        FlowName: {
-          severity: 'error',
-        },
-      },
-      exceptions: {},
-    });
-    expect(cosmiMock.search).not.toHaveBeenCalled();
+  it('writeConfigFile: writes a new config file', async () => {
+    mockFs.writeFile.mockResolvedValueOnce(undefined);
+    const result = await (provider as any).writeConfigFile(
+      'flow-scanner',
+      '/base'
+    );
+    expect(result.fspath).toContain('/base/.flow-scanner.yml');
+    expect(mockFs.writeFile).toHaveBeenCalled();
   });
 
-  it('should resolve a config via workspace directory', async () => {
-    const cosmiMock = {
-      load: jest.fn(),
-      search: jest.fn().mockImplementation(() => ({
-        config: {
-          rules: {
-            APIVersion: {
-              severity: 'error',
-            },
-          },
-          exceptions: {},
-        },
-        filepath: '',
-      })),
-    };
-    const cosmiSpy = jest.spyOn(cosmi, 'cosmiconfig');
-    cosmiSpy.mockReturnValue(cosmiMock as any);
+  it('attemptToReadConfig: returns config if file exists', async () => {
+    mockFs.stat.mockResolvedValueOnce(true);
+    mockFs.readFile.mockResolvedValueOnce(Buffer.from('{"a":3}'));
+    const parser = jest.fn().mockReturnValue({ a: 3 });
+    const result = await (provider as any).attemptToReadConfig(
+      '/foo',
+      ['bar.json'],
+      parser
+    );
+    expect(result).toBeDefined();
+    expect(result.config).toEqual({ a: 3 });
+  });
+
+  it('attemptToReadConfig: returns null if file does not exist', async () => {
+    mockFs.stat.mockRejectedValue(new Error('not found'));
+    const parser = jest.fn();
+    const result = await (provider as any).attemptToReadConfig(
+      '/foo',
+      ['bar.json'],
+      parser
+    );
+    expect(result).toBeUndefined();
+  });
 
-    const configProvider = new ConfigProvider();
-    await expect(configProvider.loadConfig()).resolves.toStrictEqual({
-      rules: {
-        APIVersion: {
-          severity: 'error',
-        },
-      },
-      exceptions: {},
-    });
-    expect(cosmiMock.load).not.toHaveBeenCalled();
+  it('loadConfig: returns config from discover', async () => {
+    const fakeConfig = { rules: { test: { severity: 'error' } } };
+    jest
+      .spyOn(provider, 'discover')
+      .mockResolvedValueOnce({ fspath: '/f', config: fakeConfig });
+    const result = await provider.loadConfig('/some');
+    expect(result).toEqual(fakeConfig);
   });
 });