1 | import {assert} from 'chai';
|
2 |
|
3 | import OrderedElements from '../src/ordered-elements';
|
4 |
|
5 | describe('OrderedElements', () => {
|
6 | it('can identify elements it has', () => {
|
7 | const elems = new OrderedElements();
|
8 |
|
9 | elems.set('a', 1);
|
10 | assert.equal(elems.has('a'), true);
|
11 | });
|
12 |
|
13 | it('can identify elements it does not have', () => {
|
14 | const elems = new OrderedElements();
|
15 |
|
16 | elems.set('a', 1);
|
17 | assert.equal(elems.has('b'), false);
|
18 | });
|
19 |
|
20 | it('can get elements it has', () => {
|
21 | const elems = new OrderedElements();
|
22 |
|
23 | elems.set('a', 1);
|
24 | assert.equal(elems.get('a'), 1);
|
25 | });
|
26 |
|
27 | it('adds new elements in order', () => {
|
28 | const elems = new OrderedElements();
|
29 |
|
30 | elems.set('a', 1);
|
31 | elems.set('b', 2);
|
32 |
|
33 | assert.deepEqual({
|
34 | elements: {
|
35 | a: 1,
|
36 | b: 2,
|
37 | },
|
38 | keyOrder: ['a', 'b'],
|
39 | }, elems);
|
40 | });
|
41 |
|
42 | it("overrides old elements but doesn't add to the key ordering", () => {
|
43 | const elems = new OrderedElements();
|
44 |
|
45 | elems.set('a', 1);
|
46 | elems.set('a', 2);
|
47 |
|
48 | assert.deepEqual({
|
49 | elements: {
|
50 | a: 2,
|
51 | },
|
52 | keyOrder: ['a'],
|
53 | }, elems);
|
54 | });
|
55 |
|
56 | it('preserves original order when overriding', () => {
|
57 | const elems = new OrderedElements();
|
58 |
|
59 | elems.set('a', 1);
|
60 | elems.set('b', 1);
|
61 | elems.set('a', 2);
|
62 |
|
63 | assert.deepEqual({
|
64 | elements: {
|
65 | a: 2,
|
66 | b: 1,
|
67 | },
|
68 | keyOrder: ['a', 'b'],
|
69 | }, elems);
|
70 | });
|
71 |
|
72 | it('can reorder when overriding', () => {
|
73 | const elems = new OrderedElements();
|
74 |
|
75 | elems.set('a', 1);
|
76 | elems.set('b', 1);
|
77 | elems.set('a', 2, true);
|
78 |
|
79 | assert.deepEqual({
|
80 | elements: {
|
81 | b: 1,
|
82 | a: 2,
|
83 | },
|
84 | keyOrder: ['b', 'a'],
|
85 | }, elems);
|
86 | });
|
87 |
|
88 | it('iterates over the elements in the correct order', () => {
|
89 | const elems = new OrderedElements();
|
90 |
|
91 | elems.set('a', 1);
|
92 | elems.set('b', 2);
|
93 | elems.set('c', 3);
|
94 |
|
95 | const order = [];
|
96 |
|
97 | elems.forEach((value, key) => {
|
98 | order.push([key, value]);
|
99 | });
|
100 |
|
101 | assert.deepEqual([
|
102 | ['a', 1],
|
103 | ['b', 2],
|
104 | ['c', 3],
|
105 | ], order);
|
106 | });
|
107 |
|
108 | it('works with nested Maps', () => {
|
109 | const elems = new OrderedElements();
|
110 | elems.set('a', 1);
|
111 | elems.set('b', new Map([['ba', 1], ['bb', 2]]));
|
112 | elems.set('c', 3);
|
113 |
|
114 | elems.set('b', new Map([['ba', 3]]));
|
115 |
|
116 | assert.deepEqual({
|
117 | elements: {
|
118 | a: 1,
|
119 | b: {
|
120 | elements: {
|
121 | ba: 3,
|
122 | bb: 2,
|
123 | },
|
124 | keyOrder: ['ba', 'bb'],
|
125 | },
|
126 | c: 3,
|
127 | },
|
128 | keyOrder: ['a', 'b', 'c'],
|
129 | }, elems);
|
130 | });
|
131 | });
|