Mailspring/internal_packages/composer-templates/spec/template-store-spec.es6
Matt Bilker 5fd8faa82c fix(imports): switch to Electron's require('electron') (#1907)
* fix(imports): switch to Electron's require('electron')

Electron in 0.37.5 phases out the usage of `require('built-in-module')`
in favor of `require('electron').builtInModule`. This commit corrects usage in
some cases that cause N1 to not start under Electron 0.37.5.

* fix(specs): use new Electron remote import
2016-04-12 18:09:13 -07:00

180 lines
6.3 KiB
JavaScript

import fs from 'fs';
import { remote } from 'electron';
import {Message, DraftStore} from 'nylas-exports';
import TemplateStore from '../lib/template-store';
const { shell } = remote;
const stubTemplatesDir = '~/.nylas/templates';
const stubTemplateFiles = {
'template1.html': '<p>bla1</p>',
'template2.html': '<p>bla2</p>',
};
const stubTemplates = [
{id: 'template1.html', name: 'template1', path: `${stubTemplatesDir}/template1.html`},
{id: 'template2.html', name: 'template2', path: `${stubTemplatesDir}/template2.html`},
];
describe('TemplateStore', ()=> {
beforeEach(()=> {
spyOn(fs, 'mkdir');
spyOn(shell, 'showItemInFolder').andCallFake(()=> {});
spyOn(fs, 'writeFile').andCallFake((path, contents, callback)=> {
callback(null);
});
spyOn(fs, 'readFile').andCallFake((path, callback)=> {
const filename = path.split('/').pop();
callback(null, stubTemplateFiles[filename]);
});
});
it('should create the templates folder if it does not exist', ()=> {
spyOn(fs, 'exists').andCallFake((path, callback)=> callback(false) );
TemplateStore._init(stubTemplatesDir);
expect(fs.mkdir).toHaveBeenCalled();
});
it('should expose templates in the templates directory', ()=> {
let watchCallback;
spyOn(fs, 'exists').andCallFake((path, callback)=> { callback(true); });
spyOn(fs, 'watch').andCallFake((path, callback)=> watchCallback = callback);
spyOn(fs, 'readdir').andCallFake((path, callback)=> { callback(null, Object.keys(stubTemplateFiles)); });
TemplateStore._init(stubTemplatesDir);
watchCallback();
expect(TemplateStore.items()).toEqual(stubTemplates);
});
it('should watch the templates directory and reflect changes', ()=> {
let watchCallback = null;
let watchFired = false;
spyOn(fs, 'exists').andCallFake((path, callback)=> callback(true));
spyOn(fs, 'watch').andCallFake((path, callback)=> watchCallback = callback);
spyOn(fs, 'readdir').andCallFake((path, callback)=> {
if (watchFired) {
callback(null, Object.keys(stubTemplateFiles));
} else {
callback(null, []);
}
});
TemplateStore._init(stubTemplatesDir);
expect(TemplateStore.items()).toEqual([]);
watchFired = true;
watchCallback();
expect(TemplateStore.items()).toEqual(stubTemplates);
});
describe('insertTemplateId', ()=> {
xit('should insert the template with the given id into the draft with the given id', ()=> {
let watchCallback;
spyOn(fs, 'exists').andCallFake((path, callback)=> { callback(true); });
spyOn(fs, 'watch').andCallFake((path, callback)=> watchCallback = callback);
spyOn(fs, 'readdir').andCallFake((path, callback)=> { callback(null, Object.keys(stubTemplateFiles)); });
TemplateStore._init(stubTemplatesDir);
watchCallback();
const add = jasmine.createSpy('add');
spyOn(DraftStore, 'sessionForClientId').andCallFake(()=> {
return Promise.resolve({changes: {add}});
});
runs(()=> {
TemplateStore._onInsertTemplateId({
templateId: 'template1.html',
draftClientId: 'localid-draft',
});
});
waitsFor(()=> add.calls.length > 0);
runs(()=> {
expect(add).toHaveBeenCalledWith({
body: stubTemplateFiles['template1.html'],
});
});
});
});
describe('onCreateTemplate', ()=> {
beforeEach(()=> {
let d;
spyOn(DraftStore, 'sessionForClientId').andCallFake((draftClientId)=> {
if (draftClientId === 'localid-nosubject') {
d = new Message({subject: '', body: '<p>Body</p>'});
} else {
d = new Message({subject: 'Subject', body: '<p>Body</p>'});
}
const session = {draft() { return d; }};
return Promise.resolve(session);
});
TemplateStore._init(stubTemplatesDir);
});
xit('should create a template with the given name and contents', ()=> {
const ref = TemplateStore.items();
TemplateStore._onCreateTemplate({name: '123', contents: 'bla'});
const item = (ref != null ? ref[0] : undefined);
expect(item.id).toBe('123.html');
expect(item.name).toBe('123');
expect(item.path.split('/').pop()).toBe('123.html');
});
xit('should display an error if no name is provided', ()=> {
spyOn(TemplateStore, '_displayError');
TemplateStore._onCreateTemplate({contents: 'bla'});
expect(TemplateStore._displayError).toHaveBeenCalled();
});
xit('should display an error if no content is provided', ()=> {
spyOn(TemplateStore, '_displayError');
TemplateStore._onCreateTemplate({name: 'bla'});
expect(TemplateStore._displayError).toHaveBeenCalled();
});
xit('should save the template file to the templates folder', ()=> {
TemplateStore._onCreateTemplate({name: '123', contents: 'bla'});
const path = `${stubTemplatesDir}/123.html`;
expect(fs.writeFile).toHaveBeenCalled();
expect(fs.writeFile.mostRecentCall.args[0]).toEqual(path);
expect(fs.writeFile.mostRecentCall.args[1]).toEqual('bla');
});
xit('should open the template so you can see it', ()=> {
TemplateStore._onCreateTemplate({name: '123', contents: 'bla'});
expect(shell.showItemInFolder).toHaveBeenCalled();
});
describe('when given a draft id', ()=> {
xit('should create a template from the name and contents of the given draft', ()=> {
spyOn(TemplateStore, 'trigger');
spyOn(TemplateStore, '_populate');
runs(()=> {
TemplateStore._onCreateTemplate({draftClientId: 'localid-b'});
});
waitsFor(()=> TemplateStore.trigger.callCount > 0 );
runs(()=> {
expect(TemplateStore.items().length).toEqual(1);
});
});
it('should display an error if the draft has no subject', ()=> {
spyOn(TemplateStore, '_displayError');
spyOn(fs, 'watch');
runs(()=> {
TemplateStore._onCreateTemplate({draftClientId: 'localid-nosubject'});
});
waitsFor(()=> TemplateStore._displayError.callCount > 0 );
runs(()=> {
expect(TemplateStore._displayError).toHaveBeenCalled();
});
});
});
});
describe('onShowTemplates', ()=> {
xit('should open the templates folder in the Finder', ()=> {
TemplateStore._onShowTemplates();
expect(shell.showItemInFolder).toHaveBeenCalled();
});
});
});