TypeScript actions.killKernel方法代码示例

    test("and allows continuing", async () => {
      let registeredCallback;
      ipc.once = (event, callback) => {
        if (event === "show-message-box-response") {
          registeredCallback = callback;
        }
      };
      ipc.send = (event, data) => {
        expect(event).toBe("show-message-box");
        expect(data.message).toEqual(
          "Unsaved data will be lost. Are you sure you want to quit?"
        );

        // "Yes"
        registeredCallback("dummy-event", 0);
      };

      const state = buildState(true);
      const responses = await closeNotebookEpic(
        ActionsObservable.of(
          actions.closeNotebook({ contentRef: "contentRef1" })
        ),
        { value: state }
      )
        .pipe(toArray())
        .toPromise();

      expect(responses).toEqual([
        coreActions.killKernel({ kernelRef: "kernelRef1", restarting: false }),
        actions.closeNotebookProgress({
          newState: DESKTOP_NOTEBOOK_CLOSING_READY_TO_CLOSE
        })
      ]);
    });

      testScheduler.run(helpers => {
        const { hot, expectObservable } = helpers;
        const inputActions = {
          a: actions.closeNotebook({ contentRef: "contentRef1" })
        };

        const outputActions = {
          c: coreActions.killKernel({
            kernelRef: "kernelRef1",
            restarting: false
          }),
          d: actions.closeNotebookProgress({
            newState: DESKTOP_NOTEBOOK_CLOSING_READY_TO_CLOSE
          })
        };

        const inputMarbles = "a          6000ms |";
        const outputMarbles = "c 4999ms d 1000ms |"; // Timeout after 5s

        const inputAction$ = hot(inputMarbles, inputActions);

        const outputAction$ = closeNotebookEpic(inputAction$, { value: state });

        expectObservable(outputAction$).toBe(outputMarbles, outputActions);
      });

      testScheduler.run(helpers => {
        const { hot, expectObservable } = helpers;
        const inputActions = {
          a: actions.closeNotebook({ contentRef: "contentRef1" }),
          b: coreActions.killKernelFailed({
            kernelRef: "kernelRef1",
            error: new Error("barf")
          })
        };

        const outputActions = {
          c: coreActions.killKernel({
            kernelRef: "kernelRef1",
            restarting: false
          }),
          d: actions.closeNotebookProgress({
            newState: DESKTOP_NOTEBOOK_CLOSING_READY_TO_CLOSE
          })
        };

        const inputMarbles = "a b";
        const outputMarbles = "c d";

        const inputAction$ = hot(inputMarbles, inputActions);
        const outputAction$ = closeNotebookEpic(inputAction$, { value: state });

        expectObservable(outputAction$).toBe(outputMarbles, outputActions);
      });

export function dispatchKillKernel(
  ownProps: { contentRef: ContentRef },
  store: DesktopStore
) {
  const state = store.getState();
  const kernelRef = selectors.kernelRefByContentRef(state, ownProps);
  if (!kernelRef) {
    store.dispatch(actions.coreError(new Error("kernel not set")));
    return;
  }

  store.dispatch(actions.killKernel({ restarting: false, kernelRef }));
}

    switchMap((action: actions.LaunchKernelAction) => {
      if (
        !action.payload ||
        !action.payload.kernelSpec ||
        !action.payload.kernelRef
      ) {
        return of(
          actions.launchKernelFailed({
            error: new Error("launchKernel needs a kernelSpec and a kernelRef"),
            kernelRef: action.payload && action.payload.kernelRef,
            contentRef: action.payload.contentRef
          })
        );
      }

      ipc.send("nteract:ping:kernel", action.payload.kernelSpec);

      const oldKernelRef = selectors.currentKernelRef(state$.value);

      // Kill the old kernel by emitting the action to kill it if it exists
      let cleanupOldKernel$:
        | Observable<never>
        | Observable<actions.KillKernelAction> = empty();
      if (oldKernelRef && oldKernelRef !== action.payload.kernelRef) {
        cleanupOldKernel$ = of(
          actions.killKernel({ restarting: false, kernelRef: oldKernelRef })
        );
      }

      return merge(
        launchKernelObservable(
          action.payload.kernelSpec,
          action.payload.cwd,
          action.payload.kernelRef,
          action.payload.contentRef
        ),
        // Was there a kernel before (?) -- kill it if so, otherwise nothing else
        cleanupOldKernel$
      ).pipe(
        catchError((error: Error) =>
          of(
            actions.launchKernelFailed({
              error,
              kernelRef: action.payload.kernelRef,
              contentRef: action.payload.contentRef
            })
          )
        )
      );
    }),

    testScheduler.run(helpers => {
      const { hot, expectObservable } = helpers;
      const inputActions = {
        a: actionsModule.restartKernel({
          outputHandling: "None",
          kernelRef: "oldKernelRef",
          contentRef: contentRef
        }),
        b: actionsModule.launchKernelSuccessful({
          kernel: "",
          kernelRef: newKernelRef,
          contentRef: contentRef,
          selectNextKernel: true
        })
      };

      const outputActions = {
        c: actionsModule.killKernel({
          restarting: true,
          kernelRef: "oldKernelRef"
        }),
        d: actionsModule.launchKernelByName({
          kernelSpecName: null,
          cwd: ".",
          kernelRef: newKernelRef,
          selectNextKernel: true,
          contentRef: contentRef
        }),
        e: actionsModule.restartKernelSuccessful({
          kernelRef: newKernelRef,
          contentRef: contentRef
        })
      };

      const inputMarbles = "a---b|";
      const outputMarbles = "(cd)e|";

      const inputAction$ = hot(inputMarbles, inputActions);
      const outputAction$ = restartKernelEpic(
        inputAction$,
        { value: state },
        () => newKernelRef
      );

      expectObservable(outputAction$).toBe(outputMarbles, outputActions);
    });