unistack-org/micro-tests
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update test

Browse Source 
Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>
This commit is contained in:
Василий Толстов
2023-01-18 10:11:41 +03:00
parent 71f7338a41
commit 301e584869
5 changed files with 156 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
wrapper/sql/wrapper_test.go
View File

@@ -16,6 +16,7 @@ import (
"github.com/uber/jaeger-client-go"
"github.com/uber/jaeger-client-go/config"
vmeter "go.unistack.org/micro-meter-victoriametrics/v3"
ot "go.unistack.org/micro-tracer-opentracing/v3"
wrapper "go.unistack.org/micro-wrapper-sql/v3"
"go.unistack.org/micro/v3/logger"
"go.unistack.org/micro/v3/meter"
@@ -65,12 +66,10 @@ func TestWrapper(t *testing.T) {
t.Fatal(err)
}
tr, c := initJaeger("Test tracing")
tr, c := initJaeger(fmt.Sprintf("Test tracing %s", time.Now().Format(time.RFC1123Z)))
defer c.Close()
opentracing.SetGlobalTracer(tr)
tracer.DefaultTracer = &opentracingTracer{
tracer: tr,
}
tracer.DefaultTracer = ot.NewTracer(ot.Tracer(tr))
if err := tracer.DefaultTracer.Init(); err != nil {
logger.Fatal(ctx, err)
}
@@ -81,7 +80,7 @@ func TestWrapper(t *testing.T) {
wrapper.LoggerLevel(logger.DebugLevel),
wrapper.LoggerEnabled(true),
))
wdb, err := sql.Open("micro-wrapper-sql", ":memory:")
wdb, err := sql.Open("micro-wrapper-sql", "test.db?cache=shared&mode=memory")
if err != nil {
t.Fatal(err)
}
@@ -92,42 +91,38 @@ func TestWrapper(t *testing.T) {
defer cancel()
wrapper.NewStatsMeter(ctx, db, wrapper.DatabaseHost("localhost"), wrapper.DatabaseName("memory"))
if _, err := wdb.ExecContext(wrapper.QueryName(ctx, "schema create"), schema); err != nil {
t.Fatal(err)
}
fmt.Printf("begintx\n")
tx1, err := wdb.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
t.Fatal(err)
}
tx2, err := wdb.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
tx, err := wdb.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
fmt.Printf("exec1\n")
if _, err := tx1.ExecContext(wrapper.QueryName(ctx, "insert one"), "INSERT OR REPLACE INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "Fist1", "Last1", "Email1"); err != nil {
if _, err := tx.ExecContext(wrapper.QueryName(ctx, "schema create"), schema); err != nil {
t.Fatal(err)
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
tx, err = wdb.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
if _, err := tx.ExecContext(wrapper.QueryName(ctx, "insert one"), "INSERT INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "Fist1", "Last1", "Email1"); err != nil {
t.Fatal(err)
}
fmt.Printf("exec none\n")
if _, err := wdb.ExecContext(wrapper.QueryName(ctx, "double schema"), schema); err != nil {
t.Fatal(err)
}
fmt.Printf("exec2\n")
if _, err := tx2.ExecContext(wrapper.QueryName(ctx, "insert two"), "INSERT OR REPLACE INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "Fist2", "Last2", "Email2"); err != nil {
if _, err := tx.ExecContext(wrapper.QueryName(ctx, "insert two"), "INSERT INTO person (first_name, last_name, email) VALUES ($1, $2, $3)", "Fist2", "Last2", "Email2"); err != nil {
t.Fatal(err)
}
fmt.Printf("commit1\n")
if err := tx1.Commit(); err != nil {
t.Fatal(err)
}
fmt.Printf("commit2\n")
if err := tx2.Commit(); err != nil {
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
@@ -138,6 +133,7 @@ func TestWrapper(t *testing.T) {
_ = peoples
time.Sleep(1 * time.Second)
mbuf := bytes.NewBuffer(nil)
_ = meter.DefaultMeter.Write(mbuf, meter.WriteProcessMetrics(true))
@@ -155,7 +151,7 @@ func TestWrapper(t *testing.T) {
[]byte(`"took":`),
} {
if !bytes.Contains(buf.Bytes(), tcase) {
t.Fatalf("micro-wrapper-sql logger output contains invalid output: %s", buf.Bytes())
t.Fatalf("micro-wrapper-sql logger output miss %s in output: %s", tcase, buf.Bytes())
}
}

210
wrapper/trace/datadog/datadog_test.go
View File

@@ -1,210 +0,0 @@
//go:build ignore
// +build ignore
package datadog
import (
"context"
"sync"
"testing"
"github.com/stretchr/testify/assert"
rrouter "go.unistack.org/micro-router-register/v3"
"go.unistack.org/micro/register/memory"
"go.unistack.org/micro/v3/client"
microerr "go.unistack.org/micro/v3/errors"
"go.unistack.org/micro/v3/router"
"go.unistack.org/micro/v3/server"
"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/ext"
"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/mocktracer"
"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
cli "go.unistack.org/micro/v3/client"
srv "go.unistack.org/micro/v3/server"
)
type Test interface {
Method(ctx context.Context, in *TestRequest, opts ...client.CallOption) (*TestResponse, error)
}
type TestRequest struct {
IsError bool
}
type TestResponse struct {
Message string
}
type testHandler struct{}
func (t *testHandler) Method(ctx context.Context, req *TestRequest, rsp *TestResponse) error {
if req.IsError {
return microerr.BadRequest("bad", "test error")
}
rsp.Message = "passed"
return nil
}
func TestClient(t *testing.T) {
// setup
assert := assert.New(t)
for name, tt := range map[string]struct {
message string
isError bool
wantMessage string
wantStatus string
}{
"OK": {
message: "passed",
isError: false,
wantMessage: "passed",
wantStatus: "OK",
},
"Invalid": {
message: "",
isError: true,
wantMessage: "",
wantStatus: "InvalidArgument",
},
} {
t.Run(name, func(t *testing.T) {
mt := mocktracer.Start()
defer mt.Stop()
register := memory.NewRegister()
serverName := "micro.server.name"
serverID := "id-1234567890"
serverVersion := "1.0.0"
c := cli.NewClient(
client.Router(rrouter.NewRouter(router.Register(register))),
client.WrapCall(NewCallWrapper()),
)
s := srv.NewServer(
server.Name(serverName),
server.Version(serverVersion),
server.Id(serverID),
server.Register(register),
server.WrapSubscriber(NewSubscriberWrapper()),
server.WrapHandler(NewHandlerWrapper()),
)
defer s.Stop()
type Test struct {
*testHandler
}
s.Handle(s.NewHandler(&Test{new(testHandler)}))
if err := s.Start(); err != nil {
t.Fatalf("Unexpected error starting server: %v", err)
}
span, ctx := StartSpanFromContext(context.Background(), "root", tracer.ServiceName("root"), tracer.ResourceName("root"))
req := c.NewRequest(serverName, "Test.Method", &TestRequest{IsError: tt.isError}, client.WithContentType("application/json"))
rsp := TestResponse{}
err := c.Call(ctx, req, &rsp)
if tt.isError {
assert.Error(err)
} else {
assert.NoError(err)
}
assert.Equal(rsp.Message, tt.message)
span.Finish()
spans := mt.FinishedSpans()
assert.Len(spans, 3)
var serverSpan, clientSpan, rootSpan mocktracer.Span
for _, s := range spans {
// order of traces in buffer is not garanteed
switch s.OperationName() {
case "micro.server":
serverSpan = s
case "micro.client":
clientSpan = s
case "root":
rootSpan = s
}
}
assert.NotNil(serverSpan)
assert.NotNil(clientSpan)
assert.NotNil(rootSpan)
assert.Equal(rootSpan.TraceID(), clientSpan.TraceID())
assert.Equal(serverSpan.Tag(tagStatus), tt.wantStatus)
assert.Equal("Test.Method", serverSpan.Tag(ext.ResourceName))
assert.Equal(rootSpan.TraceID(), serverSpan.TraceID())
})
}
}
func TestRace(t *testing.T) {
// setup
assert := assert.New(t)
mt := mocktracer.Start()
defer mt.Stop()
register := memory.NewRegister()
serverName := "micro.server.name"
serverID := "id-1234567890"
serverVersion := "1.0.0"
c := cli.NewClient(
client.Router(rrouter.NewRouter(router.Register(register))),
client.WrapCall(NewCallWrapper()),
)
s := srv.NewServer(
server.Name(serverName),
server.Version(serverVersion),
server.Id(serverID),
server.Register(register),
server.WrapSubscriber(NewSubscriberWrapper()),
server.WrapHandler(NewHandlerWrapper()),
)
defer s.Stop()
type Test struct {
*testHandler
}
s.Handle(s.NewHandler(&Test{new(testHandler)}))
if err := s.Start(); err != nil {
t.Fatalf("Unexpected error starting server: %v", err)
}
span, ctx := StartSpanFromContext(context.Background(), "root", tracer.ServiceName("root"), tracer.ResourceName("root"))
num := 100
var wg sync.WaitGroup
wg.Add(num)
for i := 0; i < num; i++ {
func() {
go func(i int) {
defer wg.Done()
req := c.NewRequest(serverName, "Test.Method", &TestRequest{IsError: false}, client.WithContentType("application/json"))
rsp := TestResponse{}
err := c.Call(ctx, req, &rsp)
assert.NoError(err)
}(i)
}()
}
wg.Wait()
span.Finish()
spans := mt.FinishedSpans()
assert.Len(spans, (num*2)+1)
}

151
wrapper/trace/opentracing/opentracing_test.go
View File

@@ -1,151 +0,0 @@
package opentracing_test
import (
"context"
"testing"
opentracing "github.com/opentracing/opentracing-go"
"github.com/opentracing/opentracing-go/mocktracer"
"github.com/stretchr/testify/assert"
cli "go.unistack.org/micro-client-grpc/v3"
jsoncodec "go.unistack.org/micro-codec-json/v3"
rrouter "go.unistack.org/micro-router-register/v3"
srv "go.unistack.org/micro-server-grpc/v3"
otwrapper "go.unistack.org/micro-wrapper-trace-opentracing/v3"
"go.unistack.org/micro/v3/broker"
"go.unistack.org/micro/v3/client"
"go.unistack.org/micro/v3/errors"
"go.unistack.org/micro/v3/register"
"go.unistack.org/micro/v3/router"
"go.unistack.org/micro/v3/server"
)
type Test interface {
Method(ctx context.Context, in *TestRequest, opts ...client.CallOption) (*TestResponse, error)
}
type TestRequest struct {
IsError bool
}
type TestResponse struct {
Message string
}
type testHandler struct{}
func (t *testHandler) Method(ctx context.Context, req *TestRequest, rsp *TestResponse) error {
if req.IsError {
return errors.BadRequest("bad", "test error")
}
rsp.Message = "passed"
return nil
}
func TestClient(t *testing.T) {
// setup
assert := assert.New(t)
for name, tt := range map[string]struct {
message string
isError bool
wantMessage string
wantStatus string
}{
"OK": {
message: "passed",
isError: false,
wantMessage: "passed",
wantStatus: "OK",
},
"Invalid": {
message: "",
isError: true,
wantMessage: "",
wantStatus: "InvalidArgument",
},
} {
t.Run(name, func(t *testing.T) {
tracer := mocktracer.New()
reg := register.NewRegister()
brk := broker.NewBroker(broker.Register(reg))
serverName := "micro.server.name"
serverID := "id-1234567890"
serverVersion := "1.0.0"
rt := rrouter.NewRouter(router.Register(reg))
c := cli.NewClient(
client.Codec("application/grpc+json", jsoncodec.NewCodec()),
client.Codec("application/json", jsoncodec.NewCodec()),
client.Router(rt),
client.Wrap(otwrapper.NewClientWrapper(otwrapper.WithTracer(tracer))),
)
s := srv.NewServer(
server.Codec("application/grpc+json", jsoncodec.NewCodec()),
server.Codec("application/json", jsoncodec.NewCodec()),
server.Name(serverName),
server.Version(serverVersion),
server.ID(serverID),
server.Register(reg),
server.Broker(brk),
server.WrapSubscriber(otwrapper.NewServerSubscriberWrapper(otwrapper.WithTracer(tracer))),
server.WrapHandler(otwrapper.NewServerHandlerWrapper(otwrapper.WithTracer(tracer))),
server.Address("127.0.0.1:0"),
)
if err := s.Init(); err != nil {
t.Fatal(err)
}
defer func() {
_ = s.Stop()
}()
type Test struct {
*testHandler
}
if err := s.Handle(s.NewHandler(&Test{new(testHandler)})); err != nil {
t.Fatal(err)
}
if err := s.Start(); err != nil {
t.Fatalf("Unexpected error starting server: %v", err)
}
ctx, span, err := otwrapper.StartSpanFromOutgoingContext(context.Background(), tracer, "root")
assert.NoError(err)
req := c.NewRequest(serverName, "Test.Method", &TestRequest{IsError: tt.isError}, client.RequestContentType("application/json"))
rsp := TestResponse{}
err = c.Call(ctx, req, &rsp)
if tt.isError {
assert.Error(err)
} else {
assert.NoError(err)
}
assert.Equal(rsp.Message, tt.message)
span.Finish()
spans := tracer.FinishedSpans()
assert.Len(spans, 3)
var rootSpan opentracing.Span
for _, s := range spans {
// order of traces in buffer is not garanteed
switch s.OperationName {
case "root":
rootSpan = s
}
}
for _, s := range spans {
assert.Equal(rootSpan.Context().(mocktracer.MockSpanContext).TraceID, s.Context().(mocktracer.MockSpanContext).TraceID)
}
})
}
}