op-packages/smart-srun/core/internal/daemon/switch_test.go

//go:build unix

package daemon

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"testing"

	"github.com/matthewlu070111/smart-srun/core/internal/application"
	"github.com/matthewlu070111/smart-srun/core/internal/config"
	"github.com/matthewlu070111/smart-srun/core/internal/domain"
)

type switchRunner struct{}

func (switchRunner) Run(_ context.Context, a application.Action, _ func(application.Phase)) application.Outcome {
	if a.Request.IdempotencyKey == "reject" {
		return application.Outcome{State: application.StateFailed, Code: domain.CodeAuthRejected, Message: "rejected"}
	}
	return application.Outcome{State: application.StateSucceeded, Message: "connected"}
}

func setupSwitchRPC(t *testing.T, configure ...func(*Options)) *running {
	r := start(t, func(o *Options) {
		o.Runner = switchRunner{}
		for _, apply := range configure {
			apply(o)
		}
	})
	for i := 0; i < 2; i++ {
		r.writeConfig("campus.upsert", fmt.Sprintf(`{"expected_revision":%d,"account":{"user_id":"student%d","wired_iface":"wan"}}`, i, i))
	}
	for i := 0; i < 2; i++ {
		r.writeConfig("hotspot.upsert", fmt.Sprintf(`{"expected_revision":%d,"profile":{"ssid":"hotspot%d","radio":"radio1","encryption":"none"}}`, 2+i, i))
	}
	return r
}

func TestSwitchRPCPersistsSelectionWithoutChangingDefaultsOrEnabled(t *testing.T) {
	r := setupSwitchRPC(t)
	var revision uint64 = 4
	for _, target := range []struct{ kind, account, hotspot string }{{"switch_campus", "c2", ""}, {"switch_hotspot", "", "h2"}} {
		params := SubmitParams{Kind: target.kind, AccountID: target.account, HotspotID: target.hotspot,
			ExpectedRevision: &revision, IdempotencyKey: target.kind}
		var receipt SubmitResult
		if err := json.Unmarshal(r.call("action.submit", params), &receipt); err != nil {
			t.Fatal(err)
		}
		if got := r.awaitTerminal(receipt.ActionID); got.State != application.StateSucceeded {
			t.Fatalf("switch failed: %+v", got)
		}
		var retry SubmitResult
		if err := json.Unmarshal(r.call("action.submit", params), &retry); err != nil {
			t.Fatal(err)
		}
		if !retry.Duplicate || retry.ActionID != receipt.ActionID {
			t.Fatal("retry started another switch after commit")
		}
		revision++
	}
	loaded, err := config.LoadFile(r.paths.ConfigFile())
	if err != nil {
		t.Fatal(err)
	}
	if loaded.Revision != 6 || loaded.Enabled || loaded.Selection != (domain.Selection{ActiveCampusID: "c2", DefaultCampusID: "c1", ActiveHotspotID: "h2", DefaultHotspotID: "h1"}) {
		t.Fatalf("wrong durable choice: %+v", loaded.Selection)
	}
	for _, key := range []string{"same-target", "reject"} {
		var receipt SubmitResult
		json.Unmarshal(r.call("action.submit", SubmitParams{Kind: "switch_campus", AccountID: "c2", ExpectedRevision: &revision, IdempotencyKey: key}), &receipt)
		got := r.awaitTerminal(receipt.ActionID)
		if key == "reject" && got.State != application.StateFailed {
			t.Fatal("failure was changed to success")
		}
	}
	loaded, err = config.LoadFile(r.paths.ConfigFile())
	if err != nil || loaded.Revision != 6 {
		t.Fatal("same target or failed action wrote config", err)
	}
	// A new process opens precisely the saved selection, with no replay needed.
	reopened, err := config.Open(r.paths.ConfigFile())
	if err != nil || reopened.Snapshot().Selection != loaded.Selection {
		t.Fatal("selection did not survive reopen", err)
	}
}

func TestSwitchRPCReportsRecoveryWhenSelectionCannotBeSaved(t *testing.T) {
	faults := make(chan error, 1)
	worker := blockingRunner{entered: make(chan struct{}, 1), release: make(chan struct{})}
	r := setupSwitchRPC(t, func(o *Options) {
		o.OnError = func(err error) { faults <- err }
		o.Runner = worker
	})
	var receipt SubmitResult
	json.Unmarshal(r.call("action.submit", SubmitParams{Kind: "switch_campus", AccountID: "c2", IdempotencyKey: "save-failure"}), &receipt)
	<-worker.entered
	// Fail persistence after dispatch. An already unreadable recovery parent
	// is now correctly refused by the updater guard before a switch begins.
	backup := r.paths.Config + "-saved"
	if err := os.Rename(r.paths.Config, backup); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(r.paths.Config, []byte("block config directory"), 0o600); err != nil {
		t.Fatal(err)
	}
	close(worker.release)
	got := r.awaitTerminal(receipt.ActionID)
	if got.State != application.StateFailed || got.Code != domain.CodeRecoveryRequired {
		t.Fatalf("save failure reported success: %+v", got)
	}
	if err := <-faults; err == nil {
		t.Fatal("write failure was not reported")
	}
	var cfg domain.Config
	json.Unmarshal(r.call("config.get", nil), &cfg)
	if cfg.Selection.ActiveCampusID != "c1" || cfg.Revision != 4 {
		t.Fatal("failed save published a new selection")
	}
}