iris/middleware/accesslog/accesslog_test.go

192 lines
3.7 KiB
Go
Raw Normal View History

package accesslog
import (
"bytes"
2020-09-10 18:41:30 +02:00
"fmt"
"io"
"io/ioutil"
"net/http"
"net/http/httptest"
"sync"
"testing"
"time"
"github.com/kataras/iris/v12/context"
"github.com/kataras/iris/v12/core/memstore"
)
func TestAccessLogPrint_Simple(t *testing.T) {
t.Parallel()
const goroutinesN = 42
w := new(bytes.Buffer)
ac := New(w)
ac.TimeFormat = "2006-01-02 15:04:05"
ac.Clock = TClock(time.Time{})
if !ac.LockWriter { // should be true because we register a *bytes.Buffer.
t.Fatalf("expected LockRriter to be true")
}
var (
expected string
wg = new(sync.WaitGroup)
)
for i := 0; i < goroutinesN; i++ {
wg.Add(1)
expected += "0001-01-01 00:00:00|1s|200|GET|/path_value?url_query=url_query_value|::1|path_param=path_param_value url_query=url_query_value custom=custom_value|||Incoming|Outcoming|\n"
go func() {
defer wg.Done()
ac.Print(
nil,
1*time.Second,
ac.TimeFormat,
200,
"GET",
"/path_value?url_query=url_query_value",
"::1",
"Incoming",
"Outcoming",
0,
0,
&context.RequestParams{
Store: []memstore.Entry{
{Key: "path_param", ValueRaw: "path_param_value"},
},
}, []memstore.StringEntry{
{Key: "url_query", Value: "url_query_value"},
}, []memstore.Entry{
{Key: "custom", ValueRaw: "custom_value"},
})
}()
}
wg.Wait()
if got := w.String(); expected != got {
t.Fatalf("expected printed result to be:\n'%s'\n\nbut got:\n'%s'", expected, got)
}
}
2020-09-10 18:41:30 +02:00
func TestAccessLogBroker(t *testing.T) {
w := new(bytes.Buffer)
ac := New(w)
ac.Clock = TClock(time.Time{})
broker := ac.Broker()
closed := make(chan struct{})
wg := new(sync.WaitGroup)
n := 4
wg.Add(4)
go func() {
defer wg.Done()
i := 0
ln := broker.NewListener()
for {
select {
case <-closed:
broker.CloseListener(ln)
t.Log("Log Listener Closed")
return
case log := <-ln:
lat := log.Latency
t.Log(lat.String())
wg.Done()
if expected := time.Duration(i) * time.Second; expected != lat {
panic(fmt.Sprintf("expected latency: %s but got: %s", expected, lat))
}
i++
time.Sleep(1350 * time.Millisecond)
if i == 2 {
time.Sleep(2 * time.Second) // "random" sleep even more.
}
if log.Latency != lat {
panic("expected logger to wait for notifier before release the log")
}
}
}
}()
time.Sleep(time.Second)
printLog := func(lat time.Duration) {
err := ac.Print(
nil,
lat,
"",
0,
"",
"",
"",
"",
"",
2020-09-10 18:41:30 +02:00
0,
0,
&context.RequestParams{},
nil,
nil,
)
if err != nil {
t.Fatal(err)
}
}
for i := 0; i < n; i++ {
printLog(time.Duration(i) * time.Second)
}
// wait for all listeners to finish.
wg.Wait()
// wait for close messages.
wg.Add(1)
close(closed)
wg.Wait()
}
type noOpFormatter struct{}
func (*noOpFormatter) SetOutput(io.Writer) {}
// Format prints the logs in text/template format.
func (*noOpFormatter) Format(*Log) (bool, error) {
return true, nil
}
// go test -run=^$ -bench=BenchmarkAccessLogAfter -benchmem
func BenchmarkAccessLogAfter(b *testing.B) {
ac := New(ioutil.Discard)
ac.Clock = TClock(time.Time{})
ac.BytesReceived = false
ac.BytesSent = false
ac.BodyMinify = false
ac.RequestBody = false
ac.ResponseBody = false
ac.KeepMultiLineError = true
ac.Async = false
ac.IP = false
2020-09-10 18:41:30 +02:00
ac.SetFormatter(new(noOpFormatter)) // just to create the log structure.)
ctx := new(context.Context)
req, err := http.NewRequest("GET", "/", nil)
if err != nil {
b.Fatal(err)
}
ctx.ResetRequest(req)
recorder := httptest.NewRecorder()
w := context.AcquireResponseWriter()
w.BeginResponse(recorder)
ctx.ResetResponseWriter(w)
b.ResetTimer()
for n := 0; n < b.N; n++ {
ac.after(ctx, time.Millisecond, "GET", "/")
}
w.EndResponse()
}