pss/outbox: outbox_tests, now using Epic's testing framework (ut)

Author: aperonam

pss/outbox/outbox.go

@@ -29,6 +29,8 @@ type outbox struct {
 
 type forwardFunction func(msg *message.Message) error
 
+var ErrOutboxFull = errors.New("outbox full")
+
 func NewOutbox(config *Config) *outbox {
 	outbox := outbox{
 		forwardFunc: config.Forward,
@@ -60,7 +62,7 @@ func (o *outbox) Enqueue(outboxMsg *outboxMsg) error {
 		return nil
 	default:
 		metrics.GetOrRegisterCounter("pss.enqueue.outbox.full", nil).Inc(1)
-		return errors.New("outbox full")
+		return ErrOutboxFull
 	}
 }
 

pss/outbox/outbox_test.go

@@ -2,12 +2,18 @@ package outbox
 
 import (
 	"errors"
-	"github.com/ethersphere/swarm/pss/message"
 	"testing"
 	"time"
+
+	"github.com/epiclabs-io/ut"
+	"github.com/ethersphere/swarm/pss/message"
 )
 
-func TestMessageOutbox(t *testing.T) {
+const waitTimeout = 2 * time.Second
+
+func TestOutbox(tx *testing.T) {
+	t := ut.BeginTest(tx, false)
+	defer t.FinishTest()
 
 	outboxCapacity := 2
 	successC := make(chan struct{})
@@ -21,22 +27,17 @@ func TestMessageOutbox(t *testing.T) {
 		QuitC:       nil,
 		Forward:     mockForwardFunction,
 	})
-
 	go testOutbox.ProcessOutbox()
 
 	err := testOutbox.Enqueue(testOutboxMessage)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
+	t.Ok(err)
 
 	usedSlots := testOutbox.len()
-	if usedSlots != 1 {
-		t.Fatalf("incorrect outbox length. expected 1, got %v", usedSlots)
-	}
+	t.Assert(usedSlots == 1, "incorrect outbox length. expected 1, got %v", usedSlots)
 
 	select {
 	case <-successC:
-	case <-time.After(2 * time.Second):
+	case <-time.After(waitTimeout):
 		t.Fatal("timeout waiting for success forward")
 	}
 
@@ -49,39 +50,39 @@ func TestMessageOutbox(t *testing.T) {
 		<-continueC
 		return errors.New("forced test error forwarding message")
 	}
-
 	testOutbox.forwardFunc = failedForward
 
 	err = testOutbox.Enqueue(testOutboxMessage)
-	if err != nil {
-		t.Fatalf("Expected no error enqueing, got %v", err.Error())
-	}
+	t.Ok(err)
 
 	select {
 	case <-failedC:
-	case <-time.After(2 * time.Second):
+	case <-time.After(waitTimeout):
 		t.Fatal("timeout waiting for failing forward")
 	}
 
-	if len(failed) == 0 {
-		t.Fatal("Incorrect number of failed messages, expected 1 got 0")
-	}
+	failedMessages := len(failed)
+	t.Assert(failedMessages == 1, "incorrect number of failed messages, expected 1 got %v", failedMessages)
+
 	// The message will be retried once we send to continueC, so first, we change the forward function
 	testOutbox.forwardFunc = mockForwardFunction
 	continueC <- struct{}{}
+
 	select {
 	case <-successC:
-	case <-time.After(2 * time.Second):
-		t.Fatal("Timeout waiting for second success forward")
+	case <-time.After(waitTimeout):
+		t.Fatal("timeout waiting for second success forward")
 	}
 }
 
-func TestOutboxFull(t *testing.T) {
+func TestOutboxFull(tx *testing.T) {
+	t := ut.BeginTest(tx, false)
+	defer t.FinishTest()
 
 	outboxCapacity := 2
-	procChan := make(chan struct{})
+	processC := make(chan struct{})
 	successForward := func(msg *message.Message) error {
-		<-procChan
+		<-processC
 		return nil
 	}
 
@@ -90,28 +91,24 @@ func TestOutboxFull(t *testing.T) {
 		QuitC:       nil,
 		Forward:     successForward,
 	})
-
 	go testOutbox.ProcessOutbox()
 
 	err := testOutbox.Enqueue(testOutboxMessage)
-	if err != nil {
-		t.Fatalf("expected no error enqueing first message, got %v", err)
-	}
+	t.Ok(err)
+
 	err = testOutbox.Enqueue(testOutboxMessage)
-	if err != nil {
-		t.Fatalf("expected no error enqueing second message, got %v", err)
-	}
+	t.Ok(err)
 
-	//As we haven't signaled procChan, the messages are still in the outbox
+	//As we haven't signaled processC, the messages are still in the outbox
 	err = testOutbox.Enqueue(testOutboxMessage)
-	if err == nil {
-		t.Fatalf("expected error enqueing third message, instead got nil")
-	}
-	procChan <- struct{}{}
+	t.MustFailWith(err, ErrOutboxFull)
+
+	processC <- struct{}{}
+
 	//There should be a slot again in the outbox
 	select {
 	case <-testOutbox.slots:
-	case <-time.After(2 * time.Second):
+	case <-time.After(waitTimeout):
 		t.Fatalf("timeout waiting for a free slot")
 	}
 }