Skip to content
This repository was archived by the owner on Feb 4, 2018. It is now read-only.

Commit 942e0d3

Browse files
author
blond
committed
test(refactor)
* got rid of the extra methods * use full names for block, elem, mod fields * use `entityName` instead `entity` * update case titles
1 parent f66e347 commit 942e0d3

11 files changed

+124
-125
lines changed

‎test/bem-fields.test.js‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -3,55 +3,55 @@ import test from 'ava';
33
import BemEntityName from '../index';
44

55
test('should provide `block` field', t => {
6-
const entity = new BemEntityName({ block: 'block' });
6+
const entityName = new BemEntityName({ block: 'block' });
77

8-
t.is(entity.block, 'block');
8+
t.is(entityName.block, 'block');
99
});
1010

1111
test('should provide `elem` field', t => {
12-
const entity = new BemEntityName({ block: 'block', elem: 'elem' });
12+
const entityName = new BemEntityName({ block: 'block', elem: 'elem' });
1313

14-
t.is(entity.elem, 'elem');
14+
t.is(entityName.elem, 'elem');
1515
});
1616

1717
test('should provide `mod` field', t => {
18-
const entity = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
18+
const entityName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
1919

20-
t.deepEqual(entity.mod, { name: 'mod', val: 'val' });
20+
t.deepEqual(entityName.mod, { name: 'mod', val: 'val' });
2121
});
2222

2323
test('should provide `modName` field', t => {
24-
const entity = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
24+
const entityName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
2525

26-
t.is(entity.modName, 'mod');
26+
t.is(entityName.modName, 'mod');
2727
});
2828

2929
test('should provide `modVal` field', t => {
30-
const entity = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
30+
const entityName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
3131

32-
t.is(entity.modVal, 'val');
32+
t.is(entityName.modVal, 'val');
3333
});
3434

3535
test('should return `undefined` if entity is not element', t => {
36-
const entity = new BemEntityName({ block: 'block' });
36+
const entityName = new BemEntityName({ block: 'block' });
3737

38-
t.is(entity.elem, undefined);
38+
t.is(entityName.elem, undefined);
3939
});
4040

4141
test('should return `undefined` if entity is not modifier', t => {
42-
const entity = new BemEntityName({ block: 'block' });
42+
const entityName = new BemEntityName({ block: 'block' });
4343

44-
t.deepEqual(entity.mod, undefined);
44+
t.deepEqual(entityName.mod, undefined);
4545
});
4646

4747
test('should return `undefined` in `modName` property if entity is not modifier', t => {
48-
const entity = new BemEntityName({ block: 'block' });
48+
const entityName = new BemEntityName({ block: 'block' });
4949

50-
t.is(entity.modName, undefined);
50+
t.is(entityName.modName, undefined);
5151
});
5252

5353
test('should return `undefined` in `modVal` property if entity is not modifier', t => {
54-
const entity = new BemEntityName({ block: 'block' });
54+
const entityName = new BemEntityName({ block: 'block' });
5555

56-
t.is(entity.modVal, undefined);
56+
t.is(entityName.modVal, undefined);
5757
});

‎test/constructor/constructor.test.js‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -3,25 +3,29 @@ import test from 'ava';
33
import BemEntityName from '../../index';
44

55
test('should create block', t => {
6-
const data = { block: 'block' };
6+
const obj = { block: 'block' };
7+
const entityName = new BemEntityName(obj);
78

8-
t.deepEqual((new BemEntityName(data)).valueOf(), data);
9+
t.deepEqual((entityName).valueOf(), obj);
910
});
1011

1112
test('should create modifier of block', t => {
12-
const data = { block: 'block', mod: { name: 'mod', val: 'val' } };
13+
const obj = { block: 'block', mod: { name: 'mod', val: 'val' } };
14+
const entityName = new BemEntityName(obj);
1315

14-
t.deepEqual((new BemEntityName(data)).valueOf(), data);
16+
t.deepEqual((entityName).valueOf(), obj);
1517
});
1618

1719
test('should create element', t => {
18-
const data = { block: 'block', elem: 'elem' };
20+
const obj = { block: 'block', elem: 'elem' };
21+
const entityName = new BemEntityName(obj);
1922

20-
t.deepEqual((new BemEntityName(data)).valueOf(), data);
23+
t.deepEqual((entityName).valueOf(), obj);
2124
});
2225

2326
test('should create modifier of element', t => {
24-
const data = { block: 'block', elem: 'elem', mod: { name: 'mod', val: 'val' } };
27+
const obj = { block: 'block', elem: 'elem', mod: { name: 'mod', val: 'val' } };
28+
const entityName = new BemEntityName(obj);
2529

26-
t.deepEqual((new BemEntityName(data)).valueOf(), data);
30+
t.deepEqual((entityName).valueOf(), obj);
2731
});

‎test/create.test.js‎

Lines changed: 38 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -3,86 +3,86 @@ import test from 'ava';
33
import BemEntityName from '../index';
44

55
test('should return object as is if it`s a BemEntityName', t => {
6-
const entity = new BemEntityName({ block: 'b' });
6+
const entityName = new BemEntityName({ block: 'block' });
77

8-
t.is(BemEntityName.create(entity), entity);
8+
t.is(BemEntityName.create(entityName), entityName);
99
});
1010

11-
test('should create BemEntityName for block from obj', t => {
12-
const entity = BemEntityName.create({ block: 'b' });
11+
test('should create block from object', t => {
12+
const entityName = BemEntityName.create({ block: 'block' });
1313

14-
t.pass(entity instanceof BemEntityName, 'Should be an instance of BemEntityName');
15-
t.deepEqual(entity.valueOf(), { block: 'b' }, 'Should contain a name for same entity');
14+
t.pass(entityName instanceof BemEntityName, 'Should be an instance of BemEntityName');
15+
t.deepEqual(entityName.valueOf(), { block: 'block' }, 'Should contain a name for same entity');
1616
});
1717

18-
test('should create entity for elem from obj', t => {
19-
const entity = BemEntityName.create({ block: 'b', elem: 'e' });
18+
test('should create block by a string', t => {
19+
const entityName = BemEntityName.create('block');
2020

21-
t.deepEqual(entity.valueOf(), { block: 'b', elem: 'e' });
21+
t.deepEqual(entityName.valueOf(), { block: 'block' });
2222
});
2323

24-
test('should create entity from obj with deps mods without value', t => {
25-
const entity = BemEntityName.create({ block: 'b', mod: 'm' });
24+
test('should create element from object', t => {
25+
const entityName = BemEntityName.create({ block: 'block', elem: 'elem' });
2626

27-
t.deepEqual(entity.valueOf(), { block: 'b', mod: { name: 'm', val: true } });
27+
t.deepEqual(entityName.valueOf(), { block: 'block', elem: 'elem' });
2828
});
2929

30-
test('should create entity from obj with deps mods', t => {
31-
const entity = BemEntityName.create({ block: 'b', mod: 'm', val: 'v' });
30+
test('should create simple modifier of block from object', t => {
31+
const entityName = BemEntityName.create({ block: 'block', mod: 'mod' });
3232

33-
t.deepEqual(entity.valueOf(), { block: 'b', mod: { name: 'm', val: 'v' } });
33+
t.deepEqual(entityName.valueOf(), { block: 'block', mod: { name: 'mod', val: true } });
34+
});
35+
36+
test('should create modifier of block from object', t => {
37+
const entityName = BemEntityName.create({ block: 'block', mod: 'mod', val: 'val' });
38+
39+
t.deepEqual(entityName.valueOf(), { block: 'block', mod: { name: 'mod', val: 'val' } });
3440
});
3541

3642
test('should normalize boolean modifier', t => {
37-
const entity = BemEntityName.create({ block: 'block', mod: { name: 'mod' } });
43+
const entityName = BemEntityName.create({ block: 'block', mod: { name: 'mod' } });
3844

39-
t.true(entity.mod.val);
45+
t.true(entityName.mod.val);
4046
});
4147

42-
test('should normalize short entry for boolean modifier', t => {
43-
const entity = BemEntityName.create({ block: 'block', mod: 'mod' });
48+
test('should save normalized boolean modifier', t => {
49+
const entityName = BemEntityName.create({ block: 'block', mod: { name: 'mod' } });
4450

45-
t.true(entity.mod.val);
51+
t.true(entityName.mod.val);
4652
});
4753

4854
test('should support `modName` and `modVal` fields', t => {
49-
const entity = BemEntityName.create({ block: 'block', modName: 'mod', modVal: 'val' });
55+
const entityName = BemEntityName.create({ block: 'block', modName: 'mod', modVal: 'val' });
5056

51-
t.deepEqual(entity.mod, { name: 'mod', val: 'val' });
57+
t.deepEqual(entityName.mod, { name: 'mod', val: 'val' });
5258
});
5359

5460
test('should support `modName` field only', t => {
55-
const entity = BemEntityName.create({ block: 'block', modName: 'mod' });
61+
const entityName = BemEntityName.create({ block: 'block', modName: 'mod' });
5662

57-
t.deepEqual(entity.mod, { name: 'mod', val: true });
63+
t.deepEqual(entityName.mod, { name: 'mod', val: true });
5864
});
5965

6066
test('should use `mod.name` field instead of `modName`', t => {
61-
const entity = BemEntityName.create({ block: 'block', mod: { name: 'mod1' }, modName: 'mod2' });
67+
const entityName = BemEntityName.create({ block: 'block', mod: { name: 'mod1' }, modName: 'mod2' });
6268

63-
t.is(entity.mod.name, 'mod1');
69+
t.is(entityName.mod.name, 'mod1');
6470
});
6571

6672
test('should use `mod.val` field instead of `modVal`', t => {
67-
const entity = BemEntityName.create({ block: 'block', mod: { name: 'm', val: 'v1' }, modVal: 'v2' });
73+
const entityName = BemEntityName.create({ block: 'block', mod: { name: 'm', val: 'v1' }, modVal: 'v2' });
6874

69-
t.is(entity.mod.val, 'v1');
75+
t.is(entityName.mod.val, 'v1');
7076
});
7177

7278
test('should use `mod.name` and `mod.val` instead of `val`', t => {
73-
const entity = BemEntityName.create({ block: 'block', mod: { name: 'm', val: 'v1' }, val: 'v3'});
79+
const entityName = BemEntityName.create({ block: 'block', mod: { name: 'm', val: 'v1' }, val: 'v3'});
7480

75-
t.is(entity.mod.val, 'v1');
81+
t.is(entityName.mod.val, 'v1');
7682
});
7783

7884
test('should use `mod.name` and `mod.val` instead of `modVal` and `val`', t => {
79-
const entity = BemEntityName.create({ block: 'block', mod: { name: 'm', val: 'v1' }, modVal: 'v2', val: 'v3'});
80-
81-
t.is(entity.mod.val, 'v1');
82-
});
83-
84-
test('should create block entity by a string', t => {
85-
const entity = BemEntityName.create('my-block');
85+
const entityName = BemEntityName.create({ block: 'block', mod: { name: 'm', val: 'v1' }, modVal: 'v2', val: 'v3'});
8686

87-
t.deepEqual(entity.valueOf(), { block: 'my-block' });
87+
t.is(entityName.mod.val, 'v1');
8888
});

‎test/id.test.js‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -5,17 +5,17 @@ const proxyquire = require('proxyquire');
55
import BemEntityName from '../index';
66

77
test('should build equal id for equal blocks', t => {
8-
const entity1 = new BemEntityName({ block: 'block' });
9-
const entity2 = new BemEntityName({ block: 'block' });
8+
const entityName1 = new BemEntityName({ block: 'block' });
9+
const entityName2 = new BemEntityName({ block: 'block' });
1010

11-
t.is(entity1.id, entity2.id);
11+
t.is(entityName1.id, entityName2.id);
1212
});
1313

1414
test('should build not equal id for not equal blocks', t => {
15-
const entity1 = new BemEntityName({ block: 'block1' });
16-
const entity2 = new BemEntityName({ block: 'block2' });
15+
const entityName1 = new BemEntityName({ block: 'block1' });
16+
const entityName2 = new BemEntityName({ block: 'block2' });
1717

18-
t.not(entity1.id, entity2.id);
18+
t.not(entityName1.id, entityName2.id);
1919
});
2020

2121
test('should cache id value', t => {
@@ -26,11 +26,11 @@ test('should cache id value', t => {
2626
}
2727
});
2828

29-
const entity = new StubBemEntityName({ block: 'block' });
29+
const entityName = new StubBemEntityName({ block: 'block' });
3030

3131
/*eslint no-unused-expressions: "off"*/
32-
entity.id;
33-
entity.id;
32+
entityName.id;
33+
entityName.id;
3434

3535
t.is(stub.callCount, 1);
3636
});

‎test/inspect.test.js‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -15,9 +15,9 @@ test.afterEach(t => {
1515

1616
test('should return entity object', t => {
1717
const obj = { block: 'block' };
18-
const entity = new BemEntityName(obj);
18+
const entityName = new BemEntityName(obj);
1919

20-
console.log(entity);
20+
console.log(entityName);
2121

2222
const message = `BemEntityName { block: 'block' }${EOL}`;
2323

‎test/is-bem-entity-name.test.js‎

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,10 +8,18 @@ test('should check valid entities', t => {
88
t.true(BemEntityName.isBemEntityName(entityName));
99
});
1010

11-
test('should not pass invalid blocks', t => {
11+
test('should not pass entity representation object', t => {
12+
t.falsy(BemEntityName.isBemEntityName({ block: 'block' }));
13+
});
14+
15+
test('should not pass invalid entity', t => {
1216
t.falsy(BemEntityName.isBemEntityName(new Array()));
1317
});
1418

1519
test('should not pass null', t => {
1620
t.falsy(BemEntityName.isBemEntityName(null));
1721
});
22+
23+
test('should not pass undefined', t => {
24+
t.falsy(BemEntityName.isBemEntityName(null));
25+
});

‎test/is-equal.test.js‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,15 +3,15 @@ import test from 'ava';
33
import BemEntityName from '../index';
44

55
test('should detect equal block', t => {
6-
const entity1 = new BemEntityName({ block: 'block' });
7-
const entity2 = new BemEntityName({ block: 'block' });
6+
const entityName1 = new BemEntityName({ block: 'block' });
7+
const entityName2 = new BemEntityName({ block: 'block' });
88

9-
t.true(entity1.isEqual(entity2));
9+
t.true(entityName1.isEqual(entityName2));
1010
});
1111

1212
test('should not detect another block', t => {
13-
const entity1 = new BemEntityName({ block: 'block1' });
14-
const entity2 = new BemEntityName({ block: 'block2' });
13+
const entityName1 = new BemEntityName({ block: 'block1' });
14+
const entityName2 = new BemEntityName({ block: 'block2' });
1515

16-
t.false(entity1.isEqual(entity2));
16+
t.false(entityName1.isEqual(entityName2));
1717
});

‎test/is-simple-mod.test.js‎

Lines changed: 10 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -3,43 +3,25 @@ import test from 'ava';
33
import BemEntityName from '../index';
44

55
test('should be true for simple modifiers', t => {
6-
const entity = BemEntityName.create({ block: 'button2', mod: { name: 'theme' } });
6+
const entityName = new BemEntityName({ block: 'block', mod: 'mod' });
77

8-
t.true(entity.isSimpleMod());
9-
});
10-
11-
test('should be true for tricky modifiers', t => {
12-
const entity = BemEntityName.create({ block: 'button2', mod: { name: 'theme', val: true } });
13-
14-
t.true(entity.isSimpleMod());
8+
t.true(entityName.isSimpleMod());
159
});
1610

1711
test('should be false for complex modifiers', t => {
18-
const entity = BemEntityName.create({ block: 'button2', mod: { name: 'theme', val: 'normal' } });
19-
20-
t.false(entity.isSimpleMod());
21-
});
22-
23-
test('should be false for crafty modifiers', t => {
24-
const entity = BemEntityName.create({ block: 'button2', mod: { name: 'theme', val: 42 } });
25-
26-
t.false(entity.isSimpleMod());
27-
});
28-
29-
test('should be false for sneaky modifiers', t => {
30-
const entity = BemEntityName.create({ block: 'button2', mod: { name: 'theme', val: false } });
12+
const entityName = new BemEntityName({ block: 'block', mod: { name: 'mod', val: 'val' } });
3113

32-
t.falsy(entity.isSimpleMod());
14+
t.false(entityName.isSimpleMod());
3315
});
3416

35-
test('should be false for block', t => {
36-
const entity = BemEntityName.create({ block: 'button2' });
17+
test('should be null for block', t => {
18+
const entityName = BemEntityName.create({ block: 'button2' });
3719

38-
t.falsy(entity.isSimpleMod());
20+
t.is(entityName.isSimpleMod(), null);
3921
});
4022

41-
test('should be false for elem', t => {
42-
const entity = BemEntityName.create({ block: 'button2', elem: 'text' });
23+
test('should be null for element', t => {
24+
const entityName = BemEntityName.create({ block: 'button2', elem: 'text' });
4325

44-
t.falsy(entity.isSimpleMod());
26+
t.is(entityName.isSimpleMod(), null);
4527
});

0 commit comments

Comments
 (0)