package testutil_test

import (

"context"

"fmt"

"sync"

"testing"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

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

)

func TestWaitBuffer_WaitFor_Blocks(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

done := make(chan struct{})

go func() {

defer close(done)

_ = wb.WaitFor(ctx, "hello")

}()

// Write the signal after the goroutine is blocking.

_, err := wb.Write([]byte("hello"))

require.NoError(t, err)

select {

case <-done:

case <-ctx.Done():

t.Fatal("WaitFor did not unblock after signal was written")

}

}

func TestWaitBuffer_WaitFor_AlreadyPresent(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("already here"))

require.NoError(t, err)

// Signal is already in the buffer; WaitFor returns immediately.

require.NoError(t, wb.WaitFor(ctx, "already"))

}

func TestWaitBuffer_WaitFor_ContextExpired(t *testing.T) {

t.Parallel()

ctx, cancel := context.WithCancel(context.Background())

cancel() // Already expired.

wb := testutil.NewWaitBuffer()

err := wb.WaitFor(ctx, "never")

require.ErrorIs(t, err, context.Canceled)

}

func TestWaitBuffer_WaitFor_MultipleWrites(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

// Write partial content that doesn't satisfy the condition.

_, err := wb.Write([]byte("hell"))

require.NoError(t, err)

done := make(chan struct{})

go func() {

defer close(done)

_ = wb.WaitFor(ctx, "hello")

}()

// Complete the signal with a second write.

_, err = wb.Write([]byte("o"))

require.NoError(t, err)

select {

case <-done:

case <-ctx.Done():

t.Fatal("WaitFor did not unblock after multiple writes completed the signal")

}

}

func TestWaitBuffer_WaitForCond(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

done := make(chan struct{})

go func() {

defer close(done)

// Wait until the buffer has at least 10 bytes.

_ = wb.WaitForCond(ctx, func(s string) bool {

return len(s) >= 10

})

}()

_, err := wb.Write([]byte("12345"))

require.NoError(t, err)

_, err = wb.Write([]byte("67890"))

require.NoError(t, err)

select {

case <-done:

case <-ctx.Done():

t.Fatal("WaitForCond did not unblock when condition was met")

}

}

func TestWaitBuffer_ConcurrentWrites(t *testing.T) {

t.Parallel()

wb := testutil.NewWaitBuffer()

var wg sync.WaitGroup

const writers = 10

const iterations = 100

wg.Add(writers)

for i := range writers {

go func() {

defer wg.Done()

for j := range iterations {

_, _ = wb.Write([]byte(fmt.Sprintf("w%d-%d ", i, j)))

}

}()

}

wg.Wait()

// Every write should have landed; verify no data was lost by

// checking the length is at least as large as expected.

assert.GreaterOrEqual(t, len(wb.Bytes()), writers*iterations)

}

func TestWaitBuffer_WaitFor_BackgroundGoroutine(t *testing.T) {

t.Parallel()

ctx, cancel := context.WithCancel(context.Background())

cancel() // Expire immediately.

wb := testutil.NewWaitBuffer()

// WaitFor from a background goroutine should return the

// context error rather than calling t.Fatal.

done := make(chan error, 1)

go func() {

done <- wb.WaitFor(ctx, "never")

}()

err := <-done

require.ErrorIs(t, err, context.Canceled)

}

func TestWaitBuffer_SequentialWaits(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("first "))

require.NoError(t, err)

require.NoError(t, wb.WaitFor(ctx, "first"))

_, err = wb.Write([]byte("second"))

require.NoError(t, err)

require.NoError(t, wb.WaitFor(ctx, "second"))

}

func TestWaitBuffer_WaitForNth_Blocks(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("Foo "))

require.NoError(t, err)

// First occurrence is already present, but we want two.

done := make(chan struct{})

go func() {

defer close(done)

_ = wb.WaitForNth(ctx, "Foo", 2)

}()

_, err = wb.Write([]byte("Bar Foo"))

require.NoError(t, err)

select {

case <-done:

case <-ctx.Done():

t.Fatal("WaitForNth did not unblock after second occurrence")

}

}

func TestWaitBuffer_WaitForNth_AlreadySatisfied(t *testing.T) {

t.Parallel()

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

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("Foo Foo Foo"))

require.NoError(t, err)

// All three occurrences already present.

require.NoError(t, wb.WaitForNth(ctx, "Foo", 3))

}

func TestWaitBuffer_RequireWaitFor_Timeout(t *testing.T) {

t.Parallel()

// Use a mock testing.TB to capture the fatal call without

// killing the real test.

mock := &tbMock{}

ctx, cancel := context.WithCancel(context.Background())

cancel()

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("some output"))

require.NoError(t, err)

wb.RequireWaitFor(ctx, mock, "missing-signal")

assert.True(t, mock.failed(), "expected RequireWaitFor to fail the mock test")

}

// tbMock is a minimal testing.TB that records Fatalf calls.

type tbMock struct {

testing.TB // Embed to satisfy the interface.

mu sync.Mutex

fatalCalls int

}

func (*tbMock) Helper() {}

func (m *tbMock) Fatalf(string, ...any) {

m.mu.Lock()

defer m.mu.Unlock()

m.fatalCalls++

}

func (m *tbMock) failed() bool {

m.mu.Lock()

defer m.mu.Unlock()

return m.fatalCalls > 0

}

func TestWaitBuffer_Bytes_ReturnsCopy(t *testing.T) {

t.Parallel()

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("original"))

require.NoError(t, err)

b := wb.Bytes()

// Mutate the returned slice.

for i := range b {

b[i] = 'X'

}

// The internal buffer must be unchanged.

require.Equal(t, "original", wb.String())

}

func TestWaitBuffer_PlainBuffer(t *testing.T) {

t.Parallel()

wb := testutil.NewWaitBuffer()

_, err := wb.Write([]byte("hello "))

require.NoError(t, err)

_, err = wb.Write([]byte("world"))

require.NoError(t, err)

require.Equal(t, "hello world", wb.String())

require.Equal(t, []byte("hello world"), wb.Bytes())

}