Skip to content
Snippets Groups Projects
Select Git revision
  • 265cadca3c59ab91fe884e28c633daeff3b6a157
  • master default protected
  • feature/PRXS-3383-CollectionsRankSortAPI
  • fix/PRXS-3401-ValidateValidationOpts
  • feature/3149-LocaleCodeAsID-Feature
  • feature/PRXS-3383-CollectionsSort
  • feature/3109-SerializeFeature
  • release/0.33
  • feature/3109-RecoverySchema
  • feature/3109-feature
  • fix/PRXS-3369-ValidateFields
  • refactor/PRXS-3306-MovePkgGroup1
  • refactor/6-pkg-refactor-expr
  • fix/PRXS-3360-TemplateBuilderPatch
  • feature/3293-MongoV2
  • feature/3272-GoVersionUp
  • feature/PRXS-3218-HideTemplateActions
  • feature/PRXS-3234-PruneIdents
  • feature/3146-UpdateItemStorageInterface
  • feature/3274-ObjectIndexesFixes
  • feature/PRXS-3143-3235-ReferenceOptions
  • v0.33.1
  • v0.32.0
  • v0.31.1
  • v0.31.0
  • v0.30.0
  • v0.29.0
  • v0.28.0
  • v0.27.0-alpha.1+16
  • v0.27.0-alpha.1+15
  • v0.27.0-alpha.1+14
  • v0.27.0-alpha.1+13
  • v0.27.0-alpha.1+12
  • v0.27.0-alpha.1+11
  • v0.27.0-alpha.1+10
  • v0.27.0-alpha.1+9
  • v0.27.0-alpha.1+8
  • v0.27.0-alpha.1+7
  • v0.27.0-alpha.1+6
  • v0.27.0-alpha.1+5
  • v0.27.0-alpha.1+4
41 results

field_test.go

Blame
  • field_test.go 4.61 KiB
    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"
    )
    
    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.Skip()},
    	}
    
    	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.Skip()},
    	}
    
    	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.Skip()},
    	}
    
    	for _, tc := range tests {
    		t.Run(tc.name, func(t *testing.T) {
    			assert.True(t, tc.want.Equals(tc.field))
    		})
    	}
    }
    
    func TestObjectID(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.Skip()},
    	}
    
    	for _, tc := range tests {
    		t.Run(tc.name, func(t *testing.T) {
    			if tc.want.Equals(zap.Skip()) {
    				assert.True(t, tc.want.Equals(tc.field))
    				return
    			}
    			assert.Equal(t, tc.want.Interface.(id.Descriptor).String(), tc.field.Interface.(id.Descriptor).String())
    		})
    	}
    }
    
    func TestCallerID(t *testing.T) {
    	user := &users.User{
    		ID: "c4ca4238a0b923820dcc509a6f75849b",
    	}
    
    	oid := id.MustObjectId(user)
    	userId := id.NewUserId(user.ID)
    
    	tests := []struct {
    		name  string
    		field zap.Field
    		want  zap.Field
    	}{
    		{name: "system object", field: Caller(user), want: zap.Reflect("caller", oid)},
    		{name: "object id", field: Caller(userId), want: zap.Reflect("caller", oid)},
    		{name: "string", field: Caller(oid.String()), want: zap.Reflect("caller", oid)},
    		{name: "invalid", field: Caller(nil), want: zap.Skip()},
    	}
    
    	for _, tc := range tests {
    		t.Run(tc.name, func(t *testing.T) {
    			if tc.want.Equals(zap.Skip()) {
    				assert.True(t, tc.want.Equals(tc.field))
    				return
    			}
    			assert.Equal(t, tc.want.Interface.(id.Descriptor).String(), tc.field.Interface.(id.Descriptor).String())
    		})
    	}
    }
    
    func TestCallerIDFromContext(t *testing.T) {
    	ctx := auth.WithSystem(context.Background())
    	oid := id.MustObjectId(auth.GetPrincipal(ctx))
    
    	tests := []struct {
    		name  string
    		field zap.Field
    		want  zap.Field
    	}{
    		{name: "ok", field: CallerFromContext(ctx), want: zap.Reflect("caller", oid)},
    		{name: "invalid", field: CallerFromContext(context.TODO()), want: zap.Skip()},
    	}
    
    	for _, tc := range tests {
    		t.Run(tc.name, func(t *testing.T) {
    			if tc.want.Equals(zap.Skip()) {
    				assert.True(t, tc.want.Equals(tc.field))
    				return
    			}
    			assert.Equal(t, tc.want.Interface.(id.Descriptor).String(), tc.field.Interface.(id.Descriptor).String())
    		})
    	}
    }
    
    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.Skip()},
    	}
    
    	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.Strings("tags", []string{"a", "b", "c"})},
    		{name: "invalid", field: Tags(nil...), want: zap.Skip()},
    	}
    
    	for _, tc := range tests {
    		t.Run(tc.name, func(t *testing.T) {
    			assert.True(t, tc.want.Equals(tc.field))
    		})
    	}
    }