diff --git a/api/runners_test.go b/api/runners_test.go
index 6bd521f..5b7da35 100644
--- a/api/runners_test.go
+++ b/api/runners_test.go
@@ -3,12 +3,12 @@ package api
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/gorilla/mux"
-	"github.com/stretchr/testify/assert"
+	"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/runner"
 	"net/http"
 	"net/http/httptest"
@@ -19,69 +19,65 @@ import (
 
 type MiddlewareTestSuite struct {
 	suite.Suite
-	manager          *runner.ManagerMock
-	router           *mux.Router
-	runnerController *RunnerController
-	testRunner       runner.Runner
+	manager        *runner.ManagerMock
+	router         *mux.Router
+	runner         runner.Runner
+	capturedRunner runner.Runner
+	runnerRequest  func(string) *http.Request
 }
 
 func (suite *MiddlewareTestSuite) SetupTest() {
 	suite.manager = &runner.ManagerMock{}
-	suite.router = mux.NewRouter()
-	suite.runnerController = &RunnerController{suite.manager, suite.router}
-	suite.testRunner = runner.NewRunner("runner")
-}
-
-func TestMiddlewareTestSuite(t *testing.T) {
-	suite.Run(t, new(MiddlewareTestSuite))
-}
-
-func (suite *MiddlewareTestSuite) TestFindRunnerMiddleware() {
-	var capturedRunner runner.Runner
-
-	testRunnerIdRoute := func(writer http.ResponseWriter, request *http.Request) {
+	suite.runner = runner.NewRunner("runner")
+	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)
+		}
+		request, err := http.NewRequest(http.MethodPost, path.String(), nil)
+		if err != nil {
+			suite.T().Fatal(err)
+		}
+		return request
+	}
+	runnerRouteHandler := func(writer http.ResponseWriter, request *http.Request) {
 		var ok bool
-		capturedRunner, ok = runner.FromContext(request.Context())
+		suite.capturedRunner, ok = runner.FromContext(request.Context())
 		if ok {
 			writer.WriteHeader(http.StatusOK)
 		} else {
 			writer.WriteHeader(http.StatusInternalServerError)
 		}
 	}
-	testRunnerRequest := func(t *testing.T, runnerId string) *http.Request {
-		path, err := suite.router.Get("test-runner-id").URL(RunnerIdKey, runnerId)
-		if err != nil {
-			t.Fatal(err)
-		}
-		request, err := http.NewRequest(http.MethodPost, path.String(), nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return request
-	}
+	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")
+}
 
-	suite.router.Use(suite.runnerController.findRunnerMiddleware)
-	suite.router.HandleFunc(fmt.Sprintf("/test/{%s}", RunnerIdKey), testRunnerIdRoute).Name("test-runner-id")
+func TestMiddlewareTestSuite(t *testing.T) {
+	suite.Run(t, new(MiddlewareTestSuite))
+}
 
-	suite.manager.On("Get", suite.testRunner.Id()).Return(suite.testRunner, nil)
-	suite.T().Run("sets runner in context if runner exists", func(t *testing.T) {
-		capturedRunner = nil
+func (suite *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerExists() {
+	suite.manager.On("Get", suite.runner.Id()).Return(suite.runner, nil)
 
-		recorder := httptest.NewRecorder()
-		suite.router.ServeHTTP(recorder, testRunnerRequest(t, suite.testRunner.Id()))
+	recorder := httptest.NewRecorder()
+	suite.router.ServeHTTP(recorder, suite.runnerRequest(suite.runner.Id()))
 
-		assert.Equal(t, http.StatusOK, recorder.Code)
-		assert.Equal(t, suite.testRunner, capturedRunner)
-	})
+	suite.Equal(http.StatusOK, recorder.Code)
+	suite.Equal(suite.runner, suite.capturedRunner)
+}
 
+func (suite *MiddlewareTestSuite) TestFindRunnerMiddlewareIfRunnerDoesNotExist() {
 	invalidID := "some-invalid-runner-id"
 	suite.manager.On("Get", invalidID).Return(nil, runner.ErrRunnerNotFound)
-	suite.T().Run("returns 404 if runner does not exist", func(t *testing.T) {
-		recorder := httptest.NewRecorder()
-		suite.router.ServeHTTP(recorder, testRunnerRequest(t, invalidID))
 
-		assert.Equal(t, http.StatusNotFound, recorder.Code)
-	})
+	recorder := httptest.NewRecorder()
+	suite.router.ServeHTTP(recorder, suite.runnerRequest(invalidID))
+
+	suite.Equal(http.StatusNotFound, recorder.Code)
 }
 
 func TestRunnerRouteTestSuite(t *testing.T) {
@@ -90,16 +86,14 @@ func TestRunnerRouteTestSuite(t *testing.T) {
 
 type RunnerRouteTestSuite struct {
 	suite.Suite
-	runnerManager      *runner.ManagerMock
-	environmentManager *environment.ManagerMock
-	router             *mux.Router
-	runner             runner.Runner
+	runnerManager *runner.ManagerMock
+	router        *mux.Router
+	runner        runner.Runner
 }
 
 func (suite *RunnerRouteTestSuite) SetupTest() {
 	suite.runnerManager = &runner.ManagerMock{}
-	suite.environmentManager = &environment.ManagerMock{}
-	suite.router = NewRouter(suite.runnerManager, suite.environmentManager)
+	suite.router = NewRouter(suite.runnerManager, nil)
 	suite.runner = runner.NewRunner("test_runner")
 	suite.runnerManager.On("Get", suite.runner.Id()).Return(suite.runner, nil)
 }
@@ -162,27 +156,71 @@ func (suite *RunnerRouteTestSuite) TestExecuteRoute() {
 	})
 }
 
-func (suite *RunnerRouteTestSuite) TestDeleteRoute() {
+func TestDeleteRunnerRouteTestSuite(t *testing.T) {
+	suite.Run(t, new(DeleteRunnerRouteTestSuite))
+}
+
+type DeleteRunnerRouteTestSuite struct {
+	RunnerRouteTestSuite
+	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)
 	}
-	deletePath := deleteURL.String()
+	suite.path = deleteURL.String()
+}
+
+func (suite *DeleteRunnerRouteTestSuite) TestValidRequestReturnsNoContent() {
 	suite.runnerManager.On("Return", suite.runner).Return(nil)
 
-	suite.Run("valid request", func() {
-		recorder := httptest.NewRecorder()
-		request, err := http.NewRequest(http.MethodDelete, deletePath, nil)
-		if err != nil {
-			suite.T().Fatal(err)
-		}
+	recorder := httptest.NewRecorder()
+	request, err := http.NewRequest(http.MethodDelete, suite.path, nil)
+	if err != nil {
+		suite.T().Fatal(err)
+	}
 
-		suite.router.ServeHTTP(recorder, request)
+	suite.router.ServeHTTP(recorder, request)
 
-		suite.Equal(http.StatusNoContent, recorder.Code)
+	suite.Equal(http.StatusNoContent, recorder.Code)
 
-		suite.Run("runner was returned to runner manager", func() {
-			suite.runnerManager.AssertCalled(suite.T(), "Return", suite.runner)
-		})
+	suite.Run("runner was returned to runner manager", func() {
+		suite.runnerManager.AssertCalled(suite.T(), "Return", suite.runner)
 	})
 }
+
+func (suite *DeleteRunnerRouteTestSuite) TestReturnInternalServerErrorWhenApiCallToNomadFailed() {
+	suite.runnerManager.On("Return", suite.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)
+	}
+
+	suite.router.ServeHTTP(recorder, request)
+
+	suite.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)
+	}
+	deletePath := deleteURL.String()
+
+	recorder := httptest.NewRecorder()
+	request, err := http.NewRequest(http.MethodDelete, deletePath, nil)
+	if err != nil {
+		suite.T().Fatal(err)
+	}
+
+	suite.router.ServeHTTP(recorder, request)
+
+	suite.Equal(http.StatusNotFound, recorder.Code)
+}
diff --git a/api/websocket_test.go b/api/websocket_test.go
index 667356a..0cb7a7e 100644
--- a/api/websocket_test.go
+++ b/api/websocket_test.go
@@ -5,7 +5,6 @@ import (
 	"github.com/gorilla/websocket"
 	"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/runner"
 	"net/http"
 	"net/http/httptest"
@@ -13,20 +12,19 @@ import (
 	"testing"
 )
 
+func TestWebsocketTestSuite(t *testing.T) {
+	suite.Run(t, new(WebsocketTestSuite))
+}
+
 type WebsocketTestSuite struct {
 	RunnerRouteTestSuite
 	server      *httptest.Server
 	executionId runner.ExecutionId
 }
 
-func TestWebsocketTestSuite(t *testing.T) {
-	suite.Run(t, new(WebsocketTestSuite))
-}
-
 func (suite *WebsocketTestSuite) SetupTest() {
 	suite.runnerManager = &runner.ManagerMock{}
-	suite.environmentManager = &environment.ManagerMock{}
-	suite.router = NewRouter(suite.runnerManager, suite.environmentManager)
+	suite.router = NewRouter(suite.runnerManager, nil)
 	suite.runner = runner.NewRunner("test_runner")
 	suite.runnerManager.On("Get", suite.runner.Id()).Return(suite.runner, nil)
 	var err error
@@ -37,7 +35,6 @@ func (suite *WebsocketTestSuite) SetupTest() {
 	})
 	suite.Require().NoError(err)
 
-	// router.HandleFunc(fmt.Sprintf("%s/{%s}%s", RouteRunners, RunnerIdKey, WebsocketPath), connectToRunner).Methods(http.MethodGet).Name(WebsocketPath)
 	suite.server = httptest.NewServer(suite.router)
 }