Restructure project

We previously didn't really had any structure in our project apart from creating a new folder for each package in our project root. Now that we have accumulated some packages, we use the well-known Golang project layout in order to clearly communicate our intent with packages. See https://github.com/golang-standards/project-layout
2021-07-16 09:19:42 +02:00
parent 2f1383b743
commit 8b26ecbe5f
66 changed files with 95 additions and 95 deletions
--- a/internal/runner/runner_test.go
+++ b/internal/runner/runner_test.go
@@ -0,0 +1,401 @@
+package runner
+
+import (
+	"archive/tar"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/internal/nomad"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/pkg/dto"
+	"gitlab.hpi.de/codeocean/codemoon/poseidon/tests"
+	"io"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestIdIsStored(t *testing.T) {
+	runner := NewNomadJob(tests.DefaultJobID, nil, nil, nil)
+	assert.Equal(t, tests.DefaultJobID, runner.ID())
+}
+
+func TestMappedPortsAreStoredCorrectly(t *testing.T) {
+	runner := NewNomadJob(tests.DefaultJobID, tests.DefaultPortMappings, nil, nil)
+	assert.Equal(t, tests.DefaultMappedPorts, runner.MappedPorts())
+
+	runner = NewNomadJob(tests.DefaultJobID, nil, nil, nil)
+	assert.Empty(t, runner.MappedPorts())
+}
+
+func TestMarshalRunner(t *testing.T) {
+	runner := NewNomadJob(tests.DefaultJobID, nil, nil, nil)
+	marshal, err := json.Marshal(runner)
+	assert.NoError(t, err)
+	assert.Equal(t, "{\"runnerId\":\""+tests.DefaultJobID+"\"}", string(marshal))
+}
+
+func TestExecutionRequestIsStored(t *testing.T) {
+	runner := NewNomadJob(tests.DefaultJobID, nil, nil, nil)
+	executionRequest := &dto.ExecutionRequest{
+		Command:     "command",
+		TimeLimit:   10,
+		Environment: nil,
+	}
+	id := ExecutionID("test-execution")
+	runner.Add(id, executionRequest)
+	storedExecutionRunner, ok := runner.Pop(id)
+
+	assert.True(t, ok, "Getting an execution should not return ok false")
+	assert.Equal(t, executionRequest, storedExecutionRunner)
+}
+
+func TestNewContextReturnsNewContextWithRunner(t *testing.T) {
+	runner := NewNomadJob(tests.DefaultRunnerID, nil, nil, nil)
+	ctx := context.Background()
+	newCtx := NewContext(ctx, runner)
+	storedRunner, ok := newCtx.Value(runnerContextKey).(Runner)
+	require.True(t, ok)
+
+	assert.NotEqual(t, ctx, newCtx)
+	assert.Equal(t, runner, storedRunner)
+}
+
+func TestFromContextReturnsRunner(t *testing.T) {
+	runner := NewNomadJob(tests.DefaultRunnerID, nil, nil, nil)
+	ctx := NewContext(context.Background(), runner)
+	storedRunner, ok := FromContext(ctx)
+
+	assert.True(t, ok)
+	assert.Equal(t, runner, storedRunner)
+}
+
+func TestFromContextReturnsIsNotOkWhenContextHasNoRunner(t *testing.T) {
+	ctx := context.Background()
+	_, ok := FromContext(ctx)
+
+	assert.False(t, ok)
+}
+
+func TestExecuteInteractivelyTestSuite(t *testing.T) {
+	suite.Run(t, new(ExecuteInteractivelyTestSuite))
+}
+
+type ExecuteInteractivelyTestSuite struct {
+	suite.Suite
+	runner                   *NomadJob
+	apiMock                  *nomad.ExecutorAPIMock
+	timer                    *InactivityTimerMock
+	mockedExecuteCommandCall *mock.Call
+	mockedTimeoutPassedCall  *mock.Call
+}
+
+func (s *ExecuteInteractivelyTestSuite) SetupTest() {
+	s.apiMock = &nomad.ExecutorAPIMock{}
+	s.mockedExecuteCommandCall = s.apiMock.
+		On("ExecuteCommand", mock.Anything, mock.Anything, mock.Anything, true, mock.Anything, mock.Anything, mock.Anything).
+		Return(0, nil)
+	s.timer = &InactivityTimerMock{}
+	s.timer.On("ResetTimeout").Return()
+	s.mockedTimeoutPassedCall = s.timer.On("TimeoutPassed").Return(false)
+	s.runner = &NomadJob{
+		ExecutionStorage: NewLocalExecutionStorage(),
+		InactivityTimer:  s.timer,
+		id:               tests.DefaultRunnerID,
+		api:              s.apiMock,
+	}
+}
+
+func (s *ExecuteInteractivelyTestSuite) TestCallsApi() {
+	request := &dto.ExecutionRequest{Command: "echo 'Hello World!'"}
+	s.runner.ExecuteInteractively(request, nil, nil, nil)
+
+	time.Sleep(tests.ShortTimeout)
+	s.apiMock.AssertCalled(s.T(), "ExecuteCommand", tests.DefaultRunnerID, mock.Anything, request.FullCommand(),
+		true, mock.Anything, mock.Anything, mock.Anything)
+}
+
+func (s *ExecuteInteractivelyTestSuite) TestReturnsAfterTimeout() {
+	s.mockedExecuteCommandCall.Run(func(args mock.Arguments) {
+		ctx, ok := args.Get(1).(context.Context)
+		s.Require().True(ok)
+		<-ctx.Done()
+	}).
+		Return(0, nil)
+
+	timeLimit := 1
+	execution := &dto.ExecutionRequest{TimeLimit: timeLimit}
+	exit, _ := s.runner.ExecuteInteractively(execution, nil, nil, nil)
+
+	select {
+	case <-exit:
+		s.FailNow("ExecuteInteractively should not terminate instantly")
+	case <-time.After(tests.ShortTimeout):
+	}
+
+	select {
+	case <-time.After(time.Duration(timeLimit) * time.Second):
+		s.FailNow("ExecuteInteractively should return after the time limit")
+	case exitInfo := <-exit:
+		s.Equal(uint8(0), exitInfo.Code)
+	}
+}
+
+func (s *ExecuteInteractivelyTestSuite) TestResetTimerGetsCalled() {
+	execution := &dto.ExecutionRequest{}
+	s.runner.ExecuteInteractively(execution, nil, nil, nil)
+	s.timer.AssertCalled(s.T(), "ResetTimeout")
+}
+
+func (s *ExecuteInteractivelyTestSuite) TestExitHasTimeoutErrorIfExecutionTimesOut() {
+	s.mockedTimeoutPassedCall.Return(true)
+	execution := &dto.ExecutionRequest{}
+	exitChannel, _ := s.runner.ExecuteInteractively(execution, nil, nil, nil)
+	exit := <-exitChannel
+	s.Equal(ErrorRunnerInactivityTimeout, exit.Err)
+}
+
+func TestUpdateFileSystemTestSuite(t *testing.T) {
+	suite.Run(t, new(UpdateFileSystemTestSuite))
+}
+
+type UpdateFileSystemTestSuite struct {
+	suite.Suite
+	runner                   *NomadJob
+	timer                    *InactivityTimerMock
+	apiMock                  *nomad.ExecutorAPIMock
+	mockedExecuteCommandCall *mock.Call
+	command                  []string
+	stdin                    *bytes.Buffer
+}
+
+func (s *UpdateFileSystemTestSuite) SetupTest() {
+	s.apiMock = &nomad.ExecutorAPIMock{}
+	s.timer = &InactivityTimerMock{}
+	s.timer.On("ResetTimeout").Return()
+	s.timer.On("TimeoutPassed").Return(false)
+	s.runner = &NomadJob{
+		ExecutionStorage: NewLocalExecutionStorage(),
+		InactivityTimer:  s.timer,
+		id:               tests.DefaultRunnerID,
+		api:              s.apiMock,
+	}
+	s.mockedExecuteCommandCall = s.apiMock.On("ExecuteCommand", tests.DefaultRunnerID, mock.Anything,
+		mock.Anything, false, mock.Anything, mock.Anything, mock.Anything).
+		Run(func(args mock.Arguments) {
+			var ok bool
+			s.command, ok = args.Get(2).([]string)
+			s.Require().True(ok)
+			s.stdin, ok = args.Get(4).(*bytes.Buffer)
+			s.Require().True(ok)
+		}).Return(0, nil)
+}
+
+func (s *UpdateFileSystemTestSuite) TestUpdateFileSystemForRunnerPerformsTarExtractionWithAbsoluteNamesOnRunner() {
+	// note: this method tests an implementation detail of the method UpdateFileSystemOfRunner method
+	// if the implementation changes, delete this test and write a new one
+	copyRequest := &dto.UpdateFileSystemRequest{}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.NoError(err)
+	s.apiMock.AssertCalled(s.T(), "ExecuteCommand", mock.Anything, mock.Anything, mock.Anything,
+		false, mock.Anything, mock.Anything, mock.Anything)
+	s.Regexp("tar --extract --absolute-names", s.command)
+}
+
+func (s *UpdateFileSystemTestSuite) TestUpdateFileSystemForRunnerReturnsErrorIfExitCodeIsNotZero() {
+	s.mockedExecuteCommandCall.Return(1, nil)
+	copyRequest := &dto.UpdateFileSystemRequest{}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.ErrorIs(err, ErrorFileCopyFailed)
+}
+
+func (s *UpdateFileSystemTestSuite) TestUpdateFileSystemForRunnerReturnsErrorIfApiCallDid() {
+	s.mockedExecuteCommandCall.Return(0, tests.ErrDefault)
+	copyRequest := &dto.UpdateFileSystemRequest{}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.ErrorIs(err, nomad.ErrorExecutorCommunicationFailed)
+}
+
+func (s *UpdateFileSystemTestSuite) TestFilesToCopyAreIncludedInTarArchive() {
+	copyRequest := &dto.UpdateFileSystemRequest{Copy: []dto.File{
+		{Path: tests.DefaultFileName, Content: []byte(tests.DefaultFileContent)}}}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.NoError(err)
+	s.apiMock.AssertCalled(s.T(), "ExecuteCommand", mock.Anything, mock.Anything, mock.Anything, false,
+		mock.Anything, mock.Anything, mock.Anything)
+
+	tarFiles := s.readFilesFromTarArchive(s.stdin)
+	s.Len(tarFiles, 1)
+	tarFile := tarFiles[0]
+	s.True(strings.HasSuffix(tarFile.Name, tests.DefaultFileName))
+	s.Equal(byte(tar.TypeReg), tarFile.TypeFlag)
+	s.Equal(tests.DefaultFileContent, tarFile.Content)
+}
+
+func (s *UpdateFileSystemTestSuite) TestTarFilesContainCorrectPathForRelativeFilePath() {
+	copyRequest := &dto.UpdateFileSystemRequest{Copy: []dto.File{
+		{Path: tests.DefaultFileName, Content: []byte(tests.DefaultFileContent)}}}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.Require().NoError(err)
+
+	tarFiles := s.readFilesFromTarArchive(s.stdin)
+	s.Len(tarFiles, 1)
+	// tar is extracted in the active workdir of the container, file will be put relative to that
+	s.Equal(tests.DefaultFileName, tarFiles[0].Name)
+}
+
+func (s *UpdateFileSystemTestSuite) TestFilesWithAbsolutePathArePutInAbsoluteLocation() {
+	copyRequest := &dto.UpdateFileSystemRequest{Copy: []dto.File{
+		{Path: tests.FileNameWithAbsolutePath, Content: []byte(tests.DefaultFileContent)}}}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.Require().NoError(err)
+
+	tarFiles := s.readFilesFromTarArchive(s.stdin)
+	s.Len(tarFiles, 1)
+	s.Equal(tarFiles[0].Name, tests.FileNameWithAbsolutePath)
+}
+
+func (s *UpdateFileSystemTestSuite) TestDirectoriesAreMarkedAsDirectoryInTar() {
+	copyRequest := &dto.UpdateFileSystemRequest{Copy: []dto.File{{Path: tests.DefaultDirectoryName, Content: []byte{}}}}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.Require().NoError(err)
+
+	tarFiles := s.readFilesFromTarArchive(s.stdin)
+	s.Len(tarFiles, 1)
+	tarFile := tarFiles[0]
+	s.True(strings.HasSuffix(tarFile.Name+"/", tests.DefaultDirectoryName))
+	s.Equal(byte(tar.TypeDir), tarFile.TypeFlag)
+	s.Equal("", tarFile.Content)
+}
+
+func (s *UpdateFileSystemTestSuite) TestFilesToRemoveGetRemoved() {
+	copyRequest := &dto.UpdateFileSystemRequest{Delete: []dto.FilePath{tests.DefaultFileName}}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.NoError(err)
+	s.apiMock.AssertCalled(s.T(), "ExecuteCommand", mock.Anything, mock.Anything, mock.Anything, false,
+		mock.Anything, mock.Anything, mock.Anything)
+	s.Regexp(fmt.Sprintf("rm[^;]+%s' *;", regexp.QuoteMeta(tests.DefaultFileName)), s.command)
+}
+
+func (s *UpdateFileSystemTestSuite) TestFilesToRemoveGetEscaped() {
+	copyRequest := &dto.UpdateFileSystemRequest{Delete: []dto.FilePath{"/some/potentially/harmful'filename"}}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.NoError(err)
+	s.apiMock.AssertCalled(s.T(), "ExecuteCommand", mock.Anything, mock.Anything, mock.Anything, false,
+		mock.Anything, mock.Anything, mock.Anything)
+	s.Contains(strings.Join(s.command, " "), "'/some/potentially/harmful'\\''filename'")
+}
+
+func (s *UpdateFileSystemTestSuite) TestResetTimerGetsCalled() {
+	copyRequest := &dto.UpdateFileSystemRequest{}
+	err := s.runner.UpdateFileSystem(copyRequest)
+	s.NoError(err)
+	s.timer.AssertCalled(s.T(), "ResetTimeout")
+}
+
+type TarFile struct {
+	Name     string
+	Content  string
+	TypeFlag byte
+}
+
+func (s *UpdateFileSystemTestSuite) readFilesFromTarArchive(tarArchive io.Reader) (files []TarFile) {
+	reader := tar.NewReader(tarArchive)
+	for {
+		hdr, err := reader.Next()
+		if err != nil {
+			break
+		}
+		bf, err := io.ReadAll(reader)
+		s.Require().NoError(err)
+		files = append(files, TarFile{Name: hdr.Name, Content: string(bf), TypeFlag: hdr.Typeflag})
+	}
+	return files
+}
+
+func TestInactivityTimerTestSuite(t *testing.T) {
+	suite.Run(t, new(InactivityTimerTestSuite))
+}
+
+type InactivityTimerTestSuite struct {
+	suite.Suite
+	runner   Runner
+	manager  *ManagerMock
+	returned chan bool
+}
+
+func (s *InactivityTimerTestSuite) SetupTest() {
+	s.returned = make(chan bool, 1)
+	s.manager = &ManagerMock{}
+	s.manager.On("Return", mock.Anything).Run(func(_ mock.Arguments) {
+		s.returned <- true
+	}).Return(nil)
+
+	s.runner = NewRunner(tests.DefaultRunnerID, s.manager)
+
+	s.runner.SetupTimeout(tests.ShortTimeout)
+}
+
+func (s *InactivityTimerTestSuite) TearDownTest() {
+	s.runner.StopTimeout()
+}
+
+func (s *InactivityTimerTestSuite) TestRunnerIsReturnedAfterTimeout() {
+	s.True(tests.ChannelReceivesSomething(s.returned, 2*tests.ShortTimeout))
+}
+
+func (s *InactivityTimerTestSuite) TestRunnerIsNotReturnedBeforeTimeout() {
+	s.False(tests.ChannelReceivesSomething(s.returned, tests.ShortTimeout/2))
+}
+
+func (s *InactivityTimerTestSuite) TestResetTimeoutExtendsTheDeadline() {
+	time.Sleep(3 * tests.ShortTimeout / 4)
+	s.runner.ResetTimeout()
+	s.False(tests.ChannelReceivesSomething(s.returned, 3*tests.ShortTimeout/4),
+		"Because of the reset, the timeout should not be reached by now.")
+	s.True(tests.ChannelReceivesSomething(s.returned, 5*tests.ShortTimeout/4),
+		"After reset, the timout should be reached by now.")
+}
+
+func (s *InactivityTimerTestSuite) TestStopTimeoutStopsTimeout() {
+	s.runner.StopTimeout()
+	s.False(tests.ChannelReceivesSomething(s.returned, 2*tests.ShortTimeout))
+}
+
+func (s *InactivityTimerTestSuite) TestTimeoutPassedReturnsFalseBeforeDeadline() {
+	s.False(s.runner.TimeoutPassed())
+}
+
+func (s *InactivityTimerTestSuite) TestTimeoutPassedReturnsTrueAfterDeadline() {
+	time.Sleep(2 * tests.ShortTimeout)
+	s.True(s.runner.TimeoutPassed())
+}
+
+func (s *InactivityTimerTestSuite) TestTimerIsNotResetAfterDeadline() {
+	time.Sleep(2 * tests.ShortTimeout)
+	// We need to empty the returned channel so Return can send to it again.
+	tests.ChannelReceivesSomething(s.returned, 0)
+	s.runner.ResetTimeout()
+	s.False(tests.ChannelReceivesSomething(s.returned, 2*tests.ShortTimeout))
+}
+
+func (s *InactivityTimerTestSuite) TestSetupTimeoutStopsOldTimeout() {
+	s.runner.SetupTimeout(3 * tests.ShortTimeout)
+	s.False(tests.ChannelReceivesSomething(s.returned, 2*tests.ShortTimeout))
+	s.True(tests.ChannelReceivesSomething(s.returned, 2*tests.ShortTimeout))
+}
+
+func (s *InactivityTimerTestSuite) TestTimerIsInactiveWhenDurationIsZero() {
+	s.runner.SetupTimeout(0)
+	s.False(tests.ChannelReceivesSomething(s.returned, tests.ShortTimeout))
+}
+
+// NewRunner creates a new runner with the provided id and manager.
+func NewRunner(id string, manager Manager) Runner {
+	return NewNomadJob(id, nil, nil, manager)
+}