function createFactory() {
  return new WidgetFactory({
    name: utils.uuid(),
    fileExtensions: ['.txt', '.foo.bar'],
    defaultFor: ['.txt', '.foo.bar']
  });
}

 beforeEach(() => {
   let path = utils.uuid() + '.py';
   context = new Context({ manager, factory: modelFactory, path });
   widget = new EditorWidget({
     factory: (host: Widget) => factory.newDocumentEditor(host.node, {}),
     mimeTypeService,
     context
   });
 });

 beforeEach(() => {
   let path = utils.uuid() + '.py';
   context = new Context({ manager, factory: modelFactory, path });
   widget = new EditorWidget({
     factory: options => factoryService.newDocumentEditor(options),
     mimeTypeService,
     context
   });
 });

 it('should update the title when the path changes', (done) => {
   let path = utils.uuid() + '.jl';
   context.pathChanged.connect((sender, args) => {
     expect(widget.title.label).to.be(path);
     done();
   });
   context.save().then(() => {
     return manager.contents.rename(context.path, path);
   }).catch(done);
 });

 execute: () => {
   // If help resource will generate a mixed content error, load externally.
   if (LAB_IS_SECURE && utils.urlParse(command.url).protocol !== 'https:') {
     window.open(command.url);
     return;
   }
   attachHelp();
   iframe.url = command.url;
   showHelp();
 }

 /**
  * Create a new editor for a full document.
  */
 newDocumentEditor(host: HTMLElement, options: CodeEditor.IOptions): CodeEditor.IEditor {
   return this.newEditor(host, {
     uuid: utils.uuid(),
     extraKeys: {
       'Tab': 'indentMore',
       'Shift-Enter': () => { /* no-op */ }
     },
     indentUnit: 4,
     theme: DEFAULT_CODEMIRROR_THEME,
     lineNumbers: true,
     lineWrapping: true
   }, options);
 }

    execute: args => {
      const url = args['url'] as string;
      const text = args['text'] as string;

      // If help resource will generate a mixed content error, load externally.
      if (LAB_IS_SECURE && utils.urlParse(url).protocol !== 'https:') {
        window.open(url);
        return;
      }

      let iframe = newClosableIFrame(url, text);
      app.shell.addToMainArea(iframe);
      app.shell.activateMain(iframe.id);
    }

 /**
  * Create a new editor for inline code.
  */
 newInlineEditor(host: HTMLElement, options: CodeEditor.IOptions): CodeEditor.IEditor {
   return this.newEditor(host, {
     uuid: utils.uuid(),
     indentUnit: 4,
     theme: DEFAULT_CODEMIRROR_THEME,
     extraKeys: {
       'Cmd-Right': 'goLineRight',
       'End': 'goLineRight',
       'Cmd-Left': 'goLineLeft',
       'Tab': 'indentMore',
       'Shift-Tab': 'indentLess',
       'Cmd-Alt-[': 'indentAuto',
       'Ctrl-Alt-[': 'indentAuto',
       'Cmd-/': 'toggleComment',
       'Ctrl-/': 'toggleComment',
     }
   }, options);
 }

    execute: (args: ICreateConsoleArgs) => {
      args = args || {};

      let name = `Console ${++count}`;

      // If we get a session, use it.
      if (args.id) {
        return manager.ready.then(() => {
          return manager.connectTo(args.id);
        }).then(session => {
          name = session.path.split('/').pop();
          name = `Console ${name.match(CONSOLE_REGEX)[1]}`;
          createConsole(session, name);
          return session.id;
        });
      }

      // Find the correct path for the new session.
      // Use the given path or the cwd.
      let path = args.path || pathTracker.path;
      if (ContentsManager.extname(path)) {
        path = ContentsManager.dirname(path);
      }
      path = `${path}/console-${count}-${utils.uuid()}`;

      // Get the kernel model.
      return manager.ready.then(() => getKernel(args, name)).then(kernel => {
        if (!kernel || (kernel && !kernel.id && !kernel.name)) {
          return;
        }
        // Start the session.
        let options: Session.IOptions = {
          path,
          kernelName: kernel.name,
          kernelId: kernel.id
        };
        return manager.startNew(options).then(session => {
          createConsole(session, name);
          return session.id;
        });
      });
    }

    execute: (args: ICreateConsoleArgs) => {
      args = args || {};

      let name = `Console ${++count}`;

      // If we get a session, use it.
      if (args.sessionId) {
        return manager.connectTo(args.sessionId).then(session => {
          createConsole(session, name);
          return session.id;
        });
      }

      // Find the correct path for the new session.
      // Use the given path or the cwd.
      let path = args.path || pathTracker.path;
      if (ContentsManager.extname(path)) {
        path = ContentsManager.dirname(path);
      }
      path = `${path}/console-${utils.uuid()}`;

      // Get the kernel model.
      return getKernel(args, name).then(kernel => {
        if (!kernel) {
          return;
        }
        // Start the session.
        let options: Session.IOptions = {
          path,
          kernelName: kernel.name,
          kernelId: kernel.id
        };
        return manager.startNew(options).then(session => {
          createConsole(session, name);
          return session.id;
        });
      });
    }