FilesExpand file tree

 main

/

function-rule.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

53 lines (46 loc) · 1.86 KB

 main

/

function-rule.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

53 lines (46 loc) · 1.86 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

import { Commit, RuleOutcome } from '@commitlint/types';

import functionRule from './function-rule';

import sinon from 'sinon';

import test from 'ava';

test('calls an implementation fuction once', (t) => {

const implementation = sinon.fake();

functionRule({} as Commit, 'always', implementation);

t.true(implementation.calledOnce);

});

test('passes arguments to an implementation function', (t) => {

const implementation = sinon.fake();

const commit = { type: 'test' };

functionRule(commit as Commit, 'always', implementation);

t.deepEqual(implementation.firstCall.args, [commit, 'always']);

});

test('defaults rule condition to "always"', (t) => {

const implementation = sinon.fake();

functionRule({} as Commit, undefined, implementation);

t.deepEqual(implementation.firstCall.args, [{}, 'always']);

});

test('returns a value from an implementation function', (t) => {

const ruleOutcome: RuleOutcome = [true, t.title];

const implementation = sinon.fake(() => ruleOutcome);

const returnValue = functionRule({} as Commit, 'always', implementation);

t.deepEqual(returnValue, ruleOutcome);

});

test('returns successful for an undefined implementation', (t) => {

const returnValue = functionRule({} as Commit, 'always', undefined);

t.deepEqual(returnValue, [true]);

});

test('returns a value from an async implementation function', async (t) => {

const ruleOutcome: RuleOutcome = [true, t.title];

const implementation = sinon.fake(async () => ruleOutcome);

const returnValue = await functionRule(

{} as Commit,

'always',

implementation,

);

t.deepEqual(returnValue, ruleOutcome);

});

test('throws an error when an implementation is not a function', (t) => {

t.throws(() => {

// @ts-expect-error: TS2345: Argument of type ... is not assignable to parameter of type ...

functionRule({} as Commit, 'always', 'not a function!');

});

});