pubsubcontracts

Documentation

Index

• Variables
• type Blocking
  • func (c Blocking[Data]) Benchmark(b *testing.B)
  • func (c Blocking[Data]) Spec(s *testcase.Spec)
  • func (c Blocking[Data]) Test(t *testing.T)
• type BlockingSubject
• type Buffered
  • func (c Buffered[Data]) Benchmark(b *testing.B)
  • func (c Buffered[Data]) Spec(s *testcase.Spec)
  • func (c Buffered[Data]) Test(t *testing.T)
• type BufferedSubject
• type FIFO
  • func (c FIFO[Data]) Benchmark(b *testing.B)
  • func (c FIFO[Data]) Spec(s *testcase.Spec)
  • func (c FIFO[Data]) Test(t *testing.T)
• type FIFOSubject
• type FanOut
  • func (c FanOut[Data]) Benchmark(b *testing.B)
  • func (c FanOut[Data]) Spec(s *testcase.Spec)
  • func (c FanOut[Data]) Test(t *testing.T)
• type FanOutSubject
• type LIFO
  • func (c LIFO[Data]) Benchmark(b *testing.B)
  • func (c LIFO[Data]) Spec(s *testcase.Spec)
  • func (c LIFO[Data]) Test(t *testing.T)
• type LIFOSubject
• type Ordering
  • func (c Ordering[Data]) Benchmark(b *testing.B)
  • func (c Ordering[Data]) Spec(s *testcase.Spec)
  • func (c Ordering[Data]) Test(t *testing.T)
• type OrderingSubject
• type PubSub
• type Queue
  • func (c Queue[Data]) Benchmark(b *testing.B)
  • func (c Queue[Data]) Spec(s *testcase.Spec)
  • func (c Queue[Data]) Test(t *testing.T)
• type QueueSubject
• type Volatile
  • func (c Volatile[Data]) Benchmark(b *testing.B)
  • func (c Volatile[Data]) Spec(s *testcase.Spec)
  • func (c Volatile[Data]) Test(t *testing.T)
• type VolatileSubject

Variables

var DrainTimeout = 256 * time.Millisecond

Types

type Blocking

type Blocking[Data any] func(testing.TB) BlockingSubject[Data]

func (Blocking[Data]) Benchmark

func (c Blocking[Data]) Benchmark(b *testing.B)

func (Blocking[Data]) Spec

func (c Blocking[Data]) Spec(s *testcase.Spec)

func (Blocking[Data]) Test

func (c Blocking[Data]) Test(t *testing.T)

type BlockingSubject

type BlockingSubject[Data any] struct {
	PubSub PubSub[Data]

	MakeContext func() context.Context
	MakeData    func() Data

	RollbackOnPublishCancellation bool
}

type Buffered

type Buffered[Data any] func(testing.TB) BufferedSubject[Data]

Buffered defines a publisher behaviour where if the subscription is canceled, the publisher messages can be still consumed after resubscribing.

func (Buffered[Data]) Benchmark

func (c Buffered[Data]) Benchmark(b *testing.B)

func (Buffered[Data]) Spec

func (c Buffered[Data]) Spec(s *testcase.Spec)

func (Buffered[Data]) Test

func (c Buffered[Data]) Test(t *testing.T)

type BufferedSubject

type BufferedSubject[Data any] struct {
	PubSub      PubSub[Data]
	MakeContext func() context.Context
	MakeData    func() Data
}

type FIFO

type FIFO[Data any] func(testing.TB) FIFOSubject[Data]

FIFO

It stands for First-In-First-Out approach. In this, the new element is inserted below the existing element, So that the oldest element can be at the top and taken out first. Therefore, the first element to be entered in this approach, gets out First. In computing, FIFO approach is used as an operating system algorithm, which gives every process CPU time in the order they arrive. The data structure that implements FIFO is Queue.

func (FIFO[Data]) Benchmark

func (c FIFO[Data]) Benchmark(b *testing.B)

func (FIFO[Data]) Spec

func (c FIFO[Data]) Spec(s *testcase.Spec)

func (FIFO[Data]) Test

func (c FIFO[Data]) Test(t *testing.T)

type FIFOSubject

type FIFOSubject[Data any] struct {
	PubSub      PubSub[Data]
	MakeContext func() context.Context
	MakeData    func() Data
}

type FanOut

type FanOut[Data any] func(testing.TB) FanOutSubject[Data]

FanOut defines an exchange behaviour where messages are published to all the associated pubsub.Queue.

func (FanOut[Data]) Benchmark

func (c FanOut[Data]) Benchmark(b *testing.B)

func (FanOut[Data]) Spec

func (c FanOut[Data]) Spec(s *testcase.Spec)

func (FanOut[Data]) Test

func (c FanOut[Data]) Test(t *testing.T)

type FanOutSubject

type FanOutSubject[Data any] struct {
	// Exchange is the publisher that suppose to publish to all queue made with MakeQueue.
	Exchange pubsub.Publisher[Data]
	// MakeQueue creates a queue and binds it to the Exchange to receive events.
	// Queues made with MakeQueue suppose to be cleaned up after the test.
	// For the cleanup purpose, use the testing.TB received as part of FanOut.
	MakeQueue func() pubsub.Subscriber[Data]

	MakeContext func() context.Context
	MakeData    func() Data
}

type LIFO

type LIFO[Data any] func(testing.TB) LIFOSubject[Data]

LIFO

It stands for Last-In-First-Out approach in programming. In this, the new element is inserted above the existing element, So that the newest element can be at the top and taken out first. Therefore, the first element to be entered in this approach, gets out Last. In computing, LIFO approach is used as a queuing theory that refers to the way items are stored in types of data structures. The data structure that implements LIFO is Stack.

func (LIFO[Data]) Benchmark

func (c LIFO[Data]) Benchmark(b *testing.B)

func (LIFO[Data]) Spec

func (c LIFO[Data]) Spec(s *testcase.Spec)

func (LIFO[Data]) Test

func (c LIFO[Data]) Test(t *testing.T)

type LIFOSubject

type LIFOSubject[Data any] struct {
	PubSub      PubSub[Data]
	MakeContext func() context.Context
	MakeData    func() Data
}

type Ordering

type Ordering[Data any] func(testing.TB) OrderingSubject[Data]

Ordering is a contract that describes how the ordering should happen with a given

func (Ordering[Data]) Benchmark

func (c Ordering[Data]) Benchmark(b *testing.B)

func (Ordering[Data]) Spec

func (c Ordering[Data]) Spec(s *testcase.Spec)

func (Ordering[Data]) Test

func (c Ordering[Data]) Test(t *testing.T)

type OrderingSubject

type OrderingSubject[Data any] struct {
	PubSub PubSub[Data]
	// Sort function arranges a list of data
	// in the order that it's expected to be received from the PubSub
	// when the data is published into the PubSub.
	Sort func([]Data)

	MakeContext func() context.Context
	MakeData    func() Data
}

type PubSub

type PubSub[Data any] struct {
	pubsub.Publisher[Data]
	pubsub.Subscriber[Data]
}

type Queue

type Queue[Data any] func(testing.TB) QueueSubject[Data]

Queue defines a publisher behaviour where each message is only delivered to a single subscriber, and not to all registered subscribers. If a message is ack-ed, the message will be permanently removed from the Queue.

func (Queue[Data]) Benchmark

func (c Queue[Data]) Benchmark(b *testing.B)

func (Queue[Data]) Spec

func (c Queue[Data]) Spec(s *testcase.Spec)

func (Queue[Data]) Test

func (c Queue[Data]) Test(t *testing.T)

type QueueSubject

type QueueSubject[Data any] struct {
	PubSub      PubSub[Data]
	MakeContext func() context.Context
	MakeData    func() Data
}

type Volatile

type Volatile[Data any] func(testing.TB) VolatileSubject[Data]

Volatile defines a publisher behaviour where if the subscription is canceled, published messages won't be delivered. In certain scenarios, you may want to send a volatile message with no assurances over a publisher, when timely delivery is more important than losing messages.

func (Volatile[Data]) Benchmark

func (c Volatile[Data]) Benchmark(b *testing.B)

func (Volatile[Data]) Spec

func (c Volatile[Data]) Spec(s *testcase.Spec)

func (Volatile[Data]) Test

func (c Volatile[Data]) Test(t *testing.T)

type VolatileSubject

type VolatileSubject[Data any] struct {
	PubSub      PubSub[Data]
	MakeContext func() context.Context
	MakeData    func() Data
}