testScheduler.run(helpers => {
      const { hot, expectObservable } = helpers;

      const inputActions = {
        a: actionsModule.restartKernel({
          outputHandling: "Run All",
          kernelRef: "oldKernelRef"
        }),
        b: actionsModule.launchKernelSuccessful({
          kernel: "",
          kernelRef: newKernelRef,
          selectNextKernel: true
        })
      };

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

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

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

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

 map(data =>
   actions.configLoaded({
     config: JSON.parse(data.toString())
   })

export function dispatchLoadConfig(
  _ownProps: { contentRef: ContentRef },
  store: DesktopStore
) {
  store.dispatch(actions.loadConfig());
}

 .catch(e => store.dispatch(actions.coreError(e)));

export function dispatchDeleteCell(
  ownProps: { contentRef: ContentRef },
  store: DesktopStore
) {
  store.dispatch(actions.deleteCell({ contentRef: ownProps.contentRef }));
}

export function dispatchPasteCell(
  ownProps: { contentRef: ContentRef },
  store: DesktopStore
) {
  store.dispatch(actions.pasteCell(ownProps));
}

export function dispatchClearAll(
  ownProps: { contentRef: ContentRef },
  store: DesktopStore
) {
  store.dispatch(actions.clearAllOutputs(ownProps));
}

export function dispatchRunAll(
  ownProps: { contentRef: ContentRef },
  store: DesktopStore
) {
  store.dispatch(actions.executeAllCells(ownProps));
}

export function dispatchPublishGist(
  ownProps: { contentRef: ContentRef },
  store: DesktopStore,
  _event: Event
) {
  const state = store.getState();
  const githubToken = state.app.get("githubToken");

  // The simple case -- we have a token and can publish
  if (githubToken != null) {
    store.dispatch(actions.publishGist(ownProps));
    return;
  }

  // If the Github Token isn't set, use our oauth server to acquire a token

  // Because the remote object from Electron main <--> renderer can be "cleaned up"
  // we re-require electron here and get the remote object
  const remote = require("electron").remote;

  // Create our oauth window
  const win = new remote.BrowserWindow({
    show: false,
    webPreferences: { zoomFactor: 0.75 }
  });

  // TODO: This needs to be moved to an epic
  win.webContents.on("dom-ready", () => {
    // When we're at our callback code page, keep the page hidden
    if (win.webContents.getURL().indexOf("callback?code=") !== -1) {
      // Extract the text content
      win.webContents.executeJavaScript(
        "require('electron').ipcRenderer.send('auth', document.body.textContent);"
      );
      remote.ipcMain.on("auth", (_event: Event, auth: string) => {
        try {
          const accessToken = JSON.parse(auth).access_token;
          store.dispatch(actions.setGithubToken(accessToken));

          const notificationSystem = selectors.notificationSystem(state);

          notificationSystem.addNotification({
            title: "Authenticated",
            message: "🔒",
            level: "info"
          });

          // We are now authenticated and can finally publish
          store.dispatch(actions.publishGist(ownProps));
        } catch (e) {
          store.dispatch(actions.coreError(e));
        } finally {
          win.close();
        }
      });
    } else {
      win.show();
    }
  });
  win.loadURL("https://oauth.nteract.io/github");
}

    mergeMap((action: actions.PublishGist) => {
      const state = state$.value;

      const contentRef = action.payload.contentRef;
      if (!contentRef) {
        return empty();
      }

      // TODO: Switch GitHub publishing actions to content refs
      const content = selectors.content(state, { contentRef });
      // NOTE: This could save by having selectors for each model type
      //       have toDisk() selectors
      if (!content || content.type !== "notebook") {
        return empty();
      }

      const filepath = content.filepath;
      const notificationSystem = selectors.notificationSystem(state);

      const model = content.model;

      const notebookString = selectors.notebook.asString(model);
      const gistId = selectors.notebook.gistId(model);

      // Allow falling back on the GITHUB_TOKEN environment variable
      const githubToken = state.app.get("githubToken");

      if (githubToken == null) {
        return of(
          actions.coreError(
            new Error("need a github token in order to publish")
          )
        );
      }

      if (gistId && typeof gistId !== "string") {
        return of(
          actions.coreError(new Error("gist id in notebook is not a string"))
        );
      }

      // We are updating, so we require both a gist Id and a github token
      // If this doesn't happen to be our originally gisted notebook,
      // we should likely fork and publish
      //
      // TODO: Check to see if the token matches that of the username listed
      //       in the notebook itself
      if (gistId) {
        notificationSystem.addNotification({
          title: "Updating Gist...",
          message: "💖📓💖",
          dismissible: true,
          position: "tr",
          level: "success"
        });
      } else {
        notificationSystem.addNotification({
          title: "Publishing a New Gist...",
          message: "✨📓✨",
          dismissible: true,
          position: "tr",
          level: "success"
        });
      }

      const filename = filepath ? path.parse(filepath).base : "Untitled.ipynb";
      const files: GithubFiles = {
        [filename]: { content: notebookString }
      };

      return publishGist(
        { files, description: filename, public: false },
        githubToken,
        gistId
      ).pipe(
        mergeMap(xhr => {
          const notificationSystem = selectors.notificationSystem(state$.value);

          const { id, login } = xhr.response;

          // NOTE: One day we need to make this part of our proper store
          //       instead of hidden side effects
          notificationSystem.addNotification({
            title: "Gist uploaded",
            message: "📓 📢",
            dismissible: true,
            position: "tr",
            level: "success",
            action: {
              label: "Open Gist",
              callback() {
                shell.openExternal(`https://nbviewer.jupyter.org/${id}`);
              }
            }
          });

          // TODO: Turn this into one action that does both, even if its
          // sometimes a no-op
          return of(
            actions.overwriteMetadataField({
//.........这里部分代码省略.........