github.com/secure-build/gitlab-runner@v12.5.0+incompatible/executors/virtualbox/executor_virtualbox_test.go (about)

     1  package virtualbox_test
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  
    11  	"gitlab.com/gitlab-org/gitlab-runner/common"
    12  	"gitlab.com/gitlab-org/gitlab-runner/helpers"
    13  	"gitlab.com/gitlab-org/gitlab-runner/helpers/ssh"
    14  )
    15  
    16  const vboxImage = "ubuntu-runner"
    17  const vboxManage = "vboxmanage"
    18  
    19  var vboxSSHConfig = &ssh.Config{
    20  	User:     "vagrant",
    21  	Password: "vagrant",
    22  }
    23  
    24  func TestVirtualBoxExecutorRegistered(t *testing.T) {
    25  	executors := common.GetExecutors()
    26  	assert.Contains(t, executors, "virtualbox")
    27  }
    28  
    29  func TestVirtualBoxCreateExecutor(t *testing.T) {
    30  	executor := common.NewExecutor("virtualbox")
    31  	assert.NotNil(t, executor)
    32  }
    33  
    34  func TestVirtualBoxSuccessRun(t *testing.T) {
    35  	if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
    36  		return
    37  	}
    38  
    39  	successfulBuild, err := common.GetRemoteSuccessfulBuild()
    40  	assert.NoError(t, err)
    41  	build := &common.Build{
    42  		JobResponse: successfulBuild,
    43  		Runner: &common.RunnerConfig{
    44  			RunnerSettings: common.RunnerSettings{
    45  				Executor: "virtualbox",
    46  				VirtualBox: &common.VirtualBoxConfig{
    47  					BaseName:         vboxImage,
    48  					DisableSnapshots: true,
    49  				},
    50  				SSH: vboxSSHConfig,
    51  			},
    52  		},
    53  	}
    54  
    55  	err = build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
    56  	assert.NoError(t, err, "Make sure that you have done 'make -C tests/ubuntu virtualbox'")
    57  }
    58  
    59  func TestVirtualBoxBuildFail(t *testing.T) {
    60  	if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
    61  		return
    62  	}
    63  
    64  	failedBuild, err := common.GetRemoteFailedBuild()
    65  	assert.NoError(t, err)
    66  	build := &common.Build{
    67  		JobResponse: failedBuild,
    68  		Runner: &common.RunnerConfig{
    69  			RunnerSettings: common.RunnerSettings{
    70  				Executor: "virtualbox",
    71  				VirtualBox: &common.VirtualBoxConfig{
    72  					BaseName:         vboxImage,
    73  					DisableSnapshots: true,
    74  				},
    75  				SSH: vboxSSHConfig,
    76  			},
    77  		},
    78  	}
    79  
    80  	err = build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
    81  	require.Error(t, err, "error")
    82  	assert.IsType(t, err, &common.BuildError{})
    83  	assert.Contains(t, err.Error(), "Process exited with: 1")
    84  }
    85  
    86  func TestVirtualBoxMissingImage(t *testing.T) {
    87  	if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
    88  		return
    89  	}
    90  
    91  	build := &common.Build{
    92  		Runner: &common.RunnerConfig{
    93  			RunnerSettings: common.RunnerSettings{
    94  				Executor: "virtualbox",
    95  				VirtualBox: &common.VirtualBoxConfig{
    96  					BaseName:         "non-existing-image",
    97  					DisableSnapshots: true,
    98  				},
    99  				SSH: vboxSSHConfig,
   100  			},
   101  		},
   102  	}
   103  
   104  	err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
   105  	require.Error(t, err)
   106  	assert.Contains(t, err.Error(), "Could not find a registered machine named")
   107  }
   108  
   109  func TestVirtualBoxMissingSSHCredentials(t *testing.T) {
   110  	if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
   111  		return
   112  	}
   113  
   114  	build := &common.Build{
   115  		Runner: &common.RunnerConfig{
   116  			RunnerSettings: common.RunnerSettings{
   117  				Executor: "virtualbox",
   118  				VirtualBox: &common.VirtualBoxConfig{
   119  					BaseName:         "non-existing-image",
   120  					DisableSnapshots: true,
   121  				},
   122  			},
   123  		},
   124  	}
   125  
   126  	err := build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
   127  	require.Error(t, err)
   128  	assert.Contains(t, err.Error(), "Missing SSH config")
   129  }
   130  
   131  func TestVirtualBoxBuildAbort(t *testing.T) {
   132  	if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
   133  		return
   134  	}
   135  
   136  	longRunningBuild, err := common.GetRemoteLongRunningBuild()
   137  	assert.NoError(t, err)
   138  	build := &common.Build{
   139  		JobResponse: longRunningBuild,
   140  		Runner: &common.RunnerConfig{
   141  			RunnerSettings: common.RunnerSettings{
   142  				Executor: "virtualbox",
   143  				VirtualBox: &common.VirtualBoxConfig{
   144  					BaseName:         vboxImage,
   145  					DisableSnapshots: true,
   146  				},
   147  				SSH: vboxSSHConfig,
   148  			},
   149  		},
   150  		SystemInterrupt: make(chan os.Signal, 1),
   151  	}
   152  
   153  	abortTimer := time.AfterFunc(time.Second, func() {
   154  		t.Log("Interrupt")
   155  		build.SystemInterrupt <- os.Interrupt
   156  	})
   157  	defer abortTimer.Stop()
   158  
   159  	timeoutTimer := time.AfterFunc(time.Minute, func() {
   160  		t.Log("Timedout")
   161  		t.FailNow()
   162  	})
   163  	defer timeoutTimer.Stop()
   164  
   165  	err = build.Run(&common.Config{}, &common.Trace{Writer: os.Stdout})
   166  	assert.EqualError(t, err, "aborted: interrupt")
   167  }
   168  
   169  func TestVirtualBoxBuildCancel(t *testing.T) {
   170  	if helpers.SkipIntegrationTests(t, vboxManage, "--version") {
   171  		return
   172  	}
   173  
   174  	longRunningBuild, err := common.GetRemoteLongRunningBuild()
   175  	assert.NoError(t, err)
   176  	build := &common.Build{
   177  		JobResponse: longRunningBuild,
   178  		Runner: &common.RunnerConfig{
   179  			RunnerSettings: common.RunnerSettings{
   180  				Executor: "virtualbox",
   181  				VirtualBox: &common.VirtualBoxConfig{
   182  					BaseName:         vboxImage,
   183  					DisableSnapshots: true,
   184  				},
   185  				SSH: vboxSSHConfig,
   186  			},
   187  		},
   188  	}
   189  
   190  	trace := &common.Trace{Writer: os.Stdout}
   191  
   192  	abortTimer := time.AfterFunc(time.Second, func() {
   193  		t.Log("Interrupt")
   194  		trace.CancelFunc()
   195  	})
   196  	defer abortTimer.Stop()
   197  
   198  	timeoutTimer := time.AfterFunc(time.Minute, func() {
   199  		t.Log("Timedout")
   200  		t.FailNow()
   201  	})
   202  	defer timeoutTimer.Stop()
   203  
   204  	err = build.Run(&common.Config{}, trace)
   205  	assert.IsType(t, err, &common.BuildError{})
   206  	assert.EqualError(t, err, "canceled")
   207  }