feat: update per API change for importing ruleset

src/azure/ApiCenter/ApiCenterService.ts

@@ -4,7 +4,7 @@
 import { ISubscriptionContext } from "@microsoft/vscode-azext-utils";
 import { getCredentialForToken } from "../../utils/credentialUtil";
 import { APICenterRestAPIs } from "./ApiCenterRestAPIs";
-import { ApiCenter, ApiCenterApi, ApiCenterApiDeployment, ApiCenterApiVersion, ApiCenterApiVersionDefinition, ApiCenterApiVersionDefinitionExport, ApiCenterApiVersionDefinitionImport, ApiCenterEnvironment, ApiCenterRulesetConfig, ApiCenterRulesetExport, ApiCenterRulesetImport } from "./contracts";
+import { ApiCenter, ApiCenterApi, ApiCenterApiDeployment, ApiCenterApiVersion, ApiCenterApiVersionDefinition, ApiCenterApiVersionDefinitionExport, ApiCenterApiVersionDefinitionImport, ApiCenterEnvironment, ApiCenterRulesetConfig, ApiCenterRulesetExport, ApiCenterRulesetImport, ApiCenterRulesetImportResult } from "./contracts";
 
 export class ApiCenterService {
   private susbcriptionContext: ISubscriptionContext;
@@ -226,16 +226,40 @@
     return response.parsedBody;
   }
 
-  public async importRuleset(importPayload: ApiCenterRulesetImport): Promise<HttpOperationResponse> {
+  public async importRuleset(importPayload: ApiCenterRulesetImport): Promise<ApiCenterRulesetImportResult> {
     const creds = getCredentialForToken(await this.susbcriptionContext.credentials.getToken());
     const client = new ServiceClient(creds);
-    const options: RequestPrepareOptions = {
+    let options: RequestPrepareOptions = {
       method: "POST",
       url: APICenterRestAPIs.ImportRuleset(this.susbcriptionContext.subscriptionId, this.resourceGroupName, this.apiCenterName, this.apiVersionPreview),
       body: importPayload
     };
-    const response = await client.sendRequest(options);
-    return response;
+    let response = await client.sendRequest(options);
+
+    if (response.status === 202) {
+      const location = response.headers.get("Location");
+
+      if (!location) {
+        return { isSuccessful: false };
+      }
+
+      options = {
+        method: "GET",
+        url: location,
+      };
+
+      const timeout = 30000; // 30 seconds in milliseconds
+      let startTime = Date.now();
+      do {
+        response = await client.sendRequest(options);
+        if (response.parsedBody?.status === "Succeeded") {
+          return { isSuccessful: true };
+        }
+      } while (Date.now() - startTime < timeout);
+      return { isSuccessful: false };
+    } else {
+      return { isSuccessful: false, message: response.bodyAsText };
+    }
   }
 
   public async exportRuleset(): Promise<ApiCenterRulesetExport> {

src/azure/ApiCenter/contracts.ts

@@ -96,6 +96,11 @@ export type ApiCenterRulesetImport = {
     value: string;
 };
 
+export type ApiCenterRulesetImportResult = {
+    isSuccessful: boolean;
+    message?: string | null;
+};
+
 export type ApiCenterRulesetExport = {
     format: string;
     value: string;

src/commands/rules/deployRules.ts

@@ -29,9 +29,9 @@
     };
     const response = await apiCenterService.importRuleset(importPayload);
 
-    if (response.status === 200) {
+    if (response.isSuccessful) {
         vscode.window.showInformationMessage(vscode.l10n.t(UiStrings.RulesDeployed, node.apiCenter.name));
     } else {
-        vscode.window.showErrorMessage(vscode.l10n.t(UiStrings.FailedToDeployRules, response.bodyAsText ?? `status code ${response.status}`));
+        vscode.window.showErrorMessage(vscode.l10n.t(UiStrings.FailedToDeployRules, response.message ?? `Error: ${response.message}`));
     }
 }

src/commands/rules/enableRules.ts

@@ -23,7 +23,7 @@
     const resourceGroupName = getResourceGroupFromId(node.apiCenter.id);
     const apiCenterService = new ApiCenterService(node.parent?.subscription!, resourceGroupName, node.apiCenter.name);
 
-    let response = await apiCenterService.createOrUpdateApiCenterRulesetConfig(apiCenterRulesetConfig);
+    const response = await apiCenterService.createOrUpdateApiCenterRulesetConfig(apiCenterRulesetConfig);
 
     if (response.status === 200) {
         vscode.window.showInformationMessage((vscode.l10n.t(UiStrings.RulesEnabled, node.apiCenter.name)));
@@ -42,13 +42,13 @@
         value: content,
         format: "InlineZip",
     };
-    response = await apiCenterService.importRuleset(importPayload);
+    const importRulesetResponse = await apiCenterService.importRuleset(importPayload);
 
-    if (response.status === 200) {
+    if (importRulesetResponse.isSuccessful) {
         vscode.window.showInformationMessage(vscode.l10n.t(UiStrings.RulesDeployed, node.apiCenter.name));
         node.updateStatusToEnable();
         await node.refresh(context);
     } else {
-        vscode.window.showErrorMessage(vscode.l10n.t(UiStrings.FailedToDeployRules, response.bodyAsText ?? `status code ${response.status}`));
+        vscode.window.showErrorMessage(vscode.l10n.t(UiStrings.FailedToDeployRules, importRulesetResponse.message ?? `Error: ${importRulesetResponse.message}`));
     }
 }

src/test/unit/azure/ApiCenter/ApiCenterService.test.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { HttpHeaders, HttpOperationResponse, ServiceClient } from "@azure/ms-rest-js";
+import { ISubscriptionContext } from "@microsoft/vscode-azext-utils";
+import * as assert from "assert";
+import * as sinon from "sinon";
+import { ApiCenterService } from "../../../../azure/ApiCenter/ApiCenterService";
+import { ApiCenterRulesetImport } from "../../../../azure/ApiCenter/contracts";
+
+describe("ApiCenterService", () => {
+    let sandbox: sinon.SinonSandbox;
+    let subscriptionContext: ISubscriptionContext;
+    before(() => {
+        sandbox = sinon.createSandbox();
+    });
+    beforeEach(() => {
+        subscriptionContext = {
+            credentials: {
+                getToken: sandbox.stub().resolves({ token: 'fake-token' })
+            }
+        } as unknown as ISubscriptionContext;
+    });
+    afterEach(() => {
+        sandbox.restore();
+    });
+    it("importRuleset succeeded", async () => {
+        const mockResponse1 = { status: 202 } as HttpOperationResponse;
+        mockResponse1.headers = new HttpHeaders({ Location: "fakeLocation" });
+        const mockResponse2 = {
+            status: 200,
+            parsedBody: { status: "Succeeded" },
+        } as HttpOperationResponse;
+        const sendRequestStub = sandbox.stub(ServiceClient.prototype, "sendRequest");
+        sendRequestStub.onFirstCall().resolves(mockResponse1);
+        sendRequestStub.onSecondCall().resolves(mockResponse2);
+
+        const apiCenterService = new ApiCenterService(subscriptionContext, "fakeResourceGroup", "fakeServiceName");
+        const importPayload: ApiCenterRulesetImport = {
+            value: "fakeValue",
+            format: "InlineZip",
+        };
+
+        const response = await apiCenterService.importRuleset(importPayload);
+
+        assert.strictEqual(response.isSuccessful, true);
+    });
+    it("importRuleset failed", async () => {
+        sandbox.stub(ServiceClient.prototype, "sendRequest").resolves({ status: 500, bodyAsText: "error" } as HttpOperationResponse);
+
+        const apiCenterService = new ApiCenterService(subscriptionContext, "fakeResourceGroup", "fakeServiceName");
+        const importPayload: ApiCenterRulesetImport = {
+            value: "fakeValue",
+            format: "InlineZip",
+        };
+
+        const response = await apiCenterService.importRuleset(importPayload);
+
+        assert.strictEqual(response.isSuccessful, false);
+        assert.strictEqual(response.message, "error");
+    });
+});

src/test/unit/commands/rules/enableRules.test.ts

@@ -7,7 +7,7 @@ import * as path from 'path';
 import * as sinon from "sinon";
 import * as vscode from "vscode";
 import { ApiCenterService } from "../../../../azure/ApiCenter/ApiCenterService";
-import { ApiCenter } from "../../../../azure/ApiCenter/contracts";
+import { ApiCenter, ApiCenterRulesetImportResult } from "../../../../azure/ApiCenter/contracts";
 import { enableRules } from "../../../../commands/rules/enableRules";
 import { RulesTreeItem } from "../../../../tree/rules/RulesTreeItem";
 
@@ -34,7 +34,7 @@ describe("enableRules", () => {
         sandbox.stub(path, 'join').returns(__dirname);
         const showInformationMessage = sandbox.spy(vscode.window, "showInformationMessage");
         sandbox.stub(ApiCenterService.prototype, "createOrUpdateApiCenterRulesetConfig").resolves({ status: 200 } as HttpOperationResponse);
-        sandbox.stub(ApiCenterService.prototype, "importRuleset").resolves({ status: 200 } as HttpOperationResponse);
+        sandbox.stub(ApiCenterService.prototype, "importRuleset").resolves({ isSuccessful: true } as ApiCenterRulesetImportResult);
         await enableRules({} as IActionContext, node);
         sandbox.assert.calledTwice(showInformationMessage);
         assert.ok(node.isEnabled);

src/uiStrings.ts

@@ -107,7 +107,7 @@ export class UiStrings {
     static readonly FileAlreadyExists = vscode.l10n.t("The file '{0}' already exists. Please input a different name.");
     static readonly NoRulesFolder = vscode.l10n.t("Rules folder '{0}' is empty. No files to deploy.");
     static readonly RulesDeployed = vscode.l10n.t("Rules deployed to '{0}'.");
-    static readonly FailedToDeployRules = vscode.l10n.t("Failed to deploy rules. Error: {0}");
+    static readonly FailedToDeployRules = vscode.l10n.t("Failed to deploy rules. {0}");
     static readonly RulesEnabled = vscode.l10n.t("API Analysis enabled for '{0}'.");
     static readonly FailedToEnableRules = vscode.l10n.t("Failed to enable API Analysis. Error: {0}");
     static readonly RulesFolderNotEmpty = vscode.l10n.t("The rules folder '{0}' is not empty. Do you want to overwrite the existing files?");