This is an automated email from the ASF dual-hosted git repository.
littlecui pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/servicecomb-service-center.git
The following commit(s) were added to refs/heads/master by this push:
new 1ae29f4 Bug: govern api return empty schemaIds (#1257)
1ae29f4 is described below
commit 1ae29f4ba254997dee74c7717d028ef5702f8955
Author: little-cui <[email protected]>
AuthorDate: Fri Feb 11 14:46:02 2022 +0800
Bug: govern api return empty schemaIds (#1257)
---
datasource/etcd/ms.go | 63 +++-----
datasource/etcd/util.go | 26 ----
datasource/mongo/dao/microservice.go | 17 ---
datasource/mongo/microservice_util.go | 12 --
datasource/mongo/ms.go | 58 +++----
datasource/ms.go | 2 +-
datasource/service_test.go | 20 ---
server/service/disco/metadata.go | 4 +
server/service/govern/view.go | 77 +++++++++-
server/service/govern/view_test.go | 279 +++++++++++++++-------------------
10 files changed, 250 insertions(+), 308 deletions(-)
diff --git a/datasource/etcd/ms.go b/datasource/etcd/ms.go
index 85e64b1..d20c6ee 100644
--- a/datasource/etcd/ms.go
+++ b/datasource/etcd/ms.go
@@ -194,47 +194,6 @@ func (ds *MetadataManager) GetService(ctx context.Context,
request *pb.GetServic
return singleService, nil
}
-func (ds *MetadataManager) GetServiceDetail(ctx context.Context, request
*pb.GetServiceRequest) (
- *pb.ServiceDetail, error) {
- domainProject := util.ParseDomainProject(ctx)
-
- service, err := eutil.GetService(ctx, domainProject, request.ServiceId)
- if err != nil {
- if errors.Is(err, datasource.ErrNoData) {
- return nil, pb.NewError(pb.ErrServiceNotExists,
"Service does not exist.")
- }
- return nil, pb.NewError(pb.ErrInternal, err.Error())
- }
-
- key := &pb.MicroServiceKey{
- Tenant: domainProject,
- Environment: service.Environment,
- AppId: service.AppId,
- ServiceName: service.ServiceName,
- Version: "",
- }
- versions, err := getServiceAllVersions(ctx, key)
- if err != nil {
- log.Error(fmt.Sprintf("get service[%s/%s/%s] all versions
failed",
- service.Environment, service.AppId,
service.ServiceName), err)
- return nil, pb.NewError(pb.ErrInternal, err.Error())
- }
-
- options := []string{"tags", "instances", "schemas", "dependencies"}
- serviceInfo, err := getServiceDetailUtil(ctx, ServiceDetailOpt{
- domainProject: domainProject,
- service: service,
- options: options,
- })
- if err != nil {
- return nil, pb.NewError(pb.ErrInternal, err.Error())
- }
-
- serviceInfo.MicroService = service
- serviceInfo.MicroServiceVersions = versions
- return serviceInfo, nil
-}
-
func (ds *MetadataManager) ListServiceDetail(ctx context.Context, request
*pb.GetServicesInfoRequest) (
*pb.GetServicesInfoResponse, error) {
ctx = util.WithCacheOnly(ctx)
@@ -404,6 +363,28 @@ func (ds *MetadataManager) ExistService(ctx
context.Context, request *pb.GetExis
return ids[0], nil
}
+func (ds *MetadataManager) FindService(ctx context.Context, request
*pb.MicroServiceKey) (*pb.GetServicesResponse, error) {
+ copyKey := *request
+ copyKey.Tenant = util.ParseDomainProject(ctx)
+ copyKey.Version = ""
+ key := path.GenerateServiceIndexKey(©Key)
+ opts := append(eutil.FromContext(ctx), etcdadpt.WithStrKey(key),
etcdadpt.WithPrefix())
+
+ resp, err := sd.ServiceIndex().Search(ctx, opts...)
+ if err != nil {
+ return nil, err
+ }
+ result := &pb.GetServicesResponse{}
+ for _, kv := range resp.Kvs {
+ svc, err := ds.GetService(ctx, &pb.GetServiceRequest{ServiceId:
kv.Value.(string)})
+ if err != nil {
+ return nil, err
+ }
+ result.Services = append(result.Services, svc)
+ }
+ return result, nil
+}
+
func (ds *MetadataManager) PutServiceProperties(ctx context.Context, request
*pb.UpdateServicePropsRequest) error {
remoteIP := util.GetIPFromContext(ctx)
domainProject := util.ParseDomainProject(ctx)
diff --git a/datasource/etcd/util.go b/datasource/etcd/util.go
index a6267d2..2c641e0 100644
--- a/datasource/etcd/util.go
+++ b/datasource/etcd/util.go
@@ -171,32 +171,6 @@ func revokeInstance(ctx context.Context, domainProject
string, serviceID string,
return nil
}
-// governServiceCtrl util
-func getServiceAllVersions(ctx context.Context, serviceKey
*pb.MicroServiceKey) ([]string, error) {
- var versions []string
-
- copyKey := *serviceKey
- copyKey.Version = ""
- key := path.GenerateServiceIndexKey(©Key)
-
- opts := append(serviceUtil.FromContext(ctx),
- etcdadpt.WithStrKey(key),
- etcdadpt.WithPrefix())
-
- resp, err := sd.ServiceIndex().Search(ctx, opts...)
- if err != nil {
- return nil, err
- }
- if resp == nil || len(resp.Kvs) == 0 {
- return versions, nil
- }
- for _, keyValue := range resp.Kvs {
- key := path.GetInfoFromSvcIndexKV(keyValue.Key)
- versions = append(versions, key.Version)
- }
- return versions, nil
-}
-
func getServiceDetailUtil(ctx context.Context, serviceDetailOpt
ServiceDetailOpt) (*pb.ServiceDetail, error) {
serviceID := serviceDetailOpt.service.ServiceId
options := serviceDetailOpt.options
diff --git a/datasource/mongo/dao/microservice.go
b/datasource/mongo/dao/microservice.go
index 404da70..23f424c 100644
--- a/datasource/mongo/dao/microservice.go
+++ b/datasource/mongo/dao/microservice.go
@@ -128,23 +128,6 @@ func UpdateService(ctx context.Context, filter
interface{}, update interface{},
return nil
}
-func GetServicesVersions(ctx context.Context, filter interface{}) ([]string,
error) {
- res, err :=
mongo.GetClient().GetDB().Collection(model.CollectionService).Find(ctx, filter)
- if err != nil {
- return nil, nil
- }
- var versions []string
- for res.Next(ctx) {
- var tmp model.Service
- err := res.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- versions = append(versions, tmp.Service.Version)
- }
- return versions, nil
-}
-
func CountService(ctx context.Context, filter interface{}) (int64, error) {
count, err :=
mongo.GetClient().GetDB().Collection(model.CollectionService).CountDocuments(ctx,
filter)
if err != nil {
diff --git a/datasource/mongo/microservice_util.go
b/datasource/mongo/microservice_util.go
index 7b61a34..ef1ee44 100644
--- a/datasource/mongo/microservice_util.go
+++ b/datasource/mongo/microservice_util.go
@@ -60,18 +60,6 @@ func ServiceExistID(ctx context.Context, serviceID string)
(bool, error) {
return num != 0, err
}
-func GetAllServicesByDomainProject(ctx context.Context) ([]*model.Service,
error) {
- services, exist :=
cache.GetServicesByDomainProject(util.ParseDomainProject(ctx))
- if exist {
- return services, nil
- }
-
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{model.ColumnDomain: domain, model.ColumnProject:
project}
- return dao.GetServices(ctx, filter)
-}
-
func GetAllMicroServicesByDomainProject(ctx context.Context)
([]*discovery.MicroService, error) {
services, exist :=
cache.GetMicroServicesByDomainProject(util.ParseDomainProject(ctx))
if exist {
diff --git a/datasource/mongo/ms.go b/datasource/mongo/ms.go
index e871bbb..fd8a837 100644
--- a/datasource/mongo/ms.go
+++ b/datasource/mongo/ms.go
@@ -248,6 +248,28 @@ func (ds *MetadataManager) ExistService(ctx
context.Context, request *discovery.
return ids[0], nil
}
+func (ds *MetadataManager) FindService(ctx context.Context, request
*discovery.MicroServiceKey) (*discovery.GetServicesResponse, error) {
+ filter := mutil.NewBasicFilter(ctx,
+ mutil.ServiceEnv(request.Environment),
+ mutil.ServiceAppID(request.AppId),
+ mutil.ServiceServiceName(request.ServiceName),
+ )
+ res, err :=
dmongo.GetClient().GetDB().Collection(model.CollectionService).Find(ctx, filter)
+ if err != nil {
+ return nil, err
+ }
+ result := &discovery.GetServicesResponse{}
+ for res.Next(ctx) {
+ var tmp model.Service
+ err := res.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ result.Services = append(result.Services, tmp.Service)
+ }
+ return result, nil
+}
+
func (ds *MetadataManager) UnregisterService(ctx context.Context, request
*discovery.DeleteServiceRequest) error {
remoteIP := util.GetIPFromContext(ctx)
serviceID := request.ServiceId
@@ -379,42 +401,6 @@ func updateServiceTxn(ctx context.Context, request
*discovery.UpdateServiceProps
})
}
-func (ds *MetadataManager) GetServiceDetail(ctx context.Context, request
*discovery.GetServiceRequest) (
- *discovery.ServiceDetail, error) {
- mgSvc, err := GetServiceByID(ctx, request.ServiceId)
- if err != nil {
- if errors.Is(err, datasource.ErrNoData) {
- return nil,
discovery.NewError(discovery.ErrServiceNotExists, "Service does not exist.")
- }
- return nil, discovery.NewError(discovery.ErrInternal,
err.Error())
- }
- svc := mgSvc.Service
- key := &discovery.MicroServiceKey{
- Environment: svc.Environment,
- AppId: svc.AppId,
- ServiceName: svc.ServiceName,
- }
- filter := mutil.NewBasicFilter(ctx,
- mutil.ServiceEnv(key.Environment),
- mutil.ServiceAppID(key.AppId),
- mutil.ServiceServiceName(key.ServiceName),
- )
- versions, err := dao.GetServicesVersions(ctx, filter)
- if err != nil {
- log.Error(fmt.Sprintf("get service %s %s %s all versions
failed", svc.Environment, svc.AppId, svc.ServiceName), err)
- return nil, discovery.NewError(discovery.ErrInternal,
err.Error())
- }
- options := []string{"tags", "instances", "schemas", "dependencies"}
- serviceInfo, err := getServiceDetailUtil(ctx, mgSvc, false, options)
- if err != nil {
- return nil, discovery.NewError(discovery.ErrInternal,
err.Error())
- }
- serviceInfo.MicroService = svc
- serviceInfo.MicroServiceVersions = versions
- return serviceInfo, nil
-
-}
-
func (ds *MetadataManager) ListServiceDetail(ctx context.Context, request
*discovery.GetServicesInfoRequest) (*discovery.GetServicesInfoResponse, error) {
optionMap := make(map[string]struct{}, len(request.Options))
for _, opt := range request.Options {
diff --git a/datasource/ms.go b/datasource/ms.go
index 15a9f55..073a3dd 100644
--- a/datasource/ms.go
+++ b/datasource/ms.go
@@ -46,7 +46,6 @@ type MetadataManager interface {
ListService(ctx context.Context, request *pb.GetServicesRequest)
(*pb.GetServicesResponse, error)
GetService(ctx context.Context, request *pb.GetServiceRequest)
(*pb.MicroService, error)
- GetServiceDetail(ctx context.Context, request *pb.GetServiceRequest)
(*pb.ServiceDetail, error)
ListServiceDetail(ctx context.Context, request
*pb.GetServicesInfoRequest) (*pb.GetServicesInfoResponse, error)
GetOverview(ctx context.Context, request *pb.GetServicesRequest)
(*pb.Statistics, error)
ListApp(ctx context.Context, request *pb.GetAppsRequest)
(*pb.GetAppsResponse, error)
@@ -56,6 +55,7 @@ type MetadataManager interface {
PutServiceProperties(ctx context.Context, request
*pb.UpdateServicePropsRequest) error
UnregisterService(ctx context.Context, request
*pb.DeleteServiceRequest) error
CountService(ctx context.Context, request *pb.GetServiceCountRequest)
(*pb.GetServiceCountResponse, error)
+ FindService(ctx context.Context, request *pb.MicroServiceKey)
(*pb.GetServicesResponse, error)
// Instance management
RegisterInstance(ctx context.Context, request
*pb.RegisterInstanceRequest) (*pb.RegisterInstanceResponse, error)
diff --git a/datasource/service_test.go b/datasource/service_test.go
index 3be93c6..b736bfb 100644
--- a/datasource/service_test.go
+++ b/datasource/service_test.go
@@ -709,31 +709,11 @@ func TestService_Detail(t *testing.T) {
})
assert.NoError(t, err)
- log.Info("when get invalid service detail, should be failed")
- respD, err :=
datasource.GetMetadataManager().GetServiceDetail(ctx, &pb.GetServiceRequest{
- ServiceId: "",
- })
- assert.Error(t, err)
- assert.Nil(t, respD)
-
- log.Info("when get a service detail, should be passed")
- respGetServiceDetail, err :=
datasource.GetMetadataManager().GetServiceDetail(ctx, &pb.GetServiceRequest{
- ServiceId: serviceId,
- })
- assert.NoError(t, err)
- assert.Equal(t, serviceId,
respGetServiceDetail.MicroService.ServiceId)
-
err = datasource.GetMetadataManager().UnregisterService(ctx,
&pb.DeleteServiceRequest{
ServiceId: serviceId,
Force: true,
})
assert.NoError(t, err)
-
- respGetServiceDetail, err =
datasource.GetMetadataManager().GetServiceDetail(ctx, &pb.GetServiceRequest{
- ServiceId: serviceId,
- })
- assert.Error(t, err)
- assert.Nil(t, respGetServiceDetail)
})
}
diff --git a/server/service/disco/metadata.go b/server/service/disco/metadata.go
index 87b801b..9fbb253 100644
--- a/server/service/disco/metadata.go
+++ b/server/service/disco/metadata.go
@@ -153,6 +153,10 @@ func ListService(ctx context.Context, in
*pb.GetServicesRequest) (*pb.GetService
return resp, err
}
+func FindService(ctx context.Context, in *pb.MicroServiceKey)
(*pb.GetServicesResponse, error) {
+ return datasource.GetMetadataManager().FindService(ctx, in)
+}
+
func UnregisterManyService(ctx context.Context, request
*pb.DelServicesRequest) (*pb.DelServicesResponse, error) {
remoteIP := util.GetIPFromContext(ctx)
diff --git a/server/service/govern/view.go b/server/service/govern/view.go
index b0b165d..d519cdd 100644
--- a/server/service/govern/view.go
+++ b/server/service/govern/view.go
@@ -19,9 +19,12 @@ package govern
import (
"context"
+ "fmt"
"github.com/apache/servicecomb-service-center/datasource"
+ "github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
+ discosvc
"github.com/apache/servicecomb-service-center/server/service/disco"
"github.com/apache/servicecomb-service-center/server/service/validator"
pb "github.com/go-chassis/cari/discovery"
)
@@ -34,11 +37,81 @@ func ListServiceDetail(ctx context.Context, in
*pb.GetServicesInfoRequest) (*pb.
func GetServiceDetail(ctx context.Context, in *pb.GetServiceRequest)
(*pb.ServiceDetail, error) {
ctx = util.WithCacheOnly(ctx)
- if len(in.ServiceId) == 0 {
+ serviceID := in.ServiceId
+ if len(serviceID) == 0 {
return nil, pb.NewError(pb.ErrInvalidParams, "Invalid request
for getting service detail.")
}
- return datasource.GetMetadataManager().GetServiceDetail(ctx, in)
+ service, err := discosvc.GetService(ctx, in)
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s] failed", serviceID), err)
+ return nil, err
+ }
+
+ serviceInfo := new(pb.ServiceDetail)
+ serviceInfo.MicroService = service
+
+ key := &pb.MicroServiceKey{
+ Environment: service.Environment,
+ AppId: service.AppId,
+ ServiceName: service.ServiceName,
+ }
+ versions, err := getServiceAllVersions(ctx, key)
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s/%s/%s] all versions
failed",
+ service.Environment, service.AppId,
service.ServiceName), err)
+ return nil, pb.NewError(pb.ErrInternal, err.Error())
+ }
+ serviceInfo.MicroServiceVersions = versions
+
+ tagsResp, err := discosvc.ListTag(ctx,
&pb.GetServiceTagsRequest{ServiceId: serviceID})
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s] tags failed",
serviceID), err)
+ return nil, err
+ }
+ serviceInfo.Tags = tagsResp.Tags
+
+ schemas, err := discosvc.ListSchema(ctx,
&pb.GetAllSchemaRequest{ServiceId: serviceID, WithSchema: true})
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s] schemas failed",
serviceID), err)
+ return nil, err
+ }
+ serviceInfo.SchemaInfos = schemas
+
+ providerResp, err := discosvc.ListProviders(ctx,
&pb.GetDependenciesRequest{ServiceId: serviceID})
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s] providers failed",
serviceID), err)
+ return nil, err
+ }
+ serviceInfo.Providers = providerResp.Providers
+
+ consumerResp, err := discosvc.ListConsumers(ctx,
&pb.GetDependenciesRequest{ServiceId: serviceID})
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s] consumers failed",
serviceID), err)
+ return nil, err
+ }
+ serviceInfo.Consumers = consumerResp.Consumers
+
+ instResp, err := discosvc.ListInstance(ctx,
&pb.GetInstancesRequest{ProviderServiceId: serviceID})
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s] instances failed",
serviceID), err)
+ return nil, err
+ }
+ serviceInfo.Instances = instResp.Instances
+
+ return serviceInfo, nil
+}
+
+func getServiceAllVersions(ctx context.Context, key *pb.MicroServiceKey)
([]string, error) {
+ resp, err := discosvc.FindService(ctx, key)
+ if err != nil {
+ return nil, err
+ }
+ versions := make([]string, 0, len(resp.Services))
+ for _, svc := range resp.Services {
+ versions = append(versions, svc.Version)
+ }
+ return versions, nil
}
func ListApp(ctx context.Context, in *pb.GetAppsRequest) (*pb.GetAppsResponse,
error) {
diff --git a/server/service/govern/view_test.go
b/server/service/govern/view_test.go
index 6ac832e..70684fe 100644
--- a/server/service/govern/view_test.go
+++ b/server/service/govern/view_test.go
@@ -20,186 +20,159 @@ import (
"context"
"testing"
- "github.com/onsi/ginkgo/reporters"
-
_ "github.com/apache/servicecomb-service-center/test"
"github.com/apache/servicecomb-service-center/pkg/util"
"github.com/apache/servicecomb-service-center/server/service/disco"
"github.com/apache/servicecomb-service-center/server/service/govern"
pb "github.com/go-chassis/cari/discovery"
- . "github.com/onsi/ginkgo"
- . "github.com/onsi/gomega"
+ "github.com/go-chassis/cari/pkg/errsvc"
+ "github.com/stretchr/testify/assert"
)
-func TestGovern(t *testing.T) {
- RegisterFailHandler(Fail)
- junitReporter := reporters.NewJUnitReporter("model.junit.xml")
- RunSpecsWithDefaultAndCustomReporters(t, "model Suite",
[]Reporter{junitReporter})
-}
-
func getContext() context.Context {
return util.WithNoCache(util.SetDomainProject(context.Background(),
"default", "default"))
}
-var _ = Describe("'Govern' service", func() {
- Describe("execute 'get all' operation", func() {
- Context("when get all services", func() {
- It("should be passed", func() {
- By("all options")
- resp, err :=
govern.ListServiceDetail(getContext(), &pb.GetServicesInfoRequest{
- Options: []string{"all"},
- })
- Expect(err).To(BeNil())
- Expect(resp).ToNot(BeNil())
-
- By("only service metadata")
- resp, err =
govern.ListServiceDetail(getContext(), &pb.GetServicesInfoRequest{
- Options: []string{""},
- })
- Expect(err).To(BeNil())
- Expect(resp).ToNot(BeNil())
-
- By("custom options")
- resp, err =
govern.ListServiceDetail(getContext(), &pb.GetServicesInfoRequest{
- Options: []string{"tags", "rules",
"instances", "schemas", "statistics"},
- })
- Expect(err).To(BeNil())
- Expect(resp).ToNot(BeNil())
-
- By("'statistics' option")
- resp, err =
govern.ListServiceDetail(getContext(), &pb.GetServicesInfoRequest{
- Options: []string{"statistics"},
- })
- Expect(err).To(BeNil())
- Expect(resp).ToNot(BeNil())
-
- By("get instance count")
- resp, err =
govern.ListServiceDetail(getContext(), &pb.GetServicesInfoRequest{
- Options: []string{"instances"},
- CountOnly: true,
- })
- Expect(err).To(BeNil())
- Expect(resp).ToNot(BeNil())
- })
+func TestListServiceDetail(t *testing.T) {
+ t.Run("when get all services, should be passed", func(t *testing.T) {
+ resp, err := govern.ListServiceDetail(getContext(),
&pb.GetServicesInfoRequest{
+ Options: []string{"all"},
+ })
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
+
+ resp, err = govern.ListServiceDetail(getContext(),
&pb.GetServicesInfoRequest{
+ Options: []string{""},
+ })
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
+
+ resp, err = govern.ListServiceDetail(getContext(),
&pb.GetServicesInfoRequest{
+ Options: []string{"tags", "rules", "instances",
"schemas", "statistics"},
})
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
- Context("when get top graph", func() {
- It("should be passed", func() {
- respC, err :=
disco.RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId:
"govern_service_group",
- ServiceName:
"govern_service_graph",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
-
Expect(respC.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- graph, err := govern.Draw(getContext(), false)
- Expect(err).To(BeNil())
- Expect(len(graph.Nodes)).ToNot(Equal(0))
- })
+ resp, err = govern.ListServiceDetail(getContext(),
&pb.GetServicesInfoRequest{
+ Options: []string{"statistics"},
})
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
+
+ resp, err = govern.ListServiceDetail(getContext(),
&pb.GetServicesInfoRequest{
+ Options: []string{"instances"},
+ CountOnly: true,
+ })
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
})
- Describe("execute 'get detail' operation", func() {
- var (
- serviceId string
- )
-
- It("should be passed", func() {
- resp, err := disco.RegisterService(getContext(),
&pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "govern_service_group",
- ServiceName: "govern_service_name",
- Version: "3.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
-
Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- serviceId = resp.ServiceId
+ t.Run("when get top graph, should be passed", func(t *testing.T) {
+ respC, err := disco.RegisterService(getContext(),
&pb.CreateServiceRequest{
+ Service: &pb.MicroService{
+ AppId: "govern_service_group",
+ ServiceName: "govern_service_graph",
+ Version: "1.0.0",
+ Level: "FRONT",
+ Status: pb.MS_UP,
+ },
+ })
+ assert.NoError(t, err)
+ assert.NotNil(t, respC)
- err = disco.PutSchema(getContext(),
&pb.ModifySchemaRequest{
+ graph, err := govern.Draw(getContext(), false)
+ assert.NoError(t, err)
+ assert.NotEqual(t, 0, len(graph.Nodes))
+ })
+}
+
+func TestListApp(t *testing.T) {
+ t.Run("when request is invalid, should be failed", func(t *testing.T) {
+ resp, err := govern.ListApp(getContext(), &pb.GetAppsRequest{
+ Environment: "non-exist-env",
+ })
+ assert.True(t, errsvc.IsErrEqualCode(err, pb.ErrInvalidParams),
err)
+ assert.Nil(t, resp)
+ })
+
+ t.Run("when request is valid, should be passed", func(t *testing.T) {
+ resp, err := govern.ListApp(getContext(), &pb.GetAppsRequest{})
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
+
+ resp, err = govern.ListApp(getContext(), &pb.GetAppsRequest{
+ Environment: pb.ENV_ACCEPT,
+ })
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
+ })
+}
+
+func TestGetServiceDetail(t *testing.T) {
+ var (
+ serviceId string
+ )
+
+ t.Run("prepare data, should be passed", func(t *testing.T) {
+ resp, err := disco.RegisterService(getContext(),
&pb.CreateServiceRequest{
+ Service: &pb.MicroService{
+ AppId: "govern_service_group",
+ ServiceName: "govern_service_name",
+ Version: "3.0.0",
+ Level: "FRONT",
+ Status: pb.MS_UP,
+ },
+ })
+ assert.NoError(t, err)
+ assert.NotNil(t, resp)
+ serviceId = resp.ServiceId
+
+ err = disco.PutSchema(getContext(), &pb.ModifySchemaRequest{
+ ServiceId: serviceId,
+ SchemaId: "schemaId",
+ Schema: "detail",
+ })
+ assert.NoError(t, err)
+
+ _, err = disco.RegisterInstance(getContext(),
&pb.RegisterInstanceRequest{
+ Instance: &pb.MicroServiceInstance{
ServiceId: serviceId,
- SchemaId: "schemaId",
- Schema: "detail",
- })
- Expect(err).To(BeNil())
-
- _, err = disco.RegisterInstance(getContext(),
&pb.RegisterInstanceRequest{
- Instance: &pb.MicroServiceInstance{
- ServiceId: serviceId,
- Endpoints: []string{
- "govern:127.0.0.1:8080",
- },
- HostName: "UT-HOST",
- Status: pb.MSI_UP,
+ Endpoints: []string{
+ "govern:127.0.0.1:8080",
},
- })
- Expect(err).To(BeNil())
+ HostName: "UT-HOST",
+ Status: pb.MSI_UP,
+ },
})
+ assert.NoError(t, err)
+ })
- Context("when get invalid service detail", func() {
- It("should be failed", func() {
- resp, err :=
govern.GetServiceDetail(getContext(), &pb.GetServiceRequest{
- ServiceId: "",
- })
- Expect(err).ToNot(BeNil())
- Expect(resp).To(BeNil())
- })
+ t.Run("when get invalid service detail, should be failed", func(t
*testing.T) {
+ resp, err := govern.GetServiceDetail(getContext(),
&pb.GetServiceRequest{
+ ServiceId: "",
})
+ assert.True(t, errsvc.IsErrEqualCode(err, pb.ErrInvalidParams),
err)
+ assert.Nil(t, resp)
+ })
- Context("when get a service detail", func() {
- It("should be passed", func() {
- respGetServiceDetail, err :=
govern.GetServiceDetail(getContext(), &pb.GetServiceRequest{
- ServiceId: serviceId,
- })
- Expect(err).To(BeNil())
- Expect(respGetServiceDetail).ToNot(BeNil())
-
- err = disco.UnregisterService(getContext(),
&pb.DeleteServiceRequest{
- ServiceId: serviceId,
- Force: true,
- })
- Expect(err).To(BeNil())
-
- respGetServiceDetail, err =
govern.GetServiceDetail(getContext(), &pb.GetServiceRequest{
- ServiceId: serviceId,
- })
- Expect(err).ToNot(BeNil())
- Expect(respGetServiceDetail).To(BeNil())
- })
+ t.Run("when get a service detail, should be passed", func(t *testing.T)
{
+ respGetServiceDetail, err :=
govern.GetServiceDetail(getContext(), &pb.GetServiceRequest{
+ ServiceId: serviceId,
})
- })
+ assert.NoError(t, err)
+ assert.NotNil(t, respGetServiceDetail)
- Describe("execute 'get apps' operation", func() {
- Context("when request is invalid", func() {
- It("should be failed", func() {
- resp, err := govern.ListApp(getContext(),
&pb.GetAppsRequest{
- Environment: "non-exist-env",
- })
- Expect(err).ToNot(BeNil())
- Expect(resp).To(BeNil())
- })
+ err = disco.UnregisterService(getContext(),
&pb.DeleteServiceRequest{
+ ServiceId: serviceId,
+ Force: true,
})
+ assert.NoError(t, err)
- Context("when request is valid", func() {
- It("should be passed", func() {
- resp, err := govern.ListApp(getContext(),
&pb.GetAppsRequest{})
- Expect(err).To(BeNil())
-
Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- resp, err = govern.ListApp(getContext(),
&pb.GetAppsRequest{
- Environment: pb.ENV_ACCEPT,
- })
- Expect(err).To(BeNil())
-
Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- })
+ respGetServiceDetail, err =
govern.GetServiceDetail(getContext(), &pb.GetServiceRequest{
+ ServiceId: serviceId,
})
+ assert.True(t, errsvc.IsErrEqualCode(err,
pb.ErrServiceNotExists), err)
+ assert.Nil(t, respGetServiceDetail)
})
-})
+}
