go-workflow-auditlog/loader_test.go at master · LarsArtmann/go-workflow-auditlog · 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
package auditlog_test

import (
	"bytes"
	"testing"

	auditlog "github.com/larsartmann/go-workflow-auditlog"
	testhelpers "github.com/larsartmann/go-workflow-auditlog/testhelpers"
)

func TestLoadReport_RoundTrip(t *testing.T) {
	t.Parallel()

	a, w := testhelpers.NewAuditAndWorkflow(t)
	s1 := testhelpers.NewSucceed("load-step-1")
	s2 := testhelpers.NewFail("load-step-2", "err")
	testhelpers.AddParallelSteps(w, s1, s2)
	testhelpers.RunWorkflow(t, a, w)

	// Export to JSON.
	var buf bytes.Buffer

	err := a.WriteJSON(&buf)
	if err != nil {
		t.Fatalf("WriteJSON: %v", err)
	}

	// Load it back.
	loaded, err := auditlog.LoadReportFromBytes(buf.Bytes())
	if err != nil {
		t.Fatalf("LoadReportFromBytes: %v", err)
	}

	if loaded.WorkflowID != "test" {
		t.Errorf("expected WorkflowID 'test', got %q", loaded.WorkflowID)
	}

	testhelpers.AssertStepCount(t, loaded, 2)

	if loaded.FailedCount != 1 {
		t.Errorf("expected 1 failed, got %d", loaded.FailedCount)
	}
}

func TestLoadReport_FromFile(t *testing.T) {
	t.Parallel()

	a, path := testhelpers.SingleSucceedExportPath(t, "file-load-step", "report.json")

	err := a.ExportJSON(path)
	if err != nil {
		t.Fatalf("ExportJSON: %v", err)
	}

	loaded, err := auditlog.LoadReport(path)
	if err != nil {
		t.Fatalf("LoadReport: %v", err)
	}

	testhelpers.AssertStepCount(t, loaded, 1)
}

func TestLoadReport_FromReader(t *testing.T) {
	t.Parallel()

	a := testhelpers.RunSingleSucceed(t, "reader-step")

	var buf bytes.Buffer

	_ = a.WriteJSON(&buf)

	loaded, err := auditlog.LoadReportFromReader(&buf)
	if err != nil {
		t.Fatalf("LoadReportFromReader: %v", err)
	}

	testhelpers.AssertStepCount(t, loaded, 1)
}

func TestLoadReport_InvalidJSON(t *testing.T) {
	t.Parallel()

	_, err := auditlog.LoadReportFromBytes([]byte(`{"bad json`))
	if err == nil {
		t.Fatal("expected error for invalid JSON")
	}
}

func TestLoadReport_NonexistentFile(t *testing.T) {
	t.Parallel()

	_, err := auditlog.LoadReport("/nonexistent/path/report.json")
	if err == nil {
		t.Fatal("expected error for nonexistent file")
	}
}

func TestReportWriteNDJSON(t *testing.T) {
	t.Parallel()

	report := testhelpers.RunSingleSucceedWithReport(t, "ndjson-report-step")

	var buf bytes.Buffer

	err := report.WriteNDJSON(&buf)
	if err != nil {
		t.Fatalf("WriteNDJSON: %v", err)
	}

	if buf.Len() == 0 {
		t.Error("expected non-empty NDJSON output")
	}

	// Verify we can read it back.
	events, err := auditlog.ReadEvents(&buf)
	if err != nil {
		t.Fatalf("ReadEvents: %v", err)
	}

	if len(events) != report.EventCount {
		t.Errorf("expected %d events, got %d", report.EventCount, len(events))
	}
}