1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
//go:build !integration
// +build !integration
package s3
import (
"errors"
"net/url"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"gitlab.com/gitlab-org/gitlab-runner/cache"
"gitlab.com/gitlab-org/gitlab-runner/common"
)
var defaultTimeout = 1 * time.Hour
const (
bucketName = "test"
objectName = "key"
bucketLocation = "location"
)
func defaultCacheFactory() *common.CacheConfig {
return &common.CacheConfig{
Type: "s3",
S3: &common.CacheS3Config{
ServerAddress: "server.com",
AccessKey: "access",
SecretKey: "key",
BucketName: bucketName,
BucketLocation: bucketLocation},
}
}
type cacheOperationTest struct {
errorOnMinioClientInitialization bool
errorOnURLPresigning bool
presignedURL *url.URL
expectedURL *url.URL
}
func onFakeMinioURLGenerator(tc cacheOperationTest) func() {
client := new(mockMinioClient)
var err error
if tc.errorOnURLPresigning {
err = errors.New("test error")
}
client.
On("PresignedGetObject", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).
Return(tc.presignedURL, err)
client.
On("PresignedPutObject", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
Return(tc.presignedURL, err)
oldNewMinioURLGenerator := newMinioClient
newMinioClient = func(s3 *common.CacheS3Config) (minioClient, error) {
if tc.errorOnMinioClientInitialization {
return nil, errors.New("test error")
}
return client, nil
}
return func() {
newMinioClient = oldNewMinioURLGenerator
}
}
func testCacheOperation(
t *testing.T,
operationName string,
operation func(adapter cache.Adapter) *url.URL,
tc cacheOperationTest,
) {
t.Run(operationName, func(t *testing.T) {
cleanupMinioURLGeneratorMock := onFakeMinioURLGenerator(tc)
defer cleanupMinioURLGeneratorMock()
cacheConfig := defaultCacheFactory()
adapter, err := New(cacheConfig, defaultTimeout, objectName)
if tc.errorOnMinioClientInitialization {
assert.EqualError(t, err, "error while creating S3 cache storage client: test error")
return
}
require.NoError(t, err)
URL := operation(adapter)
assert.Equal(t, tc.expectedURL, URL)
headers := adapter.GetUploadHeaders()
assert.Nil(t, headers)
assert.Nil(t, adapter.GetGoCloudURL())
assert.Empty(t, adapter.GetUploadEnv())
})
}
func TestCacheOperation(t *testing.T) {
URL, err := url.Parse("https://s3.example.com")
require.NoError(t, err)
tests := map[string]cacheOperationTest{
"error-on-minio-client-initialization": {
errorOnMinioClientInitialization: true,
},
"error-on-presigning-url": {
errorOnURLPresigning: true,
presignedURL: URL,
expectedURL: nil,
},
"presigned-url": {
presignedURL: URL,
expectedURL: URL,
},
}
for testName, test := range tests {
t.Run(testName, func(t *testing.T) {
testCacheOperation(
t,
"GetDownloadURL",
func(adapter cache.Adapter) *url.URL { return adapter.GetDownloadURL() },
test,
)
testCacheOperation(
t,
"GetUploadURL",
func(adapter cache.Adapter) *url.URL { return adapter.GetUploadURL() },
test,
)
})
}
}
func TestNoConfiguration(t *testing.T) {
s3Cache := defaultCacheFactory()
s3Cache.S3 = nil
adapter, err := New(s3Cache, defaultTimeout, objectName)
assert.Nil(t, adapter)
assert.EqualError(t, err, "missing S3 configuration")
}
|
