mergeMap(action => {
      const state = state$.value;
      const contentRef = action.payload.contentRef;

      const content = selectors.content(state, { contentRef });
      if (!content) {
        return of(
          actions.saveFailed({
            contentRef: action.payload.contentRef,
            error: new Error("no notebook loaded to save")
          })
        );
      }
      const model = content.model;

      if (!model || model.type !== "notebook") {
        return of(
          actions.saveFailed({
            contentRef: action.payload.contentRef,
            error: new Error("no notebook loaded to save")
          })
        );
      }

      const filepath = content.filepath;
      const appVersion = selectors.appVersion(state);
      const notebook = stringifyNotebook(
        toJS(
          model.notebook.setIn(["metadata", "nteract", "version"], appVersion)
        )
      );
      return writeFileObservable(filepath, notebook).pipe(
        map(() => {
          if (process.platform !== "darwin") {
            const notificationSystem = selectors.notificationSystem(
              state$.value
            );
            notificationSystem.addNotification({
              autoDismiss: 2,
              level: "success",
              title: "Save successful!"
            });
          }
          return actions.saveFulfilled({
            contentRef: action.payload.contentRef,
            model: {
              last_modified: new Date()
            }
          });
        }),
        catchError((error: Error) =>
          of(
            actions.saveFailed({
              contentRef: action.payload.contentRef,
              error
            })
          )
        )
      );
    })

  test("calls new Kernel after creating a new notebook", async () => {
    const action$ = ActionsObservable.of({
      type: actions.NEW_NOTEBOOK,
      payload: {
        cwd: "/home/whatever",
        kernelSpec: {
          name: "hylang"
        },
        kernelRef: "kRef",
        contentRef: "cRef"
      }
    });
    const responseActions = await newNotebookEpic(action$)
      .pipe(toArray())
      .toPromise();

    expect(responseActions).toEqual([
      {
        type: actions.FETCH_CONTENT_FULFILLED,
        payload: {
          contentRef: "cRef",
          kernelRef: "kRef",
          filepath: "",
          model: {
            type: "notebook",
            mimetype: "application/x-ipynb+json",
            format: "json",
            content: toJS(
              monocellNotebook
                .setIn(["metadata", "kernel_info", "name"], "hylang")
                .setIn(["metadata", "language_info", "name"], "hylang")
            ),
            writable: true,
            name: "Untitled.ipynb",
            path:
              process.platform === "win32"
                ? "\\home\\whatever\\Untitled.ipynb"
                : "/home/whatever/Untitled.ipynb",
            created: expect.any(String),
            last_modified: expect.any(String)
          }
        }
      }
    ]);
  });

    map((action: actions.NewNotebook) => {
      const {
        payload: {
          kernelSpec: { name, spec }
        }
      } = action;

      // TODO: work on a raw javascript object since we convert it over again
      let notebook = monocellNotebook;
      if (name) {
        notebook = notebook
          .setIn(["metadata", "kernel_info", "name"], name)
          .setIn(["metadata", "language_info", "name"], name);
      }
      if (spec) {
        notebook = notebook
          .setIn(["metadata", "kernelspec"], spec)
          .setIn(["metadata", "kernelspec", "name"], name);
      }

      const timestamp = new Date();

      return actions.fetchContentFulfilled({
        filepath: "",
        model: {
          type: "notebook",
          mimetype: notebookMediaType,
          format: "json",
          // Back to JS, only to immutableify it inside of the reducer
          content: toJS(notebook),
          writable: true,
          name: "Untitled.ipynb",
          path: path.join(action.payload.cwd, "Untitled.ipynb"),
          created: timestamp.toString(),
          last_modified: timestamp.toString()
        },
        kernelRef: action.payload.kernelRef,
        contentRef: action.payload.contentRef
      });
    })

 notebook => {
   return commutable.toJS(notebook);
 }

      (
        action: actions.Save | actions.DownloadContent
      ):
        | Observable<
            | actions.DownloadContentFailed
            | actions.DownloadContentFulfilled
            | actions.SaveFailed
            | actions.SaveFulfilled
          >
        | Observable<never> => {
        const state = state$.value;

        const host = selectors.currentHost(state);
        if (host.type !== "jupyter") {
          // Dismiss any usage that isn't targeting a jupyter server
          return empty();
        }
        const contentRef = action.payload.contentRef;
        const content = selectors.content(state, { contentRef });

        // NOTE: This could save by having selectors for each model type
        //       have toDisk() selectors
        //       It will need to be cased off when we have more than one type
        //       of content we actually save
        if (!content) {
          const errorPayload = {
            error: new Error("Content was not set."),
            contentRef: action.payload.contentRef
          };
          if (action.type === actions.DOWNLOAD_CONTENT) {
            return of(actions.downloadContentFailed(errorPayload));
          }
          return of(actions.saveFailed(errorPayload));
        }

        if (content.type === "directory") {
          // Don't save directories
          return empty();
        }

        let filepath = content.filepath;

        // This could be object for notebook, or string for files
        let serializedData: Notebook | string;
        let saveModel: Partial<contents.Payload> = {};
        if (content.type === "notebook") {
          const appVersion = selectors.appVersion(state);

          // contents API takes notebook as raw JSON whereas downloading takes
          // a string
          serializedData = toJS(
            content.model.notebook.setIn(
              ["metadata", "nteract", "version"],
              appVersion
            )
          );
          saveModel = {
            content: serializedData,
            type: content.type
          };
        } else if (content.type === "file") {
          serializedData = content.model.text;
          saveModel = {
            content: serializedData,
            type: content.type,
            format: "text"
          };
        } else {
          // We shouldn't save directories
          return empty();
        }

        switch (action.type) {
          case actions.DOWNLOAD_CONTENT: {
            // FIXME: Convert this to downloadString, so it works for both files & notebooks
            if (
              content.type === "notebook" &&
              typeof serializedData === "object"
            ) {
              downloadString(
                stringifyNotebook(serializedData),
                filepath || "notebook.ipynb",
                "application/json"
              );
            } else if (
              content.type === "file" &&
              typeof serializedData === "string"
            ) {
              downloadString(
                serializedData,
                filepath,
                content.mimetype || "application/octet-stream"
              );
            } else {
              // This shouldn't happen, is here for safety
              return empty();
            }
            return of(
              actions.downloadContentFulfilled({
                contentRef: action.payload.contentRef
//.........这里部分代码省略.........