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

Add unit tests for provide runner route

Browse Source
This commit is contained in:
Jan-Eric Hellenberg
2021-06-08 15:50:48 +02:00
committed by Jan-Eric Hellenberg
parent 7bbd7b7bae
commit 61bc7d0143
7 changed files with 206 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
api/runners.go
View File

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

249
api/runners_test.go
View File

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

8
runner/manager.go
View File

@ -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

3
tests/constants.go
View File

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

48
tests/e2e/runners_test.go
View File

@ -15,25 +15,45 @@ import (
)
func (s *E2ETestSuite) TestProvideRunnerRoute() {
runnerRequestString, _ := json.Marshal(dto.RunnerRequest{})
reader := strings.NewReader(string(runnerRequestString))
runnerRequestByteString, _ := json.Marshal(dto.RunnerRequest{
ExecutionEnvironmentId: tests.DefaultEnvironmentIDAsInteger,
})
reader := bytes.NewReader(runnerRequestByteString)
s.Run("valid request returns a runner", func() {
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")
s.Require().NoError(err)
s.Equal(http.StatusOK, resp.StatusCode)
runnerResponse := new(dto.RunnerResponse)
err = json.NewDecoder(resp.Body).Decode(runnerResponse)
s.NoError(err)
s.Require().NoError(err)
s.NotEmpty(runnerResponse.Id)
})
s.True(runnerResponse.Id != "", "The response contains a runner 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)
})

13
tests/e2e/websocket_test.go
View File

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

5
tests/helpers/test_helpers.go
View File

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