Refactor all tests to use the MemoryLeakTestSuite.

pkg/nullio/content_length_test.go

@@ -2,10 +2,7 @@ package nullio
 
 import (
 	"bytes"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"net/http"
-	"testing"
 )
 
 type responseWriterStub struct {
@@ -19,7 +16,7 @@ func (r *responseWriterStub) Header() http.Header {
 func (r *responseWriterStub) WriteHeader(_ int) {
 }
 
-func TestContentLengthWriter_Write(t *testing.T) {
+func (s *MainTestSuite) TestContentLengthWriter_Write() {
 	header := http.Header(make(map[string][]string))
 	buf := &responseWriterStub{header: header}
 	writer := &ContentLengthWriter{Target: buf}
@@ -29,20 +26,20 @@ func TestContentLengthWriter_Write(t *testing.T) {
 	part3 := []byte("AG")
 
 	count, err := writer.Write(part1)
-	require.NoError(t, err)
-	assert.Equal(t, len(part1), count)
-	assert.Empty(t, buf.String())
-	assert.Equal(t, "", header.Get("Content-Length"))
+	s.Require().NoError(err)
+	s.Equal(len(part1), count)
+	s.Empty(buf.String())
+	s.Equal("", header.Get("Content-Length"))
 
 	count, err = writer.Write(part2)
-	require.NoError(t, err)
-	assert.Equal(t, len(part2), count)
-	assert.Equal(t, "FL", buf.String())
-	assert.Equal(t, contentLength, header.Get("Content-Length"))
+	s.Require().NoError(err)
+	s.Equal(len(part2), count)
+	s.Equal("FL", buf.String())
+	s.Equal(contentLength, header.Get("Content-Length"))
 
 	count, err = writer.Write(part3)
-	require.NoError(t, err)
-	assert.Equal(t, len(part3), count)
-	assert.Equal(t, "FLAG", buf.String())
-	assert.Equal(t, contentLength, header.Get("Content-Length"))
+	s.Require().NoError(err)
+	s.Equal(len(part3), count)
+	s.Equal("FLAG", buf.String())
+	s.Equal(contentLength, header.Get("Content-Length"))
 }

pkg/nullio/ls2json_test.go

@@ -3,6 +3,7 @@ package nullio
 import (
 	"bytes"
 	"context"
+	"github.com/openHPI/poseidon/tests"
 	"github.com/stretchr/testify/suite"
 	"testing"
 )
@@ -12,12 +13,13 @@ func TestLs2JsonTestSuite(t *testing.T) {
 }
 
 type Ls2JsonTestSuite struct {
-	suite.Suite
+	tests.MemoryLeakTestSuite
 	buf    *bytes.Buffer
 	writer *Ls2JsonWriter
 }
 
 func (s *Ls2JsonTestSuite) SetupTest() {
+	s.MemoryLeakTestSuite.SetupTest()
 	s.buf = &bytes.Buffer{}
 	s.writer = &Ls2JsonWriter{Target: s.buf, Ctx: context.Background()}
 }

pkg/nullio/nullio_test.go

@@ -2,23 +2,30 @@ package nullio
 
 import (
 	"context"
-	"github.com/stretchr/testify/assert"
+	"github.com/openHPI/poseidon/tests"
+	"github.com/stretchr/testify/suite"
 	"io"
 	"testing"
 	"time"
 )
 
-const shortTimeout = 100 * time.Millisecond
+type MainTestSuite struct {
+	tests.MemoryLeakTestSuite
+}
 
-func TestReader_Read(t *testing.T) {
+func TestMainTestSuite(t *testing.T) {
+	suite.Run(t, new(MainTestSuite))
+}
+
+func (s *MainTestSuite) TestReader_Read() {
 	read := func(reader io.Reader, ret chan<- bool) {
 		p := make([]byte, 0, 5)
 		_, err := reader.Read(p)
-		assert.ErrorIs(t, io.EOF, err)
+		s.ErrorIs(io.EOF, err)
 		close(ret)
 	}
 
-	t.Run("WithContext_DoesNotReturnImmediately", func(t *testing.T) {
+	s.Run("WithContext_DoesNotReturnImmediately", func() {
 		readingContext, cancel := context.WithCancel(context.Background())
 		defer cancel()
 
@@ -27,27 +34,27 @@ func TestReader_Read(t *testing.T) {
 
 		select {
 		case <-readerReturned:
-			assert.Fail(t, "The reader returned before the timeout was reached")
-		case <-time.After(shortTimeout):
+			s.Fail("The reader returned before the timeout was reached")
+		case <-time.After(tests.ShortTimeout):
 		}
 	})
 
-	t.Run("WithoutContext_DoesReturnImmediately", func(t *testing.T) {
+	s.Run("WithoutContext_DoesReturnImmediately", func() {
 		readerReturned := make(chan bool)
 		go read(&Reader{}, readerReturned)
 
 		select {
 		case <-readerReturned:
-		case <-time.After(shortTimeout):
-			assert.Fail(t, "The reader returned before the timeout was reached")
+		case <-time.After(tests.ShortTimeout):
+			s.Fail("The reader returned before the timeout was reached")
 		}
 	})
 }
 
-func TestReadWriterWritesEverything(t *testing.T) {
+func (s *MainTestSuite) TestReadWriterWritesEverything() {
 	readWriter := &ReadWriter{}
 	p := []byte{1, 2, 3}
 	n, err := readWriter.Write(p)
-	assert.NoError(t, err)
-	assert.Equal(t, len(p), n)
+	s.NoError(err)
+	s.Equal(len(p), n)
 }