[core-lro] Set isCancelled when operation status is cancelled

sdk/core/core-lro/src/lroEngine/locationPolling.ts

@@ -8,21 +8,20 @@ import {
   LroResponse,
   LroStatus,
   RawResponse,
-  failureStates,
-  successStates,
 } from "./models";
+import { PollOperationState } from "../pollOperation";
 import { isUnexpectedPollingResponse } from "./requestUtils";
 
-function isPollingDone(rawResponse: RawResponse): boolean {
+function getStatus(rawResponse: RawResponse): string {
+  const { status } = (rawResponse.body as LroBody) ?? {};
+  return typeof status === "string" ? status.toLowerCase() : "succeeded";
+}
+
+function isPollingDone(rawResponse: RawResponse, status: string): boolean {
   if (isUnexpectedPollingResponse(rawResponse) || rawResponse.statusCode === 202) {
     return false;
   }
-  const { status } = (rawResponse.body as LroBody) ?? {};
-  const state = typeof status === "string" ? status.toLowerCase() : "succeeded";
-  if (isUnexpectedPollingResponse(rawResponse) || failureStates.includes(state)) {
-    throw new Error(`The long running operation has failed. The provisioning state: ${state}.`);
-  }
-  return successStates.includes(state);
+  return status === "succeeded";
 }
 
 /**
@@ -44,13 +43,39 @@ async function sendFinalRequest<TResult>(
   }
 }
 
-export function processLocationPollingOperationResult<TResult>(
+export function processLocationPollingOperationResult<
+  TResult,
+  TState extends PollOperationState<TResult>
+>(
   lro: LongRunningOperation<TResult>,
+  state: TState,
   resourceLocation?: string,
   lroResourceLocationConfig?: LroResourceLocationConfig
 ): (response: LroResponse<TResult>) => LroStatus<TResult> {
   return (response: LroResponse<TResult>): LroStatus<TResult> => {
-    if (isPollingDone(response.rawResponse)) {
+    const rawResponse = response.rawResponse;
+    const status = getStatus(rawResponse);
+    if (isUnexpectedPollingResponse(rawResponse) || status === "failed") {
+      throw new Error(`The long running operation has failed.`);
+    }
+    /**
+     * These HTTP request methods are typically used around provisioned resources
+     * so if the LRO was cancelled, there is nothing useful can be returned to
+     * the customer. POST requests on the other hand could support partial results
+     * so throwing an error in this case could be prevent customer from getting
+     * access to those partial results.
+     */
+    if (["PUT", "DELETE", "PATCH"].includes(lro.requestMethod) && status === "canceled") {
+      throw new Error(`The long running operation has been canceled.`);
+    }
+    if (["canceled", "cancelled"].includes(status)) {
+      state.isCancelled = true;
+      return {
+        ...response,
+        done: true,
+      };
+    }
+    if (isPollingDone(response.rawResponse, status)) {
       if (resourceLocation === undefined) {
         return { ...response, done: true };
       } else {

sdk/core/core-lro/src/lroEngine/models.ts

@@ -33,7 +33,8 @@ export interface LroEngineOptions<TResult, TState> {
   isDone?: (lastResponse: unknown, state: TState) => boolean;
 
   /**
-   * A function to cancel the LRO.
+   * A function that takes the mutable state as input and attempts to cancel the
+   * LRO.
    */
   cancel?: (state: TState) => Promise<void>;
 }

sdk/core/core-lro/src/lroEngine/operation.ts

@@ -86,7 +86,12 @@ export class GenericPollOperation<TResult, TState extends PollOperationState<TRe
               ...response,
               done: isDone(response.flatResponse, this.state),
             })
-          : createGetLroStatusFromResponse(this.lro, state.config, this.lroResourceLocationConfig);
+          : createGetLroStatusFromResponse(
+              this.lro,
+              state.config,
+              this.state,
+              this.lroResourceLocationConfig
+            );
         this.poll = createPoll(this.lro);
       }
       if (!state.pollingURL) {
@@ -122,8 +127,12 @@ export class GenericPollOperation<TResult, TState extends PollOperationState<TRe
   }
 
   async cancel(): Promise<PollOperation<TState, TResult>> {
-    this.state.isCancelled = true;
-    await this.cancelOp?.(this.state);
+    const cancelOp =
+      this.cancelOp ??
+      (async (state: TState) => {
+        state.isCancelled = true;
+      });
+    await cancelOp(this.state);
     return this;
   }
 

sdk/core/core-lro/src/lroEngine/stateMachine.ts

@@ -13,22 +13,25 @@ import {
 } from "./models";
 import { getPollingUrl, inferLroMode, isUnexpectedInitialResponse } from "./requestUtils";
 import { isBodyPollingDone, processBodyPollingOperationResult } from "./bodyPolling";
+import { PollOperationState } from "../pollOperation";
 import { logger } from "./logger";
 import { processLocationPollingOperationResult } from "./locationPolling";
 import { processPassthroughOperationResult } from "./passthrough";
 
 /**
  * creates a stepping function that maps an LRO state to another.
  */
-export function createGetLroStatusFromResponse<TResult>(
+export function createGetLroStatusFromResponse<TResult, TState extends PollOperationState<TResult>>(
   lroPrimitives: LongRunningOperation<TResult>,
   config: LroConfig,
+  state: TState,
   lroResourceLocationConfig?: LroResourceLocationConfig
 ): GetLroStatusFromResponse<TResult> {
   switch (config.mode) {
     case "Location": {
       return processLocationPollingOperationResult(
         lroPrimitives,
+        state,
         config.resourceLocation,
         lroResourceLocationConfig
       );

sdk/core/core-lro/test/engine.spec.ts

@@ -216,10 +216,7 @@ describe("Lro Engine", function () {
           await runMockedLro("DELETE", `/delete${rootPrefix}/retry/canceled`);
           throw new Error("should have thrown instead");
         } catch (e: any) {
-          assert.equal(
-            e.message,
-            "The long running operation has failed. The provisioning state: canceled."
-          );
+          assert.equal(e.message, "The long running operation has been canceled.");
         }
       });
 
@@ -228,10 +225,7 @@ describe("Lro Engine", function () {
           await runMockedLro("DELETE", `/delete${rootPrefix}/retry/failed`);
           throw new Error("should have thrown instead");
         } catch (e: any) {
-          assert.equal(
-            e.message,
-            "The long running operation has failed. The provisioning state: failed."
-          );
+          assert.equal(e.message, "The long running operation has failed.");
         }
       });
 
@@ -256,10 +250,7 @@ describe("Lro Engine", function () {
           await runMockedLro("PUT", `/put${rootPrefix}/retry/failed`);
           throw new Error("should have thrown instead");
         } catch (e: any) {
-          assert.equal(
-            e.message,
-            "The long running operation has failed. The provisioning state: failed."
-          );
+          assert.equal(e.message, "The long running operation has failed.");
         }
       });
 
@@ -293,10 +284,7 @@ describe("Lro Engine", function () {
           await runMockedLro("PUT", `/put${rootPrefix}/noretry/canceled`);
           throw new Error("should have thrown instead");
         } catch (e: any) {
-          assert.equal(
-            e.message,
-            "The long running operation has failed. The provisioning state: canceled."
-          );
+          assert.equal(e.message, "The long running operation has been canceled.");
         }
       });
 
@@ -321,10 +309,7 @@ describe("Lro Engine", function () {
           await runMockedLro("POST", `/post${rootPrefix}/retry/failed`);
           throw new Error("should have thrown instead");
         } catch (e: any) {
-          assert.equal(
-            e.message,
-            "The long running operation has failed. The provisioning state: failed."
-          );
+          assert.equal(e.message, "The long running operation has failed.");
         }
       });
 
@@ -335,15 +320,8 @@ describe("Lro Engine", function () {
       });
 
       it("should handle postAsyncRetrycanceled", async () => {
-        try {
-          await runMockedLro("POST", `/post${rootPrefix}/retry/canceled`);
-          throw new Error("should have thrown instead");
-        } catch (e: any) {
-          assert.equal(
-            e.message,
-            "The long running operation has failed. The provisioning state: canceled."
-          );
-        }
+        const results = await runMockedLro("POST", `/post${rootPrefix}/retry/canceled`);
+        assert.equal(results.status, "Canceled");
       });
     });
   });

sdk/textanalytics/ai-text-analytics/test/public/analyzeBatch.spec.ts

@@ -946,7 +946,6 @@ matrix([["APIKey", "AAD"]] as const, async (authMethod: AuthMethod) => {
             assert.fail(`Operation has finished processing before requested to be cancelled`);
           }
           await originalPoller.cancelOperation();
-          assert.isTrue(originalPoller.getOperationState().isCancelled);
           await assert.isRejected(originalPoller.pollUntilDone(), /Poller cancelled/);
         });