github.com/secure-build/gitlab-runner@v12.5.0+incompatible/commands/helpers/artifacts_uploader_test.go (about)

     1  package helpers
     2  
     3  import (
     4  	"os"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"gitlab.com/gitlab-org/gitlab-runner/common"
    10  	"gitlab.com/gitlab-org/gitlab-runner/helpers"
    11  )
    12  
    13  var UploaderCredentials = common.JobCredentials{
    14  	ID:    1000,
    15  	Token: "test",
    16  	URL:   "test",
    17  }
    18  
    19  func TestArtifactsUploaderRequirements(t *testing.T) {
    20  	removeHook := helpers.MakeFatalToPanic()
    21  	defer removeHook()
    22  
    23  	cmd := ArtifactsUploaderCommand{}
    24  	assert.Panics(t, func() {
    25  		cmd.Execute(nil)
    26  	})
    27  }
    28  
    29  func TestArtifactsUploaderTooLarge(t *testing.T) {
    30  	network := &testNetwork{
    31  		uploadState: common.UploadTooLarge,
    32  	}
    33  	cmd := ArtifactsUploaderCommand{
    34  		JobCredentials: UploaderCredentials,
    35  		network:        network,
    36  		fileArchiver: fileArchiver{
    37  			Paths: []string{artifactsTestArchivedFile},
    38  		},
    39  	}
    40  
    41  	writeTestFile(t, artifactsTestArchivedFile)
    42  	defer os.Remove(artifactsTestArchivedFile)
    43  
    44  	removeHook := helpers.MakeFatalToPanic()
    45  	defer removeHook()
    46  
    47  	assert.Panics(t, func() {
    48  		cmd.Execute(nil)
    49  	})
    50  
    51  	assert.Equal(t, 1, network.uploadCalled)
    52  }
    53  
    54  func TestArtifactsUploaderForbidden(t *testing.T) {
    55  	network := &testNetwork{
    56  		uploadState: common.UploadForbidden,
    57  	}
    58  	cmd := ArtifactsUploaderCommand{
    59  		JobCredentials: UploaderCredentials,
    60  		network:        network,
    61  		fileArchiver: fileArchiver{
    62  			Paths: []string{artifactsTestArchivedFile},
    63  		},
    64  	}
    65  
    66  	writeTestFile(t, artifactsTestArchivedFile)
    67  	defer os.Remove(artifactsTestArchivedFile)
    68  
    69  	removeHook := helpers.MakeFatalToPanic()
    70  	defer removeHook()
    71  
    72  	assert.Panics(t, func() {
    73  		cmd.Execute(nil)
    74  	})
    75  
    76  	assert.Equal(t, 1, network.uploadCalled)
    77  }
    78  
    79  func TestArtifactsUploaderRetry(t *testing.T) {
    80  	network := &testNetwork{
    81  		uploadState: common.UploadFailed,
    82  	}
    83  	cmd := ArtifactsUploaderCommand{
    84  		JobCredentials: UploaderCredentials,
    85  		network:        network,
    86  		retryHelper: retryHelper{
    87  			Retry: 2,
    88  		},
    89  		fileArchiver: fileArchiver{
    90  			Paths: []string{artifactsTestArchivedFile},
    91  		},
    92  	}
    93  
    94  	writeTestFile(t, artifactsTestArchivedFile)
    95  	defer os.Remove(artifactsTestArchivedFile)
    96  
    97  	removeHook := helpers.MakeFatalToPanic()
    98  	defer removeHook()
    99  
   100  	assert.Panics(t, func() {
   101  		cmd.Execute(nil)
   102  	})
   103  
   104  	assert.Equal(t, 3, network.uploadCalled)
   105  }
   106  
   107  func TestArtifactsUploaderDefaultSucceeded(t *testing.T) {
   108  	network := &testNetwork{
   109  		uploadState: common.UploadSucceeded,
   110  	}
   111  	cmd := ArtifactsUploaderCommand{
   112  		JobCredentials: UploaderCredentials,
   113  		network:        network,
   114  		fileArchiver: fileArchiver{
   115  			Paths: []string{artifactsTestArchivedFile},
   116  		},
   117  	}
   118  
   119  	writeTestFile(t, artifactsTestArchivedFile)
   120  	defer os.Remove(artifactsTestArchivedFile)
   121  
   122  	cmd.Execute(nil)
   123  	assert.Equal(t, 1, network.uploadCalled)
   124  	assert.Equal(t, common.ArtifactFormatZip, network.uploadFormat)
   125  	assert.Equal(t, DefaultUploadName+".zip", network.uploadName)
   126  	assert.Empty(t, network.uploadType)
   127  }
   128  
   129  func TestArtifactsUploaderZipSucceeded(t *testing.T) {
   130  	network := &testNetwork{
   131  		uploadState: common.UploadSucceeded,
   132  	}
   133  	cmd := ArtifactsUploaderCommand{
   134  		JobCredentials: UploaderCredentials,
   135  		Format:         common.ArtifactFormatZip,
   136  		Name:           "my-release",
   137  		Type:           "my-type",
   138  		network:        network,
   139  		fileArchiver: fileArchiver{
   140  			Paths: []string{artifactsTestArchivedFile},
   141  		},
   142  	}
   143  
   144  	writeTestFile(t, artifactsTestArchivedFile)
   145  	defer os.Remove(artifactsTestArchivedFile)
   146  
   147  	cmd.Execute(nil)
   148  	assert.Equal(t, 1, network.uploadCalled)
   149  	assert.Equal(t, common.ArtifactFormatZip, network.uploadFormat)
   150  	assert.Equal(t, "my-release.zip", network.uploadName)
   151  	assert.Equal(t, "my-type", network.uploadType)
   152  	assert.Contains(t, network.uploadedFiles, artifactsTestArchivedFile)
   153  }
   154  
   155  func TestArtifactsUploaderGzipSendsMultipleFiles(t *testing.T) {
   156  	network := &testNetwork{
   157  		uploadState: common.UploadSucceeded,
   158  	}
   159  	cmd := ArtifactsUploaderCommand{
   160  		JobCredentials: UploaderCredentials,
   161  		Format:         common.ArtifactFormatGzip,
   162  		Name:           "junit.xml",
   163  		Type:           "junit",
   164  		network:        network,
   165  		fileArchiver: fileArchiver{
   166  			Paths: []string{artifactsTestArchivedFile, artifactsTestArchivedFile2},
   167  		},
   168  	}
   169  
   170  	writeTestFile(t, artifactsTestArchivedFile)
   171  	defer os.Remove(artifactsTestArchivedFile)
   172  
   173  	writeTestFile(t, artifactsTestArchivedFile2)
   174  	defer os.Remove(artifactsTestArchivedFile)
   175  
   176  	cmd.Execute(nil)
   177  	assert.Equal(t, 1, network.uploadCalled)
   178  	assert.Equal(t, "junit.xml.gz", network.uploadName)
   179  	assert.Equal(t, common.ArtifactFormatGzip, network.uploadFormat)
   180  	assert.Equal(t, "junit", network.uploadType)
   181  	assert.Contains(t, network.uploadedFiles, artifactsTestArchivedFile)
   182  	assert.Contains(t, network.uploadedFiles, artifactsTestArchivedFile2)
   183  }
   184  
   185  func TestArtifactsUploaderRawSucceeded(t *testing.T) {
   186  	network := &testNetwork{
   187  		uploadState: common.UploadSucceeded,
   188  	}
   189  	cmd := ArtifactsUploaderCommand{
   190  		JobCredentials: UploaderCredentials,
   191  		Format:         common.ArtifactFormatRaw,
   192  		Name:           "my-release",
   193  		Type:           "my-type",
   194  		network:        network,
   195  		fileArchiver: fileArchiver{
   196  			Paths: []string{artifactsTestArchivedFile},
   197  		},
   198  	}
   199  
   200  	writeTestFile(t, artifactsTestArchivedFile)
   201  	defer os.Remove(artifactsTestArchivedFile)
   202  
   203  	cmd.Execute(nil)
   204  	assert.Equal(t, 1, network.uploadCalled)
   205  	assert.Equal(t, common.ArtifactFormatRaw, network.uploadFormat)
   206  	assert.Equal(t, "my-release", network.uploadName)
   207  	assert.Equal(t, "my-type", network.uploadType)
   208  	assert.Contains(t, network.uploadedFiles, "raw")
   209  }
   210  
   211  func TestArtifactsUploaderRawDoesNotSendMultipleFiles(t *testing.T) {
   212  	network := &testNetwork{
   213  		uploadState: common.UploadSucceeded,
   214  	}
   215  	cmd := ArtifactsUploaderCommand{
   216  		JobCredentials: UploaderCredentials,
   217  		Format:         common.ArtifactFormatRaw,
   218  		Name:           "junit.xml",
   219  		Type:           "junit",
   220  		network:        network,
   221  		fileArchiver: fileArchiver{
   222  			Paths: []string{artifactsTestArchivedFile, artifactsTestArchivedFile2},
   223  		},
   224  	}
   225  
   226  	writeTestFile(t, artifactsTestArchivedFile)
   227  	defer os.Remove(artifactsTestArchivedFile)
   228  
   229  	writeTestFile(t, artifactsTestArchivedFile2)
   230  	defer os.Remove(artifactsTestArchivedFile)
   231  
   232  	removeHook := helpers.MakeFatalToPanic()
   233  	defer removeHook()
   234  
   235  	assert.Panics(t, func() {
   236  		cmd.Execute(nil)
   237  	})
   238  }
   239  
   240  func TestArtifactsUploaderNoFilesDoNotGenerateError(t *testing.T) {
   241  	network := &testNetwork{
   242  		uploadState: common.UploadSucceeded,
   243  	}
   244  	cmd := ArtifactsUploaderCommand{
   245  		JobCredentials: UploaderCredentials,
   246  		network:        network,
   247  		fileArchiver:   fileArchiver{},
   248  	}
   249  
   250  	removeHook := helpers.MakeFatalToPanic()
   251  	defer removeHook()
   252  
   253  	assert.NotPanics(t, func() {
   254  		cmd.Execute(nil)
   255  	})
   256  }