All checks were successful
Tests / test (push) Successful in 3m46s
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
556 lines
19 KiB
Go
556 lines
19 KiB
Go
package topology
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"net/netip"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func compute(t *testing.T, doc string) *Plan {
|
|
t.Helper()
|
|
p, err := Compute(parse(t, doc))
|
|
if err != nil {
|
|
t.Fatalf("Compute: %v", err)
|
|
}
|
|
return p
|
|
}
|
|
|
|
func computeError(t *testing.T, doc string) string {
|
|
t.Helper()
|
|
_, err := Compute(parse(t, doc))
|
|
if err == nil {
|
|
t.Fatalf("Compute accepted:\n%s", doc)
|
|
}
|
|
return err.Error()
|
|
}
|
|
|
|
func portOf(t *testing.T, p *Plan, node, segment string) Port {
|
|
t.Helper()
|
|
for _, port := range p.Ports {
|
|
if port.Node == node && port.Segment == segment {
|
|
return port
|
|
}
|
|
}
|
|
t.Fatalf("no port for %s on %s", node, segment)
|
|
return Port{}
|
|
}
|
|
|
|
func segmentOf(t *testing.T, p *Plan, name string) SegmentPlan {
|
|
t.Helper()
|
|
for _, s := range p.Segments {
|
|
if s.Name == name {
|
|
return s
|
|
}
|
|
}
|
|
t.Fatalf("no segment %s", name)
|
|
return SegmentPlan{}
|
|
}
|
|
|
|
func nodeOf(t *testing.T, p *Plan, name string) NodePlan {
|
|
t.Helper()
|
|
for _, n := range p.Nodes {
|
|
if n.Name == name {
|
|
return n
|
|
}
|
|
}
|
|
t.Fatalf("no node %s", name)
|
|
return NodePlan{}
|
|
}
|
|
|
|
const twoHypervisors = header + `
|
|
segments:
|
|
underlay: { routers: [sw1], cidr: 10.250.0.0/24, mtu: 9000 }
|
|
nodes:
|
|
sw1: { role: router, image: deb, cpus: 2, memory: 1024, segments: [underlay] }
|
|
rr1: { role: rr, image: deb, cpus: 1, memory: 1024, segments: [underlay] }
|
|
hv1: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay] }
|
|
hv2: { role: host, image: deb, cpus: 4, memory: 16384, segments: [underlay] }
|
|
`
|
|
|
|
func TestCompute_TwoHypervisorsPlan(t *testing.T) {
|
|
p := compute(t, twoHypervisors)
|
|
|
|
if len(p.Segments) != 1 {
|
|
t.Fatalf("%d segments, want 1", len(p.Segments))
|
|
}
|
|
s := p.Segments[0]
|
|
if s.Bridge != "lb-underlay" || s.Gateway != netip.MustParseAddr("10.250.0.1") || s.MTU != 9000 || !reflect.DeepEqual(s.Routers, []string{"sw1"}) || s.VRID != 0 {
|
|
t.Errorf("segment = %+v", s)
|
|
}
|
|
|
|
want := []struct {
|
|
node, address, mac, tap string
|
|
}{
|
|
{"sw1", "10.250.0.2/24", "02:4c:00:00:00:00", "lt0"},
|
|
{"rr1", "10.250.0.3/24", "02:4c:00:01:00:00", "lt1"},
|
|
{"hv1", "10.250.0.4/24", "02:4c:00:02:00:00", "lt2"},
|
|
{"hv2", "10.250.0.5/24", "02:4c:00:03:00:00", "lt3"},
|
|
}
|
|
if len(p.Ports) != len(want) {
|
|
t.Fatalf("%d ports, want %d", len(p.Ports), len(want))
|
|
}
|
|
for _, w := range want {
|
|
port := portOf(t, p, w.node, "underlay")
|
|
if port.Address.String() != w.address {
|
|
t.Errorf("%s address = %s, want %s", w.node, port.Address, w.address)
|
|
}
|
|
if port.MAC.String() != w.mac {
|
|
t.Errorf("%s mac = %s, want %s", w.node, port.MAC, w.mac)
|
|
}
|
|
if port.Tap != w.tap {
|
|
t.Errorf("%s tap = %s, want %s", w.node, port.Tap, w.tap)
|
|
}
|
|
if port.Interface != "underlay" || port.MTU != 9000 {
|
|
t.Errorf("%s port = %+v", w.node, port)
|
|
}
|
|
}
|
|
|
|
for name, port := range map[string]int{"sw1": 2200, "rr1": 2201, "hv1": 2202, "hv2": 2203} {
|
|
if got := nodeOf(t, p, name).SSHPort; got != port {
|
|
t.Errorf("%s ssh port = %d, want %d", name, got, port)
|
|
}
|
|
}
|
|
if hv := nodeOf(t, p, "hv1"); hv.Role != "host" || hv.CPUs != 4 || hv.Memory != 16384 || hv.Image != "deb" {
|
|
t.Errorf("hv1 = %+v", hv)
|
|
}
|
|
}
|
|
|
|
func TestCompute_CarriesTheDeclaredImages(t *testing.T) {
|
|
p := compute(t, twoHypervisors)
|
|
want := []Image{{Name: "deb", URL: "https://example.invalid/deb.qcow2", Sums: "https://example.invalid/SHA512SUMS"}}
|
|
if !reflect.DeepEqual(p.Images, want) {
|
|
t.Errorf("images = %+v, want %+v", p.Images, want)
|
|
}
|
|
}
|
|
|
|
func TestCompute_IsStableAcrossRuns(t *testing.T) {
|
|
first := compute(t, twoHypervisors)
|
|
for i := 0; i < 20; i++ {
|
|
if again := compute(t, twoHypervisors); !reflect.DeepEqual(first, again) {
|
|
t.Fatalf("plan differs on run %d", i)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_AddressesFollowDeclarationOrderNotNames(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
under: { routers: [sw], cidr: 10.0.0.0/24 }
|
|
nodes:
|
|
zeta: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] }
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under] }
|
|
alfa: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] }
|
|
`)
|
|
for node, want := range map[string]string{"zeta": "10.0.0.2/24", "sw": "10.0.0.3/24", "alfa": "10.0.0.4/24"} {
|
|
if got := portOf(t, p, node, "under").Address.String(); got != want {
|
|
t.Errorf("%s = %s, want %s", node, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_ExplicitAddressIsKeptAndSkippedByAllocation(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
under: { routers: [sw], cidr: 10.0.0.0/24 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.254} }
|
|
a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] }
|
|
b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.3} }
|
|
c: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under] }
|
|
`)
|
|
for node, want := range map[string]string{"sw": "10.0.0.254/24", "a": "10.0.0.2/24", "b": "10.0.0.3/24", "c": "10.0.0.4/24"} {
|
|
if got := portOf(t, p, node, "under").Address.String(); got != want {
|
|
t.Errorf("%s = %s, want %s", node, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_SegmentWithoutRouterHasNoGateway(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
l2: { cidr: 10.3.0.0/24 }
|
|
nodes:
|
|
a: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2] }
|
|
b: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2] }
|
|
`)
|
|
s := segmentOf(t, p, "l2")
|
|
if s.Gateway.IsValid() || s.VRID != 0 || len(s.Routers) != 0 || s.Bridge != "lb-l2" {
|
|
t.Errorf("segment = %+v, want no gateway", s)
|
|
}
|
|
for node, want := range map[string]string{"a": "10.3.0.1/24", "b": "10.3.0.2/24"} {
|
|
if got := portOf(t, p, node, "l2").Address.String(); got != want {
|
|
t.Errorf("%s = %s, want %s", node, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_SegmentWithoutRouterAcceptsTheFirstAddress(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
l2: { cidr: 10.3.0.0/24 }
|
|
nodes:
|
|
a: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2] }
|
|
b: { role: host, image: deb, cpus: 1, memory: 512, segments: [l2], addresses: {l2: 10.3.0.1} }
|
|
`)
|
|
for node, want := range map[string]string{"a": "10.3.0.2/24", "b": "10.3.0.1/24"} {
|
|
if got := portOf(t, p, node, "l2").Address.String(); got != want {
|
|
t.Errorf("%s = %s, want %s", node, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_SegmentWithOneRouter(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
red: { routers: [r1], cidr: 10.1.0.0/24 }
|
|
nodes:
|
|
hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [red] }
|
|
r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red] }
|
|
`)
|
|
s := segmentOf(t, p, "red")
|
|
if s.Gateway != netip.MustParseAddr("10.1.0.1") || s.VRID != 0 || !reflect.DeepEqual(s.Routers, []string{"r1"}) {
|
|
t.Errorf("segment = %+v", s)
|
|
}
|
|
for node, want := range map[string]string{"hv": "10.1.0.2/24", "r1": "10.1.0.3/24"} {
|
|
if got := portOf(t, p, node, "red").Address.String(); got != want {
|
|
t.Errorf("%s = %s, want %s", node, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_SegmentWithTwoRoutersUsesVRRP(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
red: { routers: [r1], cidr: 10.1.0.0/24 }
|
|
blue: { routers: [r2, r1], cidr: 10.2.0.0/24 }
|
|
pure: { cidr: 10.3.0.0/24 }
|
|
nodes:
|
|
r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red, blue] }
|
|
r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [blue], addresses: {blue: 10.2.0.250} }
|
|
hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [red, blue, pure] }
|
|
`)
|
|
blue := segmentOf(t, p, "blue")
|
|
if blue.VRID != 2 || blue.Gateway != netip.MustParseAddr("10.2.0.1") || !reflect.DeepEqual(blue.Routers, []string{"r2", "r1"}) {
|
|
t.Errorf("blue = %+v", blue)
|
|
}
|
|
if red := segmentOf(t, p, "red"); red.VRID != 0 {
|
|
t.Errorf("red vrid = %d, want 0", red.VRID)
|
|
}
|
|
if pure := segmentOf(t, p, "pure"); pure.VRID != 0 || pure.Gateway.IsValid() {
|
|
t.Errorf("pure = %+v", pure)
|
|
}
|
|
for node, want := range map[string]string{"r1": "10.2.0.2/24", "r2": "10.2.0.250/24", "hv": "10.2.0.3/24"} {
|
|
if got := portOf(t, p, node, "blue").Address.String(); got != want {
|
|
t.Errorf("%s = %s, want %s", node, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_TwoSegmentsPortOrderMacsAndTaps(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
red: { routers: [sw], cidr: 10.1.0.0/24 }
|
|
blue: { cidr: 10.2.0.0/24, mtu: 1500 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [red] }
|
|
hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [blue, red] }
|
|
rr: { role: rr, image: deb, cpus: 1, memory: 512, segments: [red, blue] }
|
|
`)
|
|
got := make([]string, 0, len(p.Ports))
|
|
for _, port := range p.Ports {
|
|
got = append(got, port.Segment+"/"+port.Node+"/"+port.Tap)
|
|
}
|
|
if strings.Join(got, ",") != "red/sw/lt0,red/hv/lt1,red/rr/lt2,blue/hv/lt3,blue/rr/lt4" {
|
|
t.Errorf("port order = %v", got)
|
|
}
|
|
blue := portOf(t, p, "hv", "blue")
|
|
if blue.MAC.String() != "02:4c:00:01:01:00" || blue.Tap != "lt3" || blue.MTU != 1500 || blue.Interface != "blue" || blue.Address.String() != "10.2.0.1/24" {
|
|
t.Errorf("hv on blue = %+v", blue)
|
|
}
|
|
if red := portOf(t, p, "hv", "red"); red.MAC.String() != "02:4c:00:01:00:00" || red.Address.String() != "10.1.0.3/24" {
|
|
t.Errorf("hv on red = %+v", red)
|
|
}
|
|
if rr := portOf(t, p, "rr", "blue"); rr.MAC.String() != "02:4c:00:02:01:00" || rr.Address.String() != "10.2.0.2/24" {
|
|
t.Errorf("rr on blue = %+v", rr)
|
|
}
|
|
}
|
|
|
|
func TestCompute_MacEncodesNodeAndSegmentRanks(t *testing.T) {
|
|
p := compute(t, generated(3, 300))
|
|
if got := portOf(t, p, "n299", "s2").MAC.String(); got != "02:4c:01:2b:02:00" {
|
|
t.Errorf("n299 on s2 mac = %s, want 02:4c:01:2b:02:00", got)
|
|
}
|
|
}
|
|
|
|
func TestCompute_EveryMacTapAndPortIsUnique(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
a: { routers: [sw], cidr: 10.1.0.0/24 }
|
|
b: { routers: [sw], cidr: 10.2.0.0/24 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [a, b] }
|
|
n1: { role: rr, image: deb, cpus: 1, memory: 512, segments: [a, b] }
|
|
n2: { role: rr, image: deb, cpus: 1, memory: 512, segments: [a, b] }
|
|
n3: { role: host, image: deb, cpus: 1, memory: 512, segments: [b, a] }
|
|
`)
|
|
macs := map[string]bool{}
|
|
taps := map[string]bool{}
|
|
ports := map[int]bool{}
|
|
for _, n := range p.Nodes {
|
|
if ports[n.SSHPort] {
|
|
t.Errorf("ssh port %d used twice", n.SSHPort)
|
|
}
|
|
ports[n.SSHPort] = true
|
|
}
|
|
for _, port := range p.Ports {
|
|
if macs[port.MAC.String()] {
|
|
t.Errorf("mac %s used twice", port.MAC)
|
|
}
|
|
macs[port.MAC.String()] = true
|
|
if taps[port.Tap] {
|
|
t.Errorf("tap %s used twice", port.Tap)
|
|
}
|
|
taps[port.Tap] = true
|
|
}
|
|
if len(macs) != 8 || len(taps) != 8 {
|
|
t.Errorf("%d distinct macs and %d distinct taps, want 8", len(macs), len(taps))
|
|
}
|
|
}
|
|
|
|
func TestCompute_MacsAreLocallyAdministeredUnicast(t *testing.T) {
|
|
for _, port := range compute(t, twoHypervisors).Ports {
|
|
if m := port.MAC.String(); !strings.HasPrefix(m, "02:") {
|
|
t.Errorf("mac %s is not locally administered unicast", m)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_InterfaceAndTapNamesFitInIFNAMSIZ(t *testing.T) {
|
|
p := compute(t, generated(23, 1000))
|
|
for _, port := range p.Ports {
|
|
if len(port.Tap) > 15 || len(port.Interface) > 15 {
|
|
t.Fatalf("port %+v has a name longer than 15", port)
|
|
}
|
|
}
|
|
for _, s := range p.Segments {
|
|
if len(s.Bridge) > 15 {
|
|
t.Fatalf("bridge %s is longer than 15", s.Bridge)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompute_AddressRejections(t *testing.T) {
|
|
base := func(addresses string) string {
|
|
return header + `
|
|
segments:
|
|
under: { routers: [sw], cidr: 10.0.0.0/29 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under] }
|
|
a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under]` + addresses + ` }
|
|
b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.5} }
|
|
`
|
|
}
|
|
cases := []struct{ name, addresses, want string }{
|
|
{"outside", ", addresses: {under: 10.0.1.2}", "node a: address 10.0.1.2 is outside segment under"},
|
|
{"network", ", addresses: {under: 10.0.0.0}", "node a: address 10.0.0.0 is the network or broadcast"},
|
|
{"broadcast", ", addresses: {under: 10.0.0.7}", "node a: address 10.0.0.7 is the network or broadcast"},
|
|
{"gateway", ", addresses: {under: 10.0.0.1}", "node a: address 10.0.0.1 on segment under is already taken by the gateway"},
|
|
{"duplicate", ", addresses: {under: 10.0.0.5}", "node b: address 10.0.0.5 on segment under is already taken by a"},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
requireContains(t, computeError(t, base(c.addresses)), c.want)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCompute_RouterAddressCannotBeTheGateway(t *testing.T) {
|
|
got := computeError(t, header+`
|
|
segments:
|
|
under: { routers: [sw], cidr: 10.0.0.0/24 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [under], addresses: {under: 10.0.0.1} }
|
|
`)
|
|
requireContains(t, got, "node sw: address 10.0.0.1 on segment under is already taken by the gateway")
|
|
}
|
|
|
|
func TestCompute_ReportsExhaustedSegment(t *testing.T) {
|
|
got := computeError(t, header+`
|
|
segments:
|
|
tiny: { routers: [sw], cidr: 10.0.0.0/30 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
`)
|
|
requireContains(t, got, "segment tiny: no address left in 10.0.0.0/30 for node a")
|
|
}
|
|
|
|
func TestCompute_FillsSegmentExactly(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
tiny: { routers: [sw], cidr: 10.0.0.0/29 }
|
|
nodes:
|
|
sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
c: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
d: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
`)
|
|
if got := portOf(t, p, "d", "tiny").Address.String(); got != "10.0.0.6/29" {
|
|
t.Errorf("last node = %s, want 10.0.0.6/29", got)
|
|
}
|
|
}
|
|
|
|
func TestCompute_FillsSegmentWithoutRouterExactly(t *testing.T) {
|
|
p := compute(t, header+`
|
|
segments:
|
|
tiny: { cidr: 10.0.0.0/30 }
|
|
nodes:
|
|
a: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
b: { role: rr, image: deb, cpus: 1, memory: 512, segments: [tiny] }
|
|
`)
|
|
if got := portOf(t, p, "b", "tiny").Address.String(); got != "10.0.0.2/30" {
|
|
t.Errorf("last node = %s, want 10.0.0.2/30", got)
|
|
}
|
|
}
|
|
|
|
func TestCompute_RefusesInvalidTopology(t *testing.T) {
|
|
requireContains(t, computeError(t, strings.Replace(valid, "role: rr", "role: spine", 1)), `role "spine"`)
|
|
}
|
|
|
|
func TestLastAddr(t *testing.T) {
|
|
for cidr, want := range map[string]string{
|
|
"10.0.0.0/24": "10.0.0.255",
|
|
"10.0.0.0/30": "10.0.0.3",
|
|
"10.250.0.0/16": "10.250.255.255",
|
|
"192.168.4.8/29": "192.168.4.15",
|
|
} {
|
|
if got := lastAddr(netip.MustParsePrefix(cidr)).String(); got != want {
|
|
t.Errorf("lastAddr(%s) = %s, want %s", cidr, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWrite_TwoHypervisorsPlan(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
if err := compute(t, twoHypervisors).Write(&buf); err != nil {
|
|
t.Fatalf("Write: %v", err)
|
|
}
|
|
want := `lab lab-test: nodes 4, segments 1, ports 4
|
|
|
|
nodes
|
|
name role image cpus memory ssh
|
|
sw1 router deb 2 1024 MiB 127.0.0.1:2200
|
|
rr1 rr deb 1 1024 MiB 127.0.0.1:2201
|
|
hv1 host deb 4 16384 MiB 127.0.0.1:2202
|
|
hv2 host deb 4 16384 MiB 127.0.0.1:2203
|
|
|
|
segment underlay: 10.250.0.0/24, mtu 9000, bridge lb-underlay, gateway 10.250.0.1 on sw1
|
|
node interface address mac tap
|
|
sw1 underlay 10.250.0.2/24 02:4c:00:00:00:00 lt0
|
|
rr1 underlay 10.250.0.3/24 02:4c:00:01:00:00 lt1
|
|
hv1 underlay 10.250.0.4/24 02:4c:00:02:00:00 lt2
|
|
hv2 underlay 10.250.0.5/24 02:4c:00:03:00:00 lt3
|
|
`
|
|
if buf.String() != want {
|
|
t.Errorf("output:\n%s\nwant:\n%s", buf.String(), want)
|
|
}
|
|
}
|
|
|
|
func TestWrite_GatewayLines(t *testing.T) {
|
|
var buf bytes.Buffer
|
|
if err := compute(t, header+`
|
|
segments:
|
|
red: { routers: [r1], cidr: 10.1.0.0/24 }
|
|
blue: { routers: [r2, r1], cidr: 10.2.0.0/24, mtu: 1500 }
|
|
pure: { cidr: 10.3.0.0/24 }
|
|
nodes:
|
|
r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [red, blue] }
|
|
r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [blue] }
|
|
hv: { role: host, image: deb, cpus: 1, memory: 512, segments: [blue, pure] }
|
|
`).Write(&buf); err != nil {
|
|
t.Fatalf("Write: %v", err)
|
|
}
|
|
for _, want := range []string{
|
|
"lab lab-test: nodes 3, segments 3, ports 5\n",
|
|
"\nsegment red: 10.1.0.0/24, mtu 9000, bridge lb-red, gateway 10.1.0.1 on r1\n",
|
|
"\nsegment blue: 10.2.0.0/24, mtu 1500, bridge lb-blue, gateway 10.2.0.1 by vrrp 2 on r2, r1\n",
|
|
"\nsegment pure: 10.3.0.0/24, mtu 9000, bridge lb-pure, no gateway\n",
|
|
" hv pure 10.3.0.1/24 02:4c:00:02:02:00 lt4\n",
|
|
} {
|
|
if !strings.Contains(buf.String(), want) {
|
|
t.Errorf("plan:\n%s\ndoes not contain %q", buf.String(), want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func generated(segments, nodes int) string {
|
|
var b strings.Builder
|
|
b.WriteString(header + "segments:\n")
|
|
names := make([]string, segments)
|
|
for i := range names {
|
|
names[i] = fmt.Sprintf("s%d", i)
|
|
fmt.Fprintf(&b, " %s: { routers: [sw], cidr: 10.%d.0.0/16 }\n", names[i], i%250)
|
|
}
|
|
fmt.Fprintf(&b, "nodes:\n sw: { role: router, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", strings.Join(names, ", "))
|
|
for i := 1; i < nodes; i++ {
|
|
fmt.Fprintf(&b, " n%d: { role: rr, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", i, strings.Join(names, ", "))
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
func withVRRPAt(segments, rank int) string {
|
|
var b strings.Builder
|
|
b.WriteString(header + "segments:\n")
|
|
names := make([]string, segments)
|
|
for i := range names {
|
|
names[i] = fmt.Sprintf("s%d", i)
|
|
routers := "[r1]"
|
|
if i == rank {
|
|
routers = "[r1, r2]"
|
|
}
|
|
fmt.Fprintf(&b, " %s: { routers: %s, cidr: 10.%d.0.0/16 }\n", names[i], routers, i%250)
|
|
}
|
|
fmt.Fprintf(&b, "nodes:\n r1: { role: router, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", strings.Join(names, ", "))
|
|
fmt.Fprintf(&b, " r2: { role: router, image: deb, cpus: 1, memory: 512, segments: [%s] }\n", names[rank])
|
|
return b.String()
|
|
}
|
|
|
|
func TestValidate_RejectsTooManyNodes(t *testing.T) {
|
|
requireContains(t, validationError(t, generated(1, 1001)), "nodes: 1001 declared, at most 1000")
|
|
}
|
|
|
|
func TestValidate_AcceptsExactlyMaxNodes(t *testing.T) {
|
|
if err := parse(t, generated(1, 1000)).Validate(); err != nil {
|
|
t.Fatalf("1000 nodes rejected: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidate_RejectsTooManySegments(t *testing.T) {
|
|
requireContains(t, validationError(t, generated(257, 2)), "segments: 257 declared, at most 256")
|
|
}
|
|
|
|
func TestValidate_RejectsVRRPBeyondTheVRIDRange(t *testing.T) {
|
|
msg := validationError(t, withVRRPAt(256, 255))
|
|
requireContains(t, msg, "segment s255: a segment with several routers must be among the first 255")
|
|
}
|
|
|
|
func TestCompute_AcceptsVRRPOnTheLastVRID(t *testing.T) {
|
|
p := compute(t, withVRRPAt(256, 254))
|
|
if got := segmentOf(t, p, "s254").VRID; got != 255 {
|
|
t.Errorf("vrid = %d, want 255", got)
|
|
}
|
|
}
|
|
|
|
func TestCompute_ManyPortsNeedNoPortRange(t *testing.T) {
|
|
p := compute(t, generated(23, 1000))
|
|
if len(p.Ports) != 23000 {
|
|
t.Fatalf("%d ports, want 23000", len(p.Ports))
|
|
}
|
|
if last := p.Ports[len(p.Ports)-1].Tap; last != "lt22999" {
|
|
t.Errorf("last tap = %s, want lt22999", last)
|
|
}
|
|
}
|