-
Notifications
You must be signed in to change notification settings - Fork 0
/
generator_test.go
127 lines (106 loc) · 2.79 KB
/
generator_test.go
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
package fakelog
import (
"errors"
"regexp"
"testing"
"time"
)
const (
apacheCommonLineRegex = `^(\S+) (\S+) (\S+) \[([\w:/]+\s[+\-]\d{4})\] "(\S+)\s?(\S+)?\s?(\S+)?" (\d{3}|-) (\d+|-)$`
apacheCombinedLineRegex = `^(\S+) (\S+) (\S+) \[([\w:/]+\s[+\-]\d{4})\] "(\S+)\s?(\S+)?\s?(\S+)?" (\d{3}|-) (\d+|-)\s?"?([^"]*)"?\s?"?([^"]*)?"?$`
)
type testOut struct{ count int }
func (to *testOut) Write(p []byte) (n int, err error) {
to.count++
return 0, nil
}
func (to *testOut) Close() error { return nil }
type testOutError struct {
testOut
}
func (toe *testOutError) Write(p []byte) (n int, err error) {
toe.count++
return 0, errors.New("full disk")
}
func TestFakeLoggerWithTooBigRate_GenerateLogs(t *testing.T) {
to := &testOut{}
fl := NewLogger(ApacheCommonLine, to, 20000)
if fl.rate > maxRate {
t.Fatalf("rate %d it bigger then the allowed maxRate %d", fl.rate, maxRate)
}
}
func TestErroneousWriteCloser(t *testing.T) {
to := &testOutError{}
fl := NewLogger(ApacheCommonLine, to, 20000)
err := fl.GenerateLogs()
if err == nil {
t.Fatalf("didn't get an error")
}
if got := to.count; got != 1 {
t.Fatalf("got too many attempted writes, generator should have stopped after 1, got %d", got)
}
}
func TestFakeLogger_Stop(t *testing.T) {
to := &testOut{}
fl := NewLogger(ApacheCommonLine, to, 200)
// run the logger async and wait it produces some logs
go func() {
err := fl.GenerateLogs()
if err != nil {
t.Fatal(err)
}
}()
start := time.Now().Add(1 * time.Second)
for {
if to.count > 50 {
break
}
if time.Now().After(start) {
fl.Stop()
t.Fatalf("slow to produce log lines, %d lines produced", to.count)
}
time.Sleep(10 * time.Millisecond)
}
fl.Stop()
// record current count of written lines
written := to.count
// sleep a little to allow Logger to potentially keep logging
time.Sleep(1 * time.Second)
if written != to.count {
t.Errorf("Stop didn't stop the fake logger from producing logs, got %v want %v", to.count, written)
}
}
func TestApacheCommonLogLine(t *testing.T) {
reg, err := regexp.Compile(apacheCommonLineRegex)
if err != nil {
t.Fatal(err)
}
for i := 0; i < 10; i++ {
l := ApacheCommonLine()
if !reg.MatchString(l) {
t.Errorf("produced line '%s' doesn't follow apache common log format", l)
}
}
}
func TestApacheCombinedLogLine(t *testing.T) {
reg, err := regexp.Compile(apacheCombinedLineRegex)
if err != nil {
t.Fatal(err)
}
for i := 0; i < 10; i++ {
l := ApacheCombinedLine()
if !reg.MatchString(l) {
t.Errorf("produced line '%s' doesn't follow apache combined log format", l)
}
}
}
func BenchmarkGenerator_ApacheCommonLogLine(b *testing.B) {
for i := 0; i < b.N; i++ {
ApacheCommonLine()
}
}
func BenchmarkGenerator_ApacheCombinedLogLine(b *testing.B) {
for i := 0; i < b.N; i++ {
ApacheCombinedLine()
}
}