From 61bc7d0143cb130d489d529d054d40bd9dcf961f Mon Sep 17 00:00:00 2001 From: Jan-Eric Hellenberg Date: Tue, 8 Jun 2021 15:50:48 +0200 Subject: [PATCH] Add unit tests for provide runner route --- api/runners.go | 3 +- api/runners_test.go | 249 ++++++++++++++++++++-------------- runner/manager.go | 8 +- tests/constants.go | 3 +- tests/e2e/runners_test.go | 54 ++++++-- tests/e2e/websocket_test.go | 13 +- tests/helpers/test_helpers.go | 5 +- 7 files changed, 206 insertions(+), 129 deletions(-) diff --git a/api/runners.go b/api/runners.go index 87f8d6f..e405bd4 100644 --- a/api/runners.go +++ b/api/runners.go @@ -18,6 +18,7 @@ const ( DeleteRoute = "deleteRunner" RunnerIdKey = "runnerId" ExecutionIdKey = "executionId" + ProvideRoute = "provideRunner" ) type RunnerController struct { @@ -28,7 +29,7 @@ type RunnerController struct { // ConfigureRoutes configures a given router with the runner routes of our API. func (r *RunnerController) ConfigureRoutes(router *mux.Router) { runnersRouter := router.PathPrefix(RunnersPath).Subrouter() - runnersRouter.HandleFunc("", r.provide).Methods(http.MethodPost) + runnersRouter.HandleFunc("", r.provide).Methods(http.MethodPost).Name(ProvideRoute) r.runnerRouter = runnersRouter.PathPrefix(fmt.Sprintf("/{%s}", RunnerIdKey)).Subrouter() r.runnerRouter.Use(r.findRunnerMiddleware) r.runnerRouter.HandleFunc(UpdateFileSystemPath, r.updateFileSystem).Methods(http.MethodPatch).Name(UpdateFileSystemPath) diff --git a/api/runners_test.go b/api/runners_test.go index f3824d5..a663a4c 100644 --- a/api/runners_test.go +++ b/api/runners_test.go @@ -27,58 +27,54 @@ type MiddlewareTestSuite struct { runnerRequest func(string) *http.Request } -func (suite *MiddlewareTestSuite) SetupTest() { - suite.manager = &runner.ManagerMock{} - suite.runner = runner.NewNomadAllocation("runner", nil) - suite.capturedRunner = nil - suite.runnerRequest = func(runnerId string) *http.Request { - path, err := suite.router.Get("test-runner-id").URL(RunnerIdKey, runnerId) - if err != nil { - suite.T().Fatal(err) - } +func (s *MiddlewareTestSuite) SetupTest() { + s.manager = &runner.ManagerMock{} + s.runner = runner.NewNomadAllocation("runner", nil) + s.capturedRunner = nil + s.runnerRequest = func(runnerId string) *http.Request { + path, err := s.router.Get("test-runner-id").URL(RunnerIdKey, runnerId) + s.Require().NoError(err) request, err := http.NewRequest(http.MethodPost, path.String(), nil) - if err != nil { - suite.T().Fatal(err) - } + s.Require().NoError(err) return request } runnerRouteHandler := func(writer http.ResponseWriter, request *http.Request) { var ok bool - suite.capturedRunner, ok = runner.FromContext(request.Context()) + s.capturedRunner, ok = runner.FromContext(request.Context()) if ok { writer.WriteHeader(http.StatusOK) } else { writer.WriteHeader(http.StatusInternalServerError) } } - suite.router = mux.NewRouter() - runnerController := &RunnerController{suite.manager, suite.router} - suite.router.Use(runnerController.findRunnerMiddleware) - suite.router.HandleFunc(fmt.Sprintf("/test/{%s}", RunnerIdKey), runnerRouteHandler).Name("test-runner-id") + s.router = mux.NewRouter() + runnerController := &RunnerController{s.manager, s.router} + s.router.Use(runnerController.findRunnerMiddleware) + s.router.HandleFunc(fmt.Sprintf("/test/{%s}", RunnerIdKey), runnerRouteHandler).Name("test-runner-id") } func TestMiddlewareTestSuite(t *testing.T) { suite.Run(t, new(MiddlewareTestSuite)) } -func (suite *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerExists() { - suite.manager.On("Get", suite.runner.Id()).Return(suite.runner, nil) +func (s *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerExists() { + s.manager.On("Get", s.runner.Id()).Return(s.runner, nil) recorder := httptest.NewRecorder() - suite.router.ServeHTTP(recorder, suite.runnerRequest(suite.runner.Id())) + s.router.ServeHTTP(recorder, s.runnerRequest(s.runner.Id())) - suite.Equal(http.StatusOK, recorder.Code) - suite.Equal(suite.runner, suite.capturedRunner) + s.Equal(http.StatusOK, recorder.Code) + s.Equal(s.runner, s.capturedRunner) } -func (suite *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerDoesNotExist() { +func (s *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerDoesNotExist() { invalidID := "some-invalid-runner-id" - suite.manager.On("Get", invalidID).Return(nil, runner.ErrRunnerNotFound) + s.manager.On("Get", invalidID).Return(nil, runner.ErrRunnerNotFound) recorder := httptest.NewRecorder() - suite.router.ServeHTTP(recorder, suite.runnerRequest(invalidID)) + s.router.ServeHTTP(recorder, s.runnerRequest(invalidID)) - suite.Equal(http.StatusNotFound, recorder.Code) + s.Equal(http.StatusNotFound, recorder.Code) } func TestRunnerRouteTestSuite(t *testing.T) { @@ -93,22 +89,93 @@ type RunnerRouteTestSuite struct { executionId runner.ExecutionId } -func (suite *RunnerRouteTestSuite) SetupTest() { - suite.runnerManager = &runner.ManagerMock{} - suite.router = NewRouter(suite.runnerManager, nil) - suite.runner = runner.NewNomadAllocation("some-id", nil) - suite.executionId = "execution-id" - suite.runner.Add(suite.executionId, &dto.ExecutionRequest{}) - suite.runnerManager.On("Get", suite.runner.Id()).Return(suite.runner, nil) +func (s *RunnerRouteTestSuite) SetupTest() { + s.runnerManager = &runner.ManagerMock{} + s.router = NewRouter(s.runnerManager, nil) + s.runner = runner.NewNomadAllocation("some-id", nil) + s.executionId = "execution-id" + s.runner.Add(s.executionId, &dto.ExecutionRequest{}) + s.runnerManager.On("Get", s.runner.Id()).Return(s.runner, nil) } -func (suite *RunnerRouteTestSuite) TestExecuteRoute() { - path, err := suite.router.Get(ExecutePath).URL(RunnerIdKey, suite.runner.Id()) - if err != nil { - suite.T().Fatal() - } +func TestProvideRunnerTestSuite(t *testing.T) { + suite.Run(t, new(ProvideRunnerTestSuite)) +} - suite.Run("valid request", func() { +type ProvideRunnerTestSuite struct { + RunnerRouteTestSuite + defaultRequest *http.Request + path string +} + +func (s *ProvideRunnerTestSuite) SetupTest() { + s.RunnerRouteTestSuite.SetupTest() + + path, err := s.router.Get(ProvideRoute).URL() + s.Require().NoError(err) + s.path = path.String() + + runnerRequest := dto.RunnerRequest{ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger} + body, err := json.Marshal(runnerRequest) + s.Require().NoError(err) + s.defaultRequest, err = http.NewRequest(http.MethodPost, s.path, bytes.NewReader(body)) + s.Require().NoError(err) +} + +func (s *ProvideRunnerTestSuite) TestValidRequestReturnsRunner() { + s.runnerManager.On("Claim", mock.AnythingOfType("runner.EnvironmentID")).Return(s.runner, nil) + recorder := httptest.NewRecorder() + + s.router.ServeHTTP(recorder, s.defaultRequest) + s.Equal(http.StatusOK, recorder.Code) + + s.Run("response contains runnerId", func() { + var runnerResponse dto.RunnerResponse + err := json.NewDecoder(recorder.Result().Body).Decode(&runnerResponse) + s.Require().NoError(err) + _ = recorder.Result().Body.Close() + s.Equal(s.runner.Id(), runnerResponse.Id) + }) +} + +func (s *ProvideRunnerTestSuite) TestInvalidRequestReturnsBadRequest() { + badRequest, err := http.NewRequest(http.MethodPost, s.path, strings.NewReader("")) + s.Require().NoError(err) + recorder := httptest.NewRecorder() + + s.router.ServeHTTP(recorder, badRequest) + s.Equal(http.StatusBadRequest, recorder.Code) +} + +func (s *ProvideRunnerTestSuite) TestWhenExecutionEnvironmentDoesNotExistReturnsNotFound() { + s.runnerManager. + On("Claim", mock.AnythingOfType("runner.EnvironmentID")). + Return(nil, runner.ErrUnknownExecutionEnvironment) + recorder := httptest.NewRecorder() + + s.router.ServeHTTP(recorder, s.defaultRequest) + s.Equal(http.StatusNotFound, recorder.Code) +} + +func (s *ProvideRunnerTestSuite) TestWhenNoRunnerAvailableReturnsNomadOverload() { + s.runnerManager.On("Claim", mock.AnythingOfType("runner.EnvironmentID")).Return(nil, runner.ErrNoRunnersAvailable) + recorder := httptest.NewRecorder() + + s.router.ServeHTTP(recorder, s.defaultRequest) + s.Equal(http.StatusInternalServerError, recorder.Code) + + var internalServerError dto.InternalServerError + err := json.NewDecoder(recorder.Result().Body).Decode(&internalServerError) + s.Require().NoError(err) + _ = recorder.Result().Body.Close() + s.Equal(dto.ErrorNomadOverload, internalServerError.ErrorCode) +} + +func (s *RunnerRouteTestSuite) TestExecuteRoute() { + path, err := s.router.Get(ExecutePath).URL(RunnerIdKey, s.runner.Id()) + s.Require().NoError(err) + + s.Run("valid request", func() { recorder := httptest.NewRecorder() executionRequest := dto.ExecutionRequest{ Command: "command", @@ -116,47 +183,37 @@ func (suite *RunnerRouteTestSuite) TestExecuteRoute() { Environment: nil, } body, err := json.Marshal(executionRequest) - if err != nil { - suite.T().Fatal(err) - } + s.Require().NoError(err) request, err := http.NewRequest(http.MethodPost, path.String(), bytes.NewReader(body)) - if err != nil { - suite.T().Fatal(err) - } + s.Require().NoError(err) - suite.router.ServeHTTP(recorder, request) + s.router.ServeHTTP(recorder, request) var webSocketResponse dto.ExecutionResponse err = json.NewDecoder(recorder.Result().Body).Decode(&webSocketResponse) - if err != nil { - suite.T().Fatal(err) - } + s.Require().NoError(err) - suite.Equal(http.StatusOK, recorder.Code) + s.Equal(http.StatusOK, recorder.Code) - suite.Run("creates an execution request for the runner", func() { + s.Run("creates an execution request for the runner", func() { webSocketUrl, err := url.Parse(webSocketResponse.WebSocketUrl) - if err != nil { - suite.T().Fatal(err) - } + s.Require().NoError(err) executionId := webSocketUrl.Query().Get(ExecutionIdKey) - storedExecutionRequest, ok := suite.runner.Pop(runner.ExecutionId(executionId)) + storedExecutionRequest, ok := s.runner.Pop(runner.ExecutionId(executionId)) - suite.True(ok, "No execution request with this id: ", executionId) - suite.Equal(&executionRequest, storedExecutionRequest) + s.True(ok, "No execution request with this id: ", executionId) + s.Equal(&executionRequest, storedExecutionRequest) }) }) - suite.Run("invalid request", func() { + s.Run("invalid request", func() { recorder := httptest.NewRecorder() body := "" request, err := http.NewRequest(http.MethodPost, path.String(), strings.NewReader(body)) - if err != nil { - suite.T().Fatal(err) - } - suite.router.ServeHTTP(recorder, request) + s.Require().NoError(err) + s.router.ServeHTTP(recorder, request) - suite.Equal(http.StatusBadRequest, recorder.Code) + s.Equal(http.StatusBadRequest, recorder.Code) }) } @@ -174,9 +231,7 @@ type UpdateFileSystemRouteTestSuite struct { func (s *UpdateFileSystemRouteTestSuite) SetupTest() { s.RunnerRouteTestSuite.SetupTest() routeUrl, err := s.router.Get(UpdateFileSystemPath).URL(RunnerIdKey, tests.DefaultMockID) - if err != nil { - s.T().Fatal(err) - } + s.Require().NoError(err) s.path = routeUrl.String() s.runnerMock = &runner.RunnerMock{} s.runnerManager.On("Get", tests.DefaultMockID).Return(s.runnerMock, nil) @@ -236,62 +291,52 @@ type DeleteRunnerRouteTestSuite struct { path string } -func (suite *DeleteRunnerRouteTestSuite) SetupTest() { - suite.RunnerRouteTestSuite.SetupTest() - deleteURL, err := suite.router.Get(DeleteRoute).URL(RunnerIdKey, suite.runner.Id()) - if err != nil { - suite.T().Fatal(err) - } - suite.path = deleteURL.String() +func (s *DeleteRunnerRouteTestSuite) SetupTest() { + s.RunnerRouteTestSuite.SetupTest() + deleteURL, err := s.router.Get(DeleteRoute).URL(RunnerIdKey, s.runner.Id()) + s.Require().NoError(err) + s.path = deleteURL.String() } -func (suite *DeleteRunnerRouteTestSuite) TestValidRequestReturnsNoContent() { - suite.runnerManager.On("Return", suite.runner).Return(nil) +func (s *DeleteRunnerRouteTestSuite) TestValidRequestReturnsNoContent() { + s.runnerManager.On("Return", s.runner).Return(nil) recorder := httptest.NewRecorder() - request, err := http.NewRequest(http.MethodDelete, suite.path, nil) - if err != nil { - suite.T().Fatal(err) - } + request, err := http.NewRequest(http.MethodDelete, s.path, nil) + s.Require().NoError(err) - suite.router.ServeHTTP(recorder, request) + s.router.ServeHTTP(recorder, request) - suite.Equal(http.StatusNoContent, recorder.Code) + s.Equal(http.StatusNoContent, recorder.Code) - suite.Run("runner was returned to runner manager", func() { - suite.runnerManager.AssertCalled(suite.T(), "Return", suite.runner) + s.Run("runner was returned to runner manager", func() { + s.runnerManager.AssertCalled(s.T(), "Return", s.runner) }) } -func (suite *DeleteRunnerRouteTestSuite) TestReturnInternalServerErrorWhenApiCallToNomadFailed() { - suite.runnerManager.On("Return", suite.runner).Return(errors.New("API call failed")) +func (s *DeleteRunnerRouteTestSuite) TestReturnInternalServerErrorWhenApiCallToNomadFailed() { + s.runnerManager.On("Return", s.runner).Return(errors.New("API call failed")) recorder := httptest.NewRecorder() - request, err := http.NewRequest(http.MethodDelete, suite.path, nil) - if err != nil { - suite.T().Fatal(err) - } + request, err := http.NewRequest(http.MethodDelete, s.path, nil) + s.Require().NoError(err) - suite.router.ServeHTTP(recorder, request) + s.router.ServeHTTP(recorder, request) - suite.Equal(http.StatusInternalServerError, recorder.Code) + s.Equal(http.StatusInternalServerError, recorder.Code) } -func (suite *DeleteRunnerRouteTestSuite) TestDeleteInvalidRunnerIdReturnsNotFound() { - suite.runnerManager.On("Get", mock.AnythingOfType("string")).Return(nil, errors.New("API call failed")) - deleteURL, err := suite.router.Get(DeleteRoute).URL(RunnerIdKey, "1nv4l1dID") - if err != nil { - suite.T().Fatal(err) - } +func (s *DeleteRunnerRouteTestSuite) TestDeleteInvalidRunnerIdReturnsNotFound() { + s.runnerManager.On("Get", mock.AnythingOfType("string")).Return(nil, errors.New("API call failed")) + deleteURL, err := s.router.Get(DeleteRoute).URL(RunnerIdKey, "1nv4l1dID") + s.Require().NoError(err) deletePath := deleteURL.String() recorder := httptest.NewRecorder() request, err := http.NewRequest(http.MethodDelete, deletePath, nil) - if err != nil { - suite.T().Fatal(err) - } + s.Require().NoError(err) - suite.router.ServeHTTP(recorder, request) + s.router.ServeHTTP(recorder, request) - suite.Equal(http.StatusNotFound, recorder.Code) + s.Equal(http.StatusNotFound, recorder.Code) } diff --git a/runner/manager.go b/runner/manager.go index 7517840..41c2a0d 100644 --- a/runner/manager.go +++ b/runner/manager.go @@ -169,7 +169,7 @@ func (m *NomadRunnerManager) refreshEnvironment(id EnvironmentID) { // this environment does not exist return } - var lastJobScaling uint = 0 + var lastJobScaling = 0 for { runners, err := m.apiClient.LoadRunners(string(job.jobID)) if err != nil { @@ -187,15 +187,15 @@ func (m *NomadRunnerManager) refreshEnvironment(id EnvironmentID) { log.WithError(err).Printf("Failed get allocation count") break } - additionallyNeededRunners := job.desiredIdleRunnersCount - uint(job.idleRunners.Length()) - requiredRunnerCount := jobScale + additionallyNeededRunners := int(job.desiredIdleRunnersCount) - job.idleRunners.Length() + requiredRunnerCount := int(jobScale) if additionallyNeededRunners > 0 { requiredRunnerCount += additionallyNeededRunners } time.Sleep(50 * time.Millisecond) if requiredRunnerCount != lastJobScaling { log.Printf("Set job scaling %d", requiredRunnerCount) - err = m.apiClient.SetJobScale(string(job.jobID), requiredRunnerCount, "Runner Requested") + err = m.apiClient.SetJobScale(string(job.jobID), uint(requiredRunnerCount), "Runner Requested") if err != nil { log.WithError(err).Printf("Failed set allocation scaling") continue diff --git a/tests/constants.go b/tests/constants.go index ccfa85c..3d6187b 100644 --- a/tests/constants.go +++ b/tests/constants.go @@ -3,7 +3,8 @@ package tests import "errors" const ( - NonExistingID = "n0n-3x1st1ng-1d" + NonExistingIntegerID = 9999 + NonExistingStringID = "n0n-3x1st1ng-1d" DefaultFileName = "test.txt" DefaultFileContent = "Hello, Codemoon!" DefaultDirectoryName = "test/" diff --git a/tests/e2e/runners_test.go b/tests/e2e/runners_test.go index 5c42385..0919848 100644 --- a/tests/e2e/runners_test.go +++ b/tests/e2e/runners_test.go @@ -15,25 +15,45 @@ import ( ) func (s *E2ETestSuite) TestProvideRunnerRoute() { - runnerRequestString, _ := json.Marshal(dto.RunnerRequest{}) - reader := strings.NewReader(string(runnerRequestString)) - resp, err := http.Post(helpers.BuildURL(api.BasePath, api.RunnersPath), "application/json", reader) - s.NoError(err) - s.Equal(http.StatusOK, resp.StatusCode, "The response code should be ok") + runnerRequestByteString, _ := json.Marshal(dto.RunnerRequest{ + ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger, + }) + reader := bytes.NewReader(runnerRequestByteString) - runnerResponse := new(dto.RunnerResponse) - err = json.NewDecoder(resp.Body).Decode(runnerResponse) - s.NoError(err) + s.Run("valid request returns a runner", func() { + resp, err := http.Post(helpers.BuildURL(api.BasePath, api.RunnersPath), "application/json", reader) + s.Require().NoError(err) + s.Equal(http.StatusOK, resp.StatusCode) - s.True(runnerResponse.Id != "", "The response contains a runner id") + runnerResponse := new(dto.RunnerResponse) + err = json.NewDecoder(resp.Body).Decode(runnerResponse) + s.Require().NoError(err) + s.NotEmpty(runnerResponse.Id) + }) + + s.Run("invalid request returns bad request", func() { + resp, err := http.Post(helpers.BuildURL(api.BasePath, api.RunnersPath), "application/json", strings.NewReader("")) + s.Require().NoError(err) + s.Equal(http.StatusBadRequest, resp.StatusCode) + }) + + s.Run("requesting runner of unknown execution environment returns not found", func() { + runnerRequestByteString, _ := json.Marshal(dto.RunnerRequest{ + ExecutionEnvironmentId: tests.NonExistingIntegerID, + }) + reader := bytes.NewReader(runnerRequestByteString) + resp, err := http.Post(helpers.BuildURL(api.BasePath, api.RunnersPath), "application/json", reader) + s.Require().NoError(err) + s.Equal(http.StatusNotFound, resp.StatusCode) + }) } // ProvideRunner creates a runner with the given RunnerRequest via an external request. // It needs a running Poseidon instance to work. func ProvideRunner(request *dto.RunnerRequest) (string, error) { url := helpers.BuildURL(api.BasePath, api.RunnersPath) - runnerRequestString, _ := json.Marshal(request) - reader := strings.NewReader(string(runnerRequestString)) + runnerRequestByteString, _ := json.Marshal(request) + reader := strings.NewReader(string(runnerRequestByteString)) resp, err := http.Post(url, "application/json", reader) if err != nil { return "", err @@ -50,7 +70,9 @@ func ProvideRunner(request *dto.RunnerRequest) (string, error) { } func (s *E2ETestSuite) TestDeleteRunnerRoute() { - runnerId, err := ProvideRunner(&dto.RunnerRequest{}) + runnerId, err := ProvideRunner(&dto.RunnerRequest{ + ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger, + }) s.NoError(err) s.Run("Deleting the runner returns NoContent", func() { @@ -66,14 +88,16 @@ func (s *E2ETestSuite) TestDeleteRunnerRoute() { }) s.Run("Deleting non-existing runner returns NotFound", func() { - resp, err := helpers.HttpDelete(helpers.BuildURL(api.BasePath, api.RunnersPath, tests.NonExistingID), nil) + resp, err := helpers.HttpDelete(helpers.BuildURL(api.BasePath, api.RunnersPath, tests.NonExistingStringID), nil) s.NoError(err) s.Equal(http.StatusNotFound, resp.StatusCode) }) } func (s *E2ETestSuite) TestCopyFilesRoute() { - runnerID, err := ProvideRunner(&dto.RunnerRequest{}) + runnerID, err := ProvideRunner(&dto.RunnerRequest{ + ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger, + }) s.NoError(err) copyFilesRequestByteString, _ := json.Marshal(&dto.UpdateFileSystemRequest{ Copy: []dto.File{{Path: tests.DefaultFileName, Content: []byte(tests.DefaultFileContent)}}, @@ -178,7 +202,7 @@ func (s *E2ETestSuite) TestCopyFilesRoute() { }) s.Run("Copying to non-existing runner returns NotFound", func() { - resp, err := helpers.HttpPatch(helpers.BuildURL(api.BasePath, api.RunnersPath, tests.NonExistingID, api.UpdateFileSystemPath), "application/json", bytes.NewReader(copyFilesRequestByteString)) + resp, err := helpers.HttpPatch(helpers.BuildURL(api.BasePath, api.RunnersPath, tests.NonExistingStringID, api.UpdateFileSystemPath), "application/json", bytes.NewReader(copyFilesRequestByteString)) s.NoError(err) s.Equal(http.StatusNotFound, resp.StatusCode) }) diff --git a/tests/e2e/websocket_test.go b/tests/e2e/websocket_test.go index 3bc529c..5151535 100644 --- a/tests/e2e/websocket_test.go +++ b/tests/e2e/websocket_test.go @@ -7,6 +7,7 @@ import ( "github.com/stretchr/testify/suite" "gitlab.hpi.de/codeocean/codemoon/poseidon/api" "gitlab.hpi.de/codeocean/codemoon/poseidon/api/dto" + "gitlab.hpi.de/codeocean/codemoon/poseidon/tests" "gitlab.hpi.de/codeocean/codemoon/poseidon/tests/helpers" "net/http" "strings" @@ -14,7 +15,9 @@ import ( ) func (s *E2ETestSuite) TestExecuteCommandRoute() { - runnerId, err := ProvideRunner(&dto.RunnerRequest{}) + runnerId, err := ProvideRunner(&dto.RunnerRequest{ + ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger, + }) s.Require().NoError(err) webSocketURL, err := ProvideWebSocketURL(&s.Suite, runnerId, &dto.ExecutionRequest{Command: "true"}) @@ -145,7 +148,9 @@ func (s *E2ETestSuite) TestEchoEnvironment() { // ProvideWebSocketConnection establishes a client WebSocket connection to run the passed ExecutionRequest. // It requires a running Poseidon instance. func ProvideWebSocketConnection(suite *suite.Suite, request *dto.ExecutionRequest) (connection *websocket.Conn, err error) { - runnerId, err := ProvideRunner(&dto.RunnerRequest{}) + runnerId, err := ProvideRunner(&dto.RunnerRequest{ + ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger, + }) if err != nil { return } @@ -161,8 +166,8 @@ func ProvideWebSocketConnection(suite *suite.Suite, request *dto.ExecutionReques // It requires a running Poseidon instance. func ProvideWebSocketURL(suite *suite.Suite, runnerId string, request *dto.ExecutionRequest) (string, error) { url := helpers.BuildURL(api.BasePath, api.RunnersPath, runnerId, api.ExecutePath) - executionRequestBytes, _ := json.Marshal(request) - reader := strings.NewReader(string(executionRequestBytes)) + executionRequestByteString, _ := json.Marshal(request) + reader := strings.NewReader(string(executionRequestByteString)) resp, err := http.Post(url, "application/json", reader) suite.Require().NoError(err) suite.Require().Equal(http.StatusOK, resp.StatusCode) diff --git a/tests/helpers/test_helpers.go b/tests/helpers/test_helpers.go index f5197a4..820c7f0 100644 --- a/tests/helpers/test_helpers.go +++ b/tests/helpers/test_helpers.go @@ -3,6 +3,7 @@ package helpers import ( + "bytes" "context" "crypto/tls" "encoding/json" @@ -157,10 +158,10 @@ func HttpPut(url string, body io.Reader) (response *http.Response, err error) { } func HttpPutJSON(url string, body interface{}) (response *http.Response, err error) { - requestString, err := json.Marshal(body) + requestByteString, err := json.Marshal(body) if err != nil { return } - reader := strings.NewReader(string(requestString)) + reader := bytes.NewReader(requestByteString) return HttpPut(url, reader) }