field_test.go

package zap

import (
	"context"
	"testing"

	"git.perx.ru/perxis/perxis-go/id"
	"git.perx.ru/perxis/perxis-go/pkg/auth"
	"git.perx.ru/perxis/perxis-go/pkg/items"
	"git.perx.ru/perxis/perxis-go/pkg/users"
	"github.com/stretchr/testify/assert"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

func TestChannels(t *testing.T) {
	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "ok", field: Channels("master"), want: zap.Field{Key: channelKey, Type: zapcore.SkipType, Interface: StringArray{"master"}}},
		{name: "invalid", field: Channels(), want: zap.Field{Key: channelKey, Type: zapcore.SkipType, Interface: StringArray(nil)}},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			assert.Equal(t, tc.want, tc.field)
		})
	}
}

func TestChannelsEncode(t *testing.T) {
	enc := zapcore.NewMapObjectEncoder()
	field := Channels("master")
	field.AddTo(enc)

	assert.Empty(t, enc.Fields)
}

func TestCategory(t *testing.T) {
	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "ok", field: Category("update"), want: zap.String("category", "update")},
		{name: "invalid", field: Category(""), want: zap.String("category", "")},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			assert.True(t, tc.want.Equals(tc.field))
		})
	}
}

func TestComponent(t *testing.T) {
	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "ok", field: Component("Items"), want: zap.String("component", "Items")},
		{name: "invalid", field: Component(""), want: zap.String("component", "")},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			assert.True(t, tc.want.Equals(tc.field))
		})
	}
}

func TestEvent(t *testing.T) {
	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "ok", field: Event("items.create"), want: zap.String("event", "items.create")},
		{name: "invalid", field: Event(""), want: zap.String("event", "")},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			assert.True(t, tc.want.Equals(tc.field))
		})
	}
}

func TestObject(t *testing.T) {
	item := &items.Item{
		ID:           "c4ca4238a0b923820dcc509a6f75849b",
		SpaceID:      "c81e728d9d4c2f636f067f89cc14862c",
		EnvID:        "eccbc87e4b5ce2fe28308fd9f2a7baf3",
		CollectionID: "a87ff679a2f3e71d9181a67b7542122c",
	}

	oid := id.MustObjectId(item)
	itemId := id.NewItemId(item.SpaceID, item.EnvID, item.CollectionID, item.ID)

	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "system object", field: Object(item), want: zap.Reflect("object", oid)},
		{name: "object id", field: Object(itemId), want: zap.Reflect("object", oid)},
		{name: "string", field: Object(oid.String()), want: zap.Reflect("object", oid)},
		{name: "invalid", field: Object(nil), want: zap.Reflect("object", (*id.ObjectId)(nil))},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			wantObjectId, ok1 := tc.want.Interface.(*id.ObjectId)
			fieldObjectId, ok2 := tc.field.Interface.(*id.ObjectId)

			if ok1 && ok2 && wantObjectId != nil && fieldObjectId != nil {
				assert.Equal(t, wantObjectId.String(), fieldObjectId.String())
			} else {
				assert.Equal(t, tc.want.Interface, tc.field.Interface)
			}
		})
	}
}

func TestCaller(t *testing.T) {
	user := &users.User{
		ID: "c4ca4238a0b923820dcc509a6f75849b",
	}

	oid := id.MustObjectId(user)
	userId := id.NewUserId(user.ID)
	ctx := auth.WithSystem(context.Background())

	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "system object", field: Caller(context.TODO(), WithObject(user)), want: zap.Reflect("caller", oid)},
		{name: "object id", field: Caller(context.TODO(), WithObject(userId)), want: zap.Reflect("caller", oid)},
		{name: "string", field: Caller(context.TODO(), WithObject(oid.String())), want: zap.Reflect("caller", oid)},
		{name: "invalid", field: Caller(context.TODO()), want: zap.Reflect("caller", (*id.ObjectId)(nil))},
		{name: "context", field: Caller(ctx), want: zap.Reflect("caller", id.MustObjectId(auth.GetPrincipal(ctx)))},
		{name: "invalid context", field: Caller(context.TODO()), want: zap.Reflect("caller", (*id.ObjectId)(nil))},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			wantObjectId, ok1 := tc.want.Interface.(*id.ObjectId)
			fieldObjectId, ok2 := tc.field.Interface.(*id.ObjectId)

			if ok1 && ok2 && wantObjectId != nil && fieldObjectId != nil {
				assert.Equal(t, wantObjectId.String(), fieldObjectId.String())
			} else {
				assert.Equal(t, tc.want.Interface, tc.field.Interface)
			}
		})
	}
}

func TestAttr(t *testing.T) {
	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "ok", field: Attr(map[string]string{"a": "b"}), want: zap.Reflect("attr", map[string]string{"a": "b"})},
		{name: "invalid", field: Attr(nil), want: zap.Reflect("attr", nil)},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			assert.True(t, tc.want.Equals(tc.field))
		})
	}
}

func TestTags(t *testing.T) {
	tests := []struct {
		name  string
		field zap.Field
		want  zap.Field
	}{
		{name: "ok", field: Tags("a", "b", "c"), want: zap.Array("tags", StringArray{"a", "b", "c"})},
		{name: "invalid", field: Tags(nil...), want: zap.Array("tags", StringArray(nil))},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			assert.Equal(t, tc.want, tc.field)
		})
	}
}