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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
package export
import (
"encoding/csv"
"os"
"path/filepath"
"strings"
"testing"
"ior/internal/statsengine"
)
// TestSnapshotCSVNilSnapshot verifies that SnapshotCSV writes a valid CSV file
// with only the header and summary rows when the snapshot is nil.
func TestSnapshotCSVNilSnapshot(t *testing.T) {
// Run inside a temp dir so the timestamped CSV file is automatically
// cleaned up after the test.
dir := t.TempDir()
origDir, err := os.Getwd()
if err != nil {
t.Fatalf("getwd: %v", err)
}
if err := os.Chdir(dir); err != nil {
t.Fatalf("chdir: %v", err)
}
t.Cleanup(func() { _ = os.Chdir(origDir) })
name, err := SnapshotCSV(nil)
if err != nil {
t.Fatalf("SnapshotCSV(nil) returned error: %v", err)
}
if name == "" {
t.Fatal("SnapshotCSV returned empty filename")
}
if !strings.HasPrefix(filepath.Base(name), "ior-snapshot-") {
t.Fatalf("unexpected filename prefix: %q", name)
}
data, err := os.ReadFile(filepath.Join(dir, name))
if err != nil {
t.Fatalf("read csv file: %v", err)
}
r := csv.NewReader(strings.NewReader(string(data)))
records, err := r.ReadAll()
if err != nil {
t.Fatalf("parse csv: %v", err)
}
// Nil snapshot: expect header + 4 summary rows.
if len(records) < 5 {
t.Fatalf("expected at least 5 CSV rows, got %d", len(records))
}
if records[0][0] != "section" {
t.Fatalf("expected header row first cell 'section', got %q", records[0][0])
}
for _, row := range records[1:5] {
if row[0] != "summary" {
t.Fatalf("expected summary row, got section=%q", row[0])
}
}
}
// TestSnapshotCSVWithData verifies that SnapshotCSV emits syscall, file, and
// process rows when the snapshot contains non-empty data.
func TestSnapshotCSVWithData(t *testing.T) {
dir := t.TempDir()
origDir, err := os.Getwd()
if err != nil {
t.Fatalf("getwd: %v", err)
}
if err := os.Chdir(dir); err != nil {
t.Fatalf("chdir: %v", err)
}
t.Cleanup(func() { _ = os.Chdir(origDir) })
snap := statsengine.NewSnapshot(
nil, nil, nil,
[]statsengine.SyscallSnapshot{
{Name: "read", Count: 10, RatePerSec: 1.5, Bytes: 4096},
},
[]statsengine.FileSnapshot{
{Path: "/tmp/x", Accesses: 3, BytesRead: 128, BytesWritten: 64, AvgLatencyNs: 100},
},
[]statsengine.ProcessSnapshot{
{PID: 42, Comm: "cat", Syscalls: 5, RatePerSec: 0.5, AvgLatencyNs: 200},
},
statsengine.NewHistogramSnapshot(1, []statsengine.HistogramBucketSnapshot{
{Label: "0-1µs", LowerNs: 0, UpperNs: 1000, Count: 1},
}),
statsengine.NewHistogramSnapshot(0, nil),
)
name, err := SnapshotCSV(&snap)
if err != nil {
t.Fatalf("SnapshotCSV returned error: %v", err)
}
data, err := os.ReadFile(filepath.Join(dir, name))
if err != nil {
t.Fatalf("read csv file: %v", err)
}
content := string(data)
for _, want := range []string{"syscall", "read", "file", "/tmp/x", "process", "42", "latency_hist", "0-1µs"} {
if !strings.Contains(content, want) {
t.Fatalf("expected %q in CSV output, got:\n%s", want, content)
}
}
}
// TestSnapValueHelpers verifies the nil-safe helper functions directly.
func TestSnapValueHelpers(t *testing.T) {
if got := snapValue(nil, func(s *statsengine.Snapshot) uint64 { return s.TotalSyscalls }); got != 0 {
t.Fatalf("snapValue(nil) = %d, want 0", got)
}
if got := snapValueF(nil, func(s *statsengine.Snapshot) float64 { return s.SyscallRatePerSec }); got != 0 {
t.Fatalf("snapValueF(nil) = %f, want 0", got)
}
if got := trendSummary(nil, func(s *statsengine.Snapshot) statsengine.Trend { return s.LatencyTrend }); got != "stable:0.00" {
t.Fatalf("trendSummary(nil) = %q, want stable:0.00", got)
}
snap := statsengine.NewSnapshot(nil, nil, nil, nil, nil, nil,
statsengine.NewHistogramSnapshot(0, nil),
statsengine.NewHistogramSnapshot(0, nil),
)
snap.TotalSyscalls = 99
snap.SyscallRatePerSec = 3.14
snap.LatencyTrend = statsengine.Trend{Direction: statsengine.TrendRising, DeltaPercent: 12.5}
if got := snapValue(&snap, func(s *statsengine.Snapshot) uint64 { return s.TotalSyscalls }); got != 99 {
t.Fatalf("snapValue = %d, want 99", got)
}
if got := snapValueF(&snap, func(s *statsengine.Snapshot) float64 { return s.SyscallRatePerSec }); got != 3.14 {
t.Fatalf("snapValueF = %f, want 3.14", got)
}
if got := trendSummary(&snap, func(s *statsengine.Snapshot) statsengine.Trend { return s.LatencyTrend }); got != "rising:12.50" {
t.Fatalf("trendSummary = %q, want rising:12.50", got)
}
}
|
