htwkmooc/poseidon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor all tests to use the MemoryLeakTestSuite.

Browse Source
This commit is contained in:
Maximilian Paß
2023-09-05 16:11:06 +02:00
parent e3161637a9
commit 3abd4d9a3d
30 changed files with 1012 additions and 759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
internal/api/api_test.go
View File

@ -3,7 +3,8 @@ package api
import (
"github.com/gorilla/mux"
"github.com/openHPI/poseidon/internal/config"
"github.com/stretchr/testify/assert"
"github.com/openHPI/poseidon/tests"
"github.com/stretchr/testify/suite"
"net/http"
"net/http/httptest"
"testing"
@ -13,58 +14,66 @@ func mockHTTPHandler(writer http.ResponseWriter, _ *http.Request) {
writer.WriteHeader(http.StatusOK)
}
func TestNewRouterV1WithAuthenticationDisabled(t *testing.T) {
type MainTestSuite struct {
tests.MemoryLeakTestSuite
}
func TestMainTestSuite(t *testing.T) {
suite.Run(t, new(MainTestSuite))
}
func (s *MainTestSuite) TestNewRouterV1WithAuthenticationDisabled() {
config.Config.Server.Token = ""
router := mux.NewRouter()
configureV1Router(router, nil, nil)
t.Run("health route is accessible", func(t *testing.T) {
s.Run("health route is accessible", func() {
request, err := http.NewRequest(http.MethodGet, "/api/v1/health", http.NoBody)
if err != nil {
t.Fatal(err)
s.T().Fatal(err)
}
recorder := httptest.NewRecorder()
router.ServeHTTP(recorder, request)
assert.Equal(t, http.StatusNoContent, recorder.Code)
s.Equal(http.StatusNoContent, recorder.Code)
})
t.Run("added route is accessible", func(t *testing.T) {
s.Run("added route is accessible", func() {
router.HandleFunc("/api/v1/test", mockHTTPHandler)
request, err := http.NewRequest(http.MethodGet, "/api/v1/test", http.NoBody)
if err != nil {
t.Fatal(err)
s.T().Fatal(err)
}
recorder := httptest.NewRecorder()
router.ServeHTTP(recorder, request)
assert.Equal(t, http.StatusOK, recorder.Code)
s.Equal(http.StatusOK, recorder.Code)
})
}
func TestNewRouterV1WithAuthenticationEnabled(t *testing.T) {
func (s *MainTestSuite) TestNewRouterV1WithAuthenticationEnabled() {
config.Config.Server.Token = "TestToken"
router := mux.NewRouter()
configureV1Router(router, nil, nil)
t.Run("health route is accessible", func(t *testing.T) {
s.Run("health route is accessible", func() {
request, err := http.NewRequest(http.MethodGet, "/api/v1/health", http.NoBody)
if err != nil {
t.Fatal(err)
s.T().Fatal(err)
}
recorder := httptest.NewRecorder()
router.ServeHTTP(recorder, request)
assert.Equal(t, http.StatusNoContent, recorder.Code)
s.Equal(http.StatusNoContent, recorder.Code)
})
t.Run("protected route is not accessible", func(t *testing.T) {
s.Run("protected route is not accessible", func() {
// request an available API route that should be guarded by authentication.
// (which one, in particular, does not matter here)
request, err := http.NewRequest(http.MethodPost, "/api/v1/runners", http.NoBody)
if err != nil {
t.Fatal(err)
s.T().Fatal(err)
}
recorder := httptest.NewRecorder()
router.ServeHTTP(recorder, request)
assert.Equal(t, http.StatusUnauthorized, recorder.Code)
s.Equal(http.StatusUnauthorized, recorder.Code)
})
config.Config.Server.Token = ""
}

5
internal/api/auth/auth_test.go
View File

@ -2,6 +2,7 @@ package auth
import (
"github.com/openHPI/poseidon/internal/config"
"github.com/openHPI/poseidon/tests"
"github.com/sirupsen/logrus"
"github.com/sirupsen/logrus/hooks/test"
"github.com/stretchr/testify/assert"
@ -14,13 +15,14 @@ import (
const testToken = "C0rr3ctT0k3n"
type AuthenticationMiddlewareTestSuite struct {
suite.Suite
tests.MemoryLeakTestSuite
request *http.Request
recorder *httptest.ResponseRecorder
httpAuthenticationMiddleware http.Handler
}
func (s *AuthenticationMiddlewareTestSuite) SetupTest() {
s.MemoryLeakTestSuite.SetupTest()
correctAuthenticationToken = []byte(testToken)
s.recorder = httptest.NewRecorder()
request, err := http.NewRequest(http.MethodGet, "/api/v1/test", http.NoBody)
@ -35,6 +37,7 @@ func (s *AuthenticationMiddlewareTestSuite) SetupTest() {
}
func (s *AuthenticationMiddlewareTestSuite) TearDownTest() {
defer s.MemoryLeakTestSuite.TearDownTest()
correctAuthenticationToken = []byte(nil)
}

8
internal/api/environments_test.go
View File

@ -20,7 +20,7 @@ import (
)
type EnvironmentControllerTestSuite struct {
suite.Suite
tests.MemoryLeakTestSuite
manager *environment.ManagerHandlerMock
router *mux.Router
}
@ -30,6 +30,7 @@ func TestEnvironmentControllerTestSuite(t *testing.T) {
}
func (s *EnvironmentControllerTestSuite) SetupTest() {
s.MemoryLeakTestSuite.SetupTest()
s.manager = &environment.ManagerHandlerMock{}
s.router = NewRouter(nil, s.manager)
}
@ -86,6 +87,9 @@ func (s *EnvironmentControllerTestSuite) TestList() {
})
s.Run("returns multiple environments", func() {
s.ExpectedGoroutingIncrease++ // We dont care to delete the created environment.
s.ExpectedGoroutingIncrease++ // Also not about the second.
call.Run(func(args mock.Arguments) {
firstEnvironment, err := environment.NewNomadEnvironment(tests.DefaultEnvironmentIDAsInteger, nil,
"job \""+nomad.TemplateJobID(tests.DefaultEnvironmentIDAsInteger)+"\" {}")
@ -148,6 +152,8 @@ func (s *EnvironmentControllerTestSuite) TestGet() {
s.manager.Calls = []mock.Call{}
s.Run("returns environment", func() {
s.ExpectedGoroutingIncrease++ // We dont care to delete the created environment.
call.Run(func(args mock.Arguments) {
testEnvironment, err := environment.NewNomadEnvironment(tests.DefaultEnvironmentIDAsInteger, nil,
"job \""+nomad.TemplateJobID(tests.DefaultEnvironmentIDAsInteger)+"\" {}")

8
internal/api/health_test.go
View File

@ -1,18 +1,16 @@
package api
import (
"github.com/stretchr/testify/assert"
"net/http"
"net/http/httptest"
"testing"
)
func TestHealthRoute(t *testing.T) {
func (s *MainTestSuite) TestHealthRoute() {
request, err := http.NewRequest(http.MethodGet, "/health", http.NoBody)
if err != nil {
t.Fatal(err)
s.T().Fatal(err)
}
recorder := httptest.NewRecorder()
http.HandlerFunc(Health).ServeHTTP(recorder, request)
assert.Equal(t, http.StatusNoContent, recorder.Code)
s.Equal(http.StatusNoContent, recorder.Code)
}

25
internal/api/runners_test.go
View File

@ -23,7 +23,7 @@ import (
const invalidID = "some-invalid-runner-id"
type MiddlewareTestSuite struct {
suite.Suite
tests.MemoryLeakTestSuite
manager *runner.ManagerMock
router *mux.Router
runner runner.Runner
@ -32,8 +32,11 @@ type MiddlewareTestSuite struct {
}
func (s *MiddlewareTestSuite) SetupTest() {
s.MemoryLeakTestSuite.SetupTest()
s.manager = &runner.ManagerMock{}
s.runner = runner.NewNomadJob(tests.DefaultRunnerID, nil, nil, nil)
apiMock := &nomad.ExecutorAPIMock{}
apiMock.On("DeleteJob", mock.AnythingOfType("string")).Return(nil)
s.runner = runner.NewNomadJob(tests.DefaultRunnerID, nil, apiMock, nil)
s.capturedRunner = nil
s.runnerRequest = func(runnerId string) *http.Request {
path, err := s.router.Get("test-runner-id").URL(RunnerIDKey, runnerId)
@ -58,6 +61,12 @@ func (s *MiddlewareTestSuite) SetupTest() {
s.router.HandleFunc(fmt.Sprintf("/test/{%s}", RunnerIDKey), runnerRouteHandler).Name("test-runner-id")
}
func (s *MiddlewareTestSuite) TearDownTest() {
defer s.MemoryLeakTestSuite.TearDownTest()
err := s.runner.Destroy(nil)
s.Require().NoError(err)
}
func TestMiddlewareTestSuite(t *testing.T) {
suite.Run(t, new(MiddlewareTestSuite))
}
@ -102,7 +111,7 @@ func TestRunnerRouteTestSuite(t *testing.T) {
}
type RunnerRouteTestSuite struct {
suite.Suite
tests.MemoryLeakTestSuite
runnerManager *runner.ManagerMock
router *mux.Router
runner runner.Runner
@ -110,14 +119,22 @@ type RunnerRouteTestSuite struct {
}
func (s *RunnerRouteTestSuite) SetupTest() {
s.MemoryLeakTestSuite.SetupTest()
s.runnerManager = &runner.ManagerMock{}
s.router = NewRouter(s.runnerManager, nil)
s.runner = runner.NewNomadJob("some-id", nil, nil, nil)
apiMock := &nomad.ExecutorAPIMock{}
apiMock.On("DeleteJob", mock.AnythingOfType("string")).Return(nil)
s.runner = runner.NewNomadJob("some-id", nil, apiMock, func(_ runner.Runner) error { return nil })
s.executionID = "execution"
s.runner.StoreExecution(s.executionID, &dto.ExecutionRequest{})
s.runnerManager.On("Get", s.runner.ID()).Return(s.runner, nil)
}
func (s *RunnerRouteTestSuite) TearDownTest() {
defer s.MemoryLeakTestSuite.TearDownTest()
s.Require().NoError(s.runner.Destroy(nil))
}
func TestProvideRunnerTestSuite(t *testing.T) {
suite.Run(t, new(ProvideRunnerTestSuite))
}

66
internal/api/websocket_test.go
View File

@ -15,9 +15,7 @@ import (
"github.com/openHPI/poseidon/tests/helpers"
"github.com/sirupsen/logrus"
"github.com/sirupsen/logrus/hooks/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"io"
"net/http"
@ -32,7 +30,7 @@ func TestWebSocketTestSuite(t *testing.T) {
}
type WebSocketTestSuite struct {
suite.Suite
tests.MemoryLeakTestSuite
router *mux.Router
executionID string
runner runner.Runner
@ -41,6 +39,7 @@ type WebSocketTestSuite struct {
}
func (s *WebSocketTestSuite) SetupTest() {
s.MemoryLeakTestSuite.SetupTest()
runnerID := "runner-id"
s.runner, s.apiMock = newNomadAllocationWithMockedAPIClient(runnerID)
@ -56,14 +55,19 @@ func (s *WebSocketTestSuite) SetupTest() {
}
func (s *WebSocketTestSuite) TearDownTest() {
defer s.MemoryLeakTestSuite.TearDownTest()
s.server.Close()
err := s.runner.Destroy(nil)
s.Require().NoError(err)
}
func (s *WebSocketTestSuite) TestWebsocketConnectionCanBeEstablished() {
wsURL, err := s.webSocketURL("ws", s.runner.ID(), s.executionID)
s.Require().NoError(err)
_, _, err = websocket.DefaultDialer.Dial(wsURL.String(), nil)
conn, _, err := websocket.DefaultDialer.Dial(wsURL.String(), nil)
s.Require().NoError(err)
err = conn.Close()
s.NoError(err)
}
func (s *WebSocketTestSuite) TestWebsocketReturns404IfExecutionDoesNotExist() {
@ -81,6 +85,8 @@ func (s *WebSocketTestSuite) TestWebsocketReturns400IfRequestedViaHttp() {
s.Require().NoError(err)
// This functionality is implemented by the WebSocket library.
s.Equal(http.StatusBadRequest, response.StatusCode)
_, err = io.ReadAll(response.Body)
s.NoError(err)
}
func (s *WebSocketTestSuite) TestWebsocketConnection() {
@ -248,7 +254,7 @@ func (s *WebSocketTestSuite) TestWebsocketNonZeroExit() {
s.Equal(&dto.WebSocketMessage{Type: dto.WebSocketExit, ExitCode: 42}, controlMessages[1])
}
func TestWebsocketTLS(t *testing.T) {
func (s *MainTestSuite) TestWebsocketTLS() {
runnerID := "runner-id"
r, apiMock := newNomadAllocationWithMockedAPIClient(runnerID)
@ -260,30 +266,31 @@ func TestWebsocketTLS(t *testing.T) {
runnerManager.On("Get", r.ID()).Return(r, nil)
router := NewRouter(runnerManager, nil)
server, err := helpers.StartTLSServer(t, router)
require.NoError(t, err)
server, err := helpers.StartTLSServer(s.T(), router)
s.Require().NoError(err)
defer server.Close()
wsURL, err := webSocketURL("wss", server, router, runnerID, executionID)
require.NoError(t, err)
s.Require().NoError(err)
config := &tls.Config{RootCAs: nil, InsecureSkipVerify: true} //nolint:gosec // test needs self-signed cert
d := websocket.Dialer{TLSClientConfig: config}
connection, _, err := d.Dial(wsURL.String(), nil)
require.NoError(t, err)
s.Require().NoError(err)
message, err := helpers.ReceiveNextWebSocketMessage(connection)
require.NoError(t, err)
assert.Equal(t, dto.WebSocketMetaStart, message.Type)
s.Require().NoError(err)
s.Equal(dto.WebSocketMetaStart, message.Type)
_, err = helpers.ReceiveAllWebSocketMessages(connection)
require.Error(t, err)
assert.True(t, websocket.IsCloseError(err, websocket.CloseNormalClosure))
s.Require().Error(err)
s.True(websocket.IsCloseError(err, websocket.CloseNormalClosure))
s.NoError(r.Destroy(nil))
}
func TestWebSocketProxyStopsReadingTheWebSocketAfterClosingIt(t *testing.T) {
func (s *MainTestSuite) TestWebSocketProxyStopsReadingTheWebSocketAfterClosingIt() {
apiMock := &nomad.ExecutorAPIMock{}
executionID := tests.DefaultExecutionID
r, wsURL := newRunnerWithNotMockedRunnerManager(t, apiMock, executionID)
r, wsURL := newRunnerWithNotMockedRunnerManager(s, apiMock, executionID)
logger, hook := test.NewNullLogger()
log = logger.WithField("pkg", "api")
@ -294,14 +301,14 @@ func TestWebSocketProxyStopsReadingTheWebSocketAfterClosingIt(t *testing.T) {
return 0, nil
})
connection, _, err := websocket.DefaultDialer.Dial(wsURL.String(), nil)
require.NoError(t, err)
s.Require().NoError(err)
_, err = helpers.ReceiveAllWebSocketMessages(connection)
require.Error(t, err)
assert.True(t, websocket.IsCloseError(err, websocket.CloseNormalClosure))
s.Require().Error(err)
s.True(websocket.IsCloseError(err, websocket.CloseNormalClosure))
for _, logMsg := range hook.Entries {
if logMsg.Level < logrus.InfoLevel {
assert.Fail(t, logMsg.Message)
s.Fail(logMsg.Message)
}
}
}
@ -310,42 +317,47 @@ func TestWebSocketProxyStopsReadingTheWebSocketAfterClosingIt(t *testing.T) {
func newNomadAllocationWithMockedAPIClient(runnerID string) (runner.Runner, *nomad.ExecutorAPIMock) {
executorAPIMock := &nomad.ExecutorAPIMock{}
executorAPIMock.On("DeleteJob", mock.AnythingOfType("string")).Return(nil)
manager := &runner.ManagerMock{}
manager.On("Return", mock.Anything).Return(nil)
r := runner.NewNomadJob(runnerID, nil, executorAPIMock, nil)
return r, executorAPIMock
}
func newRunnerWithNotMockedRunnerManager(t *testing.T, apiMock *nomad.ExecutorAPIMock, executionID string) (
func newRunnerWithNotMockedRunnerManager(s *MainTestSuite, apiMock *nomad.ExecutorAPIMock, executionID string) (
r runner.Runner, wsURL *url.URL) {
t.Helper()
s.T().Helper()
apiMock.On("MarkRunnerAsUsed", mock.AnythingOfType("string"), mock.AnythingOfType("int")).Return(nil)
apiMock.On("DeleteJob", mock.AnythingOfType("string")).Return(nil)
apiMock.On("RegisterRunnerJob", mock.AnythingOfType("*api.Job")).Return(nil)
call := apiMock.On("WatchEventStream", mock.Anything, mock.Anything, mock.Anything)
call.Run(func(args mock.Arguments) {
<-context.Background().Done()
<-s.TestCtx.Done()
call.ReturnArguments = mock.Arguments{nil}
})
runnerManager := runner.NewNomadRunnerManager(apiMock, context.Background())
runnerManager := runner.NewNomadRunnerManager(apiMock, s.TestCtx)
router := NewRouter(runnerManager, nil)
s.ExpectedGoroutingIncrease++ // We don't care about closing the server at this point.
server := httptest.NewServer(router)
runnerID := tests.DefaultRunnerID
s.ExpectedGoroutingIncrease++ // We don't care about removing the runner at this place.
runnerJob := runner.NewNomadJob(runnerID, nil, apiMock, nil)
s.ExpectedGoroutingIncrease++ // We don't care about removing the environment at this place.
e, err := environment.NewNomadEnvironment(0, apiMock, "job \"template-0\" {}")
require.NoError(t, err)
s.Require().NoError(err)
eID, err := nomad.EnvironmentIDFromRunnerID(runnerID)
require.NoError(t, err)
s.Require().NoError(err)
e.SetID(eID)
e.SetPrewarmingPoolSize(0)
runnerManager.StoreEnvironment(e)
e.AddRunner(runnerJob)
r, err = runnerManager.Claim(e.ID(), int(tests.DefaultTestTimeout.Seconds()))
require.NoError(t, err)
s.Require().NoError(err)
wsURL, err = webSocketURL("ws", server, router, r.ID(), executionID)
require.NoError(t, err)
s.Require().NoError(err)
return r, wsURL
}

36
internal/api/ws/codeocean_reader_test.go
View File

@ -4,15 +4,22 @@ import (
"context"
"github.com/gorilla/websocket"
"github.com/openHPI/poseidon/tests"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"io"
"strings"
"testing"
)
func TestCodeOceanToRawReaderReturnsOnlyAfterOneByteWasRead(t *testing.T) {
type MainTestSuite struct {
tests.MemoryLeakTestSuite
}
func TestMainTestSuite(t *testing.T) {
suite.Run(t, new(MainTestSuite))
}
func (s *MainTestSuite) TestCodeOceanToRawReaderReturnsOnlyAfterOneByteWasRead() {
readingCtx, cancel := context.WithCancel(context.Background())
forwardingCtx := readingCtx
defer cancel()
@ -23,22 +30,23 @@ func TestCodeOceanToRawReaderReturnsOnlyAfterOneByteWasRead(t *testing.T) {
//nolint:makezero // we can't make zero initial length here as the reader otherwise doesn't block
p := make([]byte, 10)
_, err := reader.Read(p)
require.NoError(t, err)
s.Require().NoError(err)
read <- true
}()
t.Run("Does not return immediately when there is no data", func(t *testing.T) {
assert.False(t, tests.ChannelReceivesSomething(read, tests.ShortTimeout))
s.Run("Does not return immediately when there is no data", func() {
s.False(tests.ChannelReceivesSomething(read, tests.ShortTimeout))
})
t.Run("Returns when there is data available", func(t *testing.T) {
s.Run("Returns when there is data available", func() {
reader.buffer <- byte(42)
assert.True(t, tests.ChannelReceivesSomething(read, tests.ShortTimeout))
s.True(tests.ChannelReceivesSomething(read, tests.ShortTimeout))
})
}
func TestCodeOceanToRawReaderReturnsOnlyAfterOneByteWasReadFromConnection(t *testing.T) {
func (s *MainTestSuite) TestCodeOceanToRawReaderReturnsOnlyAfterOneByteWasReadFromConnection() {
messages := make(chan io.Reader)
defer close(messages)
connection := &ConnectionMock{}
connection.On("WriteMessage", mock.AnythingOfType("int"), mock.AnythingOfType("[]uint8")).Return(nil)
@ -60,16 +68,16 @@ func TestCodeOceanToRawReaderReturnsOnlyAfterOneByteWasReadFromConnection(t *tes
message := make([]byte, 10)
go func() {
_, err := reader.Read(message)
require.NoError(t, err)
s.Require().NoError(err)
read <- true
}()
t.Run("Does not return immediately when there is no data", func(t *testing.T) {
assert.False(t, tests.ChannelReceivesSomething(read, tests.ShortTimeout))
s.Run("Does not return immediately when there is no data", func() {
s.False(tests.ChannelReceivesSomething(read, tests.ShortTimeout))
})
t.Run("Returns when there is data available", func(t *testing.T) {
s.Run("Returns when there is data available", func() {
messages <- strings.NewReader("Hello")
assert.True(t, tests.ChannelReceivesSomething(read, tests.ShortTimeout))
s.True(tests.ChannelReceivesSomething(read, tests.ShortTimeout))
})
}

56
internal/api/ws/codeocean_writer_test.go
View File

@ -6,45 +6,44 @@ import (
"github.com/gorilla/websocket"
"github.com/openHPI/poseidon/internal/runner"
"github.com/openHPI/poseidon/pkg/dto"
"github.com/stretchr/testify/assert"
"github.com/openHPI/poseidon/tests"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"testing"
)
func TestRawToCodeOceanWriter(t *testing.T) {
connectionMock, message := buildConnectionMock(t)
func (s *MainTestSuite) TestRawToCodeOceanWriter() {
connectionMock, messages := buildConnectionMock(&s.MemoryLeakTestSuite)
proxyCtx, cancel := context.WithCancel(context.Background())
defer cancel()
output := NewCodeOceanOutputWriter(connectionMock, proxyCtx, cancel)
<-message // start message
defer output.Close(nil)
<-messages // start messages
t.Run("StdOut", func(t *testing.T) {
s.Run("StdOut", func() {
testMessage := "testStdOut"
_, err := output.StdOut().Write([]byte(testMessage))
require.NoError(t, err)
s.Require().NoError(err)
expected, err := json.Marshal(struct {
Type string `json:"type"`
Data string `json:"data"`
}{string(dto.WebSocketOutputStdout), testMessage})
require.NoError(t, err)
s.Require().NoError(err)
assert.Equal(t, expected, <-message)
s.Equal(expected, <-messages)
})
t.Run("StdErr", func(t *testing.T) {
s.Run("StdErr", func() {
testMessage := "testStdErr"
_, err := output.StdErr().Write([]byte(testMessage))
require.NoError(t, err)
s.Require().NoError(err)
expected, err := json.Marshal(struct {
Type string `json:"type"`
Data string `json:"data"`
}{string(dto.WebSocketOutputStderr), testMessage})
require.NoError(t, err)
s.Require().NoError(err)
assert.Equal(t, expected, <-message)
s.Equal(expected, <-messages)
})
}
@ -54,7 +53,7 @@ type sendExitInfoTestCase struct {
message dto.WebSocketMessage
}
func TestCodeOceanOutputWriter_SendExitInfo(t *testing.T) {
func (s *MainTestSuite) TestCodeOceanOutputWriter_SendExitInfo() {
testCases := []sendExitInfoTestCase{
{"Timeout", &runner.ExitInfo{Err: runner.ErrorRunnerInactivityTimeout},
dto.WebSocketMessage{Type: dto.WebSocketMetaTimeout}},
@ -68,36 +67,41 @@ func TestCodeOceanOutputWriter_SendExitInfo(t *testing.T) {
}
for _, test := range testCases {
t.Run(test.name, func(t *testing.T) {
connectionMock, message := buildConnectionMock(t)
s.Run(test.name, func() {
connectionMock, messages := buildConnectionMock(&s.MemoryLeakTestSuite)
proxyCtx, cancel := context.WithCancel(context.Background())
defer cancel()
output := NewCodeOceanOutputWriter(connectionMock, proxyCtx, cancel)
<-message // start message
<-messages // start messages
output.Close(test.info)
expected, err := json.Marshal(test.message)
require.NoError(t, err)
s.Require().NoError(err)
msg := <-message
assert.Equal(t, expected, msg)
msg := <-messages
s.Equal(expected, msg)
<-messages // close message
})
}
}
func buildConnectionMock(t *testing.T) (conn *ConnectionMock, messages chan []byte) {
t.Helper()
func buildConnectionMock(s *tests.MemoryLeakTestSuite) (conn *ConnectionMock, messages <-chan []byte) {
s.T().Helper()
message := make(chan []byte)
connectionMock := &ConnectionMock{}
connectionMock.On("WriteMessage", mock.AnythingOfType("int"), mock.AnythingOfType("[]uint8")).
Run(func(args mock.Arguments) {
m, ok := args.Get(1).([]byte)
require.True(t, ok)
message <- m
s.Require().True(ok)
select {
case <-s.TestCtx.Done():
case message <- m:
}
}).
Return(nil)
connectionMock.On("CloseHandler").Return(nil)
connectionMock.On("SetCloseHandler", mock.Anything).Return()
connectionMock.On("Close").Return()
connectionMock.On("Close").Return(nil)
return connectionMock, message
}