326 lines
8.4 KiB
Go
326 lines
8.4 KiB
Go
package tailfile // import "github.com/docker/docker/pkg/tailfile"
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gotest.tools/v3/assert"
|
|
)
|
|
|
|
func TestTailFile(t *testing.T) {
|
|
f, err := os.CreateTemp("", "tail-test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
defer os.RemoveAll(f.Name())
|
|
testFile := []byte(`first line
|
|
second line
|
|
third line
|
|
fourth line
|
|
fifth line
|
|
next first line
|
|
next second line
|
|
next third line
|
|
next fourth line
|
|
next fifth line
|
|
last first line
|
|
next first line
|
|
next second line
|
|
next third line
|
|
next fourth line
|
|
next fifth line
|
|
next first line
|
|
next second line
|
|
next third line
|
|
next fourth line
|
|
next fifth line
|
|
last second line
|
|
last third line
|
|
last fourth line
|
|
last fifth line
|
|
truncated line`)
|
|
if _, err := f.Write(testFile); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := f.Seek(0, io.SeekStart); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expected := []string{"last fourth line", "last fifth line"}
|
|
res, err := TailFile(f, 2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(res) != len(expected) {
|
|
t.Fatalf("\nexpected:\n%s\n\nactual:\n%s", expected, res)
|
|
}
|
|
for i, l := range res {
|
|
if expected[i] != string(l) {
|
|
t.Fatalf("Expected line %q, got %q", expected[i], l)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTailFileManyLines(t *testing.T) {
|
|
f, err := os.CreateTemp("", "tail-test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
defer os.RemoveAll(f.Name())
|
|
testFile := []byte(`first line
|
|
second line
|
|
truncated line`)
|
|
if _, err := f.Write(testFile); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := f.Seek(0, io.SeekStart); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
expected := []string{"first line", "second line"}
|
|
res, err := TailFile(f, 10000)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(expected) != len(res) {
|
|
t.Fatalf("\nexpected:\n%s\n\nactual:\n%s", expected, res)
|
|
}
|
|
for i, l := range res {
|
|
if expected[i] != string(l) {
|
|
t.Fatalf("Expected line %s, got %s", expected[i], l)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTailEmptyFile(t *testing.T) {
|
|
f, err := os.CreateTemp("", "tail-test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
defer os.RemoveAll(f.Name())
|
|
res, err := TailFile(f, 10000)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(res) != 0 {
|
|
t.Fatal("Must be empty slice from empty file")
|
|
}
|
|
}
|
|
|
|
func TestTailNegativeN(t *testing.T) {
|
|
f, err := os.CreateTemp("", "tail-test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
defer os.RemoveAll(f.Name())
|
|
testFile := []byte(`first line
|
|
second line
|
|
truncated line`)
|
|
if _, err := f.Write(testFile); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := f.Seek(0, io.SeekStart); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := TailFile(f, -1); err != ErrNonPositiveLinesNumber {
|
|
t.Fatalf("Expected ErrNonPositiveLinesNumber, got %v", err)
|
|
}
|
|
if _, err := TailFile(f, 0); err != ErrNonPositiveLinesNumber {
|
|
t.Fatalf("Expected ErrNonPositiveLinesNumber, got %s", err)
|
|
}
|
|
}
|
|
|
|
func BenchmarkTail(b *testing.B) {
|
|
f, err := os.CreateTemp("", "tail-test")
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
defer os.RemoveAll(f.Name())
|
|
for i := 0; i < 10000; i++ {
|
|
if _, err := f.Write([]byte("tailfile pretty interesting line\n")); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
if _, err := TailFile(f, 1000); err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNewTailReader(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
|
|
for dName, delim := range map[string][]byte{
|
|
"no delimiter": {},
|
|
"single byte delimiter": {'\n'},
|
|
"2 byte delimiter": []byte(";\n"),
|
|
"4 byte delimiter": []byte("####"),
|
|
"8 byte delimiter": []byte("########"),
|
|
"12 byte delimiter": []byte("############"),
|
|
} {
|
|
t.Run(dName, func(t *testing.T) {
|
|
delim := delim
|
|
t.Parallel()
|
|
|
|
s1 := "Hello world."
|
|
s2 := "Today is a fine day."
|
|
s3 := "So long, and thanks for all the fish!"
|
|
s4 := strings.Repeat("a", blockSize/2) // same as block size
|
|
s5 := strings.Repeat("a", blockSize) // just to make sure
|
|
s6 := strings.Repeat("a", blockSize*2) // bigger than block size
|
|
s7 := strings.Repeat("a", blockSize-1) // single line same as block
|
|
|
|
s8 := `{"log":"Don't panic!\n","stream":"stdout","time":"2018-04-04T20:28:44.7207062Z"}`
|
|
jsonTest := make([]string, 0, 20)
|
|
for i := 0; i < 20; i++ {
|
|
jsonTest = append(jsonTest, s8)
|
|
}
|
|
|
|
for _, test := range []struct {
|
|
desc string
|
|
data []string
|
|
}{
|
|
{desc: "one small entry", data: []string{s1}},
|
|
{desc: "several small entries", data: []string{s1, s2, s3}},
|
|
{desc: "various sizes", data: []string{s1, s2, s3, s4, s5, s1, s2, s3, s7, s6}},
|
|
{desc: "multiple lines with one more than block", data: []string{s5, s5, s5, s5, s5}},
|
|
{desc: "multiple lines much bigger than block", data: []string{s6, s6, s6, s6, s6}},
|
|
{desc: "multiple lines same as block", data: []string{s4, s4, s4, s4, s4}},
|
|
{desc: "single line same as block", data: []string{s7}},
|
|
{desc: "single line half block", data: []string{s4}},
|
|
{desc: "single line twice block", data: []string{s6}},
|
|
{desc: "json encoded values", data: jsonTest},
|
|
{desc: "no lines", data: []string{}},
|
|
{desc: "same length as delimiter", data: []string{strings.Repeat("a", len(delim))}},
|
|
} {
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
test := test
|
|
t.Parallel()
|
|
|
|
maxLen := len(test.data)
|
|
if maxLen > 10 {
|
|
maxLen = 10
|
|
}
|
|
|
|
s := strings.Join(test.data, string(delim))
|
|
if len(test.data) > 0 {
|
|
s += string(delim)
|
|
}
|
|
|
|
for i := 1; i <= maxLen; i++ {
|
|
t.Run(fmt.Sprintf("%d lines", i), func(t *testing.T) {
|
|
i := i
|
|
t.Parallel()
|
|
|
|
r := strings.NewReader(s)
|
|
tr, lines, err := NewTailReaderWithDelimiter(ctx, r, i, delim)
|
|
if len(delim) == 0 {
|
|
assert.Assert(t, err != nil)
|
|
assert.Assert(t, lines == 0)
|
|
return
|
|
}
|
|
assert.NilError(t, err)
|
|
assert.Check(t, lines == i, "%d -- %d", lines, i)
|
|
|
|
b, err := io.ReadAll(tr)
|
|
assert.NilError(t, err)
|
|
|
|
expectLines := test.data[len(test.data)-i:]
|
|
assert.Check(t, len(expectLines) == i)
|
|
expect := strings.Join(expectLines, string(delim)) + string(delim)
|
|
assert.Check(t, string(b) == expect, "\n%v\n%v", b, []byte(expect))
|
|
})
|
|
}
|
|
|
|
t.Run("request more lines than available", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
r := strings.NewReader(s)
|
|
tr, lines, err := NewTailReaderWithDelimiter(ctx, r, len(test.data)*2, delim)
|
|
if len(delim) == 0 {
|
|
assert.Assert(t, err != nil)
|
|
assert.Assert(t, lines == 0)
|
|
return
|
|
}
|
|
if len(test.data) == 0 {
|
|
assert.Assert(t, err == ErrNonPositiveLinesNumber, err)
|
|
return
|
|
}
|
|
|
|
assert.NilError(t, err)
|
|
assert.Check(t, lines == len(test.data), "%d -- %d", lines, len(test.data))
|
|
b, err := io.ReadAll(tr)
|
|
assert.NilError(t, err)
|
|
assert.Check(t, bytes.Equal(b, []byte(s)), "\n%v\n%v", b, []byte(s))
|
|
})
|
|
})
|
|
}
|
|
})
|
|
}
|
|
t.Run("truncated last line", func(t *testing.T) {
|
|
t.Run("more than available", func(t *testing.T) {
|
|
tail, nLines, err := NewTailReader(ctx, strings.NewReader("a\nb\nextra"), 3)
|
|
assert.NilError(t, err)
|
|
assert.Check(t, nLines == 2, nLines)
|
|
|
|
rdr := bufio.NewReader(tail)
|
|
data, _, err := rdr.ReadLine()
|
|
assert.NilError(t, err)
|
|
assert.Check(t, string(data) == "a", string(data))
|
|
|
|
data, _, err = rdr.ReadLine()
|
|
assert.NilError(t, err)
|
|
assert.Check(t, string(data) == "b", string(data))
|
|
|
|
_, _, err = rdr.ReadLine()
|
|
assert.Assert(t, err == io.EOF, err)
|
|
})
|
|
})
|
|
t.Run("truncated last line", func(t *testing.T) {
|
|
t.Run("exact", func(t *testing.T) {
|
|
tail, nLines, err := NewTailReader(ctx, strings.NewReader("a\nb\nextra"), 2)
|
|
assert.NilError(t, err)
|
|
assert.Check(t, nLines == 2, nLines)
|
|
|
|
rdr := bufio.NewReader(tail)
|
|
data, _, err := rdr.ReadLine()
|
|
assert.NilError(t, err)
|
|
assert.Check(t, string(data) == "a", string(data))
|
|
|
|
data, _, err = rdr.ReadLine()
|
|
assert.NilError(t, err)
|
|
assert.Check(t, string(data) == "b", string(data))
|
|
|
|
_, _, err = rdr.ReadLine()
|
|
assert.Assert(t, err == io.EOF, err)
|
|
})
|
|
})
|
|
|
|
t.Run("truncated last line", func(t *testing.T) {
|
|
t.Run("one line", func(t *testing.T) {
|
|
tail, nLines, err := NewTailReader(ctx, strings.NewReader("a\nb\nextra"), 1)
|
|
assert.NilError(t, err)
|
|
assert.Check(t, nLines == 1, nLines)
|
|
|
|
rdr := bufio.NewReader(tail)
|
|
data, _, err := rdr.ReadLine()
|
|
assert.NilError(t, err)
|
|
assert.Check(t, string(data) == "b", string(data))
|
|
|
|
_, _, err = rdr.ReadLine()
|
|
assert.Assert(t, err == io.EOF, err)
|
|
})
|
|
})
|
|
}
|