Backport of NET-2286: Add tests for service resolver with onlypassing set to true into release/1.15.x

test/integration/consul-container/libs/assert/envoy.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/hashicorp/consul/sdk/testutil/retry"
+	libcluster "github.com/hashicorp/consul/test/integration/consul-container/libs/cluster"
 	"github.com/hashicorp/consul/test/integration/consul-container/libs/utils"
 	"github.com/hashicorp/go-cleanhttp"
 	"github.com/stretchr/testify/assert"
@@ -70,7 +71,11 @@ func AssertUpstreamEndpointStatus(t *testing.T, adminPort int, clusterName, heal
 		filter := fmt.Sprintf(`.cluster_statuses[] | select(.name|contains("%s")) | [.host_statuses[].health_status.eds_health_status] | [select(.[] == "%s")] | length`, clusterName, healthStatus)
 		results, err := utils.JQFilter(clusters, filter)
 		require.NoErrorf(r, err, "could not found cluster name %s", clusterName)
-		require.Equal(r, count, len(results))
+
+		resultToString := strings.Join(results, " ")
+		result, err := strconv.Atoi(resultToString)
+		assert.NoError(r, err)
+		require.Equal(r, count, result)
 	})
 }
 
@@ -251,3 +256,14 @@ func sanitizeResult(s string) []string {
 	result := strings.Split(strings.ReplaceAll(s, `,`, " "), " ")
 	return append(result[:0], result[1:]...)
 }
+
+// AssertServiceHasHealthyInstances asserts the number of instances of service equals count for a given service.
+// https://developer.hashicorp.com/consul/docs/connect/config-entries/service-resolver#onlypassing
+func AssertServiceHasHealthyInstances(t *testing.T, node libcluster.Agent, service string, onlypassing bool, count int) {
+	services, _, err := node.GetClient().Health().Service(service, "", onlypassing, nil)
+	require.NoError(t, err)
+	for _, v := range services {
+		fmt.Printf("%s service status: %s\n", v.Service.ID, v.Checks.AggregatedStatus())
+	}
+	require.Equal(t, count, len(services))
+}

test/integration/consul-container/libs/cluster/cluster.go

@@ -600,6 +600,20 @@ func (c *Cluster) ConfigEntryWrite(entry api.ConfigEntry) error {
 	return err
 }
 
+func (c *Cluster) ConfigEntryDelete(entry api.ConfigEntry) error {
+	client, err := c.GetClient(nil, true)
+	if err != nil {
+		return err
+	}
+
+	entries := client.ConfigEntries()
+	_, err = entries.Delete(entry.GetKind(), entry.GetName(), nil)
+	if err != nil {
+		return fmt.Errorf("error deleting config entry: %v", err)
+	}
+	return err
+}
+
 func extractSecretIDFrom(tokenOutput string) (string, error) {
 	lines := strings.Split(tokenOutput, "\n")
 	for _, line := range lines {

test/integration/consul-container/libs/service/helpers.go

@@ -3,6 +3,7 @@ package service
 import (
 	"context"
 	"fmt"
+
 	"github.com/hashicorp/consul/api"
 	libcluster "github.com/hashicorp/consul/test/integration/consul-container/libs/cluster"
 	"github.com/hashicorp/consul/test/integration/consul-container/libs/utils"
@@ -14,54 +15,46 @@ const (
 	StaticClientServiceName  = "static-client"
 )
 
+type Checks struct {
+	Name string
+	TTL  string
+}
+
+type SidecarService struct {
+	Port int
+}
+
 type ServiceOpts struct {
 	Name     string
 	ID       string
 	Meta     map[string]string
 	HTTPPort int
 	GRPCPort int
+	Checks   Checks
+	Connect  SidecarService
 }
 
-func CreateAndRegisterStaticServerAndSidecar(node libcluster.Agent, serviceOpts *ServiceOpts) (Service, Service, error) {
+// createAndRegisterStaticServerAndSidecar register the services and launch static-server containers
+func createAndRegisterStaticServerAndSidecar(node libcluster.Agent, grpcPort int, svc *api.AgentServiceRegistration) (Service, Service, error) {
 	// Do some trickery to ensure that partial completion is correctly torn
 	// down, but successful execution is not.
 	var deferClean utils.ResettableDefer
 	defer deferClean.Execute()
 
-	// Register the static-server service and sidecar first to prevent race with sidecar
-	// trying to get xDS before it's ready
-	req := &api.AgentServiceRegistration{
-		Name: serviceOpts.Name,
-		ID:   serviceOpts.ID,
-		Port: serviceOpts.HTTPPort,
-		Connect: &api.AgentServiceConnect{
-			SidecarService: &api.AgentServiceRegistration{
-				Proxy: &api.AgentServiceConnectProxyConfig{},
-			},
-		},
-		Check: &api.AgentServiceCheck{
-			Name:     "Static Server Listening",
-			TCP:      fmt.Sprintf("127.0.0.1:%d", serviceOpts.HTTPPort),
-			Interval: "10s",
-			Status:   api.HealthPassing,
-		},
-		Meta: serviceOpts.Meta,
-	}
-
-	if err := node.GetClient().Agent().ServiceRegister(req); err != nil {
+	if err := node.GetClient().Agent().ServiceRegister(svc); err != nil {
 		return nil, nil, err
 	}
 
 	// Create a service and proxy instance
-	serverService, err := NewExampleService(context.Background(), serviceOpts.ID, serviceOpts.HTTPPort, serviceOpts.GRPCPort, node)
+	serverService, err := NewExampleService(context.Background(), svc.ID, svc.Port, grpcPort, node)
 	if err != nil {
 		return nil, nil, err
 	}
 	deferClean.Add(func() {
 		_ = serverService.Terminate()
 	})
 
-	serverConnectProxy, err := NewConnectService(context.Background(), fmt.Sprintf("%s-sidecar", serviceOpts.ID), serviceOpts.ID, []int{serviceOpts.HTTPPort}, node) // bindPort not used
+	serverConnectProxy, err := NewConnectService(context.Background(), fmt.Sprintf("%s-sidecar", svc.ID), svc.ID, []int{svc.Port}, node) // bindPort not used
 	if err != nil {
 		return nil, nil, err
 	}
@@ -75,6 +68,54 @@ func CreateAndRegisterStaticServerAndSidecar(node libcluster.Agent, serviceOpts
 	return serverService, serverConnectProxy, nil
 }
 
+func CreateAndRegisterStaticServerAndSidecar(node libcluster.Agent, serviceOpts *ServiceOpts) (Service, Service, error) {
+	// Register the static-server service and sidecar first to prevent race with sidecar
+	// trying to get xDS before it's ready
+	req := &api.AgentServiceRegistration{
+		Name: serviceOpts.Name,
+		ID:   serviceOpts.ID,
+		Port: serviceOpts.HTTPPort,
+		Connect: &api.AgentServiceConnect{
+			SidecarService: &api.AgentServiceRegistration{
+				Proxy: &api.AgentServiceConnectProxyConfig{},
+			},
+		},
+		Check: &api.AgentServiceCheck{
+			Name:     "Static Server Listening",
+			TCP:      fmt.Sprintf("127.0.0.1:%d", serviceOpts.HTTPPort),
+			Interval: "10s",
+			Status:   api.HealthPassing,
+		},
+		Meta: serviceOpts.Meta,
+	}
+	return createAndRegisterStaticServerAndSidecar(node, serviceOpts.GRPCPort, req)
+}
+
+func CreateAndRegisterStaticServerAndSidecarWithChecks(node libcluster.Agent, serviceOpts *ServiceOpts) (Service, Service, error) {
+	// Register the static-server service and sidecar first to prevent race with sidecar
+	// trying to get xDS before it's ready
+	req := &api.AgentServiceRegistration{
+		Name: serviceOpts.Name,
+		ID:   serviceOpts.ID,
+		Port: serviceOpts.HTTPPort,
+		Connect: &api.AgentServiceConnect{
+			SidecarService: &api.AgentServiceRegistration{
+				Proxy: &api.AgentServiceConnectProxyConfig{},
+				Port:  serviceOpts.Connect.Port,
+			},
+		},
+		Checks: api.AgentServiceChecks{
+			{
+				Name: serviceOpts.Checks.Name,
+				TTL:  serviceOpts.Checks.TTL,
+			},
+		},
+		Meta: serviceOpts.Meta,
+	}
+
+	return createAndRegisterStaticServerAndSidecar(node, serviceOpts.GRPCPort, req)
+}
+
 func CreateAndRegisterStaticClientSidecar(
 	node libcluster.Agent,
 	peerName string,

test/integration/consul-container/test/upgrade/traffic_management_default_subset_test.go → test/integration/consul-container/test/upgrade/l7_traffic_management/resolver_default_subset_test.go

@@ -18,15 +18,15 @@ import (
 	"gotest.tools/assert"
 )
 
-// TestTrafficManagement_Upgrade Summary
+// TestTrafficManagement_ServiceResolverDefaultSubset Summary
 // This test starts up 3 servers and 1 client in the same datacenter.
 //
 // Steps:
 //   - Create a single agent cluster.
 //   - Create one static-server and 2 subsets and 1 client and sidecar, then register them with Consul
 //   - Validate static-server and 2 subsets are and proxy admin endpoint is healthy - 3 instances
 //   - Validate static servers proxy listeners should be up and have right certs
-func TestTrafficManagement_ServiceWithSubsets(t *testing.T) {
+func TestTrafficManagement_ServiceResolverDefaultSubset(t *testing.T) {
 	t.Parallel()
 
 	var responseFormat = map[string]string{"format": "json"}
@@ -151,8 +151,8 @@ func createService(t *testing.T, cluster *libcluster.Cluster) (libservice.Servic
 		GRPCPort: 8079,
 	}
 	_, serverConnectProxy, err := libservice.CreateAndRegisterStaticServerAndSidecar(node, serviceOpts)
-	libassert.CatalogServiceExists(t, client, "static-server")
 	require.NoError(t, err)
+	libassert.CatalogServiceExists(t, client, "static-server")
 
 	serviceOptsV1 := &libservice.ServiceOpts{
 		Name:     libservice.StaticServerServiceName,
@@ -162,8 +162,8 @@ func createService(t *testing.T, cluster *libcluster.Cluster) (libservice.Servic
 		GRPCPort: 8078,
 	}
 	_, serverConnectProxyV1, err := libservice.CreateAndRegisterStaticServerAndSidecar(node, serviceOptsV1)
-	libassert.CatalogServiceExists(t, client, "static-server")
 	require.NoError(t, err)
+	libassert.CatalogServiceExists(t, client, "static-server")
 
 	serviceOptsV2 := &libservice.ServiceOpts{
 		Name:     libservice.StaticServerServiceName,
@@ -173,8 +173,8 @@ func createService(t *testing.T, cluster *libcluster.Cluster) (libservice.Servic
 		GRPCPort: 8077,
 	}
 	_, serverConnectProxyV2, err := libservice.CreateAndRegisterStaticServerAndSidecar(node, serviceOptsV2)
-	libassert.CatalogServiceExists(t, client, "static-server")
 	require.NoError(t, err)
+	libassert.CatalogServiceExists(t, client, "static-server")
 
 	// Create a client proxy instance with the server as an upstream
 	clientConnectProxy, err := libservice.CreateAndRegisterStaticClientSidecar(node, "", false)