From be1ed50ac47a5db425dd71180dd714cbad389302 Mon Sep 17 00:00:00 2001 From: pa250194 Date: Fri, 10 Sep 2021 16:01:16 -0500 Subject: [PATCH] Service Account Key Authentication to GCP Provider Signed-off-by: pa250194 --- go.mod | 1 + go.sum | 1 + pkg/gcp/gcp.go | 2 +- pkg/gcp/gcp_test.go | 1 - pkg/gcp/mocks/mock_gcp_storage.go | 211 ++++++++++++++++++++++++++++++ 5 files changed, 214 insertions(+), 2 deletions(-) create mode 100644 pkg/gcp/mocks/mock_gcp_storage.go diff --git a/go.mod b/go.mod index 8fabe102..07b8d82e 100644 --- a/go.mod +++ b/go.mod @@ -23,6 +23,7 @@ require ( github.com/go-git/go-git/v5 v5.4.2 github.com/go-logr/logr v0.4.0 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/golang/mock v1.6.0 // indirect github.com/googleapis/gax-go/v2 v2.1.0 // indirect github.com/libgit2/git2go/v31 v31.6.1 github.com/minio/minio-go/v7 v7.0.10 diff --git a/go.sum b/go.sum index 34c48c50..75df5bf5 100644 --- a/go.sum +++ b/go.sum @@ -419,6 +419,7 @@ github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= diff --git a/pkg/gcp/gcp.go b/pkg/gcp/gcp.go index 38a0b99f..cd4bedac 100644 --- a/pkg/gcp/gcp.go +++ b/pkg/gcp/gcp.go @@ -127,7 +127,7 @@ func (c *GCPClient) FGetObject(ctx context.Context, bucketName, objectName, loca return err } if !exists { - return ErrorObjectDoesNotExist + return ObjectDoesNotExist } objectFile, err := os.OpenFile(localPath, os.O_CREATE|os.O_WRONLY, 0600) diff --git a/pkg/gcp/gcp_test.go b/pkg/gcp/gcp_test.go index 99d72309..f6618498 100644 --- a/pkg/gcp/gcp_test.go +++ b/pkg/gcp/gcp_test.go @@ -30,7 +30,6 @@ import ( "os" "path/filepath" "testing" - "time" gcpstorage "cloud.google.com/go/storage" "github.com/fluxcd/source-controller/pkg/gcp" diff --git a/pkg/gcp/mocks/mock_gcp_storage.go b/pkg/gcp/mocks/mock_gcp_storage.go new file mode 100644 index 00000000..54b78be1 --- /dev/null +++ b/pkg/gcp/mocks/mock_gcp_storage.go @@ -0,0 +1,211 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: gcp.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + context "context" + reflect "reflect" + + storage "cloud.google.com/go/storage" + gomock "github.com/golang/mock/gomock" +) + +// MockClient is a mock of Client interface. +type MockClient struct { + ctrl *gomock.Controller + recorder *MockClientMockRecorder +} + +// MockClientMockRecorder is the mock recorder for MockClient. +type MockClientMockRecorder struct { + mock *MockClient +} + +// NewMockClient creates a new mock instance. +func NewMockClient(ctrl *gomock.Controller) *MockClient { + mock := &MockClient{ctrl: ctrl} + mock.recorder = &MockClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockClient) EXPECT() *MockClientMockRecorder { + return m.recorder +} + +// Bucket mocks base method. +func (m *MockClient) Bucket(arg0 string) *storage.BucketHandle { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Bucket", arg0) + ret0, _ := ret[0].(*storage.BucketHandle) + return ret0 +} + +// Bucket indicates an expected call of Bucket. +func (mr *MockClientMockRecorder) Bucket(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bucket", reflect.TypeOf((*MockClient)(nil).Bucket), arg0) +} + +// Close mocks base method. +func (m *MockClient) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockClientMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close)) +} + +// MockBucketHandle is a mock of BucketHandle interface. +type MockBucketHandle struct { + ctrl *gomock.Controller + recorder *MockBucketHandleMockRecorder +} + +// MockBucketHandleMockRecorder is the mock recorder for MockBucketHandle. +type MockBucketHandleMockRecorder struct { + mock *MockBucketHandle +} + +// NewMockBucketHandle creates a new mock instance. +func NewMockBucketHandle(ctrl *gomock.Controller) *MockBucketHandle { + mock := &MockBucketHandle{ctrl: ctrl} + mock.recorder = &MockBucketHandleMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBucketHandle) EXPECT() *MockBucketHandleMockRecorder { + return m.recorder +} + +// Attrs mocks base method. +func (m *MockBucketHandle) Attrs(arg0 context.Context) (*storage.BucketAttrs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Attrs", arg0) + ret0, _ := ret[0].(*storage.BucketAttrs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Attrs indicates an expected call of Attrs. +func (mr *MockBucketHandleMockRecorder) Attrs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockBucketHandle)(nil).Attrs), arg0) +} + +// Create mocks base method. +func (m *MockBucketHandle) Create(arg0 context.Context, arg1 string, arg2 *storage.BucketAttrs) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2) + ret0, _ := ret[0].(error) + return ret0 +} + +// Create indicates an expected call of Create. +func (mr *MockBucketHandleMockRecorder) Create(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockBucketHandle)(nil).Create), arg0, arg1, arg2) +} + +// Delete mocks base method. +func (m *MockBucketHandle) Delete(arg0 context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockBucketHandleMockRecorder) Delete(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBucketHandle)(nil).Delete), arg0) +} + +// Object mocks base method. +func (m *MockBucketHandle) Object(arg0 string) *storage.ObjectHandle { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Object", arg0) + ret0, _ := ret[0].(*storage.ObjectHandle) + return ret0 +} + +// Object indicates an expected call of Object. +func (mr *MockBucketHandleMockRecorder) Object(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Object", reflect.TypeOf((*MockBucketHandle)(nil).Object), arg0) +} + +// Objects mocks base method. +func (m *MockBucketHandle) Objects(arg0 context.Context, arg1 *storage.Query) *storage.ObjectIterator { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Objects", arg0, arg1) + ret0, _ := ret[0].(*storage.ObjectIterator) + return ret0 +} + +// Objects indicates an expected call of Objects. +func (mr *MockBucketHandleMockRecorder) Objects(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Objects", reflect.TypeOf((*MockBucketHandle)(nil).Objects), arg0, arg1) +} + +// MockObjectHandle is a mock of ObjectHandle interface. +type MockObjectHandle struct { + ctrl *gomock.Controller + recorder *MockObjectHandleMockRecorder +} + +// MockObjectHandleMockRecorder is the mock recorder for MockObjectHandle. +type MockObjectHandleMockRecorder struct { + mock *MockObjectHandle +} + +// NewMockObjectHandle creates a new mock instance. +func NewMockObjectHandle(ctrl *gomock.Controller) *MockObjectHandle { + mock := &MockObjectHandle{ctrl: ctrl} + mock.recorder = &MockObjectHandleMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockObjectHandle) EXPECT() *MockObjectHandleMockRecorder { + return m.recorder +} + +// Attrs mocks base method. +func (m *MockObjectHandle) Attrs(arg0 context.Context) (*storage.ObjectAttrs, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Attrs", arg0) + ret0, _ := ret[0].(*storage.ObjectAttrs) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Attrs indicates an expected call of Attrs. +func (mr *MockObjectHandleMockRecorder) Attrs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockObjectHandle)(nil).Attrs), arg0) +} + +// NewRangeReader mocks base method. +func (m *MockObjectHandle) NewRangeReader(arg0 context.Context, arg1, arg2 int64) (*storage.Reader, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NewRangeReader", arg0, arg1, arg2) + ret0, _ := ret[0].(*storage.Reader) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// NewRangeReader indicates an expected call of NewRangeReader. +func (mr *MockObjectHandleMockRecorder) NewRangeReader(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRangeReader", reflect.TypeOf((*MockObjectHandle)(nil).NewRangeReader), arg0, arg1, arg2) +}