Golang log.New函数代码示例

func TestLogger_With_Errorf(t *testing.T) {
	now := time.Now()
	util.Now = func() time.Time { return now }
	defer func() { util.Now = time.Now }()
	var buf bytes.Buffer
	format := "test log: %v"
	msg := "this is test"
	fields := log.Fields{
		"first":  1,
		"second": "two",
	}
	expected := "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\tfirst:1\tsecond:two\n"
	for _, v := range []struct {
		level    log.Level
		expected string
	}{
		{log.NONE, expected},
		{log.DEBUG, expected},
		{log.INFO, expected},
		{log.WARN, expected},
		{log.ERROR, expected},
		{log.FATAL, ""},
		{log.PANIC, ""},
	} {
		buf.Reset()
		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
		logger.Errorf(format, msg)
		actual := buf.String()
		expected := v.expected
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf(`log level => %v; logger.With(%#v).Errorf(%#v, %#v) prints %#v; want %#v`, v.level, fields, format, msg, actual, expected)
		}
	}
}

func TestLogger_SetLevel(t *testing.T) {
	now := time.Now()
	util.Now = func() time.Time { return now }
	defer func() { util.Now = time.Now }()
	var buf bytes.Buffer
	logger := log.New(&buf, &log.LTSVFormatter{}, log.DEBUG)
	var actual interface{} = logger.Level()
	var expected interface{} = log.DEBUG
	if !reflect.DeepEqual(actual, expected) {
		t.Errorf(`logger.Level() => %v; want %v`, actual, expected)
	}
	msg := "test log"
	logger.Debug(msg)
	actual = buf.String()
	expected = "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:" + msg + "\n"
	if !reflect.DeepEqual(actual, expected) {
		t.Errorf(`logger.Debug(%#v) prints %#v; want %#v`, msg, actual, expected)
	}
	logger.SetLevel(log.INFO)
	actual = logger.Level()
	expected = log.INFO
	if !reflect.DeepEqual(actual, expected) {
		t.Errorf(`After logger.SetLevel(%v); logger.Level() => %v; want %v`, log.INFO, actual, expected)
	}
	buf.Reset()
	logger.Debug(msg)
	actual = buf.String()
	expected = ""
	if !reflect.DeepEqual(actual, expected) {
		t.Errorf(`After logger.SetLevel(%v); logger.Debug(%#v) => %#v; want %#v`, log.INFO, msg, actual, expected)
	}
}

func TestLogger_Debugln(t *testing.T) {
	now := time.Now()
	util.Now = func() time.Time { return now }
	defer func() { util.Now = time.Now }()
	var buf bytes.Buffer
	msg := "test log"
	expected := "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\n"
	for _, v := range []struct {
		level    log.Level
		expected string
	}{
		{log.NONE, expected},
		{log.DEBUG, expected},
		{log.INFO, ""},
		{log.WARN, ""},
		{log.ERROR, ""},
		{log.FATAL, ""},
		{log.PANIC, ""},
	} {
		buf.Reset()
		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
		logger.Debugln(msg)
		actual := buf.String()
		expected := v.expected
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf(`log level => %v; logger.Debugln(%#v) prints %#v; want %#v`, v.level, msg, actual, expected)
		}
	}
}

func (app *Application) buildLogger() error {
	if app.Config.Logger == nil {
		app.Config.Logger = &LoggerConfig{}
	}
	if app.Config.Logger.Writer == nil {
		app.Config.Logger.Writer = os.Stdout
	}
	if app.Config.Logger.Formatter == nil {
		app.Config.Logger.Formatter = &log.LTSVFormatter{}
	}
	app.Logger = log.New(app.Config.Logger.Writer, app.Config.Logger.Formatter, app.Config.Logger.Level)
	return nil
}

func TestLogger_Level(t *testing.T) {
	for _, level := range []log.Level{
		log.NONE,
		log.DEBUG,
		log.INFO,
		log.WARN,
		log.ERROR,
		log.FATAL,
		log.PANIC,
	} {
		logger := log.New(ioutil.Discard, &log.LTSVFormatter{}, level)
		actual := logger.Level()
		expected := level
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf(`log level => %v; logger.Level() => %v; want %v`, level, actual, expected)
		}
	}
}

func TestLogger_With_Output(t *testing.T) {
	now := time.Now()
	util.Now = func() time.Time { return now }
	defer func() { util.Now = time.Now }()
	var buf bytes.Buffer
	msg := "test log"
	fields := log.Fields{
		"first":  1,
		"second": "two",
	}
	for _, currentLevel := range []log.Level{
		log.NONE,
		log.DEBUG,
		log.INFO,
		log.WARN,
		log.ERROR,
		log.FATAL,
		log.PANIC,
	} {
		for _, v := range []struct {
			level    log.Level
			expected string
		}{
			{log.NONE, "level:NONE\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
			{log.DEBUG, "level:DEBUG\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
			{log.INFO, "level:INFO\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
			{log.WARN, "level:WARN\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
			{log.ERROR, "level:ERROR\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
			{log.FATAL, "level:FATAL\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
			{log.PANIC, "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"},
		} {
			buf.Reset()
			logger := log.New(&buf, &log.LTSVFormatter{}, currentLevel).With(fields)
			logger.Output(v.level, msg)
			actual := buf.String()
			expected := v.expected
			if !reflect.DeepEqual(actual, expected) {
				t.Errorf(`log level => %v; logger.With(%#v).Output(%v, %#v) prints %#v; want %#v`, currentLevel, fields, v.level, msg, actual, expected)
			}
		}
	}
}

func TestLogger_With_Panicln(t *testing.T) {
	now := time.Now()
	util.Now = func() time.Time { return now }
	defer func() { util.Now = time.Now }()
	var buf bytes.Buffer
	msg := "test log"
	fields := log.Fields{
		"first":  1,
		"second": "two",
	}
	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log\tfirst:1\tsecond:two\n"
	for _, v := range []struct {
		level    log.Level
		expected string
	}{
		{log.NONE, expected},
		{log.DEBUG, expected},
		{log.INFO, expected},
		{log.WARN, expected},
		{log.ERROR, expected},
		{log.FATAL, expected},
		{log.PANIC, expected},
	} {
		buf.Reset()
		logger := log.New(&buf, &log.LTSVFormatter{}, v.level).With(fields)
		func() {
			defer func() {
				if err := recover(); err == nil {
					t.Errorf("log level => %v; logger.With(%#v).Panicln(%#v) isn't calling panic()", v.level, msg)
				}
			}()
			logger.Panicln(msg)
		}()
		actual := buf.String()
		expected := v.expected
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf(`log level => %v; logger.With(%#v).Panicln(%#v) prints %#v; want %#v`, v.level, fields, msg, actual, expected)
		}
	}
}

func TestLogger_Panicf(t *testing.T) {
	now := time.Now()
	util.Now = func() time.Time { return now }
	defer func() { util.Now = time.Now }()
	var buf bytes.Buffer
	format := "test log: %v"
	msg := "this is test"
	expected := "level:PANIC\ttime:" + now.Format(time.RFC3339Nano) + "\tmessage:test log: this is test\n"
	for _, v := range []struct {
		level    log.Level
		expected string
	}{
		{log.NONE, expected},
		{log.DEBUG, expected},
		{log.INFO, expected},
		{log.WARN, expected},
		{log.ERROR, expected},
		{log.FATAL, expected},
		{log.PANIC, expected},
	} {
		buf.Reset()
		logger := log.New(&buf, &log.LTSVFormatter{}, v.level)
		func() {
			defer func() {
				if err := recover(); err == nil {
					t.Errorf("log level => %v; logger.Panicf(%#v, %#v) isn't calling panic()", v.level, format, msg)
				}
			}()
			logger.Panicf(format, msg)
		}()
		actual := buf.String()
		expected := v.expected
		if !reflect.DeepEqual(actual, expected) {
			t.Errorf(`log level => %v; logger.Panicf(%#v, %#v) prints %#v; want %#v`, v.level, format, msg, actual, expected)
		}
	}
}

func TestContext_RenderError(t *testing.T) {
	for _, v := range []struct {
		status      int
		contentType string
		expect      string
	}{
		{http.StatusInternalServerError, "text/html", "500 error\n"},
		{http.StatusBadRequest, "text/html", "400 error\n"},
		{http.StatusInternalServerError, "application/json", "{\"error\":500}\n"},
		{http.StatusTeapot, "text/html", http.StatusText(http.StatusTeapot)},
	} {
		c := newTestContext("testctrlr", "")
		w := httptest.NewRecorder()
		c.Response = &kocha.Response{ResponseWriter: w}
		c.Response.ContentType = v.contentType
		if err := c.RenderError(v.status, nil, nil); err != nil {
			t.Fatal(err)
		}
		buf, err := ioutil.ReadAll(w.Body)
		if err != nil {
			t.Fatal(err)
		}
		var actual interface{} = string(buf)
		var expect interface{} = v.expect
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`Context.RenderError(%#v, %#v, %#v) => %#v; want %#v`, v.status, nil, nil, actual, expect)
		}

		actual = c.Response.StatusCode
		expect = v.status
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`Context.RenderError(%#v, %#v, %#v); HTTP status => %#v; want %#v`, v.status, nil, nil, actual, expect)
		}
	}

	for _, v := range []struct {
		err         error
		contentType string
		expect      error
	}{
		{nil, "unknown/content-type", fmt.Errorf("kocha: unknown Content-Type: unknown/content-type")},
		{fmt.Errorf("expected error"), "unknown/content-type", fmt.Errorf("kocha: unknown Content-Type: unknown/content-type")},
	} {
		c := newTestContext("testctrlr", "")
		var buf bytes.Buffer
		c.App.Logger = log.New(&buf, c.App.Config.Logger.Formatter, c.App.Config.Logger.Level)
		c.Response.ContentType = v.contentType
		var actual interface{} = c.RenderError(http.StatusInternalServerError, v.err, nil)
		_, file, line, _ := runtime.Caller(0)
		line--
		var expect interface{} = fmt.Errorf("%s:%d: %v", file, line, v.expect)
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`Context.RenderError(%#v, %#v, %#v) => %#v; want %#v`, http.StatusInternalServerError, nil, nil, actual, expect)
		}

		func() {
			actual := buf.String()
			expect := fmt.Sprintf("message:%s:%d: %v", file, line, v.err)
			if v.err != nil && !strings.Contains(actual, expect) {
				t.Errorf(`Context.RenderError(%#v, %#v, %#v); log => %#v; want %#v`, http.StatusInternalServerError, v.err, nil, actual, expect)
			}
		}()
	}
}

func TestPanicRecoverMiddleware(t *testing.T) {
	test := func(ident string, w *httptest.ResponseRecorder) {
		var actual interface{} = w.Code
		var expect interface{} = http.StatusInternalServerError
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`PanicRecoverMiddleware: %s; status => %#v; want %#v`, ident, actual, expect)
		}

		actual = w.Body.String()
		expect = "This is layout\n500 error\n\n"
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`PanicRecoverMiddleware: %s => %#v; want %#v`, ident, actual, expect)
		}

		actual = w.Header().Get("Content-Type")
		expect = "text/html"
		if !reflect.DeepEqual(actual, expect) {
			t.Errorf(`PanicRecoverMiddleware: %s; Context-Type => %#v; want %#v`, ident, actual, expect)
		}
	}

	func() {
		req, err := http.NewRequest("GET", "/error", nil)
		if err != nil {
			t.Fatal(err)
		}
		app := kocha.NewTestApp()
		app.Config.Middlewares = []kocha.Middleware{
			&kocha.PanicRecoverMiddleware{},
			&kocha.DispatchMiddleware{},
		}
		var buf bytes.Buffer
		app.Logger = log.New(&buf, &log.LTSVFormatter{}, app.Config.Logger.Level)
		w := httptest.NewRecorder()
		app.ServeHTTP(w, req)
		test(`GET "/error"`, w)

		actual := strings.SplitN(buf.String(), "\n", 2)[0]
		expect := "\tmessage:panic test"
		if !strings.Contains(actual, expect) {
			t.Errorf(`PanicRecoverMiddleware: GET "/error"; log => %#v; want contains => %#v`, actual, expect)
		}
	}()

	func() {
		req, err := http.NewRequest("GET", "/", nil)
		if err != nil {
			t.Fatal(err)
		}
		app := kocha.NewTestApp()
		app.Config.Middlewares = []kocha.Middleware{
			&kocha.PanicRecoverMiddleware{},
			&TestPanicInBeforeMiddleware{},
			&kocha.DispatchMiddleware{},
		}
		var buf bytes.Buffer
		app.Logger = log.New(&buf, &log.LTSVFormatter{}, app.Config.Logger.Level)
		w := httptest.NewRecorder()
		app.ServeHTTP(w, req)
		test(`GET "/"`, w)

		actual := strings.SplitN(buf.String(), "\n", 2)[0]
		expect := "\tmessage:before"
		if !strings.Contains(actual, expect) {
			t.Errorf(`PanicRecoverMiddleware: GET "/error"; log => %#v; want contains => %#v`, actual, expect)
		}
	}()

	func() {
		req, err := http.NewRequest("GET", "/", nil)
		if err != nil {
			t.Fatal(err)
		}
		app := kocha.NewTestApp()
		app.Config.Middlewares = []kocha.Middleware{
			&kocha.PanicRecoverMiddleware{},
			&TestPanicInAfterMiddleware{},
			&kocha.DispatchMiddleware{},
		}
		var buf bytes.Buffer
		app.Logger = log.New(&buf, &log.LTSVFormatter{}, app.Config.Logger.Level)
		w := httptest.NewRecorder()
		app.ServeHTTP(w, req)
		test(`GET "/"`, w)

		actual := strings.SplitN(buf.String(), "\n", 2)[0]
		expect := "\tmessage:after"
		if !strings.Contains(actual, expect) {
			t.Errorf(`PanicRecoverMiddleware: GET "/error"; log => %#v; want contains => %#v`, actual, expect)
		}
	}()

	func() {
		defer func() {
			actual := recover()
			expect := "before"
			if !reflect.DeepEqual(actual, expect) {
				t.Errorf(`PanicRecoverMiddleware after panic middleware: GET "/" => %#v; want %#v`, actual, expect)
			}
		}()
//.........这里部分代码省略.........