keyvalue_test.go

/*
 * Copyright 2026 Mandelsoft. All rights reserved.
 *  This file is licensed under the Apache Software License, v. 2 except as noted
 *  otherwise in the LICENSE file
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package logging_test

import (
	"bytes"

	"github.com/mandelsoft/logging"
	"github.com/mandelsoft/logging/logrusl"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
	"github.com/tonglil/buflogr"
)

type element struct {
	attr1 string
	attr2 string
}

type logElement struct{ *element }

var _ logging.KeyValueProvider = logElement{}

func (e logElement) NormalizeTo(i *[]interface{}) {
	*i = append(*i, "attr1", e.attr1, "attr2", e.attr2)
}

func Element(e *element) logElement {
	return logElement{e}
}

var _ = Describe("Key/ValueTest Environment", func() {
	var buf bytes.Buffer
	var ctx logging.Context

	buflogr.NameSeparator = ":"

	BeforeEach(func() {
		buf.Reset()
		def := buflogr.NewWithBuffer(&buf)

		ctx = logging.New(def)
	})

	Context("fields values", func() {
		BeforeEach(func() {
			ctx = logrusl.Human().WithWriter(&buf).New()
			ctx.SetDefaultLevel(logging.InfoLevel)
		})
		It("key value", func() {
			log := ctx.Logger()
			log.Info("with key value", logging.KeyValue("name", "value"))
			Expect(buf.String()).To(MatchRegexp(`.{25} info    "with key value" name=value\n`))
		})
		It("key value sequence", func() {
			log := ctx.Logger()
			log.Info("with key value", logging.KeyValue("name", "value"), logging.KeyValue("other", "othervalue"))
			Expect(buf.String()).To(MatchRegexp(`.{25} info    "with key value" name=value other=othervalue\n`))
		})
		It("mixed key value sequence", func() {
			log := ctx.Logger()
			log.Info("with key value", logging.KeyValue("name", "value"), "other", "othervalue")
			log.Info("with key value", "first", "firstvalue", logging.KeyValue("name", "value"), "other", "othervalue")
			Expect(buf.String()).To(MatchRegexp(`.{25} info    "with key value" name=value other=othervalue\n.{25} info    "with key value" first=firstvalue name=value other=othervalue\n`))
		})
		It("attributes", func() {
			log := ctx.Logger()
			log.Info("with key value", logging.NewAttribute("name", "value"))
			Expect(buf.String()).To(MatchRegexp(`.{25} info    "with key value" name=value\n`))
		})
		It("value provider", func() {
			e := &element{
				attr1: "alice",
				attr2: "bob",
			}
			log := ctx.Logger()

			log.Info("with value provider", "first", "first", Element(e), logging.NewAttribute("name", "value"))
			Expect(buf.String()).To(MatchRegexp(`.{25} info    "with value provider" attr1=alice attr2=bob first=first name=value\n`))
		})
	})
})