Add unit tests for provide runner route

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)

api/runners_test.go

@@ -27,58 +27,54 @@ type MiddlewareTestSuite struct {
 	runnerRequest  func(string) *http.Request
 }
 
-func (suite *MiddlewareTestSuite) SetupTest() {
+func (s *MiddlewareTestSuite) SetupTest() {
-	suite.manager = &runner.ManagerMock{}
+	s.manager = &runner.ManagerMock{}
-	suite.runner = runner.NewNomadAllocation("runner", nil)
+	s.runner = runner.NewNomadAllocation("runner", nil)
-	suite.capturedRunner = nil
+	s.capturedRunner = nil
-	suite.runnerRequest = func(runnerId string) *http.Request {
+	s.runnerRequest = func(runnerId string) *http.Request {
-		path, err := suite.router.Get("test-runner-id").URL(RunnerIdKey, runnerId)
+		path, err := s.router.Get("test-runner-id").URL(RunnerIdKey, runnerId)
-		if err != nil {
+		s.Require().NoError(err)
-			suite.T().Fatal(err)
-		}
 		request, err := http.NewRequest(http.MethodPost, path.String(), nil)
-		if err != nil {
+		s.Require().NoError(err)
-			suite.T().Fatal(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()
+	s.router = mux.NewRouter()
-	runnerController := &RunnerController{suite.manager, suite.router}
+	runnerController := &RunnerController{s.manager, s.router}
-	suite.router.Use(runnerController.findRunnerMiddleware)
+	s.router.Use(runnerController.findRunnerMiddleware)
-	suite.router.HandleFunc(fmt.Sprintf("/test/{%s}", RunnerIdKey), runnerRouteHandler).Name("test-runner-id")
+	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() {
+func (s *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerExists() {
-	suite.manager.On("Get", suite.runner.Id()).Return(suite.runner, nil)
+	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)
+	s.Equal(http.StatusOK, recorder.Code)
-	suite.Equal(suite.runner, suite.capturedRunner)
+	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() {
+func (s *RunnerRouteTestSuite) SetupTest() {
-	suite.runnerManager = &runner.ManagerMock{}
+	s.runnerManager = &runner.ManagerMock{}
-	suite.router = NewRouter(suite.runnerManager, nil)
+	s.router = NewRouter(s.runnerManager, nil)
-	suite.runner = runner.NewNomadAllocation("some-id", nil)
+	s.runner = runner.NewNomadAllocation("some-id", nil)
-	suite.executionId = "execution-id"
+	s.executionId = "execution-id"
-	suite.runner.Add(suite.executionId, &dto.ExecutionRequest{})
+	s.runner.Add(s.executionId, &dto.ExecutionRequest{})
-	suite.runnerManager.On("Get", suite.runner.Id()).Return(suite.runner, nil)
+	s.runnerManager.On("Get", s.runner.Id()).Return(s.runner, nil)
 }
 
-func (suite *RunnerRouteTestSuite) TestExecuteRoute() {
+func TestProvideRunnerTestSuite(t *testing.T) {
-	path, err := suite.router.Get(ExecutePath).URL(RunnerIdKey, suite.runner.Id())
+	suite.Run(t, new(ProvideRunnerTestSuite))
-	if err != nil {
+}
-		suite.T().Fatal()
-	}
 
-	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 {
+		s.Require().NoError(err)
-			suite.T().Fatal(err)
-		}
 		request, err := http.NewRequest(http.MethodPost, path.String(), bytes.NewReader(body))
-		if err != nil {
+		s.Require().NoError(err)
-			suite.T().Fatal(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 {
+		s.Require().NoError(err)
-			suite.T().Fatal(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 {
+			s.Require().NoError(err)
-				suite.T().Fatal(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)
+			s.True(ok, "No execution request with this id: ", executionId)
-			suite.Equal(&executionRequest, storedExecutionRequest)
+			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 {
+		s.Require().NoError(err)
-			suite.T().Fatal(err)
+		s.router.ServeHTTP(recorder, request)
-		}
-		suite.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.Require().NoError(err)
-		s.T().Fatal(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() {
+func (s *DeleteRunnerRouteTestSuite) SetupTest() {
-	suite.RunnerRouteTestSuite.SetupTest()
+	s.RunnerRouteTestSuite.SetupTest()
-	deleteURL, err := suite.router.Get(DeleteRoute).URL(RunnerIdKey, suite.runner.Id())
+	deleteURL, err := s.router.Get(DeleteRoute).URL(RunnerIdKey, s.runner.Id())
-	if err != nil {
+	s.Require().NoError(err)
-		suite.T().Fatal(err)
+	s.path = deleteURL.String()
-	}
-	suite.path = deleteURL.String()
 }
 
-func (suite *DeleteRunnerRouteTestSuite) TestValidRequestReturnsNoContent() {
+func (s *DeleteRunnerRouteTestSuite) TestValidRequestReturnsNoContent() {
-	suite.runnerManager.On("Return", suite.runner).Return(nil)
+	s.runnerManager.On("Return", s.runner).Return(nil)
 
 	recorder := httptest.NewRecorder()
-	request, err := http.NewRequest(http.MethodDelete, suite.path, nil)
+	request, err := http.NewRequest(http.MethodDelete, s.path, nil)
-	if err != nil {
+	s.Require().NoError(err)
-		suite.T().Fatal(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() {
+	s.Run("runner was returned to runner manager", func() {
-		suite.runnerManager.AssertCalled(suite.T(), "Return", suite.runner)
+		s.runnerManager.AssertCalled(s.T(), "Return", s.runner)
 	})
 }
 
-func (suite *DeleteRunnerRouteTestSuite) TestReturnInternalServerErrorWhenApiCallToNomadFailed() {
+func (s *DeleteRunnerRouteTestSuite) TestReturnInternalServerErrorWhenApiCallToNomadFailed() {
-	suite.runnerManager.On("Return", suite.runner).Return(errors.New("API call failed"))
+	s.runnerManager.On("Return", s.runner).Return(errors.New("API call failed"))
 
 	recorder := httptest.NewRecorder()
-	request, err := http.NewRequest(http.MethodDelete, suite.path, nil)
+	request, err := http.NewRequest(http.MethodDelete, s.path, nil)
-	if err != nil {
+	s.Require().NoError(err)
-		suite.T().Fatal(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() {
+func (s *DeleteRunnerRouteTestSuite) TestDeleteInvalidRunnerIdReturnsNotFound() {
-	suite.runnerManager.On("Get", mock.AnythingOfType("string")).Return(nil, errors.New("API call failed"))
+	s.runnerManager.On("Get", mock.AnythingOfType("string")).Return(nil, errors.New("API call failed"))
-	deleteURL, err := suite.router.Get(DeleteRoute).URL(RunnerIdKey, "1nv4l1dID")
+	deleteURL, err := s.router.Get(DeleteRoute).URL(RunnerIdKey, "1nv4l1dID")
-	if err != nil {
+	s.Require().NoError(err)
-		suite.T().Fatal(err)
-	}
 	deletePath := deleteURL.String()
 
 	recorder := httptest.NewRecorder()
 	request, err := http.NewRequest(http.MethodDelete, deletePath, nil)
-	if err != nil {
+	s.Require().NoError(err)
-		suite.T().Fatal(err)
-	}
 
-	suite.router.ServeHTTP(recorder, request)
+	s.router.ServeHTTP(recorder, request)
 
-	suite.Equal(http.StatusNotFound, recorder.Code)
+	s.Equal(http.StatusNotFound, recorder.Code)
 }

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())
+		additionallyNeededRunners := int(job.desiredIdleRunnersCount) - job.idleRunners.Length()
-		requiredRunnerCount := jobScale
+		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

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/"

tests/e2e/runners_test.go

@@ -15,25 +15,45 @@ import (
 )
 
 func (s *E2ETestSuite) TestProvideRunnerRoute() {
-	runnerRequestString, _ := json.Marshal(dto.RunnerRequest{})
+	runnerRequestByteString, _ := json.Marshal(dto.RunnerRequest{
-	reader := strings.NewReader(string(runnerRequestString))
+		ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger,
-	resp, err := http.Post(helpers.BuildURL(api.BasePath, api.RunnersPath), "application/json", reader)
+	})
-	s.NoError(err)
+	reader := bytes.NewReader(runnerRequestByteString)
-	s.Equal(http.StatusOK, resp.StatusCode, "The response code should be ok")
 
-	runnerResponse := new(dto.RunnerResponse)
+	s.Run("valid request returns a runner", func() {
-	err = json.NewDecoder(resp.Body).Decode(runnerResponse)
+		resp, err := http.Post(helpers.BuildURL(api.BasePath, api.RunnersPath), "application/json", reader)
-	s.NoError(err)
+		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)
+	runnerRequestByteString, _ := json.Marshal(request)
-	reader := strings.NewReader(string(runnerRequestString))
+	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)
 	})

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)
+	executionRequestByteString, _ := json.Marshal(request)
-	reader := strings.NewReader(string(executionRequestBytes))
+	reader := strings.NewReader(string(executionRequestByteString))
 	resp, err := http.Post(url, "application/json", reader)
 	suite.Require().NoError(err)
 	suite.Require().Equal(http.StatusOK, resp.StatusCode)

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)
 }