1 |
|
2 | 'use strict';
|
3 |
|
4 | var assert = require('chai').assert,
|
5 | UTIL = require('util'),
|
6 | BEM = require('..'),
|
7 | PATH = BEM.require('./path'),
|
8 | createLevel = BEM.createLevel;
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 | describe('level', function() {
|
22 |
|
23 | describe("Level('data/level1') /* generic level */", function() {
|
24 |
|
25 | var level = createLevel(absolute('data/level1'));
|
26 |
|
27 | describe(".getDefaultTechs()", function() {
|
28 | it("returns empty array", function() {
|
29 | var defs = level.getDefaultTechs();
|
30 | assert.isArray(defs);
|
31 | assert.lengthOf(defs, 0);
|
32 | });
|
33 | });
|
34 |
|
35 | |
36 |
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 |
|
45 |
|
46 |
|
47 |
|
48 |
|
49 |
|
50 |
|
51 |
|
52 |
|
53 | describe(".getByObj()", function() {
|
54 | it("block, elem, mod, val", function() {
|
55 | var item = {
|
56 | block: 'block',
|
57 | elem: 'elem',
|
58 | mod: 'mod',
|
59 | val: 'val'
|
60 | };
|
61 | assert.equal(level.getByObj(item), PATH.resolve(level.dir, 'block/__elem/_mod/block__elem_mod_val'));
|
62 | });
|
63 | });
|
64 |
|
65 | describe(".getRelByObj()", function() {
|
66 | it("block, elem, mod, val", function() {
|
67 | var item = {
|
68 | block: 'block',
|
69 | elem: 'elem',
|
70 | mod: 'mod',
|
71 | val: 'val'
|
72 | };
|
73 | assert.equal(level.getRelByObj(item), 'block/__elem/_mod/block__elem_mod_val');
|
74 | });
|
75 | });
|
76 |
|
77 | describe(".getPath()", function() {
|
78 | it("block/block, css", function() {
|
79 | assert.equal(level.getPath('block/block', 'css'), 'block/block.css');
|
80 | });
|
81 | });
|
82 |
|
83 | describe(".getPathByObj()", function() {
|
84 | it("block: block", function() {
|
85 | assert.equal(level.getPathByObj({ block: 'block' }, 'css'), PATH.resolve(level.dir, 'block/block.css'));
|
86 | });
|
87 | });
|
88 |
|
89 | describe(".getRelPathByObj()", function() {
|
90 | it("block: block", function() {
|
91 | assert.equal(level.getRelPathByObj({ block: 'block' }, 'css'), 'block/block.css');
|
92 | });
|
93 | });
|
94 |
|
95 | describe(".matchAny()", function() {
|
96 |
|
97 | var abs = PATH.resolve(level.dir, 'block/block.css');
|
98 | it(abs, function() {
|
99 | assert.deepEqual(level.matchAny(abs), {
|
100 | block: 'block',
|
101 | suffix: '.css',
|
102 | tech: 'css'
|
103 | });
|
104 | });
|
105 |
|
106 | it('block/block.css', function() {
|
107 | assert.deepEqual(level.matchAny('block/block.css'), {
|
108 | block: 'block',
|
109 | suffix: '.css',
|
110 | tech: 'css'
|
111 | });
|
112 | });
|
113 |
|
114 | it('block/_mod/block_mod.css', function() {
|
115 | assert.deepEqual(level.matchAny('block/_mod/block_mod.css'), {
|
116 | block: 'block',
|
117 | mod: 'mod',
|
118 | suffix: '.css',
|
119 | tech: 'css'
|
120 | });
|
121 | });
|
122 |
|
123 | it('block/_mod/block_mod_val.css', function() {
|
124 | assert.deepEqual(level.matchAny('block/_mod/block_mod_val.css'), {
|
125 | block: 'block',
|
126 | mod: 'mod',
|
127 | val: 'val',
|
128 | suffix: '.css',
|
129 | tech: 'css'
|
130 | });
|
131 | });
|
132 |
|
133 | it('block/__elem/block__elem.css', function() {
|
134 | assert.deepEqual(level.matchAny('block/__elem/block__elem.css'), {
|
135 | block: 'block',
|
136 | elem: 'elem',
|
137 | suffix: '.css',
|
138 | tech: 'css'
|
139 | });
|
140 | });
|
141 |
|
142 | it('block/__elem/_mod/block__elem_mod.css', function() {
|
143 | assert.deepEqual(level.matchAny('block/__elem/_mod/block__elem_mod.css'), {
|
144 | block: 'block',
|
145 | elem: 'elem',
|
146 | mod: 'mod',
|
147 | suffix: '.css',
|
148 | tech: 'css'
|
149 | });
|
150 | });
|
151 |
|
152 | it('block/__elem/_mod/block__elem_mod_val.css', function() {
|
153 | assert.deepEqual(level.matchAny('block/__elem/_mod/block__elem_mod_val.css'), {
|
154 | block: 'block',
|
155 | elem: 'elem',
|
156 | mod: 'mod',
|
157 | val: 'val',
|
158 | suffix: '.css',
|
159 | tech: 'css'
|
160 | });
|
161 | });
|
162 |
|
163 | it('block/__elem/_mod/block__elem_mod_val.custom', function() {
|
164 | assert.deepEqual(level.matchAny('block/__elem/_mod/block__elem_mod_val.custom'), {
|
165 | block: 'block',
|
166 | elem: 'elem',
|
167 | mod: 'mod',
|
168 | val: 'val',
|
169 | suffix: '.custom',
|
170 | tech: undefined
|
171 | });
|
172 | });
|
173 |
|
174 | });
|
175 |
|
176 | describe(".getDeclByIntrospection()", function() {
|
177 | it("returns correct introspection", function() {
|
178 | assert.deepEqual(level.getDeclByIntrospection(), [ {
|
179 | name: 'first-block',
|
180 | elems: [ {
|
181 | name: 'elem1',
|
182 | mods: [ {
|
183 | name: 'mod2',
|
184 | techs: [ { name: 'css' } ],
|
185 | vals: [ {
|
186 | name: '3',
|
187 | techs: [ { name: 'js' } ]
|
188 | } ]
|
189 | } ]
|
190 | } ]
|
191 | } ]);
|
192 | });
|
193 | });
|
194 |
|
195 | describe(".createIntrospector() default introspector call", function() {
|
196 | it("returns correct introspection", function() {
|
197 | assert.deepEqual(level.createIntrospector()().sort(function(a, b) {
|
198 | if (a.tech < b.tech) return -1;
|
199 | if (a.tech > b.tech) return 1;
|
200 | return 0;
|
201 | }), [
|
202 | {
|
203 | block: 'first-block',
|
204 | elem: 'elem1',
|
205 | mod: 'mod2',
|
206 | suffix: '.css',
|
207 | tech: 'css'
|
208 | },
|
209 | {
|
210 | block: 'first-block',
|
211 | elem: 'elem1',
|
212 | mod: 'mod2',
|
213 | val: '3',
|
214 | suffix: '.js',
|
215 | tech: 'js'
|
216 | }
|
217 | ]);
|
218 | });
|
219 | });
|
220 |
|
221 | describe(".match-*()", function() {
|
222 | level.matchOrder().forEach(function(matcher) {
|
223 |
|
224 | if (matcher === 'block-all' || matcher === 'elem-all') return;
|
225 |
|
226 | var args = matcher.split('-'),
|
227 | match;
|
228 | if(args[0] !== 'block') args.unshift('block');
|
229 | match = level.match(matcher, level.getRel(matcher, args));
|
230 |
|
231 | it(UTIL.format("matcher '%s' complies to getter", matcher), function() {
|
232 | Object.keys(match).forEach(function(key) {
|
233 | assert.isString(match[key]);
|
234 | if(key === 'suffix') {
|
235 | assert.equal(match[key], '');
|
236 | return;
|
237 | }
|
238 | assert.equal(match[key], key);
|
239 | });
|
240 | });
|
241 |
|
242 | });
|
243 |
|
244 | });
|
245 |
|
246 | describe(".match-*-all()", function() {
|
247 |
|
248 | var blockData = ['elem',
|
249 | 'elem-mod',
|
250 | 'elem-mod-val',
|
251 | '',
|
252 | 'block',
|
253 | 'block-mod',
|
254 | 'block-mod-val'],
|
255 | matcher = 'elem-all';
|
256 |
|
257 | blockData.forEach(function(block) {
|
258 | if (block === '') {
|
259 | matcher = 'block-all';
|
260 | return;
|
261 | }
|
262 |
|
263 | var args = block.split('-');
|
264 | if (args[0] !== 'block') args.unshift('block');
|
265 |
|
266 | var match = level.match(matcher, level['get-' + block].apply(this, args));
|
267 |
|
268 | it(UTIL.format("matcher '%s' complies to getter with %s data", matcher, block), testMatch(match));
|
269 |
|
270 | }, this);
|
271 |
|
272 |
|
273 | function testMatch(match, vars) {
|
274 |
|
275 | vars = vars || {};
|
276 |
|
277 | return function() {
|
278 | Object.keys(match).forEach(function(key) {
|
279 | assert.isString(match[key]);
|
280 | if(key === 'suffix') {
|
281 | assert.equal(match[key], '');
|
282 | return;
|
283 | }
|
284 | assert.equal(match[key], vars[key] || key);
|
285 | });
|
286 | };
|
287 |
|
288 | }
|
289 |
|
290 | });
|
291 |
|
292 | });
|
293 |
|
294 | });
|
295 |
|
296 | function absolute(path) {
|
297 | return PATH.resolve(__dirname, path);
|
298 | }
|