fission-src/pkg/utils/namespace_manager_model_test.go

package utils

import (
	"testing"
	"time"

	corev1 "k8s.io/api/core/v1"
	k8sCache "k8s.io/client-go/tools/cache"
)

func TestNamespaceRecordClone(t *testing.T) {
	now := time.Now().UTC()
	record := NamespaceRecord{
		Name:       "tenant-a",
		Source:     NamespaceSourceWatcher,
		Phase:      NamespacePhaseRegistering,
		Generation: 7,
		UpdatedAt:  now,
		Labels: map[string]string{
			"fission.io/managed": "true",
		},
		RegisteredParts: map[string]NamespacePartState{
			"router": {
				State:     "active",
				UpdatedAt: now,
			},
		},
	}

	clone := record.Clone()
	clone.Labels["fission.io/managed"] = "false"
	clone.RegisteredParts["router"] = NamespacePartState{State: "failed", LastError: "boom"}

	if record.Labels["fission.io/managed"] != "true" {
		t.Fatalf("expected labels to be deep copied")
	}

	if record.RegisteredParts["router"].State != "active" {
		t.Fatalf("expected registered parts to be deep copied")
	}
}

func TestNamespaceRecordIsActive(t *testing.T) {
	record := NamespaceRecord{Phase: NamespacePhaseActive}
	if !record.IsActive() {
		t.Fatalf("expected active phase to be reported as active")
	}

	record.Phase = NamespacePhaseRegistering
	if record.IsActive() {
		t.Fatalf("expected non-active phase to be reported as inactive")
	}
}

func TestNamespaceRecordIsTerminal(t *testing.T) {
	for _, test := range []struct {
		phase    NamespacePhase
		expected bool
	}{
		{phase: NamespacePhaseRemoved, expected: true},
		{phase: NamespacePhaseFailed, expected: true},
		{phase: NamespacePhaseActive, expected: false},
		{phase: NamespacePhaseRegistering, expected: false},
	} {
		record := NamespaceRecord{Phase: test.phase}
		if record.IsTerminal() != test.expected {
			t.Fatalf("expected terminal=%v for phase %s", test.expected, test.phase)
		}
	}
}

func TestNewNamespaceEventClonesLabels(t *testing.T) {
	now := time.Now().UTC()
	labels := map[string]string{ManagedNamespaceLabelKey: ManagedNamespaceLabelValue}
	event := NewNamespaceEvent(NamespaceEventAdd, "tenant-a", labels, NamespaceSourceWatcher, now)
	labels[ManagedNamespaceLabelKey] = "false"

	if event.Labels[ManagedNamespaceLabelKey] != ManagedNamespaceLabelValue {
		t.Fatalf("expected namespace event labels to be cloned")
	}
}

func TestManagedNamespaceEvent(t *testing.T) {
	event := ManagedNamespaceEvent(NamespaceEventAdd, "tenant-a", NamespaceSourceWatcher, time.Now().UTC())
	if event.Labels[ManagedNamespaceLabelKey] != ManagedNamespaceLabelValue {
		t.Fatalf("expected managed namespace label in event")
	}
	if event.Name != "tenant-a" {
		t.Fatalf("expected tenant-a event name")
	}
}

func TestNamespaceEventFromNamespace(t *testing.T) {
	namespace := &corev1.Namespace{}
	namespace.Name = "tenant-a"
	namespace.Labels = map[string]string{ManagedNamespaceLabelKey: ManagedNamespaceLabelValue}

	event := NamespaceEventFromNamespace(NamespaceEventAdd, namespace, NamespaceSourceWatcher, time.Now().UTC())
	if event.Name != "tenant-a" {
		t.Fatalf("expected tenant-a event name")
	}
	if event.Labels[ManagedNamespaceLabelKey] != ManagedNamespaceLabelValue {
		t.Fatalf("expected namespace labels to be copied into event")
	}

	namespace.Labels[ManagedNamespaceLabelKey] = "false"
	if event.Labels[ManagedNamespaceLabelKey] != ManagedNamespaceLabelValue {
		t.Fatalf("expected event labels to stay detached from original namespace")
	}
}

func TestNamespaceFromObject(t *testing.T) {
	namespace := &corev1.Namespace{}
	namespace.Name = "tenant-a"

	extracted, ok := NamespaceFromObject(namespace)
	if !ok || extracted.Name != "tenant-a" {
		t.Fatalf("expected namespace object to be extracted directly")
	}

	extracted, ok = NamespaceFromObject(k8sCache.DeletedFinalStateUnknown{Obj: namespace})
	if !ok || extracted.Name != "tenant-a" {
		t.Fatalf("expected namespace tombstone to be extracted")
	}
}

func TestNamespaceEventFromObject(t *testing.T) {
	namespace := &corev1.Namespace{}
	namespace.Name = "tenant-a"
	namespace.Labels = map[string]string{ManagedNamespaceLabelKey: ManagedNamespaceLabelValue}

	event := NamespaceEventFromObject(NamespaceEventRemove, k8sCache.DeletedFinalStateUnknown{Obj: namespace}, NamespaceSourceWatcher, time.Now().UTC())
	if event.Type != NamespaceEventRemove {
		t.Fatalf("expected remove event type")
	}
	if event.Name != "tenant-a" {
		t.Fatalf("expected tenant-a event name")
	}
	if event.Labels[ManagedNamespaceLabelKey] != ManagedNamespaceLabelValue {
		t.Fatalf("expected labels copied from tombstone namespace")
	}

	emptyEvent := NamespaceEventFromObject(NamespaceEventRemove, "not-a-namespace", NamespaceSourceWatcher, time.Now().UTC())
	if emptyEvent.Name != "" {
		t.Fatalf("expected empty name for unsupported object")
	}
}

func TestNamespaceRemovalStrategyValues(t *testing.T) {
	if NamespaceRemovalStrategyTrackOnly != "track-only" {
		t.Fatalf("unexpected track-only strategy value")
	}
	if NamespaceRemovalStrategyDispatchRemove != "dispatch-remove" {
		t.Fatalf("unexpected dispatch-remove strategy value")
	}
}

func TestNamespaceManagerSummaryZeroValue(t *testing.T) {
	summary := NamespaceManagerSummary{}
	if summary.TotalNamespaces != 0 {
		t.Fatalf("expected zero total namespaces")
	}
}

func TestNamespaceManagerSummaryHasActiveNamespaces(t *testing.T) {
	summary := NamespaceManagerSummary{LiveNamespaces: 1}
	if !summary.HasActiveNamespaces() {
		t.Fatalf("expected positive live count to report active namespaces")
	}
	summary.LiveNamespaces = 0
	if summary.HasActiveNamespaces() {
		t.Fatalf("expected zero live count to report no active namespaces")
	}
}