vpp-maglev/cmd/client/tree_test.go

// SPDX-License-Identifier: Apache-2.0

package main

import (
	"strings"
	"testing"
)

func TestExpandPathsRoot(t *testing.T) {
	root := buildTree()
	lines := expandPaths(root, "", make(map[*Node]bool))

	// Should include well-known leaf paths.
	want := []string{
		"show version",
		"show frontends",
		"show frontends <name>",
		"show backends",
		"show backends <name>",
		"show healthchecks",
		"show healthchecks <name>",
		"set backend <name> pause",
		"set backend <name> resume",
		"set backend <name> disable",
		"set backend <name> enable",
		"set frontend <name> pool <pool> backend <backend> weight <weight>",
		"set frontend <name> pool <pool> backend <backend> weight <weight> flush",
		"watch events",
		"watch events <opt>",
		"config check",
		"show vpp info",
		"show vpp lb state",
		"show vpp lb counters",
		"config reload",
		"sync vpp lb state",
		"sync vpp lb state <name>",
		"quit",
		"exit",
	}

	paths := make(map[string]bool, len(lines))
	for _, l := range lines {
		paths[l.path] = true
	}

	for _, w := range want {
		if !paths[w] {
			t.Errorf("expandPaths(root) missing %q", w)
		}
	}
}

func TestExpandPathsShow(t *testing.T) {
	root := buildTree()
	showNode, _, _ := Walk(root, []string{"show"})
	lines := expandPaths(showNode, "show", make(map[*Node]bool))

	for _, l := range lines {
		if !strings.HasPrefix(l.path, "show ") {
			t.Errorf("unexpected path %q: should start with 'show '", l.path)
		}
		if l.help == "" {
			t.Errorf("path %q has empty help", l.path)
		}
	}
	// version, frontends, frontends <name>, backends, backends <name>,
	// healthchecks, healthchecks <name>, vpp info, vpp lb state,
	// vpp lb counters = 10 lines
	if len(lines) != 10 {
		t.Errorf("expected exactly 10 show subcommands, got %d", len(lines))
	}
}

func TestExpandPathsNoCycles(t *testing.T) {
	root := buildTree()
	// watch events has a self-referencing slot; expandPaths must terminate.
	watchEvents, _, _ := Walk(root, []string{"watch", "events"})
	lines := expandPaths(watchEvents, "watch events", make(map[*Node]bool))

	// Should produce exactly 2 lines: "watch events" and "watch events <opt>".
	if len(lines) != 2 {
		t.Errorf("watch events: expected 2 lines, got %d: %v", len(lines), lines)
	}
}

func TestExpandPathsSetBackendName(t *testing.T) {
	root := buildTree()
	// Walk to the name slot so displayPrefix carries the actual arg.
	node, _, _ := Walk(root, []string{"set", "backend", "mybackend"})
	lines := expandPaths(node, "set backend mybackend", make(map[*Node]bool))

	want := []string{
		"set backend mybackend pause",
		"set backend mybackend resume",
		"set backend mybackend disable",
		"set backend mybackend enable",
	}
	if len(lines) != len(want) {
		t.Fatalf("expected %d lines, got %d: %v", len(want), len(lines), lines)
	}
	for i, w := range want {
		if lines[i].path != w {
			t.Errorf("line %d: got %q, want %q", i, lines[i].path, w)
		}
	}
}

func TestPrefixMatchCollapsedNouns(t *testing.T) {
	root := buildTree()

	// "sh ba" → show backends (list all) via prefix matching.
	node, args, rem := Walk(root, []string{"sh", "ba"})
	if node.Run == nil {
		t.Fatal("'sh ba' did not reach a Run node")
	}
	if len(args) != 0 {
		t.Errorf("'sh ba' should have 0 args, got %v", args)
	}
	if len(rem) != 0 {
		t.Errorf("'sh ba' should fully consume tokens, got remaining %v", rem)
	}

	// "sh ba nginx0" → show backends <name> (get specific) via slot.
	node, args, rem = Walk(root, []string{"sh", "ba", "nginx0"})
	if node.Run == nil {
		t.Fatal("'sh ba nginx0' did not reach a Run node")
	}
	if len(args) != 1 || args[0] != "nginx0" {
		t.Errorf("'sh ba nginx0' args: got %v, want [nginx0]", args)
	}
	if len(rem) != 0 {
		t.Errorf("'sh ba nginx0' should fully consume tokens, got remaining %v", rem)
	}

	// "sh fr" → show frontends (list all).
	node, _, _ = Walk(root, []string{"sh", "fr"})
	if node.Run == nil {
		t.Fatal("'sh fr' did not reach a Run node")
	}

	// "sh he icmp" → show healthchecks icmp (get specific).
	node, args, _ = Walk(root, []string{"sh", "he", "icmp"})
	if node.Run == nil {
		t.Fatal("'sh he icmp' did not reach a Run node")
	}
	if len(args) != 1 || args[0] != "icmp" {
		t.Errorf("'sh he icmp' args: got %v, want [icmp]", args)
	}
}

func TestWalkUnknownTokens(t *testing.T) {
	root := buildTree()

	// A bare unknown word leaves every token unconsumed and anchors
	// the returned node at the root — callers must treat this as
	// "unknown command" rather than silently showing the whole tree.
	node, _, rem := Walk(root, []string{"foo"})
	if node != root {
		t.Errorf("'foo' should leave walk at root, got %q", node.Word)
	}
	if len(rem) != 1 || rem[0] != "foo" {
		t.Errorf("'foo' remaining: got %v, want [foo]", rem)
	}

	// Partial consumption: "show" matches but "bogus" doesn't. The
	// returned remaining is the first unmatched token onwards so the
	// caller can point at exactly what was wrong.
	node, _, rem = Walk(root, []string{"show", "bogus", "tail"})
	if node.Word != "show" {
		t.Errorf("'show bogus tail' should stop at show, got %q", node.Word)
	}
	if len(rem) != 2 || rem[0] != "bogus" || rem[1] != "tail" {
		t.Errorf("'show bogus tail' remaining: got %v, want [bogus tail]", rem)
	}
}

func TestExpandPathsWeightSlotWalk(t *testing.T) {
	// Verify the weight command is fully walkable (fixes bug: setWeightValue
	// and setFrontendPoolName were non-slot nodes that couldn't capture tokens).
	root := buildTree()
	node, args, _ := Walk(root, []string{"set", "frontend", "web", "pool", "primary", "backend", "be0", "weight", "42"})
	if node.Run == nil {
		t.Fatal("Walk did not reach a Run node for full weight command")
	}
	if len(args) != 4 {
		t.Errorf("expected 4 args (name, pool, backend, weight), got %d: %v", len(args), args)
	}
	if args[3] != "42" {
		t.Errorf("args[3] (weight): got %q, want 42", args[3])
	}
}