commitlint/@commitlint/cz-commitlint/src/utils/rules.test.ts at 9351b8e1f4e9fc1ff45e55dabcd2d887ac2a8070 · conventional-changelog/commitlint · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import {test, expect} from 'vitest';
import {RuleConfigSeverity} from '@commitlint/types';

import {
	enumRuleIsActive,
	getEnumList,
	getMaxLength,
	getMinLength,
	ruleIsActive,
	ruleIsApplicable,
	ruleIsDisabled,
	ruleIsNotApplicable,
} from './rules.js';

test('ruleIsDisabled', () => {
	expect(ruleIsDisabled([RuleConfigSeverity.Disabled])).toBe(true);
	expect(ruleIsDisabled([RuleConfigSeverity.Disabled, 'never'])).toBe(true);
	expect(ruleIsDisabled([RuleConfigSeverity.Disabled, 'always'])).toBe(true);
	expect(ruleIsDisabled([RuleConfigSeverity.Error] as any)).toBe(false);
	expect(ruleIsDisabled([RuleConfigSeverity.Error, 'always'] as any)).toBe(
		false
	);
});

test('ruleIsActive', () => {
	expect(ruleIsActive([RuleConfigSeverity.Error, 'always'])).toBe(true);
	expect(ruleIsActive([RuleConfigSeverity.Warning, 'never'])).toBe(true);
	expect(ruleIsActive([RuleConfigSeverity.Disabled, 'always'])).toBe(false);
	expect(ruleIsActive([RuleConfigSeverity.Error] as any)).toBe(true);
});

test('ruleIsApplicable', () => {
	expect(ruleIsApplicable([RuleConfigSeverity.Error, 'always'])).toBe(true);
	expect(ruleIsApplicable([RuleConfigSeverity.Warning, 'always'])).toBe(true);
	expect(ruleIsApplicable([RuleConfigSeverity.Disabled, 'always'])).toBe(true);
	expect(ruleIsApplicable(undefined as any)).toBe(false);
	expect(ruleIsApplicable('' as any)).toBe(false);
	expect(ruleIsApplicable([RuleConfigSeverity.Disabled])).toBe(false);
	expect(ruleIsApplicable([RuleConfigSeverity.Disabled, 'never'])).toBe(false);
});

test('ruleIsNotApplicable', () => {
	expect(ruleIsNotApplicable([RuleConfigSeverity.Error, 'never'])).toBe(true);
	expect(ruleIsNotApplicable([RuleConfigSeverity.Warning, 'never'])).toBe(true);
	expect(ruleIsNotApplicable([RuleConfigSeverity.Disabled, 'never'])).toBe(
		true
	);
	expect(ruleIsNotApplicable(undefined as any)).toBe(false);
	expect(ruleIsNotApplicable('' as any)).toBe(false);
	expect(ruleIsNotApplicable([RuleConfigSeverity.Error] as any)).toBe(false);
	expect(ruleIsNotApplicable([RuleConfigSeverity.Error, 'always'])).toBe(false);
	expect(ruleIsNotApplicable([RuleConfigSeverity.Error, 'always', 100])).toBe(
		false
	);
});

test('getMaxLength', () => {
	expect(getMaxLength([RuleConfigSeverity.Error, 'always', 100])).toBe(100);
	expect(getMaxLength([RuleConfigSeverity.Warning, 'never'])).toBe(Infinity);
	expect(getMaxLength([RuleConfigSeverity.Disabled, 'always'])).toBe(Infinity);
	expect(getMaxLength([RuleConfigSeverity.Error] as any)).toBe(Infinity);

	const rules: any = {
		'body-max-line-length': [RuleConfigSeverity.Error, 'always', 100],
		'header-max-length': [RuleConfigSeverity.Error, 'always', 100],
		'test-max-length': [RuleConfigSeverity.Disabled, 'always', 100],
	};
	let lengthRule = rules['header-max-length'];
	expect(getMaxLength(lengthRule)).toBe(100);

	lengthRule = rules['body-max-line-length'];
	expect(getMaxLength(lengthRule)).toBe(100);

	lengthRule = rules['body-max-length'];
	expect(getMaxLength(lengthRule)).toBe(Infinity);

	lengthRule = rules['test-max-length'];
	expect(getMaxLength(lengthRule)).toBe(Infinity);
});

test('getMinLength', () => {
	expect(getMinLength([RuleConfigSeverity.Error, 'always', 10])).toBe(10);
	expect(getMinLength([RuleConfigSeverity.Warning, 'never'])).toBe(0);
	expect(getMinLength([RuleConfigSeverity.Disabled, 'always'])).toBe(0);
	expect(getMinLength([RuleConfigSeverity.Error] as any)).toBe(0);

	const rules: any = {
		'body-min-length': [RuleConfigSeverity.Error, 'always', 10],
		'footer-min-length': [RuleConfigSeverity.Error, 'always', 20],
		'test-min-length': [RuleConfigSeverity.Disabled, 'always', 100],
	};
	let lengthRule = rules['header-min-length'];
	expect(getMinLength(lengthRule)).toBe(0);

	lengthRule = rules['body-min-length'];
	expect(getMinLength(lengthRule)).toBe(10);

	lengthRule = rules['test-min-length'];
	expect(getMinLength(lengthRule)).toBe(0);
});

test('enumRuleIsActive', () => {
	const rules: any = {
		'enum-string': [RuleConfigSeverity.Warning, 'always', ['1', '2', '3']],
		'type-enum': [RuleConfigSeverity.Error, 'always', ['build', 'chore', 'ci']],
		'scope-enum': [RuleConfigSeverity.Error, 'never', ['cli', 'core', 'lint']],
		'bar-enum': [RuleConfigSeverity.Disabled, 'always', ['foo', 'bar', 'baz']],
	};

	expect(enumRuleIsActive(rules['type-enum'])).toBe(true);
	expect(enumRuleIsActive(rules['string-enum'])).toBe(false);
	expect(enumRuleIsActive(rules['enum-string'])).toBe(true);
	expect(enumRuleIsActive(rules['bar-enum'])).toBe(false);
	expect(enumRuleIsActive(rules['scope-enum'])).toBe(false);
});

test('getEnumList', () => {
	const rules: any = {
		'type-enum': [RuleConfigSeverity.Error, 'always', ['build', 'chore', 'ci']],
		'scope-enum': [RuleConfigSeverity.Error, 'never', ''],
		'bar-enum': [RuleConfigSeverity.Disabled, 'always'],
	};

	expect(getEnumList(rules['type-enum'])).toEqual(['build', 'chore', 'ci']);
	expect(getEnumList(rules['scope-enum'])).toEqual([]);
	expect(getEnumList(rules['bar-enum'])).toEqual([]);
});