notify/session_owner_state_test.go

package notify

import (
	"sync"
	"sync/atomic"
	"testing"
)

func TestClaimOwnerSessionStopHasSingleCleanupWinner(t *testing.T) {
	var state atomic.Int32
	state.Store(ownerSessionStateRunning)

	const contenders = 32
	start := make(chan struct{})
	var wg sync.WaitGroup
	var winners atomic.Int32
	wg.Add(contenders)
	for range contenders {
		go func() {
			defer wg.Done()
			<-start
			if claimOwnerSessionStop(&state) {
				winners.Add(1)
			}
		}()
	}
	close(start)
	wg.Wait()

	if got := winners.Load(); got != 1 {
		t.Fatalf("session cleanup winners = %d, want 1", got)
	}
	if got := ownerSessionStateName(state.Load()); got != "stopping" {
		t.Fatalf("claimed session state = %q, want stopping", got)
	}
}

func TestClientOwnerSessionStateStartRollback(t *testing.T) {
	client := NewClient().(*ClientCommon)

	if !client.beginClientSessionStart() {
		t.Fatal("first beginClientSessionStart should succeed")
	}
	if client.beginClientSessionStart() {
		t.Fatal("second beginClientSessionStart should be blocked while starting")
	}

	client.rollbackClientSessionStart()
	if !client.beginClientSessionStart() {
		t.Fatal("beginClientSessionStart should succeed after rollback")
	}
}

func TestClientOwnerSessionStateLifecycle(t *testing.T) {
	client := NewClient().(*ClientCommon)

	if !client.beginClientSessionStart() {
		t.Fatal("beginClientSessionStart should succeed")
	}
	client.markSessionStarted()
	if client.beginClientSessionStart() {
		t.Fatal("beginClientSessionStart should be blocked while running")
	}

	client.markSessionStopped("stopped", nil)
	if !client.beginClientSessionStart() {
		t.Fatal("beginClientSessionStart should succeed after stopped")
	}
}

func TestServerOwnerSessionStateStartRollback(t *testing.T) {
	server := NewServer().(*ServerCommon)

	if !server.beginServerSessionStart() {
		t.Fatal("first beginServerSessionStart should succeed")
	}
	if server.beginServerSessionStart() {
		t.Fatal("second beginServerSessionStart should be blocked while starting")
	}

	server.rollbackServerSessionStart()
	if !server.beginServerSessionStart() {
		t.Fatal("beginServerSessionStart should succeed after rollback")
	}
}

func TestServerOwnerSessionStateLifecycle(t *testing.T) {
	server := NewServer().(*ServerCommon)

	if !server.beginServerSessionStart() {
		t.Fatal("beginServerSessionStart should succeed")
	}
	server.markSessionStarted()
	if server.beginServerSessionStart() {
		t.Fatal("beginServerSessionStart should be blocked while running")
	}

	server.markSessionStopped("stopped", nil)
	if !server.beginServerSessionStart() {
		t.Fatal("beginServerSessionStart should succeed after stopped")
	}
}

func TestClientOwnerSessionStateTransitionNames(t *testing.T) {
	client := NewClient().(*ClientCommon)

	if got, want := client.ownerSessionStateName(), "idle"; got != want {
		t.Fatalf("initial owner state mismatch: got %q want %q", got, want)
	}
	if !client.beginClientSessionStart() {
		t.Fatal("beginClientSessionStart should succeed from idle")
	}
	if got, want := client.ownerSessionStateName(), "starting"; got != want {
		t.Fatalf("after begin owner state mismatch: got %q want %q", got, want)
	}

	client.markSessionStarted()
	if got, want := client.ownerSessionStateName(), "running"; got != want {
		t.Fatalf("after started owner state mismatch: got %q want %q", got, want)
	}

	client.markClientSessionStopping()
	if got, want := client.ownerSessionStateName(), "stopping"; got != want {
		t.Fatalf("after stopping owner state mismatch: got %q want %q", got, want)
	}

	client.markSessionStopped("stopped", nil)
	if got, want := client.ownerSessionStateName(), "stopped"; got != want {
		t.Fatalf("after stopped owner state mismatch: got %q want %q", got, want)
	}
	if !client.beginClientSessionStart() {
		t.Fatal("beginClientSessionStart should succeed from stopped")
	}
}

func TestServerOwnerSessionStateTransitionNames(t *testing.T) {
	server := NewServer().(*ServerCommon)

	if got, want := server.ownerSessionStateName(), "idle"; got != want {
		t.Fatalf("initial owner state mismatch: got %q want %q", got, want)
	}
	if !server.beginServerSessionStart() {
		t.Fatal("beginServerSessionStart should succeed from idle")
	}
	if got, want := server.ownerSessionStateName(), "starting"; got != want {
		t.Fatalf("after begin owner state mismatch: got %q want %q", got, want)
	}

	server.markSessionStarted()
	if got, want := server.ownerSessionStateName(), "running"; got != want {
		t.Fatalf("after started owner state mismatch: got %q want %q", got, want)
	}

	server.markServerSessionStopping()
	if got, want := server.ownerSessionStateName(), "stopping"; got != want {
		t.Fatalf("after stopping owner state mismatch: got %q want %q", got, want)
	}

	server.markSessionStopped("stopped", nil)
	if got, want := server.ownerSessionStateName(), "stopped"; got != want {
		t.Fatalf("after stopped owner state mismatch: got %q want %q", got, want)
	}
	if !server.beginServerSessionStart() {
		t.Fatal("beginServerSessionStart should succeed from stopped")
	}
}