package agentgit_test

import (

"sync"

"testing"

"time"

"github.com/google/uuid"

"github.com/stretchr/testify/require"

"github.com/coder/coder/v2/agent/agentgit"

"github.com/coder/coder/v2/testutil"

)

func TestPathStore_AddPaths_StoresForChatAndAncestors(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ancestor1 := uuid.New()

ancestor2 := uuid.New()

ps.AddPaths([]uuid.UUID{chatID, ancestor1, ancestor2}, []string{"/a", "/b"})

// All three IDs should see the paths.

require.Equal(t, []string{"/a", "/b"}, ps.GetPaths(chatID))

require.Equal(t, []string{"/a", "/b"}, ps.GetPaths(ancestor1))

require.Equal(t, []string{"/a", "/b"}, ps.GetPaths(ancestor2))

// An unrelated chat should see nothing.

require.Nil(t, ps.GetPaths(uuid.New()))

}

func TestPathStore_AddPaths_SkipsNilUUIDs(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

// A nil chatID should be a no-op.

ps.AddPaths([]uuid.UUID{uuid.Nil}, []string{"/x"})

require.Nil(t, ps.GetPaths(uuid.Nil))

// A nil ancestor should be silently skipped.

chatID := uuid.New()

ps.AddPaths([]uuid.UUID{chatID, uuid.Nil}, []string{"/y"})

require.Equal(t, []string{"/y"}, ps.GetPaths(chatID))

require.Nil(t, ps.GetPaths(uuid.Nil))

}

func TestPathStore_GetPaths_DeduplicatedSorted(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ps.AddPaths([]uuid.UUID{chatID}, []string{"/z", "/a", "/m", "/a", "/z"})

ps.AddPaths([]uuid.UUID{chatID}, []string{"/a", "/b"})

got := ps.GetPaths(chatID)

require.Equal(t, []string{"/a", "/b", "/m", "/z"}, got)

}

func TestPathStore_Subscribe_ReceivesNotification(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ch, unsub := ps.Subscribe(chatID)

defer unsub()

ps.AddPaths([]uuid.UUID{chatID}, []string{"/file"})

ctx := testutil.Context(t, testutil.WaitShort)

select {

case <-ch:

// Success.

case <-ctx.Done():

t.Fatal("timed out waiting for notification")

}

}

func TestPathStore_Subscribe_MultipleSubscribers(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ch1, unsub1 := ps.Subscribe(chatID)

defer unsub1()

ch2, unsub2 := ps.Subscribe(chatID)

defer unsub2()

ps.AddPaths([]uuid.UUID{chatID}, []string{"/file"})

ctx := testutil.Context(t, testutil.WaitShort)

for i, ch := range []<-chan struct{}{ch1, ch2} {

select {

case <-ch:

// OK

case <-ctx.Done():

t.Fatalf("subscriber %d did not receive notification", i)

}

}

}

func TestPathStore_Unsubscribe_StopsNotifications(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ch, unsub := ps.Subscribe(chatID)

unsub()

ps.AddPaths([]uuid.UUID{chatID}, []string{"/file"})

// AddPaths sends synchronously via a non-blocking send to the

// buffered channel, so if a notification were going to arrive

// it would already be in the channel by now.

select {

case <-ch:

t.Fatal("received notification after unsubscribe")

default:

// Expected: no notification.

}

}

func TestPathStore_Subscribe_AncestorNotification(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ancestor := uuid.New()

// Subscribe to the ancestor, then add paths via the child.

ch, unsub := ps.Subscribe(ancestor)

defer unsub()

ps.AddPaths([]uuid.UUID{chatID, ancestor}, []string{"/file"})

ctx := testutil.Context(t, testutil.WaitShort)

select {

case <-ch:

// Success.

case <-ctx.Done():

t.Fatal("ancestor subscriber did not receive notification")

}

}

func TestPathStore_Notify_NotifiesWithoutAddingPaths(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ch, unsub := ps.Subscribe(chatID)

defer unsub()

ps.Notify([]uuid.UUID{chatID})

ctx := testutil.Context(t, testutil.WaitShort)

select {

case <-ch:

// Success.

case <-ctx.Done():

t.Fatal("timed out waiting for notification")

}

require.Nil(t, ps.GetPaths(chatID))

}

func TestPathStore_Notify_SkipsNilUUIDs(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ch, unsub := ps.Subscribe(chatID)

defer unsub()

ps.Notify([]uuid.UUID{uuid.Nil})

// Notify sends synchronously via a non-blocking send to the

// buffered channel, so if a notification were going to arrive

// it would already be in the channel by now.

select {

case <-ch:

t.Fatal("received notification for nil UUID")

default:

// Expected: no notification.

}

require.Nil(t, ps.GetPaths(chatID))

}

func TestPathStore_Notify_AncestorNotification(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

chatID := uuid.New()

ancestorID := uuid.New()

// Subscribe to the ancestor, then notify via the child.

ch, unsub := ps.Subscribe(ancestorID)

defer unsub()

ps.Notify([]uuid.UUID{chatID, ancestorID})

ctx := testutil.Context(t, testutil.WaitShort)

select {

case <-ch:

// Success.

case <-ctx.Done():

t.Fatal("ancestor subscriber did not receive notification")

}

require.Nil(t, ps.GetPaths(ancestorID))

}

func TestPathStore_ConcurrentSafety(t *testing.T) {

t.Parallel()

ps := agentgit.NewPathStore()

const goroutines = 20

const iterations = 50

chatIDs := make([]uuid.UUID, goroutines)

for i := range chatIDs {

chatIDs[i] = uuid.New()

}

var wg sync.WaitGroup

wg.Add(goroutines * 2) // writers + readers

// Writers.

for i := range goroutines {

go func(idx int) {

defer wg.Done()

for j := range iterations {

ancestors := []uuid.UUID{chatIDs[(idx+1)%goroutines]}

path := []string{

"/file-" + chatIDs[idx].String() + "-" + time.Now().Format(time.RFC3339Nano),

"/iter-" + string(rune('0'+j%10)),

}

ps.AddPaths(append([]uuid.UUID{chatIDs[idx]}, ancestors...), path)

}

}(i)

}

// Readers.

for i := range goroutines {

go func(idx int) {

defer wg.Done()

for range iterations {

_ = ps.GetPaths(chatIDs[idx])

}

}(i)

}

wg.Wait()

// Verify every chat has at least the paths it wrote.

for _, id := range chatIDs {

paths := ps.GetPaths(id)

require.NotEmpty(t, paths, "chat %s should have paths", id)

}

}