From a67ec16bf03775b9dcb43b2fb645853d397f6a17 Mon Sep 17 00:00:00 2001 From: yuemoxi <99347745@qq.com> Date: Wed, 25 Aug 2021 23:56:28 +0800 Subject: [PATCH] test(internal/context,internal/host) add test (#1334) * test(internal/context,internal/host) add test --- encoding/form/form_test.go | 9 ++ encoding/json/json_test.go | 11 ++ encoding/proto/proto_test.go | 34 ++++++ internal/context/context_test.go | 132 +++++++++++++++++++++ internal/host/host_test.go | 14 +++ internal/test/testproto/test.pb.go | 177 +++++++++++++++++++++++++++++ internal/test/testproto/test.proto | 12 ++ 7 files changed, 389 insertions(+) create mode 100644 encoding/proto/proto_test.go create mode 100644 internal/test/testproto/test.pb.go create mode 100644 internal/test/testproto/test.proto diff --git a/encoding/form/form_test.go b/encoding/form/form_test.go index 2022910aa..6e46940e2 100644 --- a/encoding/form/form_test.go +++ b/encoding/form/form_test.go @@ -1,6 +1,7 @@ package form import ( + "github.com/go-kratos/kratos/v2/internal/test/testproto" "testing" "github.com/go-kratos/kratos/v2/encoding" @@ -31,6 +32,14 @@ func TestFormCodecMarshal(t *testing.T) { content, err = encoding.GetCodec(contentType).Marshal(req) require.NoError(t, err) require.Equal(t, []byte("username=kratos"), content) + + m := testproto.TestModel{ + Id: 1, + Name: "kratos", + } + content, err = encoding.GetCodec(contentType).Marshal(m) + require.NoError(t, err) + require.Equal(t, []byte("id=1&name=kratos"), content) } func TestFormCodecUnmarshal(t *testing.T) { diff --git a/encoding/json/json_test.go b/encoding/json/json_test.go index 06d80ee2f..d104fb257 100644 --- a/encoding/json/json_test.go +++ b/encoding/json/json_test.go @@ -4,6 +4,8 @@ import ( "bytes" "strings" "testing" + + "github.com/go-kratos/kratos/v2/internal/test/testproto" ) type testEmbed struct { @@ -32,6 +34,10 @@ func TestJSON_Marshal(t *testing.T) { input: &testMessage{Field1: "a", Field2: "b", Field3: "c"}, expect: `{"a":"a","b":"b","c":"c"}`, }, + { + input: &testproto.TestModel{Id: 1, Name: "go-kratos", Hobby: []string{"1", "2"}}, + expect: `{"id":"1", "name":"go-kratos", "hobby":["1", "2"], "attrs":{}}`, + }, } for _, v := range tests { data, err := (codec{}).Marshal(v.input) @@ -50,6 +56,7 @@ func TestJSON_Marshal(t *testing.T) { func TestJSON_Unmarshal(t *testing.T) { p := &testMessage{} + p2 := &testproto.TestModel{} tests := []struct { input string expect interface{} @@ -62,6 +69,10 @@ func TestJSON_Unmarshal(t *testing.T) { input: `{"a":"a","b":"b","c":"c"}`, expect: &p, }, + { + input: `{"id":1,"name":"kratos"}`, + expect: &p2, + }, } for _, v := range tests { want := []byte(v.input) diff --git a/encoding/proto/proto_test.go b/encoding/proto/proto_test.go new file mode 100644 index 000000000..228e78925 --- /dev/null +++ b/encoding/proto/proto_test.go @@ -0,0 +1,34 @@ +package proto + +import ( + "github.com/go-kratos/kratos/v2/internal/test/testproto" + "github.com/stretchr/testify/assert" + "testing" +) + +func TestName(t *testing.T) { + c := new(codec) + assert.Equal(t, c.Name(), "proto") +} + +func TestCodec(t *testing.T) { + c := new(codec) + + model := testproto.TestModel{ + Id: 1, + Name: "kratos", + Hobby: []string{"study", "eat", "play"}, + } + + m, err := c.Marshal(&model) + assert.Nil(t, err) + + var res testproto.TestModel + + err = c.Unmarshal(m, &res) + assert.Nil(t, err) + + assert.Equal(t, res.Id,model.Id) + assert.Equal(t, res.Name,model.Name) + assert.Equal(t, res.Hobby,model.Hobby) +} diff --git a/internal/context/context_test.go b/internal/context/context_test.go index 563c8c694..19d5b35d9 100644 --- a/internal/context/context_test.go +++ b/internal/context/context_test.go @@ -2,6 +2,7 @@ package context import ( "context" + "reflect" "testing" "time" @@ -29,6 +30,18 @@ func TestContext(t *testing.T) { t.Log(value2) } +func TestMerge2(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + ctx1 := context.WithValue(context.Background(), "go-kratos", "https://github.com/go-kratos/") + ctx2 := context.WithValue(ctx, "kratos", "https://go-kratos.dev/") + + ctx, cancel = Merge(ctx1, ctx2) + defer cancel() + + t.Log(ctx) +} + func TestErr(t *testing.T) { ctx1, cancel := context.WithTimeout(context.Background(), time.Microsecond) defer cancel() @@ -83,6 +96,23 @@ func TestWait(t *testing.T) { mc.wait() t.Log(mc.doneErr) assert.Equal(t, mc.doneErr, context.Canceled) + + ctx2, cancel2 := context.WithCancel(context.Background()) + + mc = &mergeCtx{ + parent1: ctx2, + parent2: context.Background(), + done: make(chan struct{}), + cancelCh: make(chan struct{}), + } + go func() { + time.Sleep(time.Millisecond * 50) + cancel2() + }() + + mc.wait() + t.Log(mc.doneErr) + assert.Equal(t, mc.doneErr, context.Canceled) } func TestCancel(t *testing.T) { @@ -96,3 +126,105 @@ func TestCancel(t *testing.T) { assert.Equal(t, <-mc.cancelCh, struct{}{}) } + +func Test_mergeCtx_Deadline(t *testing.T) { + type fields struct { + parent1Timeout time.Time + parent2Timeout time.Time + } + tests := []struct { + name string + fields fields + want1 bool + }{ + { + name: "parent1 not deadline", + fields: fields{time.Time{}, time.Now().Add(time.Second * 100)}, + want1: true, + }, + { + name: "parent2 not deadline", + fields: fields{time.Now().Add(time.Second * 100), time.Time{}}, + want1: true, + }, + { + name: " parent1 parent2 not deadline", + fields: fields{time.Time{}, time.Time{}}, + want1: false, + }, + { + name: " parent1 < parent2", + fields: fields{time.Now().Add(time.Second * 100), time.Now().Add(time.Second * 200)}, + want1: true, + }, + { + name: " parent1 > parent2", + fields: fields{time.Now().Add(time.Second * 100), time.Now().Add(time.Second * 50)}, + want1: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + var parent1, parent2 context.Context + var cancel1, cancel2 context.CancelFunc + if reflect.DeepEqual(tt.fields.parent1Timeout, time.Time{}) { + parent1 = context.Background() + } else { + parent1, cancel1 = context.WithDeadline(context.Background(), tt.fields.parent1Timeout) + defer cancel1() + } + if reflect.DeepEqual(tt.fields.parent2Timeout, time.Time{}) { + parent2 = context.Background() + } else { + parent2, cancel2 = context.WithDeadline(context.Background(), tt.fields.parent2Timeout) + defer cancel2() + } + + mc := &mergeCtx{ + parent1: parent1, + parent2: parent2, + } + got, got1 := mc.Deadline() + t.Log(got) + if got1 != tt.want1 { + t.Errorf("Deadline() got1 = %v, want %v", got1, tt.want1) + } + }) + } +} + +func Test_Err2(t *testing.T) { + ctx1, cancel := context.WithCancel(context.Background()) + defer cancel() + time.Sleep(time.Millisecond) + + ctx, cancel := Merge(ctx1, context.Background()) + defer cancel() + + assert.Equal(t, ctx.Err(), nil) + + ctx1, cancel1 := context.WithCancel(context.Background()) + time.Sleep(time.Millisecond) + + ctx, cancel = Merge(ctx1, context.Background()) + defer cancel() + + cancel1() + + assert.Equal(t, ctx.Err(), context.Canceled) + + ctx1, cancel1 = context.WithCancel(context.Background()) + time.Sleep(time.Millisecond) + + ctx, cancel = Merge(context.Background(), ctx1) + defer cancel() + + cancel1() + + assert.Equal(t, ctx.Err(), context.Canceled) + + ctx, cancel = Merge(context.Background(), context.Background()) + cancel() + assert.Equal(t, ctx.Err(), context.Canceled) +} diff --git a/internal/host/host_test.go b/internal/host/host_test.go index 930e8c3e4..cf866274d 100644 --- a/internal/host/host_test.go +++ b/internal/host/host_test.go @@ -1,6 +1,7 @@ package host import ( + "github.com/stretchr/testify/assert" "net" "testing" ) @@ -76,6 +77,19 @@ func TestExtract(t *testing.T) { } } +func TestExtract2(t *testing.T) { + addr := "localhost:9001" + lis, err := net.Listen("tcp", addr) + if err == nil { + assert.Nil(t, err) + } + res, err := Extract(addr, lis) + if err == nil { + assert.Nil(t, err) + } + assert.Equal(t, res, "localhost:9001") +} + func TestPort(t *testing.T) { lis, err := net.Listen("tcp", ":0") if err != nil { diff --git a/internal/test/testproto/test.pb.go b/internal/test/testproto/test.pb.go new file mode 100644 index 000000000..e1c269b6d --- /dev/null +++ b/internal/test/testproto/test.pb.go @@ -0,0 +1,177 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.17.3 +// source: testproto/test.proto + +package testproto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type TestModel struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Hobby []string `protobuf:"bytes,3,rep,name=hobby,proto3" json:"hobby,omitempty"` + Attrs map[string]string `protobuf:"bytes,4,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *TestModel) Reset() { + *x = TestModel{} + if protoimpl.UnsafeEnabled { + mi := &file_testproto_test_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TestModel) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TestModel) ProtoMessage() {} + +func (x *TestModel) ProtoReflect() protoreflect.Message { + mi := &file_testproto_test_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TestModel.ProtoReflect.Descriptor instead. +func (*TestModel) Descriptor() ([]byte, []int) { + return file_testproto_test_proto_rawDescGZIP(), []int{0} +} + +func (x *TestModel) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +func (x *TestModel) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *TestModel) GetHobby() []string { + if x != nil { + return x.Hobby + } + return nil +} + +func (x *TestModel) GetAttrs() map[string]string { + if x != nil { + return x.Attrs + } + return nil +} + +var File_testproto_test_proto protoreflect.FileDescriptor + +var file_testproto_test_proto_rawDesc = []byte{ + 0x0a, 0x14, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x74, 0x65, 0x73, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x04, 0x74, 0x65, 0x73, 0x74, 0x22, 0xb3, 0x01, 0x0a, + 0x0a, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x68, 0x6f, 0x62, 0x62, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, + 0x68, 0x6f, 0x62, 0x62, 0x79, 0x12, 0x31, 0x0a, 0x05, 0x61, 0x74, 0x74, 0x72, 0x73, 0x18, 0x04, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x65, 0x73, 0x74, + 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x2e, 0x41, 0x74, 0x74, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x52, 0x05, 0x61, 0x74, 0x74, 0x72, 0x73, 0x1a, 0x38, 0x0a, 0x0a, 0x41, 0x74, 0x74, 0x72, + 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x42, 0x0e, 0x5a, 0x0c, 0x2e, 0x2e, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_testproto_test_proto_rawDescOnce sync.Once + file_testproto_test_proto_rawDescData = file_testproto_test_proto_rawDesc +) + +func file_testproto_test_proto_rawDescGZIP() []byte { + file_testproto_test_proto_rawDescOnce.Do(func() { + file_testproto_test_proto_rawDescData = protoimpl.X.CompressGZIP(file_testproto_test_proto_rawDescData) + }) + return file_testproto_test_proto_rawDescData +} + +var file_testproto_test_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_testproto_test_proto_goTypes = []interface{}{ + (*TestModel)(nil), // 0: test.test_model + nil, // 1: test.test_model.AttrsEntry +} +var file_testproto_test_proto_depIdxs = []int32{ + 1, // 0: test.test_model.attrs:type_name -> test.test_model.AttrsEntry + 1, // [1:1] is the sub-list for method output_type + 1, // [1:1] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_testproto_test_proto_init() } +func file_testproto_test_proto_init() { + if File_testproto_test_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_testproto_test_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TestModel); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_testproto_test_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_testproto_test_proto_goTypes, + DependencyIndexes: file_testproto_test_proto_depIdxs, + MessageInfos: file_testproto_test_proto_msgTypes, + }.Build() + File_testproto_test_proto = out.File + file_testproto_test_proto_rawDesc = nil + file_testproto_test_proto_goTypes = nil + file_testproto_test_proto_depIdxs = nil +} diff --git a/internal/test/testproto/test.proto b/internal/test/testproto/test.proto new file mode 100644 index 000000000..d23f0d303 --- /dev/null +++ b/internal/test/testproto/test.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; + +package test; + +option go_package = "../testproto"; + +message test_model { + int64 id = 1; + string name = 2; + repeated string hobby = 3; + map attrs = 4; +} \ No newline at end of file