util/eventbus: add test helpers to simplify testing events (#16294)

Instead of every module having to come up with a set of test methods for
the event bus, this handful of test helpers hides a lot of the needed
setup for the testing of the event bus.

The tests in portmapper is also ported over to the new helpers.

Updates #15160

Signed-off-by: Claus Lensbøl <claus@tailscale.com>

util/eventbus/eventbustest/examples_test.go

@@ -0,0 +1,201 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package eventbustest_test
+
+import (
+	"testing"
+
+	"tailscale.com/util/eventbus"
+	"tailscale.com/util/eventbus/eventbustest"
+)
+
+func TestExample_Expect(t *testing.T) {
+	type eventOfInterest struct{}
+
+	bus := eventbustest.NewBus(t)
+	tw := eventbustest.NewWatcher(t, bus)
+
+	client := bus.Client("testClient")
+	updater := eventbus.Publish[eventOfInterest](client)
+	updater.Publish(eventOfInterest{})
+
+	if err := eventbustest.Expect(tw, eventbustest.Type[eventOfInterest]()); err != nil {
+		t.Log(err.Error())
+	} else {
+		t.Log("OK")
+	}
+	// Output:
+	// OK
+}
+
+func TestExample_Expect_WithFunction(t *testing.T) {
+	type eventOfInterest struct {
+		value int
+	}
+
+	bus := eventbustest.NewBus(t)
+	tw := eventbustest.NewWatcher(t, bus)
+
+	client := bus.Client("testClient")
+	updater := eventbus.Publish[eventOfInterest](client)
+	updater.Publish(eventOfInterest{43})
+	updater.Publish(eventOfInterest{42})
+
+	// Look for an event of eventOfInterest with a specific value
+	if err := eventbustest.Expect(tw, func(event eventOfInterest) (bool, error) {
+		if event.value != 42 {
+			return false, nil // Look for another event with the expected value.
+			// You could alternatively return an error here to ensure that the
+			// first seen eventOfInterest matches the value:
+			// return false, fmt.Errorf("expected 42, got %d", event.value)
+		}
+		return true, nil
+	}); err != nil {
+		t.Log(err.Error())
+	} else {
+		t.Log("OK")
+	}
+	// Output:
+	// OK
+}
+
+func TestExample_Expect_MultipleEvents(t *testing.T) {
+	type eventOfInterest struct{}
+	type eventOfNoConcern struct{}
+	type eventOfCuriosity struct{}
+
+	bus := eventbustest.NewBus(t)
+	tw := eventbustest.NewWatcher(t, bus)
+
+	client := bus.Client("testClient")
+	updaterInterest := eventbus.Publish[eventOfInterest](client)
+	updaterConcern := eventbus.Publish[eventOfNoConcern](client)
+	updaterCuriosity := eventbus.Publish[eventOfCuriosity](client)
+	updaterInterest.Publish(eventOfInterest{})
+	updaterConcern.Publish(eventOfNoConcern{})
+	updaterCuriosity.Publish(eventOfCuriosity{})
+
+	// Even though three events was published, we just care about the two
+	if err := eventbustest.Expect(tw,
+		eventbustest.Type[eventOfInterest](),
+		eventbustest.Type[eventOfCuriosity]()); err != nil {
+		t.Log(err.Error())
+	} else {
+		t.Log("OK")
+	}
+	// Output:
+	// OK
+}
+
+func TestExample_ExpectExactly_MultipleEvents(t *testing.T) {
+	type eventOfInterest struct{}
+	type eventOfNoConcern struct{}
+	type eventOfCuriosity struct{}
+
+	bus := eventbustest.NewBus(t)
+	tw := eventbustest.NewWatcher(t, bus)
+
+	client := bus.Client("testClient")
+	updaterInterest := eventbus.Publish[eventOfInterest](client)
+	updaterConcern := eventbus.Publish[eventOfNoConcern](client)
+	updaterCuriosity := eventbus.Publish[eventOfCuriosity](client)
+	updaterInterest.Publish(eventOfInterest{})
+	updaterConcern.Publish(eventOfNoConcern{})
+	updaterCuriosity.Publish(eventOfCuriosity{})
+
+	// Will fail as more events than the two expected comes in
+	if err := eventbustest.ExpectExactly(tw,
+		eventbustest.Type[eventOfInterest](),
+		eventbustest.Type[eventOfCuriosity]()); err != nil {
+		t.Log(err.Error())
+	} else {
+		t.Log("OK")
+	}
+}
+
+func TestExample_Expect_WithMultipleFunctions(t *testing.T) {
+	type eventOfInterest struct {
+		value int
+	}
+	type eventOfNoConcern struct{}
+	type eventOfCuriosity struct {
+		value string
+	}
+
+	bus := eventbustest.NewBus(t)
+	tw := eventbustest.NewWatcher(t, bus)
+
+	client := bus.Client("testClient")
+	updaterInterest := eventbus.Publish[eventOfInterest](client)
+	updaterConcern := eventbus.Publish[eventOfNoConcern](client)
+	updaterCuriosity := eventbus.Publish[eventOfCuriosity](client)
+	updaterInterest.Publish(eventOfInterest{42})
+	updaterConcern.Publish(eventOfNoConcern{})
+	updaterCuriosity.Publish(eventOfCuriosity{"42"})
+
+	interest := func(event eventOfInterest) (bool, error) {
+		if event.value == 42 {
+			return true, nil
+		}
+		return false, nil
+	}
+	curiosity := func(event eventOfCuriosity) (bool, error) {
+		if event.value == "42" {
+			return true, nil
+		}
+		return false, nil
+	}
+
+	// Will fail as more events than the two expected comes in
+	if err := eventbustest.Expect(tw, interest, curiosity); err != nil {
+		t.Log(err.Error())
+	} else {
+		t.Log("OK")
+	}
+	// Output:
+	// OK
+}
+
+func TestExample_ExpectExactly_WithMultipleFuncions(t *testing.T) {
+	type eventOfInterest struct {
+		value int
+	}
+	type eventOfNoConcern struct{}
+	type eventOfCuriosity struct {
+		value string
+	}
+
+	bus := eventbustest.NewBus(t)
+	tw := eventbustest.NewWatcher(t, bus)
+
+	client := bus.Client("testClient")
+	updaterInterest := eventbus.Publish[eventOfInterest](client)
+	updaterConcern := eventbus.Publish[eventOfNoConcern](client)
+	updaterCuriosity := eventbus.Publish[eventOfCuriosity](client)
+	updaterInterest.Publish(eventOfInterest{42})
+	updaterConcern.Publish(eventOfNoConcern{})
+	updaterCuriosity.Publish(eventOfCuriosity{"42"})
+
+	interest := func(event eventOfInterest) (bool, error) {
+		if event.value == 42 {
+			return true, nil
+		}
+		return false, nil
+	}
+	curiosity := func(event eventOfCuriosity) (bool, error) {
+		if event.value == "42" {
+			return true, nil
+		}
+		return false, nil
+	}
+
+	// Will fail as more events than the two expected comes in
+	if err := eventbustest.ExpectExactly(tw, interest, curiosity); err != nil {
+		t.Log(err.Error())
+	} else {
+		t.Log("OK")
+	}
+	// Output:
+	// expected event type eventbustest.eventOfCuriosity, saw eventbustest.eventOfNoConcern, at index 1
+}