Add route to create or update execution environments

api/api.go

@@ -12,9 +12,10 @@ import (
 var log = logging.GetLogger("api")
 
 const (
-	BasePath    = "/api/v1"
+	BasePath         = "/api/v1"
-	HealthPath  = "/health"
+	HealthPath       = "/health"
-	RunnersPath = "/runners"
+	RunnersPath      = "/runners"
+	EnvironmentsPath = "/execution-environments"
 )
 
 // NewRouter returns a *mux.Router which can be
@@ -37,6 +38,12 @@ func configureV1Router(router *mux.Router, runnerManager runner.Manager, environ
 	v1.HandleFunc(HealthPath, Health).Methods(http.MethodGet)
 
 	runnerController := &RunnerController{manager: runnerManager}
+	environmentController := &EnvironmentController{manager: environmentManager}
+
+	configureRoutes := func(router *mux.Router) {
+		runnerController.ConfigureRoutes(router)
+		environmentController.ConfigureRoutes(router)
+	}
 
 	if auth.InitializeAuthentication() {
 		// Create new authenticated subrouter.
@@ -45,6 +52,6 @@ func configureV1Router(router *mux.Router, runnerManager runner.Manager, environ
 		authenticatedV1Router.Use(auth.HTTPAuthenticationMiddleware)
 		runnerController.ConfigureRoutes(authenticatedV1Router)
 	} else {
-		runnerController.ConfigureRoutes(v1)
+		configureRoutes(v1)
 	}
 }

api/dto/dto.go

@@ -32,14 +32,13 @@ func (er *ExecutionRequest) FullCommand() []string {
 }
 
 // ExecutionEnvironmentRequest is the expected json structure of the request body for the create execution environment function.
-// nolint:unused,structcheck
 type ExecutionEnvironmentRequest struct {
-	prewarmingPoolSize uint
+	PrewarmingPoolSize uint     `json:"prewarmingPoolSize"`
-	cpuLimit           uint
+	CPULimit           uint     `json:"cpuLimit"`
-	memoryLimit        uint
+	MemoryLimit        uint     `json:"memoryLimit"`
-	image              string
+	Image              string   `json:"image"`
-	networkAccess      bool
+	NetworkAccess      bool     `json:"networkAccess"`
-	exposedPorts       []uint16
+	ExposedPorts       []uint16 `json:"exposedPorts"`
 }
 
 // RunnerResponse is the expected response when providing a runner.

api/environments.go

@@ -1,17 +1,53 @@
 package api
 
 import (
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/mux"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/api/dto"
 	"gitlab.hpi.de/codeocean/codemoon/poseidon/environment"
 	"net/http"
 )
 
+const (
+	executionEnvironmentIDKey = "executionEnvironmentId"
+	createOrUpdateRouteName   = "createOrUpdate"
+)
+
 type EnvironmentController struct {
-	manager environment.Manager // nolint:unused,structcheck
+	manager environment.Manager
 }
 
-// create creates a new execution environment on the executor.
+func (e *EnvironmentController) ConfigureRoutes(router *mux.Router) {
-func (e *EnvironmentController) create(writer http.ResponseWriter, request *http.Request) { // nolint:unused
+	environmentRouter := router.PathPrefix(EnvironmentsPath).Subrouter()
+	specificEnvironmentRouter := environmentRouter.Path(fmt.Sprintf("/{%s:[0-9]+}", executionEnvironmentIDKey)).Subrouter()
+	specificEnvironmentRouter.HandleFunc("", e.createOrUpdate).Methods(http.MethodPut).Name(createOrUpdateRouteName)
+}
 
+// createOrUpdate creates/updates an execution environment on the executor.
+func (e *EnvironmentController) createOrUpdate(writer http.ResponseWriter, request *http.Request) {
+	req := new(dto.ExecutionEnvironmentRequest)
+	if err := json.NewDecoder(request.Body).Decode(req); err != nil {
+		writeBadRequest(writer, err)
+		return
+	}
+
+	id, ok := mux.Vars(request)[executionEnvironmentIDKey]
+	if !ok {
+		writeBadRequest(writer, fmt.Errorf("could not find %s", executionEnvironmentIDKey))
+		return
+	}
+
+	created, err := e.manager.CreateOrUpdate(id, *req)
+	if err != nil {
+		writeInternalServerError(writer, err, dto.ErrorUnknown)
+	}
+
+	if created {
+		writer.WriteHeader(http.StatusCreated)
+	} else {
+		writer.WriteHeader(http.StatusNoContent)
+	}
 }
 
 // delete removes an execution environment from the executor

api/environments_test.go

@@ -0,0 +1,100 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/gorilla/mux"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/api/dto"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/environment"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/tests"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+type EnvironmentControllerTestSuite struct {
+	suite.Suite
+	manager *environment.ManagerMock
+	router  *mux.Router
+}
+
+func TestEnvironmentControllerTestSuite(t *testing.T) {
+	suite.Run(t, new(EnvironmentControllerTestSuite))
+}
+
+func (s *EnvironmentControllerTestSuite) SetupTest() {
+	s.manager = &environment.ManagerMock{}
+	s.router = NewRouter(nil, s.manager)
+}
+
+type CreateOrUpdateEnvironmentTestSuite struct {
+	EnvironmentControllerTestSuite
+	path string
+	id   string
+	body []byte
+}
+
+func TestCreateOrUpdateEnvironmentTestSuite(t *testing.T) {
+	suite.Run(t, new(CreateOrUpdateEnvironmentTestSuite))
+}
+
+func (s *CreateOrUpdateEnvironmentTestSuite) SetupTest() {
+	s.EnvironmentControllerTestSuite.SetupTest()
+	s.id = tests.DefaultEnvironmentIdAsString
+	testURL, err := s.router.Get(createOrUpdateRouteName).URL(executionEnvironmentIDKey, s.id)
+	if err != nil {
+		s.T().Fatal(err)
+	}
+	s.path = testURL.String()
+	s.body, err = json.Marshal(dto.ExecutionEnvironmentRequest{})
+	if err != nil {
+		s.T().Fatal(err)
+	}
+}
+
+func (s *CreateOrUpdateEnvironmentTestSuite) recordRequest() *httptest.ResponseRecorder {
+	recorder := httptest.NewRecorder()
+	request, err := http.NewRequest(http.MethodPut, s.path, bytes.NewReader(s.body))
+	if err != nil {
+		s.T().Fatal(err)
+	}
+	s.router.ServeHTTP(recorder, request)
+	return recorder
+}
+
+func (s *CreateOrUpdateEnvironmentTestSuite) TestReturnsBadRequestWhenBadBody() {
+	s.body = []byte{}
+	recorder := s.recordRequest()
+	s.Equal(http.StatusBadRequest, recorder.Code)
+}
+
+func (s *CreateOrUpdateEnvironmentTestSuite) TestReturnsInternalServerErrorWhenManagerReturnsError() {
+	testError := tests.DefaultError
+	s.manager.
+		On("CreateOrUpdate", s.id, mock.AnythingOfType("dto.ExecutionEnvironmentRequest")).
+		Return(false, testError)
+
+	recorder := s.recordRequest()
+	s.Equal(http.StatusInternalServerError, recorder.Code)
+	s.Contains(recorder.Body.String(), testError.Error())
+}
+
+func (s *CreateOrUpdateEnvironmentTestSuite) TestReturnsCreatedIfNewEnvironment() {
+	s.manager.
+		On("CreateOrUpdate", s.id, mock.AnythingOfType("dto.ExecutionEnvironmentRequest")).
+		Return(true, nil)
+
+	recorder := s.recordRequest()
+	s.Equal(http.StatusCreated, recorder.Code)
+}
+
+func (s *CreateOrUpdateEnvironmentTestSuite) TestReturnsNoContentIfNotNewEnvironment() {
+	s.manager.
+		On("CreateOrUpdate", s.id, mock.AnythingOfType("dto.ExecutionEnvironmentRequest")).
+		Return(false, nil)
+
+	recorder := s.recordRequest()
+	s.Equal(http.StatusNoContent, recorder.Code)
+}

environment/manager.go

@@ -6,6 +6,7 @@ import (
 	"gitlab.hpi.de/codeocean/codemoon/poseidon/logging"
 	"gitlab.hpi.de/codeocean/codemoon/poseidon/nomad"
 	"gitlab.hpi.de/codeocean/codemoon/poseidon/runner"
+	"strconv"
 )
 
 var log = logging.GetLogger("environment")
@@ -16,11 +17,12 @@ type Manager interface {
 	// It should be called during the startup process (e.g. on creation of the Manager).
 	Load()
 
-	// Create creates a new execution environment on the executor.
+	// CreateOrUpdate creates/updates an execution environment on the executor.
-	Create(
+	// Iff the job was created, the returned boolean is true and the returned error is nil.
+	CreateOrUpdate(
 		id string,
 		request dto.ExecutionEnvironmentRequest,
-	)
+	) (bool, error)
 
 	// Delete removes the execution environment with the given id from the executor.
 	Delete(id string)
@@ -38,11 +40,28 @@ type NomadEnvironmentManager struct {
 	defaultJob    nomadApi.Job
 }
 
-func (m *NomadEnvironmentManager) Create(
+func (m *NomadEnvironmentManager) CreateOrUpdate(
 	id string,
 	request dto.ExecutionEnvironmentRequest,
-) {
+) (bool, error) {
+	idInt, err := strconv.Atoi(id)
+	if err != nil {
+		return false, err
+	}
+	exists := m.runnerManager.EnvironmentExists(runner.EnvironmentId(idInt))
 
+	err = m.registerJob(id,
+		request.PrewarmingPoolSize, request.CPULimit, request.MemoryLimit,
+		request.Image, request.NetworkAccess, request.ExposedPorts)
+
+	if err == nil {
+		if !exists {
+			m.runnerManager.RegisterEnvironment(
+				runner.EnvironmentId(idInt), runner.NomadJobId(id), int(request.PrewarmingPoolSize))
+		}
+		return !exists, nil
+	}
+	return false, err
 }
 
 func (m *NomadEnvironmentManager) Delete(id string) {

environment/manager_mock.go

@@ -2,16 +2,35 @@
 
 package environment
 
-import mock "github.com/stretchr/testify/mock"
+import (
+	mock "github.com/stretchr/testify/mock"
+	dto "gitlab.hpi.de/codeocean/codemoon/poseidon/api/dto"
+)
 
 // ManagerMock is an autogenerated mock type for the Manager type
 type ManagerMock struct {
 	mock.Mock
 }
 
-// Create provides a mock function with given fields: id, prewarmingPoolSize, cpuLimit, memoryLimit, image, networkAccess, exposedPorts
+// CreateOrUpdate provides a mock function with given fields: id, request
-func (_m *ManagerMock) Create(id string, prewarmingPoolSize uint, cpuLimit uint, memoryLimit uint, image string, networkAccess bool, exposedPorts []uint16) {
+func (_m *ManagerMock) CreateOrUpdate(id string, request dto.ExecutionEnvironmentRequest) (bool, error) {
-	_m.Called(id, prewarmingPoolSize, cpuLimit, memoryLimit, image, networkAccess, exposedPorts)
+	ret := _m.Called(id, request)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string, dto.ExecutionEnvironmentRequest) bool); ok {
+		r0 = rf(id, request)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(string, dto.ExecutionEnvironmentRequest) error); ok {
+		r1 = rf(id, request)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
 // Delete provides a mock function with given fields: id

environment/manager_test.go

@@ -0,0 +1,136 @@
+package environment
+
+import (
+	nomadApi "github.com/hashicorp/nomad/api"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/api/dto"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/nomad"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/runner"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/tests"
+	"math"
+	"strconv"
+	"testing"
+)
+
+type CreateOrUpdateTestSuite struct {
+	suite.Suite
+	runnerManagerMock        runner.ManagerMock
+	apiMock                  nomad.ExecutorApiMock
+	registerNomadJobMockCall *mock.Call
+	request                  dto.ExecutionEnvironmentRequest
+	manager                  *NomadEnvironmentManager
+}
+
+func TestCreateOrUpdateTestSuite(t *testing.T) {
+	suite.Run(t, new(CreateOrUpdateTestSuite))
+}
+
+func (s *CreateOrUpdateTestSuite) SetupTest() {
+	s.runnerManagerMock = runner.ManagerMock{}
+	s.apiMock = nomad.ExecutorApiMock{}
+	s.request = dto.ExecutionEnvironmentRequest{
+		PrewarmingPoolSize: 10,
+		CPULimit:           20,
+		MemoryLimit:        30,
+		Image:              "my-image",
+		NetworkAccess:      false,
+		ExposedPorts:       nil,
+	}
+
+	s.registerNomadJobMockCall = s.apiMock.On("RegisterNomadJob", mock.AnythingOfType("*api.Job")).Return("eval-id", nil)
+	s.apiMock.On("MonitorEvaluation", mock.AnythingOfType("string"), mock.AnythingOfType("*context.emptyCtx")).Return(nil)
+
+	s.manager = &NomadEnvironmentManager{
+		runnerManager: &s.runnerManagerMock,
+		api:           &s.apiMock,
+	}
+}
+
+func (s *CreateOrUpdateTestSuite) mockEnvironmentExists(exists bool) {
+	s.runnerManagerMock.On("EnvironmentExists", mock.AnythingOfType("EnvironmentId")).Return(exists)
+}
+
+func (s *CreateOrUpdateTestSuite) mockRegisterEnvironment() *mock.Call {
+	return s.runnerManagerMock.On("RegisterEnvironment",
+		mock.AnythingOfType("EnvironmentId"), mock.AnythingOfType("NomadJobId"), mock.AnythingOfType("int")).
+		Return()
+}
+
+func (s *CreateOrUpdateTestSuite) createJobForRequest() *nomadApi.Job {
+	return createJob(s.manager.defaultJob, tests.DefaultEnvironmentIdAsString,
+		s.request.PrewarmingPoolSize, s.request.CPULimit, s.request.MemoryLimit,
+		s.request.Image, s.request.NetworkAccess, s.request.ExposedPorts)
+}
+
+func (s *CreateOrUpdateTestSuite) TestFailsOnInvalidID() {
+	_, err := s.manager.CreateOrUpdate("invalid-id", s.request)
+	s.Error(err)
+}
+
+func (s *CreateOrUpdateTestSuite) TestFailsOnTooLargeID() {
+	tooLargeIntStr := strconv.Itoa(math.MaxInt64) + "0"
+	_, err := s.manager.CreateOrUpdate(tooLargeIntStr, s.request)
+	s.Error(err)
+}
+
+func (s *CreateOrUpdateTestSuite) TestWhenEnvironmentExistsRegistersCorrectJob() {
+	s.mockEnvironmentExists(true)
+	expectedJob := s.createJobForRequest()
+
+	created, err := s.manager.CreateOrUpdate(tests.DefaultEnvironmentIdAsString, s.request)
+	s.NoError(err)
+	s.False(created)
+	s.apiMock.AssertCalled(s.T(), "RegisterNomadJob", expectedJob)
+}
+
+func (s *CreateOrUpdateTestSuite) TestWhenEnvironmentExistsOccurredErrorIsPassed() {
+	s.mockEnvironmentExists(true)
+
+	s.registerNomadJobMockCall.Return("", tests.DefaultError)
+	created, err := s.manager.CreateOrUpdate(tests.DefaultEnvironmentIdAsString, s.request)
+	s.False(created)
+	s.Equal(tests.DefaultError, err)
+}
+
+func (s *CreateOrUpdateTestSuite) TestWhenEnvironmentExistsReturnsFalse() {
+	s.mockEnvironmentExists(true)
+
+	created, err := s.manager.CreateOrUpdate(tests.DefaultEnvironmentIdAsString, s.request)
+	s.NoError(err)
+	s.False(created)
+}
+
+func (s *CreateOrUpdateTestSuite) TestWhenEnvironmentDoesNotExistRegistersCorrectJob() {
+	s.mockEnvironmentExists(false)
+	s.mockRegisterEnvironment()
+
+	expectedJob := s.createJobForRequest()
+
+	created, err := s.manager.CreateOrUpdate(tests.DefaultEnvironmentIdAsString, s.request)
+	s.NoError(err)
+	s.True(created)
+	s.apiMock.AssertCalled(s.T(), "RegisterNomadJob", expectedJob)
+}
+
+func (s *CreateOrUpdateTestSuite) TestWhenEnvironmentDoesNotExistRegistersCorrectEnvironment() {
+	s.mockEnvironmentExists(false)
+	s.mockRegisterEnvironment()
+
+	created, err := s.manager.CreateOrUpdate(tests.DefaultEnvironmentIdAsString, s.request)
+	s.True(created)
+	s.NoError(err)
+	s.runnerManagerMock.AssertCalled(s.T(), "RegisterEnvironment",
+		runner.EnvironmentId(tests.DefaultEnvironmentIdAsInteger), runner.NomadJobId(tests.DefaultEnvironmentIdAsString), s.request.PrewarmingPoolSize)
+}
+
+func (s *CreateOrUpdateTestSuite) TestWhenEnvironmentDoesNotExistOccurredErrorIsPassedAndNoEnvironmentRegistered() {
+	s.mockEnvironmentExists(false)
+	s.mockRegisterEnvironment()
+
+	s.registerNomadJobMockCall.Return("", tests.DefaultError)
+	created, err := s.manager.CreateOrUpdate(tests.DefaultEnvironmentIdAsString, s.request)
+	s.False(created)
+	s.Equal(tests.DefaultError, err)
+	s.runnerManagerMock.AssertNotCalled(s.T(), "RegisterEnvironment")
+}

runner/manager.go

@@ -27,6 +27,9 @@ type Manager interface {
 	// RegisterEnvironment adds a new environment that should be managed.
 	RegisterEnvironment(environmentId EnvironmentId, nomadJobId NomadJobId, desiredIdleRunnersCount int)
 
+	// EnvironmentExists returns whether the environment with the given id exists.
+	EnvironmentExists(id EnvironmentId) bool
+
 	// Claim returns a new runner.
 	// It makes sure that the runner is not in use yet and returns an error if no runner could be provided.
 	Claim(id EnvironmentId) (Runner, error)
@@ -75,6 +78,11 @@ func (m *NomadRunnerManager) RegisterEnvironment(environmentId EnvironmentId, no
 	go m.refreshEnvironment(environmentId)
 }
 
+func (m *NomadRunnerManager) EnvironmentExists(id EnvironmentId) (ok bool) {
+	_, ok = m.jobs.Get(id)
+	return
+}
+
 func (m *NomadRunnerManager) Claim(environmentId EnvironmentId) (Runner, error) {
 	job, ok := m.jobs.Get(environmentId)
 	if !ok {

runner/manager_mock.go

@@ -32,6 +32,20 @@ func (_m *ManagerMock) Claim(id EnvironmentId) (Runner, error) {
 	return r0, r1
 }
 
+// EnvironmentExists provides a mock function with given fields: id
+func (_m *ManagerMock) EnvironmentExists(id EnvironmentId) bool {
+	ret := _m.Called(id)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(EnvironmentId) bool); ok {
+		r0 = rf(id)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
 // Get provides a mock function with given fields: runnerId
 func (_m *ManagerMock) Get(runnerId string) (Runner, error) {
 	ret := _m.Called(runnerId)

runner/manager_test.go

@@ -3,6 +3,7 @@ package runner
 import (
 	"errors"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	"gitlab.hpi.de/codeocean/codemoon/poseidon/nomad"
 	"gitlab.hpi.de/codeocean/codemoon/poseidon/tests"
@@ -25,156 +26,172 @@ type ManagerTestSuite struct {
 	exerciseRunner     Runner
 }
 
-func (suite *ManagerTestSuite) SetupTest() {
+func (s *ManagerTestSuite) SetupTest() {
-	suite.apiMock = &nomad.ExecutorApiMock{}
+	s.apiMock = &nomad.ExecutorApiMock{}
-	suite.nomadRunnerManager = NewNomadRunnerManager(suite.apiMock)
+	s.nomadRunnerManager = NewNomadRunnerManager(s.apiMock)
-	suite.exerciseRunner = NewRunner(tests.DefaultRunnerId)
+	s.exerciseRunner = NewRunner(tests.DefaultRunnerId)
-	suite.mockRunnerQueries([]string{})
+	s.mockRunnerQueries([]string{})
-	suite.registerDefaultEnvironment()
+	s.registerDefaultEnvironment()
 }
 
-func (suite *ManagerTestSuite) mockRunnerQueries(returnedRunnerIds []string) {
+func (s *ManagerTestSuite) mockRunnerQueries(returnedRunnerIds []string) {
 	// reset expected calls to allow new mocked return values
-	suite.apiMock.ExpectedCalls = []*mock.Call{}
+	s.apiMock.ExpectedCalls = []*mock.Call{}
-	suite.apiMock.On("LoadRunners", tests.DefaultJobId).Return(returnedRunnerIds, nil)
+	s.apiMock.On("LoadRunners", tests.DefaultJobId).Return(returnedRunnerIds, nil)
-	suite.apiMock.On("JobScale", tests.DefaultJobId).Return(len(returnedRunnerIds), nil)
+	s.apiMock.On("JobScale", tests.DefaultJobId).Return(len(returnedRunnerIds), nil)
-	suite.apiMock.On("SetJobScale", tests.DefaultJobId, mock.AnythingOfType("int"), "Runner Requested").Return(nil)
+	s.apiMock.On("SetJobScale", tests.DefaultJobId, mock.AnythingOfType("int"), "Runner Requested").Return(nil)
 }
 
-func (suite *ManagerTestSuite) registerDefaultEnvironment() {
+func (s *ManagerTestSuite) registerDefaultEnvironment() {
-	suite.nomadRunnerManager.RegisterEnvironment(defaultEnvironmentId, tests.DefaultJobId, defaultDesiredRunnersCount)
+	s.nomadRunnerManager.RegisterEnvironment(defaultEnvironmentId, tests.DefaultJobId, defaultDesiredRunnersCount)
 }
 
-func (suite *ManagerTestSuite) AddIdleRunnerForDefaultEnvironment(r Runner) {
+func (s *ManagerTestSuite) AddIdleRunnerForDefaultEnvironment(r Runner) {
-	job, _ := suite.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
+	job, _ := s.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
 	job.idleRunners.Add(r)
 }
 
-func (suite *ManagerTestSuite) waitForRunnerRefresh() {
+func (s *ManagerTestSuite) waitForRunnerRefresh() {
 	time.Sleep(100 * time.Millisecond)
 }
 
-func (suite *ManagerTestSuite) TestRegisterEnvironmentAddsNewJob() {
+func (s *ManagerTestSuite) TestRegisterEnvironmentAddsNewJob() {
-	suite.nomadRunnerManager.RegisterEnvironment(anotherEnvironmentId, tests.DefaultJobId, defaultDesiredRunnersCount)
+	s.nomadRunnerManager.RegisterEnvironment(anotherEnvironmentId, tests.DefaultJobId, defaultDesiredRunnersCount)
-	job, ok := suite.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
+	job, ok := s.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
-	suite.True(ok)
+	s.True(ok)
-	suite.NotNil(job)
+	s.NotNil(job)
 }
 
-func (suite *ManagerTestSuite) TestClaimReturnsNotFoundErrorIfEnvironmentNotFound() {
+func (s *ManagerTestSuite) TestClaimReturnsNotFoundErrorIfEnvironmentNotFound() {
-	runner, err := suite.nomadRunnerManager.Claim(EnvironmentId(42))
+	runner, err := s.nomadRunnerManager.Claim(EnvironmentId(42))
-	suite.Nil(runner)
+	s.Nil(runner)
-	suite.Equal(ErrUnknownExecutionEnvironment, err)
+	s.Equal(ErrUnknownExecutionEnvironment, err)
 }
 
-func (suite *ManagerTestSuite) TestClaimReturnsRunnerIfAvailable() {
+func (s *ManagerTestSuite) TestClaimReturnsRunnerIfAvailable() {
-	suite.AddIdleRunnerForDefaultEnvironment(suite.exerciseRunner)
+	s.AddIdleRunnerForDefaultEnvironment(s.exerciseRunner)
-	receivedRunner, err := suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	receivedRunner, err := s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	suite.NoError(err)
+	s.NoError(err)
-	suite.Equal(suite.exerciseRunner, receivedRunner)
+	s.Equal(s.exerciseRunner, receivedRunner)
 }
 
-func (suite *ManagerTestSuite) TestClaimReturnsErrorIfNoRunnerAvailable() {
+func (s *ManagerTestSuite) TestClaimReturnsErrorIfNoRunnerAvailable() {
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
-	runner, err := suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	runner, err := s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	suite.Nil(runner)
+	s.Nil(runner)
-	suite.Equal(ErrNoRunnersAvailable, err)
+	s.Equal(ErrNoRunnersAvailable, err)
 }
 
-func (suite *ManagerTestSuite) TestClaimReturnsNoRunnerOfDifferentEnvironment() {
+func (s *ManagerTestSuite) TestClaimReturnsNoRunnerOfDifferentEnvironment() {
-	suite.AddIdleRunnerForDefaultEnvironment(suite.exerciseRunner)
+	s.AddIdleRunnerForDefaultEnvironment(s.exerciseRunner)
-	receivedRunner, err := suite.nomadRunnerManager.Claim(anotherEnvironmentId)
+	receivedRunner, err := s.nomadRunnerManager.Claim(anotherEnvironmentId)
-	suite.Nil(receivedRunner)
+	s.Nil(receivedRunner)
-	suite.Error(err)
+	s.Error(err)
 }
 
-func (suite *ManagerTestSuite) TestClaimDoesNotReturnTheSameRunnerTwice() {
+func (s *ManagerTestSuite) TestClaimDoesNotReturnTheSameRunnerTwice() {
-	suite.AddIdleRunnerForDefaultEnvironment(suite.exerciseRunner)
+	s.AddIdleRunnerForDefaultEnvironment(s.exerciseRunner)
-	suite.AddIdleRunnerForDefaultEnvironment(NewRunner(tests.AnotherRunnerId))
+	s.AddIdleRunnerForDefaultEnvironment(NewRunner(tests.AnotherRunnerId))
 
-	firstReceivedRunner, _ := suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	firstReceivedRunner, _ := s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	secondReceivedRunner, _ := suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	secondReceivedRunner, _ := s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	suite.NotEqual(firstReceivedRunner, secondReceivedRunner)
+	s.NotEqual(firstReceivedRunner, secondReceivedRunner)
 }
 
-func (suite *ManagerTestSuite) TestClaimThrowsAnErrorIfNoRunnersAvailable() {
+func (s *ManagerTestSuite) TestClaimThrowsAnErrorIfNoRunnersAvailable() {
-	receivedRunner, err := suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	receivedRunner, err := s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	suite.Nil(receivedRunner)
+	s.Nil(receivedRunner)
-	suite.Error(err)
+	s.Error(err)
 }
 
-func (suite *ManagerTestSuite) TestClaimAddsRunnerToUsedRunners() {
+func (s *ManagerTestSuite) TestClaimAddsRunnerToUsedRunners() {
-	suite.mockRunnerQueries([]string{tests.DefaultRunnerId})
+	s.mockRunnerQueries([]string{tests.DefaultRunnerId})
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
-	receivedRunner, _ := suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	receivedRunner, _ := s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	savedRunner, ok := suite.nomadRunnerManager.usedRunners.Get(receivedRunner.Id())
+	savedRunner, ok := s.nomadRunnerManager.usedRunners.Get(receivedRunner.Id())
-	suite.True(ok)
+	s.True(ok)
-	suite.Equal(savedRunner, receivedRunner)
+	s.Equal(savedRunner, receivedRunner)
 }
 
-func (suite *ManagerTestSuite) TestGetReturnsRunnerIfRunnerIsUsed() {
+func (s *ManagerTestSuite) TestGetReturnsRunnerIfRunnerIsUsed() {
-	suite.nomadRunnerManager.usedRunners.Add(suite.exerciseRunner)
+	s.nomadRunnerManager.usedRunners.Add(s.exerciseRunner)
-	savedRunner, err := suite.nomadRunnerManager.Get(suite.exerciseRunner.Id())
+	savedRunner, err := s.nomadRunnerManager.Get(s.exerciseRunner.Id())
-	suite.NoError(err)
+	s.NoError(err)
-	suite.Equal(savedRunner, suite.exerciseRunner)
+	s.Equal(savedRunner, s.exerciseRunner)
 }
 
-func (suite *ManagerTestSuite) TestGetReturnsErrorIfRunnerNotFound() {
+func (s *ManagerTestSuite) TestGetReturnsErrorIfRunnerNotFound() {
-	savedRunner, err := suite.nomadRunnerManager.Get(tests.DefaultRunnerId)
+	savedRunner, err := s.nomadRunnerManager.Get(tests.DefaultRunnerId)
-	suite.Nil(savedRunner)
+	s.Nil(savedRunner)
-	suite.Error(err)
+	s.Error(err)
 }
 
-func (suite *ManagerTestSuite) TestReturnRemovesRunnerFromUsedRunners() {
+func (s *ManagerTestSuite) TestReturnRemovesRunnerFromUsedRunners() {
-	suite.apiMock.On("DeleteRunner", mock.AnythingOfType("string")).Return(nil)
+	s.apiMock.On("DeleteRunner", mock.AnythingOfType("string")).Return(nil)
-	suite.nomadRunnerManager.usedRunners.Add(suite.exerciseRunner)
+	s.nomadRunnerManager.usedRunners.Add(s.exerciseRunner)
-	err := suite.nomadRunnerManager.Return(suite.exerciseRunner)
+	err := s.nomadRunnerManager.Return(s.exerciseRunner)
-	suite.Nil(err)
+	s.Nil(err)
-	_, ok := suite.nomadRunnerManager.usedRunners.Get(suite.exerciseRunner.Id())
+	_, ok := s.nomadRunnerManager.usedRunners.Get(s.exerciseRunner.Id())
-	suite.False(ok)
+	s.False(ok)
 }
 
-func (suite *ManagerTestSuite) TestReturnCallsDeleteRunnerApiMethod() {
+func (s *ManagerTestSuite) TestReturnCallsDeleteRunnerApiMethod() {
-	suite.apiMock.On("DeleteRunner", mock.AnythingOfType("string")).Return(nil)
+	s.apiMock.On("DeleteRunner", mock.AnythingOfType("string")).Return(nil)
-	err := suite.nomadRunnerManager.Return(suite.exerciseRunner)
+	err := s.nomadRunnerManager.Return(s.exerciseRunner)
-	suite.Nil(err)
+	s.Nil(err)
-	suite.apiMock.AssertCalled(suite.T(), "DeleteRunner", suite.exerciseRunner.Id())
+	s.apiMock.AssertCalled(s.T(), "DeleteRunner", s.exerciseRunner.Id())
 }
 
-func (suite *ManagerTestSuite) TestReturnReturnsErrorWhenApiCallFailed() {
+func (s *ManagerTestSuite) TestReturnReturnsErrorWhenApiCallFailed() {
-	suite.apiMock.On("DeleteRunner", mock.AnythingOfType("string")).Return(errors.New("return failed"))
+	s.apiMock.On("DeleteRunner", mock.AnythingOfType("string")).Return(errors.New("return failed"))
-	err := suite.nomadRunnerManager.Return(suite.exerciseRunner)
+	err := s.nomadRunnerManager.Return(s.exerciseRunner)
-	suite.Error(err)
+	s.Error(err)
 }
 
-func (suite *ManagerTestSuite) TestRefreshFetchesRunners() {
+func (s *ManagerTestSuite) TestRefreshFetchesRunners() {
-	suite.mockRunnerQueries([]string{tests.DefaultRunnerId})
+	s.mockRunnerQueries([]string{tests.DefaultRunnerId})
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
-	suite.apiMock.AssertCalled(suite.T(), "LoadRunners", tests.DefaultJobId)
+	s.apiMock.AssertCalled(s.T(), "LoadRunners", tests.DefaultJobId)
 }
 
-func (suite *ManagerTestSuite) TestNewRunnersFoundInRefreshAreAddedToIdleRunners() {
+func (s *ManagerTestSuite) TestNewRunnersFoundInRefreshAreAddedToIdleRunners() {
-	suite.mockRunnerQueries([]string{tests.DefaultRunnerId})
+	s.mockRunnerQueries([]string{tests.DefaultRunnerId})
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
-	job, _ := suite.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
+	job, _ := s.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
 	_, ok := job.idleRunners.Get(tests.DefaultRunnerId)
-	suite.True(ok)
+	s.True(ok)
 }
 
-func (suite *ManagerTestSuite) TestRefreshScalesJob() {
+func (s *ManagerTestSuite) TestRefreshScalesJob() {
-	suite.mockRunnerQueries([]string{tests.DefaultRunnerId})
+	s.mockRunnerQueries([]string{tests.DefaultRunnerId})
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
 	// use one runner to necessitate rescaling
-	_, _ = suite.nomadRunnerManager.Claim(defaultEnvironmentId)
+	_, _ = s.nomadRunnerManager.Claim(defaultEnvironmentId)
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
-	suite.apiMock.AssertCalled(suite.T(), "SetJobScale", tests.DefaultJobId, defaultDesiredRunnersCount+1, "Runner Requested")
+	s.apiMock.AssertCalled(s.T(), "SetJobScale", tests.DefaultJobId, defaultDesiredRunnersCount+1, "Runner Requested")
 }
 
-func (suite *ManagerTestSuite) TestRefreshAddsRunnerToPool() {
+func (s *ManagerTestSuite) TestRefreshAddsRunnerToPool() {
-	suite.mockRunnerQueries([]string{tests.DefaultRunnerId})
+	s.mockRunnerQueries([]string{tests.DefaultRunnerId})
-	suite.waitForRunnerRefresh()
+	s.waitForRunnerRefresh()
-	job, _ := suite.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
+	job, _ := s.nomadRunnerManager.jobs.Get(defaultEnvironmentId)
 	poolRunner, ok := job.idleRunners.Get(tests.DefaultRunnerId)
-	suite.True(ok)
+	s.True(ok)
-	suite.Equal(tests.DefaultRunnerId, poolRunner.Id())
+	s.Equal(tests.DefaultRunnerId, poolRunner.Id())
+}
+
+func (s *ManagerTestSuite) TestWhenEnvironmentDoesNotExistEnvironmentExistsReturnsFalse() {
+	id := anotherEnvironmentId
+	_, ok := s.nomadRunnerManager.jobs.Get(id)
+	require.False(s.T(), ok)
+
+	s.False(s.nomadRunnerManager.EnvironmentExists(id))
+}
+
+func (s *ManagerTestSuite) TestWhenEnvironmentExistsEnvironmentExistsReturnsTrue() {
+	id := anotherEnvironmentId
+	s.nomadRunnerManager.jobs.Add(&NomadJob{environmentId: id})
+
+	exists := s.nomadRunnerManager.EnvironmentExists(id)
+	s.True(exists)
 }

tests/constants.go

@@ -9,6 +9,7 @@ const (
 	DefaultDirectoryName          = "test/"
 	FileNameWithAbsolutePath      = "/test.txt"
 	DefaultEnvironmentIdAsInteger = 0
+	DefaultEnvironmentIdAsString  = "0"
 	AnotherEnvironmentIdAsInteger = 42
 	DefaultJobId                  = "s0m3-j0b-1d"
 	AnotherJobId                  = "4n0th3r-j0b-1d"
@@ -19,5 +20,5 @@ const (
 )
 
 var (
-	DefaultError = errors.New("an error occured")
+	DefaultError = errors.New("an error occurred")
 )