Gecko [ www.smanegeri1koba.sch.id ]

Name	Size	Permission
.github	[ DIR ]	dr-xr-xr-x
level	[ DIR ]	dr-xr-xr-x
syslog	[ DIR ]	dr-xr-xr-x
term	[ DIR ]	dr-xr-xr-x
.gitignore	269 B	-r--r--r--
LICENSE	1.04 KB	-r--r--r--
README.md	5.19 KB	-r--r--r--
benchmark_test.go	443 B	-r--r--r--
concurrency_test.go	653 B	-r--r--r--
doc.go	5.23 KB	-r--r--r--
example_test.go	2.71 KB	-r--r--r--
go.mod	82 B	-r--r--r--
go.sum	173 B	-r--r--r--
json_logger.go	2.03 KB	-r--r--r--
json_logger_test.go	4.61 KB	-r--r--r--
log.go	6.32 KB	-r--r--r--
log_test.go	8.65 KB	-r--r--r--
logfmt_logger.go	1.34 KB	-r--r--r--
logfmt_logger_test.go	1.38 KB	-r--r--r--
nop_logger.go	206 B	-r--r--r--
nop_logger_test.go	502 B	-r--r--r--
staticcheck.conf	17 B	-r--r--r--
stdlib.go	4.16 KB	-r--r--r--
stdlib_test.go	9.26 KB	-r--r--r--
sync.go	3.18 KB	-r--r--r--
sync_test.go	1.99 KB	-r--r--r--
value.go	3.33 KB	-r--r--r--
value_test.go	3.84 KB	-r--r--r--

Code Editor : json_logger_test.go

package log_test

import (
	"bytes"
	"errors"
	"io/ioutil"
	"testing"

"github.com/go-kit/log"
)

func TestJSONLoggerCaller(t *testing.T) {
	t.Parallel()
	buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	logger = log.With(logger, "caller", log.DefaultCaller)

if err := logger.Log(); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"caller":"json_logger_test.go:18"}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLogger(t *testing.T) {
	t.Parallel()
	buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log("err", errors.New("err"), "m", map[string]int{"0": 0}, "a", []int{1, 2, 3}); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"a":[1,2,3],"err":"err","m":{"0":0}}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLoggerMissingValue(t *testing.T) {
	t.Parallel()
	buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log("k"); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"k":"(MISSING)"}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLoggerNilStringerKey(t *testing.T) {
	t.Parallel()

buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log((*stringer)(nil), "v"); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"NULL":"v"}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLoggerPanicStringerValue(t *testing.T) {
	t.Parallel()

buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log("k", unsafeStringer{}); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"k":"PANIC in String method: error"}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLoggerNilErrorValue(t *testing.T) {
	t.Parallel()

buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log("err", (*stringError)(nil)); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"err":null}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLoggerPanicErrorValue(t *testing.T) {
	t.Parallel()

buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log("err", unsafeError{}); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"err":"PANIC in Error method: error"}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave %#v", want, have)
	}
}

func TestJSONLoggerNoHTMLEscape(t *testing.T) {
	t.Parallel()
	buf := &bytes.Buffer{}
	logger := log.NewJSONLogger(buf)
	if err := logger.Log("k", "<&>"); err != nil {
		t.Fatal(err)
	}
	if want, have := `{"k":"<&>"}`+"\n", buf.String(); want != have {
		t.Errorf("\nwant %#v\nhave%#v", want, have)
	}
}

// aller implements json.Marshaler, encoding.TextMarshaler, and fmt.Stringer.
type aller struct{}

func (aller) MarshalJSON() ([]byte, error) {
	return []byte("\"json\""), nil
}

func (aller) MarshalText() ([]byte, error) {
	return []byte("text"), nil
}

func (aller) String() string {
	return "string"
}

func (aller) Error() string {
	return "error"
}

// textstringer implements encoding.TextMarshaler and fmt.Stringer.
type textstringer struct{}

func (textstringer) MarshalText() ([]byte, error) {
	return []byte("text"), nil
}

func (textstringer) String() string {
	return "string"
}

func TestJSONLoggerStringValue(t *testing.T) {
	t.Parallel()
	tests := []struct {
		v        interface{}
		expected string
	}{
		{
			v:        aller{},
			expected: `{"v":"json"}`,
		},
		{
			v:        textstringer{},
			expected: `{"v":"text"}`,
		},
		{
			v:        stringer("string"),
			expected: `{"v":"string"}`,
		},
	}

for _, test := range tests {
		buf := &bytes.Buffer{}
		logger := log.NewJSONLogger(buf)
		if err := logger.Log("v", test.v); err != nil {
			t.Fatal(err)
		}

if want, have := test.expected+"\n", buf.String(); want != have {
			t.Errorf("\nwant %#v\nhave %#v", want, have)
		}
	}
}

type stringer string

func (s stringer) String() string {
	return string(s)
}

type stringError string

func (s stringError) Error() string {
	return string(s)
}

type unsafeStringer struct{}

func (s unsafeStringer) String() string {
	panic("error")
}

type unsafeError struct{}

func (s unsafeError) Error() string {
	panic("error")
}

func BenchmarkJSONLoggerSimple(b *testing.B) {
	benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard), baseMessage)
}

func BenchmarkJSONLoggerContextual(b *testing.B) {
	benchmarkRunner(b, log.NewJSONLogger(ioutil.Discard), withMessage)
}

func TestJSONLoggerConcurrency(t *testing.T) {
	t.Parallel()
	testConcurrency(t, log.NewJSONLogger(ioutil.Discard), 10000)
}

${this.title}

Code Editor : json_logger_test.go