clerk: internal/linter/linter_test.go (992e56fdade7479fc6e552c869f4cfeb5187c357)

1

package linter

2

3

import (

4

	"strings"

5

	"testing"

6

7

	"olexsmir.xyz/clerk/internal/testutil/golden"

8

	"olexsmir.xyz/clerk/journal"

9

	"olexsmir.xyz/clerk/journal/semantic"

10

11

12

var tests = map[string][]Rule{

13

	"correct":                  Rules,

14

	"empty-postings":           {&EmptyPostings{}},

15

	"parse-error":              {&ParseError{}},

16

	"omitted-precision":        {&OmittedPrecision{}},

17

	"missing-commodity":        {&MissingCommodity{}},

18

	"missing-status":           {&MissingStatus{}},

19

	"account-depth":            {&AccountDepthLimit{MaxDepth: 3}},

20

	"multiple-omitted-amounts": {&MultipleOmittedAmounts{}},

21

	"orderdate":                {&OrderDate{}},

22

	"duplicated-account":       {&DuplicatedAccount{}},

23

	"duplicated-commodity":     {&DuplicatedCommodity{}},

24

	"undeclared-commodity":     {&UndeclaredCommodity{}},

25

	"undeclared-account":       {&UndeclaredAccount{}},

26

	"unbalanced-transaction":   {&UnbalancedTransaction{}},

27

28

29

func TestLinter(t *testing.T) {

30

	for tname, trules := range tests {

31

		t.Run(tname, func(t *testing.T) {

32

			inp := golden.Load(t, tname)

33

			pf, err := journal.NewLoader().LoadBytes(tname+".journal", inp)

34

			if err != nil {

35

				t.Fatalf("failed to load test journal: %v\n", err)

36

37

38

			ctx := semantic.Build([]*journal.ParsedFile{pf})

39

			finds := NewLinter(trules).Run(ctx)

40

41

			var b strings.Builder

42

			Fprint(&b, PathBasename, finds)

43

			golden.Assert(t, tname, b.String())

44

})

45

46

47

48

func BenchmarkLinter(b *testing.B) {

49

	ldr := journal.NewLoader()

50

	_, err := ldr.Load(

51

		"../../journal/testdata/journals/actual-1ktxns-100accts.journal",

52

53

	if err != nil {

54

		b.Fatalf("failed to load benchmark journal: %v", err)

55

56

57

	ctx := semantic.Build(ldr.Ordered())

58

	l := NewLinter(Rules)

59

60

	b.ResetTimer()

61

	b.ReportAllocs()

62

	for b.Loop() {

63

		l.Run(ctx)

64

65

1	package linter
2
3	import (
4	"strings"
5	"testing"
6
7	"olexsmir.xyz/clerk/internal/testutil/golden"
8	"olexsmir.xyz/clerk/journal"
9	"olexsmir.xyz/clerk/journal/semantic"
10	)
11
12	var tests = map[string][]Rule{
13	"correct": Rules,
14	"empty-postings": {&EmptyPostings{}},
15	"parse-error": {&ParseError{}},
16	"omitted-precision": {&OmittedPrecision{}},
17	"missing-commodity": {&MissingCommodity{}},
18	"missing-status": {&MissingStatus{}},
19	"account-depth": {&AccountDepthLimit{MaxDepth: 3}},
20	"multiple-omitted-amounts": {&MultipleOmittedAmounts{}},
21	"orderdate": {&OrderDate{}},
22	"duplicated-account": {&DuplicatedAccount{}},
23	"duplicated-commodity": {&DuplicatedCommodity{}},
24	"undeclared-commodity": {&UndeclaredCommodity{}},
25	"undeclared-account": {&UndeclaredAccount{}},
26	"unbalanced-transaction": {&UnbalancedTransaction{}},
27	}
28
29	func TestLinter(t *testing.T) {
30	for tname, trules := range tests {
31	t.Run(tname, func(t *testing.T) {
32	inp := golden.Load(t, tname)
33	pf, err := journal.NewLoader().LoadBytes(tname+".journal", inp)
34	if err != nil {
35	t.Fatalf("failed to load test journal: %v\n", err)
36	}
37
38	ctx := semantic.Build([]*journal.ParsedFile{pf})
39	finds := NewLinter(trules).Run(ctx)
40
41	var b strings.Builder
42	Fprint(&b, PathBasename, finds)
43	golden.Assert(t, tname, b.String())
44	})
45	}
46	}
47
48	func BenchmarkLinter(b *testing.B) {
49	ldr := journal.NewLoader()
50	_, err := ldr.Load(
51	"../../journal/testdata/journals/actual-1ktxns-100accts.journal",
52	)
53	if err != nil {
54	b.Fatalf("failed to load benchmark journal: %v", err)
55	}
56
57	ctx := semantic.Build(ldr.Ordered())
58	l := NewLinter(Rules)
59
60	b.ResetTimer()
61	b.ReportAllocs()
62	for b.Loop() {
63	l.Run(ctx)
64	}
65	}