Add unit tests for provide runner route
This commit is contained in:
Jan-Eric Hellenberg
committed by
Jan-Eric Hellenberg
Jan-Eric Hellenberg
parent
7bbd7b7bae
commit
61bc7d0143
@ -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)
|
||||
|
||||
@ -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)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user