Merge pull request #543 from KxSystems/KXI-58254-errors

add error workarounds

Author: Philip-Carneiro-KX

src/classes/insightsConnection.ts

@@ -524,6 +524,25 @@ export class InsightsConnection {
     return token;
   }
 
+  public async isUDAAvailable(udaName: string): Promise<boolean> {
+    if (!this.meta || !this.meta.payload.api) {
+      return false;
+    }
+
+    if (!this.connected || !this.connEndpoints) {
+      return false;
+    }
+
+    if (this.meta.payload.api && Array.isArray(this.meta.payload.api)) {
+      return this.meta.payload.api.some(
+        (apiItem: { api: string; custom: boolean }) =>
+          apiItem.api === udaName && apiItem.custom === true,
+      );
+    }
+
+    return false;
+  }
+
   public async getUDAScratchpadQuery(
     udaReqBody: UDARequestBody,
   ): Promise<any | undefined> {

src/commands/dataSourceCommand.ts

@@ -456,26 +456,38 @@ export async function runUDADataSource(
 ): Promise<any> {
   const UDA = fileContent.dataSource.uda;
   const returnFormat = ext.isResultsTabVisible ? "structuredText" : "text";
+
   if (!UDA) {
     return { error: "UDA not found" };
   }
+
+  const isAvailable = await selectedConn.isUDAAvailable(UDA.name);
+
   if (UDA.name === "") {
     return { error: "UDA name not found" };
   }
 
+  if (!isAvailable) {
+    return { error: `UDA ${UDA.name} is not available in this connection` };
+  }
+
   const params: { [key: string]: any } = {};
   const parameterTypes: { [key: string]: any } = {};
 
   if (UDA.params && UDA.params.length > 0) {
-    UDA.params.forEach((param) => {
+    for (const param of UDA.params) {
+      if (param.isReq && (!param.value || param.value === "")) {
+        return { error: `The UDA required the parameter ${param.name}.` };
+      }
       if (param.isVisible) {
         params[param.name] = param.value;
         parameterTypes[param.name] = param.selectedMultiTypeString
           ? retrieveDataTypeByString(param.selectedMultiTypeString)
           : param.type;
       }
-    });
+    }
   }
+
   const udaReqBody: UDARequestBody = {
     language: "q",
     name: UDA.name,

test/suite/commands.test.ts

@@ -530,12 +530,14 @@ describe("dataSourceCommand2", () => {
     let getDataInsightsStub,
       handleWSResultsStub,
       handleScratchpadTableRes,
+      isUDAAvailableStub,
       parseErrorStub: sinon.SinonStub;
 
     beforeEach(() => {
       getDataInsightsStub = sinon.stub(insightsConn, "getDatasourceQuery");
       handleWSResultsStub = sinon.stub(queryUtils, "handleWSResults");
       parseErrorStub = sinon.stub(dataSourceCommand, "parseError");
+      isUDAAvailableStub = sinon.stub(insightsConn, "isUDAAvailable");
       handleScratchpadTableRes = sinon.stub(
         queryUtils,
         "handleScratchpadTableRes",
@@ -547,6 +549,7 @@ describe("dataSourceCommand2", () => {
     });
 
     it("should call the API and handle the results", async () => {
+      isUDAAvailableStub.resolves(true);
       getDataInsightsStub.resolves({ arrayBuffer: true });
       handleWSResultsStub.resolves([
         { a: "2", b: "3" },
@@ -574,6 +577,7 @@ describe("dataSourceCommand2", () => {
     });
 
     it("should call the API and handle the error results", async () => {
+      isUDAAvailableStub.resolves(true);
       getDataInsightsStub.resolves({ error: "error test" });
       parseErrorStub.resolves({ error: "error test" });
 
@@ -586,6 +590,7 @@ describe("dataSourceCommand2", () => {
     });
 
     it("should call the API and handle undefined response ", async () => {
+      isUDAAvailableStub.resolves(true);
       getDataInsightsStub.resolves(undefined);
 
       const result = await dataSourceCommand.runUDADataSource(
@@ -596,6 +601,46 @@ describe("dataSourceCommand2", () => {
       assert.deepStrictEqual(result, { error: "UDA call failed" });
     });
 
+    it("should handle if the UDA doesn't exist in the connection", async () => {
+      isUDAAvailableStub.resolves(false);
+      getDataInsightsStub.resolves(undefined);
+
+      const result = await dataSourceCommand.runUDADataSource(
+        dummyDataSourceFiles,
+        insightsConn,
+      );
+
+      assert.deepStrictEqual(result, {
+        error: "UDA test query is not available in this connection",
+      });
+    });
+
+    it("should handle if a required param is empty", async () => {
+      isUDAAvailableStub.resolves(true);
+      getDataInsightsStub.resolves(undefined);
+
+      const dummyDSFiles2 = dummyDataSourceFiles;
+      dummyDSFiles2.dataSource.uda.params = [
+        {
+          name: "param1",
+          description: "test param",
+          default: "",
+          isReq: true,
+          type: [0],
+          value: "",
+        },
+      ];
+
+      const result = await dataSourceCommand.runUDADataSource(
+        dummyDSFiles2,
+        insightsConn,
+      );
+
+      assert.deepStrictEqual(result, {
+        error: "The UDA required the parameter param1.",
+      });
+    });
+
     it("should handle undefined UDA ", async () => {
       dummyDataSourceFiles.dataSource.uda = undefined;