status-im
/
consul
mirror of https://github.com/status-im/consul.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
consul/testing/deployer/topology/compile_test.go

2283 lines
60 KiB
Go
Raw Blame History

// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
package topology
import (
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/testing/protocmp"
"github.com/hashicorp/go-hclog"
pbcatalog "github.com/hashicorp/consul/proto-public/pbcatalog/v2beta1"
"github.com/hashicorp/consul/sdk/testutil"
)
func TestCompile_CE(t *testing.T) {
type testcase struct {
in *Config
expect *Topology
expectErr string
}
logger := hclog.NewNullLogger()
const clusterID = "87c82bd03dc89d4d"
run := func(t *testing.T, tc testcase) {
got, err := compile(logger, tc.in, nil, clusterID)
if tc.expectErr == "" {
require.NotNil(t, tc.expect, "field must be set")
require.NoError(t, err)
// Set recursive pointers on expectations.
for _, c := range tc.expect.Clusters {
for _, n := range c.Nodes {
for _, w := range n.Workloads {
w.Node = n
}
}
}
assertDeepEqual(t, tc.expect, got)
} else {
require.Nil(t, tc.expect, "field cannot be set")
require.Nil(t, got)
testutil.RequireErrorContains(t, err, tc.expectErr)
}
}
cases := map[string]testcase{
"nil": {
in: nil,
expectErr: `config is required`,
},
"consul image cannot be set at the top level": {
in: &Config{
Images: DefaultImages().ChooseConsul(true),
},
expectErr: `topology.images.consul cannot be set at this level`,
},
"no networks": {
in: &Config{},
expectErr: `topology.networks is empty`,
},
"bad network/no name": {
in: &Config{
Networks: []*Network{{
//
}},
},
expectErr: `network name is not valid`,
},
"bad network/invalid name": {
in: &Config{
Networks: []*Network{{
Name: "-123",
}},
},
expectErr: `network name is not valid`,
},
"bad network/should not use DockerName": {
in: &Config{
Networks: []*Network{{
Name: "foo",
DockerName: "blah",
}},
},
expectErr: `network "foo" should not specify DockerName`,
},
"bad network/duplicate names": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
{Name: "foo"},
},
},
expectErr: `cannot have two networks with the same name "foo"`,
},
"bad network/unknown type": {
in: &Config{
Networks: []*Network{
{Name: "foo", Type: "ext"},
},
},
expectErr: `network "foo" has unknown type "ext"`,
},
"good networks one server node": {
in: &Config{
Networks: []*Network{
{Name: "foo1"},
{Name: "foo2", Type: "lan"},
{Name: "foo3", Type: "wan"},
},
Clusters: []*Cluster{{
Name: "foo2",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "node1",
Addresses: []*Address{
{Network: "foo2"},
{Network: "foo3"},
},
}},
}},
},
expect: &Topology{
ID: clusterID,
Images: DefaultImages(),
Networks: map[string]*Network{
"foo1": {Name: "foo1", Type: "lan", DockerName: "cslc-foo1-" + clusterID},
"foo2": {Name: "foo2", Type: "lan", DockerName: "cslc-foo2-" + clusterID},
"foo3": {Name: "foo3", Type: "wan", DockerName: "cslc-foo3-" + clusterID},
},
Clusters: map[string]*Cluster{
"foo2": {
Name: "foo2",
NetworkName: "foo2",
Datacenter: "foo2",
Images: DefaultImages().ChooseConsul(false),
Nodes: []*Node{{
Kind: NodeKindServer,
Version: NodeVersionV1,
Partition: "default",
Name: "node1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindServer),
Addresses: []*Address{
{Network: "foo2", Type: "lan", DockerNetworkName: "cslc-foo2-" + clusterID},
{Network: "foo3", Type: "wan", DockerNetworkName: "cslc-foo3-" + clusterID},
},
Cluster: "foo2",
Datacenter: "foo2",
}},
Services: map[ID]*pbcatalog.Service{},
Partitions: []*Partition{{
Name: "default",
Namespaces: []string{"default"},
}},
},
},
},
},
"no clusters": {
in: &Config{
Networks: []*Network{
{Name: "foo1"},
},
},
expectErr: `topology.clusters is empty`,
},
"bad cluster/no name": {
in: &Config{
Networks: []*Network{
{Name: "foo1"},
},
Clusters: []*Cluster{{}},
},
expectErr: `error building cluster "": cluster has no name`,
},
"bad cluster/invalid name": {
in: &Config{
Networks: []*Network{
{Name: "foo1"},
},
Clusters: []*Cluster{{
Name: "-123",
}},
},
expectErr: `error building cluster "-123": cluster name is not valid: -123`,
},
"bad cluster/invalid dc": {
in: &Config{
Networks: []*Network{
{Name: "foo1"},
},
Clusters: []*Cluster{{
Name: "foo",
Datacenter: "-123",
}},
},
expectErr: `error building cluster "foo": datacenter name is not valid: -123`,
},
"bad cluster/missing network": {
in: &Config{
Networks: []*Network{
{Name: "foo1"},
},
Clusters: []*Cluster{{
Name: "foo",
NetworkName: "bar",
}},
},
expectErr: `error building cluster "foo": cluster "foo" uses network name "bar" that does not exist`,
},
"bad cluster/no nodes": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
}},
},
expectErr: `error building cluster "foo": cluster "foo" has no nodes`,
},
"colliding clusters": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{
{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "node1",
}},
},
{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "node1",
}},
},
},
},
expectErr: `cannot have two clusters with the same name "foo"; use unique names and override the Datacenter field if that's what you want`,
},
// TODO: ERR: partitions in CE
// TODO: ERR: namespaces in CE
// TODO: ERR: servers in a non-default partition
"tenancy collection": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Enterprise: true,
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
},
{
Kind: NodeKindClient,
Name: "mesh1",
Partition: "ap1",
Addresses: []*Address{
{Network: "foo"},
},
Workloads: []*Workload{
{
ID: NewID("zim", "ns1", ""),
Image: "busybox",
Port: 8888,
EnvoyAdminPort: 19000,
},
{
ID: NewID("gir", "ns2", ""),
Image: "busybox",
Port: 8877,
EnvoyAdminPort: 19001,
Destinations: []*Destination{{
ID: NewID("gaz", "ns3", "ap3"),
LocalAddress: "127.0.0.1",
LocalPort: 5000,
}},
},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh2",
Partition: "ap2",
Addresses: []*Address{
{Network: "foo"},
},
Workloads: []*Workload{
{
ID: NewID("gir", "ns4", "ap2"),
Image: "busybox",
Port: 8877,
EnvoyAdminPort: 19001,
ImpliedDestinations: []*Destination{{
ID: NewID("gaz", "", "ap4"),
PortName: "www",
}},
},
},
},
},
}},
},
expect: &Topology{
ID: clusterID,
Images: DefaultImages(),
Networks: map[string]*Network{
"foo": {Name: "foo", Type: "lan", DockerName: "cslc-foo-" + clusterID},
},
Clusters: map[string]*Cluster{
"foo": {
Name: "foo",
NetworkName: "foo",
Datacenter: "foo",
Enterprise: true,
EnableV2: true,
Images: DefaultImages().ChooseConsul(true),
Services: map[ID]*pbcatalog.Service{
NewID("gir", "ns4", "ap2"): {
Workloads: &pbcatalog.WorkloadSelector{
Names: []string{"gir-mesh2"},
},
Ports: []*pbcatalog.ServicePort{
{TargetPort: "legacy", VirtualPort: 8080, Protocol: pbcatalog.Protocol_PROTOCOL_TCP},
{TargetPort: "mesh", Protocol: pbcatalog.Protocol_PROTOCOL_MESH},
},
VirtualIps: []string{"10.244.0.2"},
},
},
Nodes: []*Node{
{
Kind: NodeKindServer,
Version: NodeVersionV1,
Name: "server1",
Partition: "default",
Images: DefaultImages().ChooseConsul(true).ChooseNode(NodeKindServer),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
},
{
Kind: NodeKindClient,
Version: NodeVersionV1,
Name: "mesh1",
Partition: "ap1",
Images: DefaultImages().ChooseConsul(true).ChooseNode(NodeKindClient),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
Index: 1,
Workloads: []*Workload{
{
ID: NewID("zim", "ns1", "ap1"),
Image: "busybox",
Port: 8888,
EnvoyAdminPort: 19000,
NodeVersion: NodeVersionV1,
},
{
ID: NewID("gir", "ns2", "ap1"),
Image: "busybox",
Port: 8877,
EnvoyAdminPort: 19001,
NodeVersion: NodeVersionV1,
Destinations: []*Destination{{
ID: NewID("gaz", "ns3", "ap3"),
Cluster: "foo",
LocalAddress: "127.0.0.1",
LocalPort: 5000,
}},
},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh2",
Partition: "ap2",
Images: DefaultImages().ChooseConsul(true).ChooseNode(NodeKindDataplane),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
Index: 2,
Workloads: []*Workload{
{
ID: NewID("gir", "ns4", "ap2"),
Image: "busybox",
Ports: map[string]*Port{
"legacy": {Number: 8877, Protocol: "tcp", ActualProtocol: pbcatalog.Protocol_PROTOCOL_TCP},
"mesh": {Number: 20000, Protocol: "mesh", ActualProtocol: pbcatalog.Protocol_PROTOCOL_MESH},
},
EnvoyAdminPort: 19001,
EnvoyPublicListenerPort: 20000,
NodeVersion: NodeVersionV2,
V2Services: []string{"gir"},
WorkloadIdentity: "gir",
Workload: "gir-mesh2",
ImpliedDestinations: []*Destination{{
ID: NewID("gaz", "default", "ap4"),
Cluster: "foo", // TODO: why is this only sometimes populated?
PortName: "www",
Implied: true,
}},
},
},
},
},
Partitions: []*Partition{
{
Name: "ap1",
Namespaces: []string{"default", "ns1", "ns2"},
},
{
Name: "ap2",
Namespaces: []string{"default", "ns4"},
},
{
Name: "ap3",
Namespaces: []string{"default", "ns3"},
},
{
Name: "ap4",
Namespaces: []string{"default"},
},
{
Name: "default",
Namespaces: []string{"default"},
},
},
},
},
},
},
"explicit v2 services": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "node1",
}},
Services: map[ID]*pbcatalog.Service{
NewID("zim", "default", "default"): {
Ports: []*pbcatalog.ServicePort{
{TargetPort: "http"},
{TargetPort: "mesh", Protocol: pbcatalog.Protocol_PROTOCOL_MESH},
},
},
},
}},
},
expect: &Topology{
ID: clusterID,
Images: DefaultImages(),
Networks: map[string]*Network{
"foo": {Name: "foo", Type: "lan", DockerName: "cslc-foo-" + clusterID},
},
Clusters: map[string]*Cluster{
"foo": {
Name: "foo",
NetworkName: "foo",
Datacenter: "foo",
Images: DefaultImages().ChooseConsul(false),
Nodes: []*Node{{
Kind: NodeKindServer,
Version: NodeVersionV1,
Partition: "default",
Name: "node1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindServer),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
}},
EnableV2: true,
Services: map[ID]*pbcatalog.Service{
NewID("zim", "default", "default"): {
Ports: []*pbcatalog.ServicePort{
{TargetPort: "http", VirtualPort: 8080, Protocol: pbcatalog.Protocol_PROTOCOL_TCP},
{TargetPort: "mesh", Protocol: pbcatalog.Protocol_PROTOCOL_MESH},
},
VirtualIps: []string{"10.244.0.2"},
},
},
Partitions: []*Partition{{
Name: "default",
Namespaces: []string{"default"},
}},
},
},
},
},
"explicit v2 services/bad workload selector": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "node1",
}},
Services: map[ID]*pbcatalog.Service{
NewID("zim", "default", "default"): {
Workloads: &pbcatalog.WorkloadSelector{Names: []string{"zzz"}},
Ports: []*pbcatalog.ServicePort{
{TargetPort: "http"},
{TargetPort: "mesh"},
},
},
},
}},
},
expectErr: `error building cluster "foo": the workloads field for v2 service "default/default/zim" is not user settable`,
},
"tls volume errantly set": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "node1",
}},
TLSVolumeName: "foo",
}},
},
expectErr: `error building cluster "foo": user cannot specify the TLSVolumeName field`,
},
"node/no name": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "": cluster "foo" node has no name`,
},
"node/invalid name": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "-123",
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "-123": node name is not valid: -123`,
},
"node/bad kind": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Name: "zim",
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": cluster "foo" node "zim" has invalid kind`,
},
"node/bad version": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Version: "v3",
Name: "zim",
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": cluster "foo" node "zim" has invalid version: v3`,
},
"node/bad version for client": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindClient,
Version: NodeVersionV2,
Name: "zim",
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": v2 does not support client agents at this time`,
},
"node/invalid partition": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Partition: "-123",
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": node partition is not valid: -123`,
},
"node/invalid usedPorts": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
usedPorts: map[int]int{5: 6},
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": user cannot specify the usedPorts field`,
},
"node/invalid index": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Index: 99,
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": user cannot specify the node index`,
},
"node/missing address network": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Addresses: []*Address{{
//
}},
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": cluster "foo" node "zim" has invalid address`,
},
"node/invalid address type": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Addresses: []*Address{{
Network: "foo",
Type: "lan",
}},
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": user cannot specify the address type directly`,
},
"node/address network does not exist": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Addresses: []*Address{{
Network: "bar",
}},
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": cluster "foo" node "zim" uses network name "bar" that does not exist`,
},
"node/no local addresses": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
{Name: "bar", Type: "wan"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Addresses: []*Address{{
Network: "bar",
}},
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": cluster "foo" node "zim" has no local addresses`,
},
"node/too many public addresses": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
{Name: "bar", Type: "wan"},
{Name: "baz", Type: "wan"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{{
Kind: NodeKindServer,
Name: "zim",
Addresses: []*Address{
{Network: "foo"},
{Network: "bar"},
{Network: "baz"},
},
}},
}},
},
expectErr: `error building cluster "foo": error compiling node "zim": cluster "foo" node "zim" has more than one public address`,
},
"node/dataplane with more than one workload": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{
{Network: "foo"},
},
Workloads: []*Workload{
{ID: NewID("zim", "default", "default")},
{ID: NewID("gir", "default", "default")},
},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" uses dataplane, but has more than one service`,
},
"workload/invalid partition": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: ID{
Name: "zim",
Namespace: "default",
Partition: "-123",
},
Image: "busybox",
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": service partition is not valid: -123`,
},
"workload/invalid namespace": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: ID{
Name: "zim",
Namespace: "-123",
Partition: "default",
},
Image: "busybox",
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": service namespace is not valid: -123`,
},
"workload/invalid name": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: ID{
Name: "-123",
Namespace: "default",
Partition: "default",
},
Image: "busybox",
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": service name is not valid: -123`,
},
"workload/mismatched partitions": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: ID{
Name: "zim",
Namespace: "default",
Partition: "ap1",
},
Image: "busybox",
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": service zim on node mesh1 has mismatched partitions: ap1 != default`,
},
"workload/node collision": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindClient,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{
{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
},
{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 9090,
EnvoyAdminPort: 19001,
},
},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cannot have two services on the same node "default/mesh1" in the same cluster "foo" with the same name "default/default/zim"`,
},
"workload/v1 and implied dest": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindClient,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
ImpliedDestinations: []*Destination{{
ID: NewID("gir", "", ""),
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": v1 does not support implied destinations yet`,
},
"workload/default-destination/impl dest need port names in v2": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
ImpliedDestinations: []*Destination{{
ID: NewID("gir", "", ""),
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": implicit destinations must use port names in v2`,
},
"workload/default-destination/expl dest port name legacy defaulting": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8888,
EnvoyAdminPort: 19000,
Destinations: []*Destination{{
ID: NewID("gir", "", ""),
LocalAddress: "127.0.0.1",
LocalPort: 5000,
}},
}},
},
},
}},
},
expect: &Topology{
ID: clusterID,
Images: DefaultImages(),
Networks: map[string]*Network{
"foo": {Name: "foo", Type: "lan", DockerName: "cslc-foo-" + clusterID},
},
Clusters: map[string]*Cluster{
"foo": {
Name: "foo",
NetworkName: "foo",
Datacenter: "foo",
Images: DefaultImages().ChooseConsul(false),
EnableV2: true,
Services: map[ID]*pbcatalog.Service{
NewID("zim", "default", "default"): {
Workloads: &pbcatalog.WorkloadSelector{
Names: []string{"zim-mesh1"},
},
Ports: []*pbcatalog.ServicePort{
{TargetPort: "legacy", VirtualPort: 8080, Protocol: pbcatalog.Protocol_PROTOCOL_TCP},
{TargetPort: "mesh", Protocol: pbcatalog.Protocol_PROTOCOL_MESH},
},
VirtualIps: []string{"10.244.0.2"},
},
},
Nodes: []*Node{
{
Kind: NodeKindServer,
Version: NodeVersionV1,
Partition: "default",
Name: "server1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindServer),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Partition: "default",
Name: "mesh1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindDataplane),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
Index: 1,
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Ports: map[string]*Port{
"legacy": {Number: 8888, Protocol: "tcp", ActualProtocol: pbcatalog.Protocol_PROTOCOL_TCP},
"mesh": {Number: 20000, Protocol: "mesh", ActualProtocol: pbcatalog.Protocol_PROTOCOL_MESH},
},
EnvoyAdminPort: 19000,
EnvoyPublicListenerPort: 20000,
NodeVersion: NodeVersionV2,
V2Services: []string{"zim"},
WorkloadIdentity: "zim",
Workload: "zim-mesh1",
Destinations: []*Destination{{
ID: NewID("gir", "", ""),
LocalAddress: "127.0.0.1",
LocalPort: 5000,
Cluster: "foo",
PortName: "legacy", // <--- this
}},
}},
},
},
Partitions: []*Partition{{
Name: "default",
Namespaces: []string{"default"},
}},
},
},
},
},
"workload/default-destination/expl dest local address defaulting": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV1,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
Destinations: []*Destination{{
ID: NewID("gir", "", ""),
LocalPort: 5000,
}},
}},
},
},
}},
},
expect: &Topology{
ID: clusterID,
Images: DefaultImages(),
Networks: map[string]*Network{
"foo": {Name: "foo", Type: "lan", DockerName: "cslc-foo-" + clusterID},
},
Clusters: map[string]*Cluster{
"foo": {
Name: "foo",
NetworkName: "foo",
Datacenter: "foo",
Images: DefaultImages().ChooseConsul(false),
Services: map[ID]*pbcatalog.Service{
//
},
Nodes: []*Node{
{
Kind: NodeKindServer,
Version: NodeVersionV1,
Partition: "default",
Name: "server1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindServer),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV1,
Partition: "default",
Name: "mesh1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindDataplane),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
Index: 1,
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
EnvoyPublicListenerPort: 20000,
NodeVersion: NodeVersionV1,
Destinations: []*Destination{{
ID: NewID("gir", "", ""),
LocalAddress: "127.0.0.1", // <--- this
LocalPort: 5000,
Cluster: "foo",
}},
}},
},
},
Partitions: []*Partition{{
Name: "default",
Namespaces: []string{"default"},
}},
},
},
},
},
"workload/default-destination/expl dest cannot use port names in v1": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV1,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
Destinations: []*Destination{{
ID: NewID("gir", "", ""),
PortName: "http",
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": explicit destinations cannot use port names in v1`,
},
"workload/validate/no name": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindClient,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": service name is not valid`,
},
"workload/validate/no image": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindClient,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Port: 8080,
EnvoyAdminPort: 19000,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: service image is required`,
},
"workload/validate/no image mesh gateway": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindClient,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Port: 8080,
EnvoyAdminPort: 19000,
IsMeshGateway: true,
}},
},
},
}},
},
expect: &Topology{
ID: clusterID,
Images: DefaultImages(),
Networks: map[string]*Network{
"foo": {Name: "foo", Type: "lan", DockerName: "cslc-foo-" + clusterID},
},
Clusters: map[string]*Cluster{
"foo": {
Name: "foo",
NetworkName: "foo",
Datacenter: "foo",
Images: DefaultImages().ChooseConsul(false),
Services: map[ID]*pbcatalog.Service{
//
},
Nodes: []*Node{
{
Kind: NodeKindServer,
Version: NodeVersionV1,
Partition: "default",
Name: "server1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindServer),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
},
{
Kind: NodeKindClient,
Version: NodeVersionV1,
Partition: "default",
Name: "mesh1",
Images: DefaultImages().ChooseConsul(false).ChooseNode(NodeKindClient),
Addresses: []*Address{
{Network: "foo", Type: "lan", DockerNetworkName: "cslc-foo-" + clusterID},
},
Cluster: "foo",
Datacenter: "foo",
Index: 1,
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Port: 8080,
EnvoyAdminPort: 19000,
IsMeshGateway: true,
NodeVersion: NodeVersionV1,
}},
},
},
Partitions: []*Partition{{
Name: "default",
Namespaces: []string{"default"},
}},
},
},
},
},
"workload/validate/single and multiport v2": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Version: NodeVersionV2,
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8080,
EnvoyAdminPort: 19000,
Ports: map[string]*Port{
"blah": {
Number: 8181,
Protocol: "tcp",
},
},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot specify both singleport and multiport on service in v2`,
},
"workload/validate/multiport nil port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Version: NodeVersionV2,
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Ports: map[string]*Port{
"blah": nil,
},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot be nil`,
},
"workload/validate/multiport negative port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Version: NodeVersionV2,
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Ports: map[string]*Port{
"blah": {
Number: -5,
},
},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: service has invalid port number`,
},
"workload/validate/multiport set actualprotocol": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Version: NodeVersionV2,
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Ports: map[string]*Port{
"blah": {
Number: 8888,
ActualProtocol: pbcatalog.Protocol_PROTOCOL_GRPC,
},
},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: user cannot specify ActualProtocol field`,
},
"workload/validate/multiport invalid port protocol": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Version: NodeVersionV2,
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Ports: map[string]*Port{
"blah": {
Number: 8888,
Protocol: "zzzz",
},
},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: service has invalid port protocol "zzzz"`,
},
"workload/validate/singleport invalid port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Port: -999,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: service has invalid port`,
},
"workload/validate/singleport tproxy": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Port: 999,
EnableTransparentProxy: true,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: tproxy does not work with v1 yet`,
},
"workload/validate/mesh with no admin port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 999,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: envoy admin port is required`,
},
"workload/validate/no mesh with admin port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
DisableServiceMesh: true,
Image: "busybox",
Port: 999,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot use envoy admin port without a service mesh`,
},
"workload/validate/expl dest with no name": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
Destinations: []*Destination{{
ID: NewID("", "", ""),
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: destination service name is required`,
},
"workload/validate/expl dest with no local port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
Destinations: []*Destination{{
ID: NewID("dib", "", ""),
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: destination local port is required`,
},
"workload/validate/expl dest bad local address": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
Destinations: []*Destination{{
ID: NewID("dib", "", ""),
LocalPort: 5000,
LocalAddress: "clown@address",
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: destination local address is invalid: clown@address`,
},
"workload/validate/expl dest with implied": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
Destinations: []*Destination{{
ID: NewID("dib", "", ""),
LocalPort: 5000,
PortName: "http",
Implied: true,
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: implied field cannot be set`,
},
"workload/validate/impl dest with no name": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
ImpliedDestinations: []*Destination{{
ID: NewID("", "", ""),
PortName: "http",
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: implied destination service name is required`,
},
"workload/validate/impl dest with local port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
ImpliedDestinations: []*Destination{{
ID: NewID("dib", "", ""),
PortName: "http",
LocalPort: 5000,
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: implied destination local port cannot be set`,
},
"workload/validate/impl dest with local address": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
EnvoyAdminPort: 19000,
Image: "busybox",
Port: 999,
ImpliedDestinations: []*Destination{{
ID: NewID("dib", "", ""),
PortName: "http",
LocalAddress: "127.0.0.1",
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: implied destination local address cannot be set`,
},
"workload/validate/v1 cannot use multiport": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Ports: map[string]*Port{"web": {Number: 8080}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot specify multiport on service in v1`,
},
"workload/validate/disable-mesh/mgw": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
IsMeshGateway: true,
Port: 8443,
DisableServiceMesh: true,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot disable service mesh and still run a mesh gateway`,
},
"workload/validate/disable-mesh/expl dest": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Port: 8443,
DisableServiceMesh: true,
Destinations: []*Destination{{
ID: NewID("gir", "", ""),
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot disable service mesh and configure destinations`,
},
"workload/validate/disable-mesh/impl dest": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Port: 8443,
DisableServiceMesh: true,
ImpliedDestinations: []*Destination{{
ID: NewID("gir", "", ""),
PortName: "web",
}},
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot disable service mesh and configure implied destinations`,
},
"workload/validate/disable-mesh/tproxy": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Port: 8443,
DisableServiceMesh: true,
EnableTransparentProxy: true,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot disable service mesh and activate tproxy`,
},
"workload/validate/disable-mesh/set admin port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
EnvoyAdminPort: 19000,
Port: 8443,
DisableServiceMesh: true,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: cannot use envoy admin port without a service mesh`,
},
"workload/validate/enable-mesh/unset admin port": {
in: &Config{
Networks: []*Network{
{Name: "foo"},
},
Clusters: []*Cluster{{
Name: "foo",
Nodes: []*Node{
{
Kind: NodeKindServer,
Name: "server1",
Addresses: []*Address{
{Network: "foo"},
},
},
{
Kind: NodeKindDataplane,
Version: NodeVersionV2,
Name: "mesh1",
Addresses: []*Address{{Network: "foo"}},
Workloads: []*Workload{{
ID: NewID("zim", "", ""),
Image: "busybox",
Port: 8443,
}},
},
},
}},
},
expectErr: `error building cluster "foo": error compiling node "mesh1": cluster "foo" node "mesh1" service "default/default/zim" is not valid: envoy admin port is required`,
},
// TODO: OK: v2 mesh gateway port defaulting
// TODO: collect tenancies from all places (cluster, initialconfigs, initialres, nodes, services, ...)
}
for name, tc := range cases {
t.Run(name, func(t *testing.T) {
run(t, tc)
})
}
}
type testingT interface {
Helper()
Fatalf(format string, args ...interface{})
require.TestingT
}
var ignoreUnexportedTypes = []any{
Cluster{},
Images{},
Node{},
Workload{},
}
func assertDeepEqual[V any](t testingT, exp, got V, msgAndArgs ...any) {
t.Helper()
if diff := cmp.Diff(exp, got, protocmp.Transform(), cmpopts.IgnoreUnexported(ignoreUnexportedTypes...)); diff != "" {
format := "assertion failed: values are not equal\n--- expected\n+++ actual\n%v"
args := []any{diff}
if len(msgAndArgs) > 0 {
suffix, ok := msgAndArgs[0].(string)
require.True(t, ok)
require.NotEmpty(t, suffix)
format += "\n\nMessage: " + suffix
args = append(args, msgAndArgs[1:]...)
}
t.Fatalf(format, args...)
}
}
Reference in New Issue View Git Blame Copy Permalink