proxy/internal/app/operation_stream_test.go

package app_test

import (
	"context"
	"errors"
	"path/filepath"
	"strings"
	"testing"

	"proxyctl/internal/app"
	"proxyctl/internal/profile"
	"proxyctl/internal/target"
)

type coordinatedOperationTarget struct {
	id           string
	state        target.State
	started      chan struct{}
	release      chan struct{}
	confirmation string
	failure      error
}

func (t *coordinatedOperationTarget) ID() string { return t.id }
func (t *coordinatedOperationTarget) Description() target.Description {
	return target.Description{Name: t.id, Summary: "operation stream test Target"}
}
func (t *coordinatedOperationTarget) Availability(context.Context) target.Availability {
	return target.Availability{Available: true, Evidence: "available"}
}
func (t *coordinatedOperationTarget) Inspect(context.Context, *profile.Profile) target.Inspection {
	return target.Inspection{State: t.state, Evidence: "fresh state"}
}
func (t *coordinatedOperationTarget) Confirmation(bool) string { return t.confirmation }
func (t *coordinatedOperationTarget) SetDesired(_ context.Context, enabled bool, _ *profile.Profile) target.OperationResult {
	if t.started != nil {
		close(t.started)
	}
	if t.release != nil {
		<-t.release
	}
	if t.failure != nil {
		t.state = target.Drifted
		return target.OperationResult{Err: t.failure}
	}
	if enabled {
		t.state = target.Enabled
	} else {
		t.state = target.Disabled
	}
	return target.OperationResult{Inspection: target.Inspection{State: t.state, Evidence: "completed"}}
}

func TestInteractiveOperationStreamSerializesMutationAndPublishesStructuredProgress(t *testing.T) {
	adapter := &coordinatedOperationTarget{id: "shell", state: target.Disabled, started: make(chan struct{}), release: make(chan struct{})}
	application, err := app.NewWithTargets(profile.NewFileStore(filepath.Join(t.TempDir(), "profiles.json")), []target.Target{adapter})
	if err != nil {
		t.Fatal(err)
	}
	if result := application.Dispatch(app.Intent{Kind: app.CreateProfile, Profile: profile.Profile{Name: "office", SingleURL: "http://proxy.example:8080"}}); result.Err != nil {
		t.Fatal(result.Err)
	}
	if result := application.Dispatch(app.Intent{Kind: app.ActivateProfile, Name: "office"}); result.Err != nil {
		t.Fatal(result.Err)
	}

	operation := application.StartOperation(app.Intent{Kind: app.SetTargetDesired, TargetID: "shell", Enabled: true})
	running := <-operation.Updates
	if running.Phase != app.OperationRunning || len(running.Progress) != 1 || running.Progress[0].Phase != app.TargetProgressRunning || running.Progress[0].TargetID != "shell" || running.Status.Kind != app.StatusProgress {
		t.Fatalf("running update = %#v", running)
	}
	<-adapter.started

	blocked := application.StartOperation(app.Intent{Kind: app.SetTargetDesired, TargetID: "shell", Enabled: false})
	blockedUpdate := <-blocked.Updates
	if blockedUpdate.Phase != app.OperationBlocked || blockedUpdate.Status.Kind != app.StatusBlocked || !strings.Contains(blockedUpdate.Status.Summary, "already in progress") {
		t.Fatalf("blocked update = %#v", blockedUpdate)
	}
	if _, open := <-blocked.Updates; open {
		t.Fatal("blocked operation stream did not close")
	}

	close(adapter.release)
	final := <-operation.Updates
	if final.Phase != app.OperationSucceeded || final.Snapshot.Targets[0].State != target.Enabled || len(final.Progress) != 1 || final.Progress[0].Phase != app.TargetProgressSucceeded {
		t.Fatalf("final update = %#v", final)
	}
	if _, open := <-operation.Updates; open {
		t.Fatal("completed operation stream did not close")
	}
}

func TestInteractiveOperationStreamUsesStructuredConfirmation(t *testing.T) {
	adapter := &coordinatedOperationTarget{id: "docker-daemon", state: target.Disabled, confirmation: "Docker will restart and may disrupt running work."}
	application, err := app.NewWithTargets(profile.NewFileStore(filepath.Join(t.TempDir(), "profiles.json")), []target.Target{adapter})
	if err != nil {
		t.Fatal(err)
	}
	if result := application.Dispatch(app.Intent{Kind: app.CreateProfile, Profile: profile.Profile{Name: "office", SingleURL: "http://proxy.example:8080"}}); result.Err != nil {
		t.Fatal(result.Err)
	}
	if result := application.Dispatch(app.Intent{Kind: app.ActivateProfile, Name: "office"}); result.Err != nil {
		t.Fatal(result.Err)
	}

	operation := application.StartOperation(app.Intent{Kind: app.SetTargetDesired, TargetID: adapter.ID(), Enabled: true})
	update := <-operation.Updates
	if update.Phase != app.OperationAwaitingConfirmation || update.Confirmation == nil || update.Confirmation.Title == "" || update.Confirmation.CancelLabel == "" || update.Status.Kind != app.StatusConfirmation {
		t.Fatalf("confirmation update = %#v", update)
	}
	if _, open := <-operation.Updates; open {
		t.Fatal("confirmation operation stream did not close")
	}
}

func TestInteractiveProfileTransitionReportsFirstFailureWithoutRollback(t *testing.T) {
	first := &coordinatedOperationTarget{id: "first", state: target.Disabled}
	second := &coordinatedOperationTarget{id: "second", state: target.Disabled}
	application, err := app.NewWithTargets(profile.NewFileStore(filepath.Join(t.TempDir(), "profiles.json")), []target.Target{first, second})
	if err != nil {
		t.Fatal(err)
	}
	for _, name := range []string{"old", "new"} {
		if result := application.Dispatch(app.Intent{Kind: app.CreateProfile, Profile: profile.Profile{Name: name, SingleURL: "http://proxy.example:8080"}}); result.Err != nil {
			t.Fatal(result.Err)
		}
	}
	if result := application.Dispatch(app.Intent{Kind: app.ActivateProfile, Name: "old"}); result.Err != nil {
		t.Fatal(result.Err)
	}
	for _, id := range []string{"first", "second"} {
		if result := application.Dispatch(app.Intent{Kind: app.SetTargetDesired, TargetID: id, Enabled: true}); result.Err != nil {
			t.Fatal(result.Err)
		}
	}
	second.failure = errors.New("second failed")

	operation := application.StartOperation(app.Intent{Kind: app.ActivateProfile, Name: "new"})
	var final app.OperationUpdate
	for update := range operation.Updates {
		final = update
	}
	if final.Phase != app.OperationFailed || final.FirstFailedTargetID != "second" || final.Snapshot.ActiveProfile != "new" {
		t.Fatalf("final transition = %#v", final)
	}
	if final.Snapshot.Targets[0].State != target.Enabled || final.Snapshot.Targets[1].State != target.Drifted {
		t.Fatalf("partial Target states = %#v", final.Snapshot.Targets)
	}
}