egg_test.go

package egg

import (
	"errors"
	"testing"
	"time"
)

func TestLazyEgg(t *testing.T) {
	b1 := New(func() any {
		return "b1"
	})
	b2 := New(func() any {
		<-time.After(10 * time.Millisecond)
		return "b2"
	})
	b3 := New(func() any {
		return "b3"
	})

	if got := <-b1(); got != "b1" {
		t.Errorf("b1: got %v, want %q", got, "b1")
	}
	if got := <-b2(); got != "b2" {
		t.Errorf("b2: got %v, want %q", got, "b2")
	}
	if got := <-b3(); got != "b3" {
		t.Errorf("b3: got %v, want %q", got, "b3")
	}
}

func TestLazyPanic(t *testing.T) {
	b1 := New(func() any {
		return "b1"
	})
	b2 := New(func() any {
		panic(errors.New("panic!!"))
	})
	b3 := New(func() any {
		return "b3"
	})

	if got := <-b1(); got != "b1" {
		t.Errorf("b1: got %v, want %q", got, "b1")
	}

	got := <-b2()
	err, ok := got.(error)
	if !ok {
		t.Fatalf("b2: got %T(%v), want error", got, got)
	}
	if err.Error() != "panic!!" {
		t.Errorf("b2: got error %q, want %q", err.Error(), "panic!!")
	}

	if got := <-b3(); got != "b3" {
		t.Errorf("b3: got %v, want %q", got, "b3")
	}
}

// TestLazyEggUnread verifies that a Worker never blocks on send even if the
// caller never reads the Responder's channel — the buffered channel and its
// goroutine must not leak.
func TestLazyEggUnread(t *testing.T) {
	done := make(chan struct{})
	go func() {
		New(func() any {
			return "unread"
		})
		close(done)
	}()

	select {
	case <-done:
	case <-time.After(time.Second):
		t.Fatal("New blocked despite unread Responder channel")
	}
}

func BenchmarkEgg(b *testing.B) {
	var bean = func(i int) Worker {
		return func() any {
			return i
		}
	}

	beans := make([]Responder, 0, b.N)

	for n := 0; n < b.N; n++ {
		beans = append(beans, New(bean(n)))
	}

	for _, be := range beans {
		<-be()
	}
}