1 | import test from 'ava';
|
2 | import execa from 'execa';
|
3 | import {fix} from '@commitlint/test';
|
4 | import * as sander from '@marionebl/sander';
|
5 | import resolveExtends from '.';
|
6 |
|
7 | const id = id => id;
|
8 |
|
9 | test('returns empty object when called without params', t => {
|
10 | const actual = resolveExtends();
|
11 | t.deepEqual(actual, {});
|
12 | });
|
13 |
|
14 | test('returns an equivalent object as passed in', t => {
|
15 | const expected = {foo: 'bar'};
|
16 | const actual = resolveExtends(expected);
|
17 | t.deepEqual(actual, expected);
|
18 | });
|
19 |
|
20 | test.serial('falls back to global install', async t => {
|
21 | const prev = process.env.PREFIX;
|
22 |
|
23 | const cwd = await fix.bootstrap('fixtures/global-install');
|
24 | const prefix = `${cwd}/commitlint-npm-packages`;
|
25 |
|
26 | const npm = args => execa('npm', args, {cwd});
|
27 |
|
28 | await sander.mkdir(cwd, 'commitlint-npm-packages');
|
29 |
|
30 | process.env.PREFIX = prefix;
|
31 |
|
32 | await npm([
|
33 | 'install',
|
34 | '--global',
|
35 | '@commitlint/config-angular',
|
36 | '--prefix',
|
37 | prefix
|
38 | ]);
|
39 |
|
40 | const expected = {extends: ['@commitlint/config-angular']};
|
41 | t.notThrows(() => resolveExtends(expected));
|
42 |
|
43 | process.env.PREFIX = prev;
|
44 | });
|
45 |
|
46 | test.serial('fails for missing extends', async t => {
|
47 | const prev = process.env.PREFIX;
|
48 |
|
49 | const cwd = await fix.bootstrap('fixtures/missing-install');
|
50 | const prefix = `${cwd}/commitlint-npm-packages`;
|
51 |
|
52 | process.env.PREFIX = prefix;
|
53 |
|
54 | const input = {extends: ['@commitlint/foo-bar']};
|
55 |
|
56 | t.throws(
|
57 | () => resolveExtends(input, {cwd}),
|
58 | /Cannot find module "@commitlint\/foo-bar" from/
|
59 | );
|
60 |
|
61 | process.env.PREFIX = prev;
|
62 | });
|
63 |
|
64 | test('uses empty prefix by default', t => {
|
65 | const input = {extends: ['extender-name']};
|
66 |
|
67 | resolveExtends(input, {
|
68 | resolve: id,
|
69 | require(id) {
|
70 | t.is(id, 'extender-name');
|
71 | }
|
72 | });
|
73 | });
|
74 |
|
75 | test('uses prefix as configured', t => {
|
76 | const input = {extends: ['extender-name']};
|
77 |
|
78 | resolveExtends(input, {
|
79 | prefix: 'prefix',
|
80 | resolve: id,
|
81 | require(id) {
|
82 | t.is(id, 'prefix-extender-name');
|
83 | }
|
84 | });
|
85 | });
|
86 |
|
87 | test('ignores prefix for scoped extends', t => {
|
88 | const input = {extends: ['@scope/extender-name']};
|
89 |
|
90 | resolveExtends(input, {
|
91 | prefix: 'prefix',
|
92 | resolve: id,
|
93 | require(id) {
|
94 | t.is(id, '@scope/extender-name');
|
95 | }
|
96 | });
|
97 | });
|
98 |
|
99 | test('ignores prefix for relative extends', t => {
|
100 | const input = {extends: ['./extender']};
|
101 |
|
102 | resolveExtends(input, {
|
103 | prefix: 'prefix',
|
104 | resolve: id,
|
105 | require(id) {
|
106 | t.is(id, './extender');
|
107 | }
|
108 | });
|
109 | });
|
110 |
|
111 | test('propagates return value of require function', t => {
|
112 | const input = {extends: ['extender-name']};
|
113 | const propagated = {foo: 'bar'};
|
114 |
|
115 | const actual = resolveExtends(input, {
|
116 | resolve: id,
|
117 | require() {
|
118 | return propagated;
|
119 | }
|
120 | });
|
121 |
|
122 | t.is(actual.foo, 'bar');
|
123 | });
|
124 |
|
125 | test('resolves extends recursively', t => {
|
126 | const input = {extends: ['extender-name']};
|
127 | const actual = [];
|
128 |
|
129 | resolveExtends(input, {
|
130 | resolve: id,
|
131 | require(id) {
|
132 | actual.push(id);
|
133 | if (id === 'extender-name') {
|
134 | return {extends: ['recursive-extender-name']};
|
135 | }
|
136 | if (id === 'recursive-extender-name') {
|
137 | return {foo: 'bar'};
|
138 | }
|
139 | }
|
140 | });
|
141 |
|
142 | t.deepEqual(actual, ['extender-name', 'recursive-extender-name']);
|
143 | });
|
144 |
|
145 | test('uses prefix key recursively', t => {
|
146 | const input = {extends: ['extender-name']};
|
147 | const actual = [];
|
148 |
|
149 | resolveExtends(input, {
|
150 | prefix: 'prefix',
|
151 | resolve: id,
|
152 | require(id) {
|
153 | actual.push(id);
|
154 | if (id === 'prefix-extender-name') {
|
155 | return {extends: ['recursive-extender-name']};
|
156 | }
|
157 | if (id === 'prefix-recursive-extender-name') {
|
158 | return {foo: 'bar'};
|
159 | }
|
160 | }
|
161 | });
|
162 |
|
163 | t.deepEqual(actual, [
|
164 | 'prefix-extender-name',
|
165 | 'prefix-recursive-extender-name'
|
166 | ]);
|
167 | });
|
168 |
|
169 | test('propagates contents recursively', t => {
|
170 | const input = {extends: ['extender-name']};
|
171 |
|
172 | const actual = resolveExtends(input, {
|
173 | resolve: id,
|
174 | require(id) {
|
175 | if (id === 'extender-name') {
|
176 | return {extends: ['recursive-extender-name'], foo: 'bar'};
|
177 | }
|
178 | if (id === 'recursive-extender-name') {
|
179 | return {baz: 'bar'};
|
180 | }
|
181 | }
|
182 | });
|
183 |
|
184 | const expected = {
|
185 | extends: ['extender-name'],
|
186 | foo: 'bar',
|
187 | baz: 'bar'
|
188 | };
|
189 |
|
190 | t.deepEqual(actual, expected);
|
191 | });
|
192 |
|
193 | test('extending contents should take precedence', t => {
|
194 | const input = {extends: ['extender-name'], zero: 'root'};
|
195 |
|
196 | const actual = resolveExtends(input, {
|
197 | resolve: id,
|
198 | require(id) {
|
199 | if (id === 'extender-name') {
|
200 | return {extends: ['recursive-extender-name'], zero: id, one: id};
|
201 | }
|
202 | if (id === 'recursive-extender-name') {
|
203 | return {
|
204 | extends: ['second-recursive-extender-name'],
|
205 | zero: id,
|
206 | one: id,
|
207 | two: id
|
208 | };
|
209 | }
|
210 | if (id === 'second-recursive-extender-name') {
|
211 | return {zero: id, one: id, two: id, three: id};
|
212 | }
|
213 | }
|
214 | });
|
215 |
|
216 | const expected = {
|
217 | extends: ['extender-name'],
|
218 | zero: 'root',
|
219 | one: 'extender-name',
|
220 | two: 'recursive-extender-name',
|
221 | three: 'second-recursive-extender-name'
|
222 | };
|
223 |
|
224 | t.deepEqual(actual, expected);
|
225 | });
|
226 |
|
227 | test('should fall back to conventional-changelog-lint-config prefix', t => {
|
228 | const input = {extends: ['extender-name']};
|
229 |
|
230 | const actual = resolveExtends(input, {
|
231 | prefix: 'prefix',
|
232 | resolve(id) {
|
233 | if (id === 'conventional-changelog-lint-config-extender-name') {
|
234 | return 'conventional-changelog-lint-config-extender-name';
|
235 | }
|
236 | throw new Error(`Could not find module "*${id}"`);
|
237 | },
|
238 | require(id) {
|
239 | if (id === 'conventional-changelog-lint-config-extender-name') {
|
240 | return {
|
241 | rules: {
|
242 | fallback: true
|
243 | }
|
244 | };
|
245 | }
|
246 | }
|
247 | });
|
248 |
|
249 | t.deepEqual(actual, {
|
250 | extends: ['extender-name'],
|
251 | rules: {
|
252 | fallback: true
|
253 | }
|
254 | });
|
255 | });
|