savvy-js
Version:
Savvy - Style sheet documentation tool
273 lines (220 loc) • 11.2 kB
JavaScript
(function () {
'use strict';
var chai = require('chai'),
should = chai.should(),
expect = chai.expect,
fs = require('fs'),
parser = require('../js/parser'),
assembler = require('../js/assembler'),
tree;
function clearTree() {
tree = assembler.getTree();
for (var key in tree) {
delete tree[key];
}
}
describe('assembler', function () {
describe('Assembler utility functions', function () {
it('Get tree', function () {
var tree = assembler.getTree();
tree.should.exist;
tree.should.eql({});
});
it('extend object', function () {
var source = {
myProperty: {
name: 'xx'
}
},
target = {};
assembler.extend(target, source);
target.should.have.a.property('myProperty', 'xx');
});
it('Sort parsed objects', function () {
var moduleAndSubmodule = {
module: 'a',
submodule: 'b'
},
onlyModule = {module: 'c'},
onlySubmodule = {submodule: 'd'},
onlyClass = {class: 'e'},
array = [onlyClass, onlyModule, moduleAndSubmodule, onlySubmodule];
assembler.sort(array);
array[0].should.equal(moduleAndSubmodule);
array[1].should.equal(onlyModule);
array[2].should.equal(onlySubmodule);
array[3].should.equal(onlyClass);
});
it('Find classes recursively inside the tree', function () {
var result;
tree = {
_classes : {
myTreeClass : { 'class' : 'myTreeClass1'}
},
myModule : {
_classes : {
myModuleClass : {
class : 'myModuleClass',
states : [
{
class : 'myModuleClass-state1',
children : [
{
class : 'myModuleClass-state1-childe1',
children : [
{
class : 'myModuleClass-state1-childe1-child1'
}
]
}
]
}
],
children : [
{
class : 'myModuleClass-childe1'
}
]
}
},
_submodules : {
mySubmodule : {
_classes : {
mySubmoduleClass : {
class : 'mySubmoduleClass',
states : [
{
class : 'mySubmoduleClass-state1',
children : [
{
class : 'mySubmoduleClass-child1'
}
]
},
{
class : 'mySubmoduleClass-state2'
}
]
}
}
}
}
}
};
result = assembler.findClassRecursive(tree, 'myModuleClass-state1-childe1-child1');
result.should.have.a.property('class', 'myModuleClass-state1-childe1-child1');
result = assembler.findClassRecursive(tree, 'mySubmoduleClass-child1');
result.should.have.a.property('class', 'mySubmoduleClass-child1');
clearTree();
});
});
describe('Get class, submodule or module', function () {
beforeEach(clearTree);
after(clearTree);
it('Find or create a module by name', function () {
var module;
// create a module if it does not exist
tree.should.not.have.a.property('myModule');
expect(module).to.not.exist;
module = assembler.getModule('myModule');
tree.should.have.a.property('myModule');
module.should.exist;
// find a module if it exist
module = assembler.getModule('myModule');
module.should.equal(tree.myModule);
// moudule should have _classes and _submodules collections by default
module.should.have.a.property('_classes');
module.should.have.a.property('_submodules');
});
it('Find or create a submodule by name and model name', function () {
var module = assembler.getModule('myModule'),
submodule;
// create a submodule if it does not exist
submodule = assembler.getSubmodule('mySubmodule', 'myModule');
expect(submodule).to.exist;
expect(module._submodules).to.exist;
expect(module._submodules.mySubmodule).to.exist;
// find a submodule if it exist
submodule = assembler.getSubmodule('mySubmodule', 'myModule');
submodule.should.equal(tree.myModule._submodules.mySubmodule);
});
it('Find or create a submodule by name without model name', function () {
var module,
submodule;
// if no module name provided, look for the submodule in all module.
//if not found, return null.
submodule = assembler.getSubmodule('mySubmodule');
expect(submodule).not.to.exist;
// create the submodule manually
module = assembler.getModule('myModule');
tree.myModule._submodules.mySubmodule = {};
// if found, return the first one.
submodule = assembler.getSubmodule('mySubmodule');
expect(submodule).to.exist;
});
it('Find or create a class by name, with a module and a submodule provided', function () {
var classObject;
// create a class if it does not exist
classObject = assembler.getClass('myClass', 'myModule', 'mySubmodule');
classObject.should.exist;
tree.myModule.should.exist;
tree.myModule._submodules.mySubmodule.should.exist;
tree.myModule._submodules.mySubmodule._classes.myClass.should.exist;
// find a class if it exist
classObject = assembler.getClass('myClass', 'myModule', 'mySubmodule');
classObject.should.equal(tree.myModule._submodules.mySubmodule._classes.myClass);
});
it('Find or create a class by name, with a module but without a submodule', function () {
var classObject;
// create a class if it does not exist
classObject = assembler.getClass('myClass', 'myModule');
classObject.should.exist;
tree.myModule.should.exist;
tree.myModule._classes.myClass.should.exist;
// find a class if it exist
classObject = assembler.getClass('myClass', 'myModule');
classObject.should.equal(tree.myModule._classes.myClass);
});
it('Find or create a class by name, with a submodule but without a module ', function () {
var classObject;
// Look for the submodule in all modules. if found, create the class.
classObject = assembler.getClass('myClass', null, 'mySubmodule');
expect(classObject).not.to.exist;
// Create the submodule and rty again.
assembler.getSubmodule('mySubmodule', 'myModule');
classObject = assembler.getClass('myClass', null, 'mySubmodule');
expect(classObject).to.exist;
// find a class if it exist
classObject = assembler.getClass('myClass', null, 'mySubmodule');
classObject.should.equal(tree.myModule._submodules.mySubmodule._classes.myClass);
});
it('Find or create a class by name, without a module or a submodule', function () {
var classObject;
// Look for the class in all modules and submodule. if found, return it.
classObject = assembler.getClass('myClass');
expect(classObject).to.exist;
// Since module and submodule were not found, we expect the class to be present under the tree._classes
expect(tree._classes.myClass).to.exist;
});
});
it('Full page test', function (done) {
var parsedComments = [];
fs.readFile('test/assemblerTestData.less', 'utf8', function (err, filecontent) {
var rawComments = parser.extractComments(filecontent),
i = rawComments.length;
while (i--) {
parsedComments.push(parser.parseComment(rawComments[i]));
}
tree = assembler.assemble(parsedComments);
tree = assembler.treeToArray(tree);
expect(tree).to.exist;
expect(tree).to.have.property('modules');
expect(tree).to.have.property('classes');
expect(tree.modules[0]).to.have.property('submodules');
expect(tree.modules[0]).to.have.property('classes');
clearTree();
done();
});
});
});
}());