test: addede tests for CommandExecutionAdapter

Author: deankevorkian

lib/adapters/command-execution-adapter.ts

@@ -1,7 +1,7 @@
-import { Command, ExecuteCommandParams } from "../languageclient";
+import { ExecuteCommandParams } from "../languageclient";
 import { LanguageClientConnection } from "../main";
 
-export type CommandCustomCallbackFunction = (command: ExecuteCommandParams) => Promise<void>;
+export type CommandCustomCallbackFunction = (command: ExecuteCommandParams) => Promise<any | void>;
 
 export default class CommandExecutionAdapter {
     private static commandsCustomCallbacks: Map<string, CommandCustomCallbackFunction> = new Map<string, CommandCustomCallbackFunction>();
@@ -17,7 +17,7 @@ export default class CommandExecutionAdapter {
         return commandCustomCallback != null ? await commandCustomCallback(executeCommandParams) : await connection.executeCommand(executeCommandParams);
     }
 
-    public static createExecuteCommandParams(command: string, commandArgs?: any[] | undefined): ExecuteCommandParams {
+    private static createExecuteCommandParams(command: string, commandArgs?: any[] | undefined): ExecuteCommandParams {
         return {
             command: command,
             arguments: commandArgs

test/adapters/command-execution-adapter.test.ts

@@ -0,0 +1,64 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import * as ls from '../../lib/languageclient';
+import CommandExecutionAdapter, { CommandCustomCallbackFunction } from '../../lib/adapters/command-execution-adapter';
+import { createSpyConnection } from '../helpers.js';
+import { ExecuteCommandParams } from '../../lib/languageclient';
+
+describe('CommandExecutionAdapter', () => {
+  describe('executeCommand', () => {
+    it('invokes an executeCommand object from given inputs', async () => {
+      const connection = createSpyConnection();
+      const languageClient = new ls.LanguageClientConnection(connection);
+      const testCommand = {
+        command: 'testCommand',
+        arguments: ['a', 'b'],
+      };
+      sinon.stub(languageClient, 'executeCommand').returns(Promise.resolve(testCommand));
+
+      const result = await CommandExecutionAdapter.executeCommand(
+        languageClient,
+        testCommand.command,
+        testCommand.arguments
+      );
+
+      expect(result.command).to.equal(testCommand.command);
+      expect(result.arguments).to.equal(testCommand.arguments);
+
+      expect((languageClient as any).executeCommand.called).to.be.true;
+      expect((languageClient as any).executeCommand.getCalls()[0].args).to.deep.equal([{
+          command: testCommand.command,
+          arguments: testCommand.arguments
+      } as ExecuteCommandParams]);
+    });
+  });
+
+  describe('registerCustomCallbackForCommand', () => {
+    it('registers a custom callback for a command, to be executed on executeCommand', async () => {
+      const connection = createSpyConnection();
+      const languageClient = new ls.LanguageClientConnection(connection);
+      const testCallback: CommandCustomCallbackFunction = (command: ExecuteCommandParams) => Promise.resolve(command.command);
+      const testCommand = {
+        command: 'testCommand',
+        arguments: ['a', 'b'],
+      };
+
+      const spiedCallback = sinon.spy(testCallback);
+      sinon.spy(languageClient, 'executeCommand');
+
+      CommandExecutionAdapter.registerCustomCallbackForCommand(testCommand.command, spiedCallback);
+
+      const result = await CommandExecutionAdapter.executeCommand(
+        languageClient,
+        testCommand.command,
+        testCommand.arguments
+      );
+
+      expect(spiedCallback.called).to.be.true;
+
+      expect((languageClient as any).executeCommand.called).to.be.false;
+
+      expect(result).to.equal(testCommand.command);
+    });
+  });
+});