99 lines
2.8 KiB
Go
99 lines
2.8 KiB
Go
package logstash
|
|
|
|
import (
|
|
"testing"
|
|
|
|
jww "github.com/spf13/jwalterweatherman"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
var (
|
|
s1 = "[test1 ] TRACE test1"
|
|
s2 = "[test2 ] ERROR test2"
|
|
s3 = "[test1 ] TRACE test3"
|
|
)
|
|
|
|
func TestLog(t *testing.T) {
|
|
log := New(3)
|
|
|
|
// old to new
|
|
log.Write([]byte(s1))
|
|
log.Write([]byte(s2))
|
|
log.Write([]byte(s3))
|
|
|
|
idx := log.data
|
|
|
|
assert.Equal(t, []string{s1, s2, s3}, log.All(nil, jww.LevelTrace, 0))
|
|
assert.Equal(t, []string{s1, s2, s3}, log.All([]string{}, jww.LevelTrace, 0))
|
|
|
|
assert.Equal(t, []string{s1, s3}, log.All([]string{"test1"}, jww.LevelTrace, 0))
|
|
assert.Equal(t, []string{s1, s2, s3}, log.All(nil, jww.LevelTrace, 0))
|
|
assert.Equal(t, []string{s3}, log.All(nil, jww.LevelTrace, 1))
|
|
|
|
assert.Equal(t, []string{}, log.All(nil, jww.LevelFatal, 0))
|
|
|
|
assert.Equal(t, idx, log.data, "data should not be changed after All() call")
|
|
assert.Equal(t, []string{"test1", "test2"}, log.Areas())
|
|
}
|
|
|
|
// TestRingGrowsThenCaps writes more lines than the configured size and verifies
|
|
// the ring grows up to size and then keeps only the most recent size entries.
|
|
// This guards the grow/cap accounting in Write (length tracked in O(1)).
|
|
func TestRingGrowsThenCaps(t *testing.T) {
|
|
const size = 3
|
|
log := New(size)
|
|
|
|
lines := []string{
|
|
"[test ] TRACE line1",
|
|
"[test ] TRACE line2",
|
|
"[test ] TRACE line3",
|
|
"[test ] TRACE line4",
|
|
"[test ] TRACE line5",
|
|
}
|
|
for _, l := range lines {
|
|
log.Write([]byte(l))
|
|
}
|
|
|
|
// only the last `size` lines survive, in chronological order
|
|
got := log.All(nil, jww.LevelTrace, 0)
|
|
assert.Len(t, got, size, "ring must not exceed configured size")
|
|
assert.Equal(t, lines[len(lines)-size:], got)
|
|
}
|
|
|
|
// TestRingSkipCacheLinesDoesNotGrow verifies that "[cache ]" lines take the
|
|
// early-return path: they are not stored and must neither grow the ring nor the
|
|
// length counter, which has to stay in sync with data.Len().
|
|
func TestRingSkipCacheLinesDoesNotGrow(t *testing.T) {
|
|
log := New(3)
|
|
|
|
// grow the ring past a single node first, so a stray cursor advance on the
|
|
// cache path would actually be observable (Next() on a 1-node ring is a no-op)
|
|
log.Write([]byte(s1))
|
|
log.Write([]byte(s2))
|
|
|
|
stored := log.All(nil, jww.LevelTrace, 0)
|
|
lenBefore := log.length
|
|
cursorBefore := log.data
|
|
|
|
for range 10 {
|
|
log.Write([]byte("[cache ] cache line"))
|
|
}
|
|
|
|
assert.Equal(t, stored, log.All(nil, jww.LevelTrace, 0), "cache lines must not change stored content")
|
|
assert.Equal(t, log.data.Len(), log.length, "length counter must stay in sync with the ring")
|
|
assert.Equal(t, lenBefore, log.length, "cache lines must not grow the ring")
|
|
assert.Same(t, cursorBefore, log.data, "cache lines must not advance the write cursor")
|
|
}
|
|
|
|
func BenchmarkLog(b *testing.B) {
|
|
log := New(10000)
|
|
|
|
// old to new
|
|
log.Write([]byte(s1))
|
|
log.Write([]byte(s2))
|
|
log.Write([]byte(s3))
|
|
|
|
for b.Loop() {
|
|
log.All(nil, jww.LevelTrace, 1)
|
|
}
|
|
}
|