/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package datasource_test

import (
	"context"
	"strconv"
	"strings"
	"testing"

	"github.com/apache/servicecomb-service-center/datasource"
	"github.com/apache/servicecomb-service-center/pkg/log"
	"github.com/apache/servicecomb-service-center/pkg/util"
	"github.com/apache/servicecomb-service-center/server/config"
	"github.com/apache/servicecomb-service-center/server/core"
	pb "github.com/go-chassis/cari/discovery"
	"github.com/go-chassis/cari/pkg/errsvc"
	"github.com/stretchr/testify/assert"
)

func TestInstance_Create(t *testing.T) {
	var serviceID string
	ctx := getContext()
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID, Force: true})

	t.Run("create service", func(t *testing.T) {
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				ServiceName: "create_instance_service_ms",
				AppId:       "create_instance_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})

		assert.NoError(t, err)
		serviceID = respCreateService.ServiceId
	})

	t.Run("register instance", func(t *testing.T) {
		respCreateInst, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID,
				Endpoints: []string{
					"createInstance_ms:127.0.0.1:8080",
				},
				HostName: "UT-HOST",
				Status:   pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		assert.NotEqual(t, "", respCreateInst.InstanceId)

		respCreateInst, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				InstanceId: "customId_ms",
				ServiceId:  serviceID,
				Endpoints: []string{
					"createInstance_ms:127.0.0.1:8080",
				},
				HostName: "UT-HOST",
				Status:   pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		assert.Equal(t, "customId_ms", respCreateInst.InstanceId)
	})

	t.Run("update the same instance", func(t *testing.T) {
		instance := &pb.MicroServiceInstance{
			ServiceId: serviceID,
			Endpoints: []string{
				"sameInstance:127.0.0.1:8080",
			},
			HostName: "UT-HOST",
			Status:   pb.MSI_UP,
		}
		resp, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: instance,
		})
		assert.NoError(t, err)

		resp, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: instance,
		})
		assert.NoError(t, err)
		assert.Equal(t, instance.InstanceId, resp.InstanceId)
	})
}

func TestInstance_HeartBeat(t *testing.T) {
	var (
		serviceID   string
		instanceID1 string
		instanceID2 string
	)
	ctx := getContext()
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID, Force: true})

	t.Run("register service and instance, should pass", func(t *testing.T) {
		log.Info("register service")
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				ServiceName: "heartbeat_service_ms",
				AppId:       "heartbeat_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID = respCreateService.ServiceId

		respCreateInstance, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"heartbeat:127.0.0.1:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID1 = respCreateInstance.InstanceId

		respCreateInstance, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"heartbeat:127.0.0.2:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID2 = respCreateInstance.InstanceId
	})

	t.Run("update a lease", func(t *testing.T) {
		log.Info("valid instance")
		err := datasource.GetMetadataManager().SendHeartbeat(ctx, &pb.HeartbeatRequest{
			ServiceId:  serviceID,
			InstanceId: instanceID1,
		})
		assert.NoError(t, err)

		log.Info("serviceId does not exist")
		err = datasource.GetMetadataManager().SendHeartbeat(ctx, &pb.HeartbeatRequest{
			ServiceId:  "100000000000",
			InstanceId: instanceID1,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)

		log.Info("instance does not exist")
		err = datasource.GetMetadataManager().SendHeartbeat(ctx, &pb.HeartbeatRequest{
			ServiceId:  serviceID,
			InstanceId: "not-exist-ins",
		})
		testErr = err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)
	})

	t.Run("batch update lease", func(t *testing.T) {
		log.Info("request contains at least 1 instances")
		resp, err := datasource.GetMetadataManager().SendManyHeartbeat(ctx, &pb.HeartbeatSetRequest{
			Instances: []*pb.HeartbeatSetElement{
				{
					ServiceId:  serviceID,
					InstanceId: instanceID1,
				},
				{
					ServiceId:  serviceID,
					InstanceId: instanceID2,
				},
			},
		})
		assert.NoError(t, err)
		assert.Equal(t, 2, len(resp.Instances))
	})
}

func TestInstance_Update(t *testing.T) {
	var (
		serviceID  string
		instanceID string
	)
	ctx := getContext()
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID, Force: true})

	respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
		Service: &pb.MicroService{
			ServiceName: "update_instance_service_ms",
			AppId:       "update_instance_service_ms",
			Version:     "1.0.0",
			Level:       "FRONT",
			Status:      pb.MS_UP,
		},
	})
	assert.NoError(t, err)
	serviceID = respCreateService.ServiceId

	registerInstanceRequest := &pb.RegisterInstanceRequest{
		Instance: &pb.MicroServiceInstance{
			ServiceId: serviceID,
			Endpoints: []string{
				"updateInstance:127.0.0.1:8080",
			},
			HostName:   "UT-HOST-MS",
			Status:     pb.MSI_UP,
			Properties: map[string]string{"nodeIP": "test"},
		},
	}

	respCreateInstance, err := datasource.GetMetadataManager().RegisterInstance(ctx, registerInstanceRequest)
	assert.NoError(t, err)
	instanceID = respCreateInstance.InstanceId

	t.Run("update instance status", func(t *testing.T) {
		log.Info("update instance status to DOWN")
		err := datasource.GetMetadataManager().PutInstanceStatus(ctx, &pb.UpdateInstanceStatusRequest{
			ServiceId:  serviceID,
			InstanceId: instanceID,
			Status:     pb.MSI_DOWN,
		})
		assert.NoError(t, err)

		log.Info("update instance status to OUTOFSERVICE")
		err = datasource.GetMetadataManager().PutInstanceStatus(ctx, &pb.UpdateInstanceStatusRequest{
			ServiceId:  serviceID,
			InstanceId: instanceID,
			Status:     pb.MSI_OUTOFSERVICE,
		})
		assert.NoError(t, err)

		log.Info("update instance status to STARTING")
		err = datasource.GetMetadataManager().PutInstanceStatus(ctx, &pb.UpdateInstanceStatusRequest{
			ServiceId:  serviceID,
			InstanceId: instanceID,
			Status:     pb.MSI_STARTING,
		})
		assert.NoError(t, err)

		log.Info("update instance status to TESTING")
		err = datasource.GetMetadataManager().PutInstanceStatus(ctx, &pb.UpdateInstanceStatusRequest{
			ServiceId:  serviceID,
			InstanceId: instanceID,
			Status:     pb.MSI_TESTING,
		})
		assert.NoError(t, err)

		log.Info("update instance status to UP")
		err = datasource.GetMetadataManager().PutInstanceStatus(ctx, &pb.UpdateInstanceStatusRequest{
			ServiceId:  serviceID,
			InstanceId: instanceID,
			Status:     pb.MSI_UP,
		})
		assert.NoError(t, err)

		log.Info("update instance status with a not exist instance")
		err = datasource.GetMetadataManager().PutInstanceStatus(ctx, &pb.UpdateInstanceStatusRequest{
			ServiceId:  serviceID,
			InstanceId: "notexistins",
			Status:     pb.MSI_STARTING,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)
	})

	t.Run("update instance properties", func(t *testing.T) {
		log.Info("update one properties")
		err := datasource.GetMetadataManager().PutInstanceProperties(ctx,
			&pb.UpdateInstancePropsRequest{
				ServiceId:  serviceID,
				InstanceId: instanceID,
				Properties: map[string]string{
					"test": "test",
				},
			})
		assert.NoError(t, err)

		log.Info("all max properties updated")
		size := 1000
		properties := make(map[string]string, size)
		for i := 0; i < size; i++ {
			s := strconv.Itoa(i) + strings.Repeat("x", 253)
			properties[s] = s
		}
		err = datasource.GetMetadataManager().PutInstanceProperties(ctx,
			&pb.UpdateInstancePropsRequest{
				ServiceId:  serviceID,
				InstanceId: instanceID,
				Properties: properties,
			})
		assert.NoError(t, err)

		log.Info("update instance that does not exist")
		err = datasource.GetMetadataManager().PutInstanceProperties(ctx,
			&pb.UpdateInstancePropsRequest{
				ServiceId:  serviceID,
				InstanceId: "not_exist_ins",
				Properties: map[string]string{
					"test": "test",
				},
			})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)

		log.Info("remove properties")
		err = datasource.GetMetadataManager().PutInstanceProperties(ctx,
			&pb.UpdateInstancePropsRequest{
				ServiceId:  serviceID,
				InstanceId: instanceID,
			})
		assert.NoError(t, err)

		log.Info("update service that does not exist")
		err = datasource.GetMetadataManager().PutInstanceProperties(ctx,
			&pb.UpdateInstancePropsRequest{
				ServiceId:  "not_exist_service",
				InstanceId: instanceID,
				Properties: map[string]string{
					"test": "test",
				},
			})
		testErr = err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)
	})

	t.Run("update instance with valid request, should be ok", func(t *testing.T) {
		registerInstanceRequest.Instance.HostName = "updated"
		err := datasource.GetMetadataManager().PutInstance(ctx, registerInstanceRequest)
		assert.NoError(t, err)

		resp, err := datasource.GetMetadataManager().GetInstance(ctx, &pb.GetOneInstanceRequest{
			ProviderServiceId: serviceID, ProviderInstanceId: instanceID,
		})
		assert.NoError(t, err)
		assert.Equal(t, "updated", resp.Instance.HostName)
	})

	t.Run("update instance with invalid request, should be failed", func(t *testing.T) {
		err := datasource.GetMetadataManager().PutInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId:  "not-exit-ms",
				InstanceId: "not-exist-inst",
			},
		})
		assert.True(t, errsvc.IsErrEqualCode(err, pb.ErrInstanceNotExists))
	})
}

func TestInstance_Query(t *testing.T) {
	var (
		serviceID1  string
		serviceID2  string
		serviceID3  string
		serviceID4  string
		serviceID5  string
		serviceID6  string
		serviceID7  string
		serviceID8  string
		instanceID1 string
		instanceID2 string
		instanceID4 string
		instanceID5 string
		instanceID8 string
	)
	ctx := getContext()

	defer func() {
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID1, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID2, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID3, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID4, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID5, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID6, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID7, Force: true})
		datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceID8, Force: true})
	}()

	t.Run("register services and instances for testInstance_query", func(t *testing.T) {
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "query_instance_ms",
				ServiceName: "query_instance_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID1 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "query_instance_ms",
				ServiceName: "query_instance_service_ms",
				Version:     "1.0.5",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID2 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "query_instance_diff_app_ms",
				ServiceName: "query_instance_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID3 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				Environment: pb.ENV_PROD,
				AppId:       "query_instance_ms",
				ServiceName: "query_instance_diff_env_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID4 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				Environment: pb.ENV_PROD,
				AppId:       "default",
				ServiceName: "query_instance_shared_provider_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
				Properties: map[string]string{
					pb.PropAllowCrossApp: "true",
				},
			},
		})
		assert.NoError(t, err)
		serviceID5 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(
			util.SetDomainProject(util.CloneContext(ctx), "user", "user"),
			&pb.CreateServiceRequest{
				Service: &pb.MicroService{
					AppId:       "default",
					ServiceName: "query_instance_diff_domain_consumer_ms",
					Version:     "1.0.0",
					Level:       "FRONT",
					Status:      pb.MS_UP,
				},
			})
		assert.NoError(t, err)
		serviceID6 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "default",
				ServiceName: "query_instance_shared_consumer_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID7 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "query_instance_ms",
				ServiceName: "query_instance_with_rev_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceID8 = respCreateService.ServiceId

		respCreateInstance, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID1,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"find:127.0.0.1:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID1 = respCreateInstance.InstanceId

		respCreateInstance, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID2,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"find:127.0.0.2:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID2 = respCreateInstance.InstanceId

		respCreateInstance, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID4,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"find:127.0.0.4:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID4 = respCreateInstance.InstanceId

		respCreateInstance, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID5,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"find:127.0.0.5:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID5 = respCreateInstance.InstanceId

		respCreateInstance, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceID8,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"find:127.0.0.8:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceID8 = respCreateInstance.InstanceId
	})

	t.Run("query instance, should ok", func(t *testing.T) {
		respFind, err := datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID1,
			AppId:             "query_instance_ms",
			ServiceName:       "query_instance_service_ms",
		})
		assert.NoError(t, err)
		assertInstancesContain(t, respFind.Instances, instanceID1)
		assertInstancesContain(t, respFind.Instances, instanceID2)
	})

	t.Run("query not exist service instance, should failed", func(t *testing.T) {
		_, err := datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID1,
			AppId:             "query_instance_ms",
			ServiceName:       "not-exist",
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrServiceNotExists, testErr.Code)
	})

	t.Run("query instance when with consumerID or specify env without consumerID, should ok", func(t *testing.T) {
		respFind, err := datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID4,
			AppId:             "query_instance_ms",
			ServiceName:       "query_instance_diff_env_service_ms",
		})
		assert.NoError(t, err)
		assert.Equal(t, 1, len(respFind.Instances))
		assertInstancesContain(t, respFind.Instances, instanceID4)

		respFind, err = datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			Environment: pb.ENV_PROD,
			AppId:       "query_instance_ms",
			ServiceName: "query_instance_diff_env_service_ms",
		})
		assert.NoError(t, err)
		assert.Equal(t, 1, len(respFind.Instances))
		assertInstancesContain(t, respFind.Instances, instanceID4)
	})

	t.Run("query instance with revision, should ok", func(t *testing.T) {
		ctx := util.SetContext(ctx, util.CtxNocache, "")
		respFind, err := datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID8,
			AppId:             "query_instance_ms",
			ServiceName:       "query_instance_with_rev_ms",
		})
		assert.NoError(t, err)
		rev, _ := ctx.Value(util.CtxResponseRevision).(string)
		assert.NotEqual(t, 0, len(rev))
		assertInstancesContain(t, respFind.Instances, instanceID8)

		util.WithRequestRev(ctx, "x")
		respFind, err = datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID8,
			AppId:             "query_instance_ms",
			ServiceName:       "query_instance_with_rev_ms",
		})
		assert.NoError(t, err)
		assert.Equal(t, ctx.Value(util.CtxResponseRevision), rev)
		assertInstancesContain(t, respFind.Instances, instanceID8)
	})

	t.Run("find should return 200 if consumer is diff apps, should ok", func(t *testing.T) {
		respFind, err := datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID3,
			AppId:             "query_instance_ms",
			ServiceName:       "query_instance_service_ms",
		})
		assert.NoError(t, err)
		assert.Equal(t, 0, len(respFind.Instances))
	})

	t.Run("find provider instance but specify tag does not exist, should ok", func(t *testing.T) {
		respFind, err := datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID1,
			AppId:             "query_instance_ms",
			ServiceName:       "query_instance_service_ms",
			Tags:              []string{"not_exist_tag"},
		})
		assert.NoError(t, err)
		assert.Equal(t, 0, len(respFind.Instances))
	})

	t.Run("find global provider instance, should ok", func(t *testing.T) {
		config.Server.Config.GlobalVisible = "query_instance_shared_provider_ms"
		core.RegisterGlobalServices()
		core.Service.Environment = pb.ENV_PROD
		respFind, err := datasource.GetMetadataManager().FindInstances(
			util.SetTargetDomainProject(
				util.SetDomainProject(util.CloneContext(ctx), "user", "user"),
				"default", "default"),
			&pb.FindInstancesRequest{
				ConsumerServiceId: serviceID6,
				AppId:             "default",
				ServiceName:       "query_instance_shared_provider_ms",
			})
		assert.NoError(t, err)
		assert.Equal(t, 1, len(respFind.Instances))
		assertInstancesContain(t, respFind.Instances, instanceID5)

		respFind, err = datasource.GetMetadataManager().FindInstances(ctx, &pb.FindInstancesRequest{
			ConsumerServiceId: serviceID7,
			AppId:             "default",
			ServiceName:       "query_instance_shared_provider_ms",
		})
		assert.NoError(t, err)
		assert.Equal(t, 1, len(respFind.Instances))
		assertInstancesContain(t, respFind.Instances, instanceID5)

		log.Info("query same domain deps")
		// todo finish ut after implementing ListProviders interface

		core.Service.Environment = pb.ENV_DEV
	})

	t.Run("query instances between diff dimensions", func(t *testing.T) {
		log.Info("diff appId")
		UTFunc := func(consumerId string, code int32) {
			_, err := datasource.GetMetadataManager().ListInstance(ctx, &pb.GetInstancesRequest{
				ConsumerServiceId: consumerId,
				ProviderServiceId: serviceID2,
			})
			if code == pb.ResponseSuccess {
				assert.NoError(t, err)
				return
			}
			testErr := err.(*errsvc.Error)
			assert.Error(t, testErr)
			assert.Equal(t, code, testErr.Code)
		}

		UTFunc(serviceID3, pb.ErrServiceNotExists)

		UTFunc(serviceID1, pb.ResponseSuccess)

		log.Info("diff env")
		_, err := datasource.GetMetadataManager().ListInstance(ctx, &pb.GetInstancesRequest{
			ConsumerServiceId: serviceID4,
			ProviderServiceId: serviceID2,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrServiceNotExists, testErr.Code)
	})
}

func assertInstancesContain(t *testing.T, instances []*pb.MicroServiceInstance, instanceId string) {
	found := false
	for _, instance := range instances {
		if instance.InstanceId == instanceId {
			found = true
			break
		}
	}
	assert.True(t, found)
}

func TestServicesStatistics_Get(t *testing.T) {
	var ctx context.Context
	var serviceId1 string
	var serviceId2 string

	t.Run("register services and instances for TestServicesStatistics_Get", func(t *testing.T) {
		//service1
		ctx = util.WithNoCache(util.SetDomainProject(context.Background(), "default", "Project1"))
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "query_statistics1",
				ServiceName: "service1",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId1 = respCreateService.ServiceId

		_, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId1,
				HostName:  "UT-HOST-MS1",
				Endpoints: []string{
					"find:127.0.0.1:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)

		_, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId1,
				HostName:  "UT-HOST-MS2",
				Endpoints: []string{
					"find:127.0.0.1:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)

		//service2
		ctx = util.WithNoCache(util.SetDomainProject(context.Background(), "DomainTest1", "Project1"))
		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "query_statistics2",
				ServiceName: "service2-DomainTest1",
				Version:     "1.0.5",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId2 = respCreateService.ServiceId

		_, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId2,
				HostName:  "UT-HOST-MS1",
				Endpoints: []string{
					"find:127.0.0.1:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
	})

	t.Run("query services statistics", func(t *testing.T) {
		ctx = util.WithNoCache(util.SetDomainProject(context.Background(), "default", "Project1"))
		log.Info("query services default domain statistics")
		st, err := datasource.GetMetadataManager().GetOverview(ctx, &pb.GetServicesRequest{})
		assert.NoError(t, err)
		assert.Equal(t, int64(2), st.Instances.CountByDomain)

		log.Info("query services domain statistics")
		ctx = util.WithNoCache(util.SetDomainProject(context.Background(), "DomainTest1", "Project1"))
		st, err = datasource.GetMetadataManager().GetOverview(ctx, &pb.GetServicesRequest{})
		assert.NoError(t, err)
		assert.Equal(t, int64(1), st.Instances.CountByDomain)
	})

	t.Run("delete a service ", func(t *testing.T) {
		ctx = util.WithNoCache(util.SetDomainProject(context.Background(), "default", "Project1"))
		err := datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{
			ServiceId: serviceId1,
			Force:     true,
		})
		assert.NoError(t, err)

		ctx = util.WithNoCache(util.SetDomainProject(context.Background(), "DomainTest1", "Project1"))
		err = datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{
			ServiceId: serviceId2,
			Force:     true,
		})
		assert.NoError(t, err)
	})
}

func TestInstance_GetOne(t *testing.T) {
	var (
		serviceId1  string
		serviceId2  string
		serviceId3  string
		instanceId2 string
	)
	ctx := getContext()
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId1, Force: true})
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId2, Force: true})
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId3, Force: true})

	t.Run("register service and instances", func(t *testing.T) {
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "get_instance_ms",
				ServiceName: "get_instance_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId1 = respCreateService.ServiceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "get_instance_ms",
				ServiceName: "get_instance_service_ms",
				Version:     "1.0.5",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId2 = respCreateService.ServiceId

		respCreateInstance, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId2,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"get:127.0.0.2:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceId2 = respCreateInstance.InstanceId

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "get_instance_cross_ms",
				ServiceName: "get_instance_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId3 = respCreateService.ServiceId
	})

	t.Run("get one instance when invalid request", func(t *testing.T) {
		log.Info("find service itself")
		resp, err := datasource.GetMetadataManager().GetInstance(ctx, &pb.GetOneInstanceRequest{
			ConsumerServiceId:  serviceId2,
			ProviderServiceId:  serviceId2,
			ProviderInstanceId: instanceId2,
		})
		assert.NoError(t, err)
		assert.NotNil(t, resp.Instance)

		log.Info("consumer does not exist")
		_, err = datasource.GetMetadataManager().GetInstance(ctx, &pb.GetOneInstanceRequest{
			ConsumerServiceId:  "not-exist-id-ms",
			ProviderServiceId:  serviceId2,
			ProviderInstanceId: instanceId2,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrServiceNotExists, testErr.Code)
	})

	t.Run("get between diff apps", func(t *testing.T) {
		_, err := datasource.GetMetadataManager().GetInstance(ctx, &pb.GetOneInstanceRequest{
			ConsumerServiceId:  serviceId3,
			ProviderServiceId:  serviceId2,
			ProviderInstanceId: instanceId2,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)

		_, err = datasource.GetMetadataManager().ListInstance(ctx, &pb.GetInstancesRequest{
			ConsumerServiceId: serviceId3,
			ProviderServiceId: serviceId2,
		})
		testErr = err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrServiceNotExists, testErr.Code)
	})

	t.Run("get instances when request is invalid", func(t *testing.T) {
		log.Info("consumer does not exist")
		resp, err := datasource.GetMetadataManager().ListInstance(ctx, &pb.GetInstancesRequest{
			ConsumerServiceId: "not-exist-service-ms",
			ProviderServiceId: serviceId2,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrServiceNotExists, testErr.Code)

		log.Info("consumer does not exist")
		resp, err = datasource.GetMetadataManager().ListInstance(ctx, &pb.GetInstancesRequest{
			ConsumerServiceId: serviceId1,
			ProviderServiceId: serviceId2,
		})
		assert.NoError(t, err)
		assert.NotNil(t, resp)
	})
}

func TestInstance_GetAll(t *testing.T) {
	t.Run("register 2 instances, get all instances count should return 2", func(t *testing.T) {
		var (
			serviceId1 string
			serviceId2 string
		)
		ctx := util.WithNoCache(util.SetDomainProject(context.Background(), "TestInstance_GetAll", "1"))

		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "get_instance_ms",
				ServiceName: "get_instance_service_ms",
				Version:     "1.0.0",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId1 = respCreateService.ServiceId
		defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId1, Force: true})

		respCreateService, err = datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "get_instance_ms",
				ServiceName: "get_instance_service_ms",
				Version:     "1.0.5",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
		})
		assert.NoError(t, err)
		serviceId2 = respCreateService.ServiceId
		defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId2, Force: true})

		_, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId1,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"get:127.0.0.2:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)

		_, err = datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId2,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"get:127.0.0.3:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)

		respAll, err := datasource.GetMetadataManager().ListManyInstances(ctx, &pb.GetAllInstancesRequest{})
		assert.NoError(t, err)
		assert.Equal(t, 2, len(respAll.Instances))
	})

	t.Run("domain contain no instances, get all instances should be pass, return 0 instance", func(t *testing.T) {
		ctx := util.WithNoCache(util.SetDomainProject(context.Background(), "TestInstance_GetAll", "2"))
		respAll, err := datasource.GetMetadataManager().ListManyInstances(ctx, &pb.GetAllInstancesRequest{})
		assert.NoError(t, err)
		assert.Equal(t, 0, len(respAll.Instances))
	})
}

func TestInstance_Unregister(t *testing.T) {
	var (
		serviceId  string
		instanceId string
	)
	ctx := getContext()
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId, Force: true})

	t.Run("register service and instances", func(t *testing.T) {
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "unregister_instance_ms",
				ServiceName: "unregister_instance_service_ms",
				Version:     "1.0.5",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
			Tags: map[string]string{
				"test": "test",
			},
		})
		assert.NoError(t, err)
		serviceId = respCreateService.ServiceId

		respCreateInstance, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"unregister:127.0.0.2:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceId = respCreateInstance.InstanceId
	})

	t.Run("unregister instance", func(t *testing.T) {
		err := datasource.GetMetadataManager().UnregisterInstance(ctx, &pb.UnregisterInstanceRequest{
			ServiceId:  serviceId,
			InstanceId: instanceId,
		})
		assert.NoError(t, err)
	})

	t.Run("unregister instance when request is invalid", func(t *testing.T) {
		log.Info("service id does not exist")
		err := datasource.GetMetadataManager().UnregisterInstance(ctx, &pb.UnregisterInstanceRequest{
			ServiceId:  "not-exist-id-ms",
			InstanceId: instanceId,
		})
		testErr := err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)

		log.Info("instance id does not exist")
		err = datasource.GetMetadataManager().UnregisterInstance(ctx, &pb.UnregisterInstanceRequest{
			ServiceId:  serviceId,
			InstanceId: "not-exist-id-ms",
		})
		testErr = err.(*errsvc.Error)
		assert.Error(t, testErr)
		assert.Equal(t, pb.ErrInstanceNotExists, testErr.Code)
	})
}

func TestInstance_Exist(t *testing.T) {
	var (
		serviceId  string
		instanceId string
	)
	ctx := getContext()
	defer datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{ServiceId: serviceId, Force: true})

	t.Run("register service and instance", func(t *testing.T) {
		respCreateService, err := datasource.GetMetadataManager().RegisterService(ctx, &pb.CreateServiceRequest{
			Service: &pb.MicroService{
				AppId:       "check_exist_instance_ms",
				ServiceName: "check_exist_instance_service_ms",
				Version:     "1.0.5",
				Level:       "FRONT",
				Status:      pb.MS_UP,
			},
			Tags: map[string]string{
				"test": "test",
			},
		})
		assert.NoError(t, err)
		serviceId = respCreateService.ServiceId

		respCreateInstance, err := datasource.GetMetadataManager().RegisterInstance(ctx, &pb.RegisterInstanceRequest{
			Instance: &pb.MicroServiceInstance{
				ServiceId: serviceId,
				HostName:  "UT-HOST-MS",
				Endpoints: []string{
					"checkExist:127.0.0.2:8080",
				},
				Status: pb.MSI_UP,
			},
		})
		assert.NoError(t, err)
		instanceId = respCreateInstance.InstanceId
	})

	t.Run("the check instance should exist", func(t *testing.T) {
		respCheckInstance, err := datasource.GetMetadataManager().ExistInstance(ctx, &pb.MicroServiceInstanceKey{
			ServiceId:  serviceId,
			InstanceId: instanceId,
		})
		assert.NoError(t, err)
		assert.True(t, respCheckInstance.Exist)
	})

	t.Run("unregister instance", func(t *testing.T) {
		err := datasource.GetMetadataManager().UnregisterInstance(ctx, &pb.UnregisterInstanceRequest{
			ServiceId:  serviceId,
			InstanceId: instanceId,
		})
		assert.NoError(t, err)
	})

	t.Run("The check instance should not exist", func(t *testing.T) {
		resp, err := datasource.GetMetadataManager().ExistInstance(ctx, &pb.MicroServiceInstanceKey{
			ServiceId:  serviceId,
			InstanceId: instanceId,
		})
		assert.NoError(t, err)
		assert.False(t, resp.Exist)
	})

	t.Run("unregister service", func(t *testing.T) {
		err := datasource.GetMetadataManager().UnregisterService(ctx, &pb.DeleteServiceRequest{
			ServiceId: serviceId,
		})
		assert.NoError(t, err)
	})
}