adding tests for the new RPC endpoint

* removed some unnecessary compiler output
* remove configurability of OverprovisioningFactor

Author: rboyer

agent/cache-types/discovery_chain_test.go

@@ -16,7 +16,6 @@ func TestCompiledDiscoveryChain(t *testing.T) {
 	typ := &CompiledDiscoveryChain{RPC: rpc}
 
 	// just do the default chain
-	entries := structs.NewDiscoveryChainConfigEntries()
 	chain := discoverychain.TestCompileConfigEntries(t, "web", "default", "dc1", nil)
 
 	// Expect the proper RPC call. This also sets the expected value
@@ -31,7 +30,6 @@ func TestCompiledDiscoveryChain(t *testing.T) {
 
 			reply := args.Get(2).(*structs.DiscoveryChainResponse)
 			reply.Chain = chain
-			reply.Entries = entries.Flatten()
 			reply.QueryMeta.Index = 48
 			resp = reply
 		})

agent/consul/discovery_chain_endpoint.go

@@ -70,7 +70,6 @@ func (c *DiscoveryChain) Get(args *structs.DiscoveryChainRequest, reply *structs
 			}
 
 			reply.Index = index
-			reply.Entries = entries.Flatten()
 			reply.Chain = chain
 
 			return nil

agent/consul/discovery_chain_endpoint_test.go

@@ -0,0 +1,135 @@
+package consul
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/hashicorp/consul/agent/structs"
+	msgpackrpc "github.com/hashicorp/net-rpc-msgpackrpc"
+	"github.com/stretchr/testify/require"
+)
+
+// TODO(rb): test ACLs
+
+func TestDiscoveryChainEndpoint_Get(t *testing.T) {
+	t.Parallel()
+	dir1, s1 := testServerWithConfig(t, func(c *Config) {
+		c.PrimaryDatacenter = "dc1"
+	})
+	defer os.RemoveAll(dir1)
+	defer s1.Shutdown()
+	codec := rpcClient(t, s1)
+	defer codec.Close()
+
+	getChain := func(args *structs.DiscoveryChainRequest) (*structs.DiscoveryChainResponse, error) {
+		resp := structs.DiscoveryChainResponse{}
+		err := msgpackrpc.CallWithCodec(codec, "DiscoveryChain.Get", &args, &resp)
+		if err != nil {
+			return nil, err
+		}
+		// clear fields that we don't care about
+		resp.QueryMeta = structs.QueryMeta{}
+		return &resp, nil
+	}
+
+	// First try compiling just the default chain (no config entries).
+	args := &structs.DiscoveryChainRequest{
+		Name:                 "web",
+		EvaluateInDatacenter: "dc1",
+		EvaluateInNamespace:  "default",
+		Datacenter:           "dc1",
+	}
+
+	resp, err := getChain(args)
+	require.NoError(t, err)
+
+	expect := &structs.DiscoveryChainResponse{
+		Chain: &structs.CompiledDiscoveryChain{
+			ServiceName: "web",
+			Namespace:   "default",
+			Datacenter:  "dc1",
+			Protocol:    "tcp",
+			StartNode:   "resolver:web,,,dc1",
+			Nodes: map[string]*structs.DiscoveryGraphNode{
+				"resolver:web,,,dc1": &structs.DiscoveryGraphNode{
+					Type: structs.DiscoveryGraphNodeTypeResolver,
+					Name: "web,,,dc1",
+					Resolver: &structs.DiscoveryResolver{
+						Default:        true,
+						ConnectTimeout: 5 * time.Second,
+						Target: structs.DiscoveryTarget{
+							Service:    "web",
+							Namespace:  "default",
+							Datacenter: "dc1",
+						},
+					},
+				},
+			},
+			Targets: map[structs.DiscoveryTarget]structs.DiscoveryTargetConfig{
+				structs.DiscoveryTarget{
+					Service:    "web",
+					Namespace:  "default",
+					Datacenter: "dc1",
+				}: {},
+			},
+		},
+	}
+	require.Equal(t, expect, resp)
+
+	// Now create one config entry.
+	out := false
+	require.NoError(t, msgpackrpc.CallWithCodec(codec, "ConfigEntry.Apply",
+		&structs.ConfigEntryRequest{
+			Datacenter: "dc1",
+			Entry: &structs.ServiceResolverConfigEntry{
+				Kind:           structs.ServiceResolver,
+				Name:           "web",
+				ConnectTimeout: 33 * time.Second,
+			},
+		}, &out))
+	require.True(t, out)
+
+	// And try compiling again.
+	args = &structs.DiscoveryChainRequest{
+		Name:                 "web",
+		EvaluateInDatacenter: "dc1",
+		EvaluateInNamespace:  "default",
+		Datacenter:           "dc1",
+	}
+
+	resp, err = getChain(args)
+	require.NoError(t, err)
+
+	expect = &structs.DiscoveryChainResponse{
+		Chain: &structs.CompiledDiscoveryChain{
+			ServiceName: "web",
+			Namespace:   "default",
+			Datacenter:  "dc1",
+			Protocol:    "tcp",
+			StartNode:   "resolver:web,,,dc1",
+			Nodes: map[string]*structs.DiscoveryGraphNode{
+				"resolver:web,,,dc1": &structs.DiscoveryGraphNode{
+					Type: structs.DiscoveryGraphNodeTypeResolver,
+					Name: "web,,,dc1",
+					Resolver: &structs.DiscoveryResolver{
+						ConnectTimeout: 33 * time.Second,
+						Target: structs.DiscoveryTarget{
+							Service:    "web",
+							Namespace:  "default",
+							Datacenter: "dc1",
+						},
+					},
+				},
+			},
+			Targets: map[structs.DiscoveryTarget]structs.DiscoveryTargetConfig{
+				structs.DiscoveryTarget{
+					Service:    "web",
+					Namespace:  "default",
+					Datacenter: "dc1",
+				}: {},
+			},
+		},
+	}
+	require.Equal(t, expect, resp)
+}

agent/consul/discoverychain/compile.go

@@ -688,7 +688,6 @@ RESOLVE_AGAIN:
 		Type: structs.DiscoveryGraphNodeTypeResolver,
 		Name: target.Identifier(),
 		Resolver: &structs.DiscoveryResolver{
-			Definition:     resolver,
 			Default:        resolver.IsDefault(),
 			Target:         target,
 			ConnectTimeout: connectTimeout,
@@ -770,9 +769,7 @@ RESOLVE_AGAIN:
 
 			// If we filtered everything out then no point in having a failover.
 			if len(failoverTargets) > 0 {
-				df := &structs.DiscoveryFailover{
-					Definition: &failover,
-				}
+				df := &structs.DiscoveryFailover{}
 				node.Resolver.Failover = df
 
 				// Convert the targets into targets by cheating a bit and