mirror of https://github.com/ColorlibHQ/gentelella
526 lines
15 KiB
JavaScript
526 lines
15 KiB
JavaScript
require('mocha');
|
|
require('should');
|
|
var path = require('path');
|
|
var assert = require('assert');
|
|
var typeOf = require('kind-of');
|
|
var support = require('./support');
|
|
var isBuffer = require('is-buffer');
|
|
var App = support.resolve();
|
|
var List = App.List;
|
|
var View = App.View;
|
|
var Views = App.Views;
|
|
var collection;
|
|
|
|
describe('views', function() {
|
|
describe('constructor', function() {
|
|
it('should create an instance of Views:', function() {
|
|
var collection = new Views();
|
|
assert(collection instanceof Views);
|
|
});
|
|
|
|
it('should instantiate without `new`:', function() {
|
|
var collection = Views();
|
|
assert(collection instanceof Views);
|
|
});
|
|
});
|
|
|
|
describe('static methods', function() {
|
|
it('should expose `extend`:', function() {
|
|
assert(typeof Views.extend === 'function');
|
|
});
|
|
});
|
|
|
|
describe('prototype methods', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
var methods = [
|
|
'use',
|
|
'setView',
|
|
'addView',
|
|
'addViews',
|
|
'addList',
|
|
'getView',
|
|
'constructor',
|
|
'set',
|
|
'get',
|
|
'del',
|
|
'define',
|
|
'visit',
|
|
'on',
|
|
'once',
|
|
'off',
|
|
'emit',
|
|
'listeners',
|
|
'hasListeners'
|
|
];
|
|
|
|
methods.forEach(function(method) {
|
|
it('should expose ' + method + ' method', function() {
|
|
assert(typeof collection[method] === 'function');
|
|
});
|
|
});
|
|
|
|
it('should expose isCollection property', function() {
|
|
assert(typeof collection.isCollection === 'boolean');
|
|
});
|
|
|
|
it('should expose queue property', function() {
|
|
assert(Array.isArray(collection.queue));
|
|
});
|
|
|
|
it('should expose views property', function() {
|
|
assert(typeOf(collection.views) === 'object');
|
|
});
|
|
|
|
it('should expose options property', function() {
|
|
assert(typeOf(collection.options) === 'object');
|
|
});
|
|
});
|
|
|
|
describe('instance', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should set a value on the instance:', function() {
|
|
collection.set('a', 'b');
|
|
assert(collection.a === 'b');
|
|
});
|
|
|
|
it('should get a value from the instance:', function() {
|
|
collection.set('a', 'b');
|
|
assert(collection.get('a') === 'b');
|
|
});
|
|
});
|
|
|
|
describe('option', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should set a key/value pair on options:', function() {
|
|
collection.option('a', 'b');
|
|
assert(collection.options.a === 'b');
|
|
});
|
|
|
|
it('should set an object on options:', function() {
|
|
collection.option({c: 'd'});
|
|
assert(collection.options.c === 'd');
|
|
});
|
|
|
|
it('should get an option:', function() {
|
|
collection.option({c: 'd'});
|
|
var c = collection.option('c');
|
|
assert(c === 'd');
|
|
});
|
|
});
|
|
|
|
describe('addView', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should throw an error when args are invalid:', function() {
|
|
(function() {
|
|
collection.addView(function() {});
|
|
}).should.throw('expected value to be an object.');
|
|
});
|
|
|
|
it('should add a view to `views`:', function() {
|
|
collection.addView('foo');
|
|
collection.views.should.have.property('foo');
|
|
|
|
collection.addView('one', {content: '...'});
|
|
assert(typeof collection.views.one === 'object');
|
|
assert(isBuffer(collection.views.one.contents));
|
|
});
|
|
|
|
it('should create an instance of `View`:', function() {
|
|
collection.addView('one', {content: '...'});
|
|
assert(collection.views.one instanceof collection.View);
|
|
});
|
|
|
|
it('should allow an `View` constructor to be passed:', function() {
|
|
View.prototype.foo = function(key, value) {
|
|
this[key] = value;
|
|
};
|
|
collection = new Views({View: View});
|
|
collection.addView('one', {content: '...'});
|
|
collection.views.one.foo('bar', 'baz');
|
|
assert(collection.views.one.bar === 'baz');
|
|
});
|
|
|
|
it('should allow an instance of `View` to be passed:', function() {
|
|
var collection = new Views({View: View});
|
|
var view = new View({content: '...'});
|
|
collection.addView('one', view);
|
|
view.set('abc', 'xyz');
|
|
assert(collection.views.one instanceof collection.View);
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(collection.views.one.abc === 'xyz');
|
|
});
|
|
|
|
it('should expose the `isType` method on items', function() {
|
|
var collection = new Views({View: View});
|
|
var view = new View({content: '...'});
|
|
collection.setView('one', view);
|
|
|
|
var one = collection.getView('one');
|
|
assert(one.isType('renderable'));
|
|
});
|
|
|
|
it('should set viewTypes on a collection', function() {
|
|
var collection = new Views({View: View});
|
|
collection.viewType(['partial']);
|
|
|
|
var view = new View({content: '...'});
|
|
collection.setView('one', view);
|
|
|
|
var one = collection.getView('one');
|
|
assert(!one.isType('renderable'));
|
|
assert(one.isType('partial'));
|
|
});
|
|
});
|
|
|
|
describe('addViews', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should emit an error if a string glob pattern is passed', function(done) {
|
|
try {
|
|
collection.addViews('*.js');
|
|
done(new Error('expected an error'));
|
|
} catch (err) {
|
|
assert(err);
|
|
assert(err.message);
|
|
assert(/glob/.test(err.message));
|
|
done();
|
|
}
|
|
});
|
|
|
|
it('should emit an error if an array glob pattern is passed', function(done) {
|
|
try {
|
|
collection.addViews(['*.js']);
|
|
done(new Error('expected an error'));
|
|
} catch (err) {
|
|
assert(err);
|
|
assert(err.message);
|
|
assert(/glob/.test(err.message));
|
|
done();
|
|
}
|
|
});
|
|
|
|
it('should add multiple views:', function() {
|
|
collection.addViews({
|
|
one: {content: 'foo'},
|
|
two: {content: 'bar'}
|
|
});
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(isBuffer(collection.views.two.contents));
|
|
});
|
|
|
|
it('should return the collection instance for chaining:', function() {
|
|
var views = collection.addViews({
|
|
one: {content: 'foo'},
|
|
two: {content: 'bar'}
|
|
});
|
|
|
|
var view = views.getView('one');
|
|
assert(view);
|
|
assert(view.content);
|
|
assert(view.content === 'foo');
|
|
});
|
|
|
|
it('should create views from an instance of Views', function() {
|
|
collection.addViews({
|
|
one: {content: 'foo'},
|
|
two: {content: 'bar'}
|
|
});
|
|
var pages = new Views(collection);
|
|
assert(isBuffer(pages.views.one.contents));
|
|
assert(isBuffer(pages.views.two.contents));
|
|
});
|
|
|
|
it('should add an array of views:', function() {
|
|
collection.addViews([
|
|
{path: 'one', content: 'foo'},
|
|
{path: 'two', content: 'bar'}
|
|
]);
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(isBuffer(collection.views.two.contents));
|
|
});
|
|
});
|
|
|
|
describe('view', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should return a single collection view from a key-value pair', function() {
|
|
var one = collection.view('one', {content: 'foo'});
|
|
var two = collection.view('two', {content: 'bar'});
|
|
|
|
assert(one.isView);
|
|
assert(one.path === 'one');
|
|
assert(two.isView);
|
|
assert(two.path === 'two');
|
|
});
|
|
|
|
it('should return a single collection view from an object', function() {
|
|
var one = collection.view({path: 'one', content: 'foo'});
|
|
var two = collection.view({path: 'two', content: 'bar'});
|
|
|
|
assert(one.isView);
|
|
assert(one.path === 'one');
|
|
assert(two.isView);
|
|
assert(two.path === 'two');
|
|
});
|
|
});
|
|
|
|
describe('addList', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should emit an error if a string glob pattern is passed', function(done) {
|
|
try {
|
|
collection.addList('*.js');
|
|
done(new Error('expected an error'));
|
|
} catch (err) {
|
|
assert(err);
|
|
assert(err.message);
|
|
assert(/glob/.test(err.message));
|
|
done();
|
|
}
|
|
});
|
|
|
|
it('should emit an error if an array glob pattern is passed', function(done) {
|
|
try {
|
|
collection.addList(['*.js']);
|
|
done(new Error('expected an error'));
|
|
} catch (err) {
|
|
assert(err);
|
|
assert(err.message);
|
|
assert(/glob/.test(err.message));
|
|
done();
|
|
}
|
|
});
|
|
|
|
it('should add a list of views:', function() {
|
|
collection.addList([
|
|
{path: 'one', content: 'foo'},
|
|
{path: 'two', content: 'bar'}
|
|
]);
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(isBuffer(collection.views.two.contents));
|
|
});
|
|
|
|
it('should add a list from the constructor:', function() {
|
|
var list = new List([
|
|
{path: 'one', content: 'foo'},
|
|
{path: 'two', content: 'bar'}
|
|
]);
|
|
|
|
collection = new Views(list);
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(isBuffer(collection.views.two.contents));
|
|
});
|
|
|
|
it('should add list items from the constructor:', function() {
|
|
var list = new List([
|
|
{path: 'one', content: 'foo'},
|
|
{path: 'two', content: 'bar'}
|
|
]);
|
|
|
|
collection = new Views(list.items);
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(isBuffer(collection.views.two.contents));
|
|
});
|
|
|
|
it('should throw an error when list is not an array:', function() {
|
|
var views = new Views();
|
|
(function() {
|
|
views.addList();
|
|
}).should.throw('expected list to be an array.');
|
|
|
|
(function() {
|
|
views.addList({});
|
|
}).should.throw('expected list to be an array.');
|
|
|
|
(function() {
|
|
views.addList('foo');
|
|
}).should.throw('expected list to be an array.');
|
|
});
|
|
|
|
it('should load an array of items from an event:', function() {
|
|
var pages = new Views();
|
|
|
|
pages.on('addList', function(list) {
|
|
while (list.length) {
|
|
pages.addView({path: list.pop()});
|
|
}
|
|
this.loaded = true;
|
|
});
|
|
|
|
pages.addList(['a.txt', 'b.txt', 'c.txt']);
|
|
assert(pages.views.hasOwnProperty('a.txt'));
|
|
assert(pages.views['a.txt'].path === 'a.txt');
|
|
});
|
|
|
|
it('should load an array of items from the addList callback:', function() {
|
|
var collection = new Views();
|
|
|
|
collection.addList(['a.txt', 'b.txt', 'c.txt'], function(fp) {
|
|
return {path: fp};
|
|
});
|
|
assert(collection.views.hasOwnProperty('a.txt'));
|
|
assert(collection.views['a.txt'].path === 'a.txt');
|
|
});
|
|
|
|
it('should load an object of views from an event:', function() {
|
|
var collection = new Views();
|
|
|
|
collection.on('addViews', function(views) {
|
|
for (var key in views) {
|
|
collection.addView('foo/' + key, views[key]);
|
|
delete views[key];
|
|
}
|
|
});
|
|
|
|
collection.addViews({
|
|
a: {path: 'a.txt'},
|
|
b: {path: 'b.txt'},
|
|
c: {path: 'c.txt'}
|
|
});
|
|
|
|
assert(collection.views.hasOwnProperty('foo/a'));
|
|
assert(collection.views['foo/a'].path === 'a.txt');
|
|
});
|
|
|
|
it('should signal `loaded` when finished:', function() {
|
|
var collection = new Views();
|
|
|
|
collection.on('addViews', function(views) {
|
|
for (var key in views) {
|
|
if (key === 'c') break;
|
|
collection.addView('foo/' + key, views[key]);
|
|
}
|
|
});
|
|
|
|
collection.addViews({
|
|
a: {path: 'a.txt'},
|
|
b: {path: 'b.txt'},
|
|
c: {path: 'c.txt'}
|
|
});
|
|
|
|
assert(collection.views.hasOwnProperty('foo/a'));
|
|
assert(!collection.views.hasOwnProperty('foo/c'));
|
|
assert(collection.views['foo/a'].path === 'a.txt');
|
|
});
|
|
});
|
|
|
|
describe('getView', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
it('should get a view from `views`:', function() {
|
|
collection.addView('one', {content: 'aaa'});
|
|
collection.addView('two', {content: 'zzz'});
|
|
assert(isBuffer(collection.views.one.contents));
|
|
assert(isBuffer(collection.getView('one').contents));
|
|
assert(collection.getView('one').contents.toString() === 'aaa');
|
|
assert(collection.getView('two').contents.toString() === 'zzz');
|
|
});
|
|
});
|
|
|
|
describe('count', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should get the number of views:', function() {
|
|
collection.addView('one', {content: 'aaa'});
|
|
collection.addView('two', {content: 'zzz'});
|
|
assert(Object.keys(collection.views).length === 2);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('options', function() {
|
|
describe('options.renameKey', function() {
|
|
beforeEach(function() {
|
|
collection = new Views({
|
|
renameKey: function(key) {
|
|
return path.basename(key);
|
|
}
|
|
});
|
|
});
|
|
|
|
it('should use a custom rename key function on view keys', function() {
|
|
collection.addView('a/b/c/d.hbs', {content: 'foo bar baz'});
|
|
assert(collection.views['d.hbs'].contents.toString() === 'foo bar baz');
|
|
});
|
|
|
|
it('should get a view with the renamed key:', function() {
|
|
collection.addView('a/b/c/d.hbs', {content: 'foo bar baz'});
|
|
assert(collection.getView('d.hbs').contents.toString() === 'foo bar baz');
|
|
});
|
|
|
|
it('should get a view with the original key:', function() {
|
|
collection.addView('a/b/c/d.hbs', {content: 'foo bar baz'});
|
|
assert(collection.getView('a/b/c/d.hbs').contents.toString() === 'foo bar baz');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('queue', function() {
|
|
beforeEach(function() {
|
|
collection = new Views();
|
|
});
|
|
|
|
it('should emit arguments on addView', function(done) {
|
|
collection.on('addView', function(args) {
|
|
assert(args[0] === 'a');
|
|
assert(args[1] === 'b');
|
|
assert(args[2] === 'c');
|
|
assert(args[3] === 'd');
|
|
assert(args[4] === 'e');
|
|
done();
|
|
});
|
|
|
|
collection.addView('a', 'b', 'c', 'd', 'e');
|
|
});
|
|
|
|
it('should expose the `queue` property for loading views', function() {
|
|
collection.queue.push(collection.view('b', {path: 'b'}));
|
|
|
|
collection.addView('a', {path: 'a'});
|
|
assert(collection.views.hasOwnProperty('a'));
|
|
assert(collection.views.hasOwnProperty('b'));
|
|
});
|
|
|
|
it('should load all views on the queue when addView is called', function() {
|
|
collection.on('addView', function(args) {
|
|
var len = args.length;
|
|
var last = args[len - 1];
|
|
if (typeof last === 'string') {
|
|
args[len - 1] = { content: last };
|
|
}
|
|
});
|
|
|
|
collection.addView('a.html', 'aaa');
|
|
collection.addView('b.html', 'bbb');
|
|
collection.addView('c.html', 'ccc');
|
|
|
|
assert(collection.views.hasOwnProperty('a.html'));
|
|
assert(collection.getView('a.html').content === 'aaa');
|
|
assert(collection.views.hasOwnProperty('b.html'));
|
|
assert(collection.getView('b.html').content === 'bbb');
|
|
assert(collection.views.hasOwnProperty('c.html'));
|
|
assert(collection.getView('c.html').content === 'ccc');
|
|
});
|
|
});
|