Add unit tests for session event handler unsubscription

Tests verify:
- Multiple handlers can be registered and all receive events
- Unsubscribing one handler doesn't affect others
- Calling unsubscribe multiple times is safe
- Handlers are called in registration order
- Concurrent subscribe/unsubscribe is safe

Addresses review feedback from PR #24.

Author: SteveSandersonMS

go/session_test.go

@@ -0,0 +1,121 @@
+package copilot
+
+import (
+	"sync"
+	"testing"
+)
+
+func TestSession_On(t *testing.T) {
+	t.Run("multiple handlers all receive events", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var received1, received2, received3 bool
+		session.On(func(event SessionEvent) { received1 = true })
+		session.On(func(event SessionEvent) { received2 = true })
+		session.On(func(event SessionEvent) { received3 = true })
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if !received1 || !received2 || !received3 {
+			t.Errorf("Expected all handlers to receive event, got received1=%v, received2=%v, received3=%v",
+				received1, received2, received3)
+		}
+	})
+
+	t.Run("unsubscribing one handler does not affect others", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var count1, count2, count3 int
+		session.On(func(event SessionEvent) { count1++ })
+		unsub2 := session.On(func(event SessionEvent) { count2++ })
+		session.On(func(event SessionEvent) { count3++ })
+
+		// First event - all handlers receive it
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		// Unsubscribe handler 2
+		unsub2()
+
+		// Second event - only handlers 1 and 3 should receive it
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if count1 != 2 {
+			t.Errorf("Expected handler 1 to receive 2 events, got %d", count1)
+		}
+		if count2 != 1 {
+			t.Errorf("Expected handler 2 to receive 1 event (before unsubscribe), got %d", count2)
+		}
+		if count3 != 2 {
+			t.Errorf("Expected handler 3 to receive 2 events, got %d", count3)
+		}
+	})
+
+	t.Run("calling unsubscribe multiple times is safe", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var count int
+		unsub := session.On(func(event SessionEvent) { count++ })
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		// Call unsubscribe multiple times - should not panic
+		unsub()
+		unsub()
+		unsub()
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if count != 1 {
+			t.Errorf("Expected handler to receive 1 event, got %d", count)
+		}
+	})
+
+	t.Run("handlers are called in registration order", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var order []int
+		session.On(func(event SessionEvent) { order = append(order, 1) })
+		session.On(func(event SessionEvent) { order = append(order, 2) })
+		session.On(func(event SessionEvent) { order = append(order, 3) })
+
+		session.dispatchEvent(SessionEvent{Type: "test"})
+
+		if len(order) != 3 || order[0] != 1 || order[1] != 2 || order[2] != 3 {
+			t.Errorf("Expected handlers to be called in order [1,2,3], got %v", order)
+		}
+	})
+
+	t.Run("concurrent subscribe and unsubscribe is safe", func(t *testing.T) {
+		session := &Session{
+			handlers: make([]sessionHandler, 0),
+		}
+
+		var wg sync.WaitGroup
+		for i := 0; i < 100; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				unsub := session.On(func(event SessionEvent) {})
+				unsub()
+			}()
+		}
+		wg.Wait()
+
+		// Should not panic and handlers should be empty
+		session.handlerMutex.RLock()
+		count := len(session.handlers)
+		session.handlerMutex.RUnlock()
+
+		if count != 0 {
+			t.Errorf("Expected 0 handlers after all unsubscribes, got %d", count)
+		}
+	})
+}