From 523800dd64d545b3c4b4fadf6ae365e9fe6da660 Mon Sep 17 00:00:00 2001 From: Matthew Wong Date: Wed, 21 Apr 2021 12:44:13 -0700 Subject: [PATCH] Fix broken gomocks --- Makefile | 2 +- hack/update-gomock | 11 +- pkg/cloud/cloud.go | 35 --- pkg/cloud/cloud_interface.go | 34 +++ pkg/cloud/ec2_interface.go | 48 ++++ pkg/cloud/metadata.go | 16 -- pkg/cloud/mocks/mock_ec2.go | 192 ++++++++++------ pkg/cloud/mocks/mock_ec2metadata.go | 79 ------- pkg/driver/mocks/mock_cloud.go | 208 +++++++++++++----- pkg/driver/mocks/mock_metadata_service.go | 105 --------- .../mocks/{mock_mounter.go => mock_mount.go} | 118 +++++----- 11 files changed, 426 insertions(+), 422 deletions(-) create mode 100644 pkg/cloud/cloud_interface.go create mode 100644 pkg/cloud/ec2_interface.go delete mode 100644 pkg/cloud/mocks/mock_ec2metadata.go delete mode 100644 pkg/driver/mocks/mock_metadata_service.go rename pkg/driver/mocks/{mock_mounter.go => mock_mount.go} (58%) diff --git a/Makefile b/Makefile index 2ff18e072e..7634351a55 100644 --- a/Makefile +++ b/Makefile @@ -45,7 +45,7 @@ bin/kubeval: | /tmp/kubeval bin @rm -rf /tmp/kubeval/* bin/mockgen: | bin - go get github.com/golang/mock/mockgen@latest + go get github.com/golang/mock/mockgen@v1.5.0 bin/golangci-lint: | bin echo "Installing golangci-lint..." diff --git a/hack/update-gomock b/hack/update-gomock index 73db48a973..e8c490e7e3 100755 --- a/hack/update-gomock +++ b/hack/update-gomock @@ -16,11 +16,6 @@ set -euo pipefail -IMPORT_PATH=github.com/kubernetes-sigs/aws-ebs-csi-driver - -./bin/mockgen -package=mocks -destination=./pkg/cloud/mocks/mock_ec2.go ${IMPORT_PATH}/pkg/cloud EC2 -./bin/mockgen -package=mocks -destination=./pkg/cloud/mocks/mock_ec2metadata.go ${IMPORT_PATH}/pkg/cloud EC2Metadata -./bin/mockgen -package=mocks -destination=./pkg/driver/mocks/mock_cloud.go ${IMPORT_PATH}/pkg/cloud Cloud -./bin/mockgen -package=mocks -destination=./pkg/driver/mocks/mock_metadata_service.go ${IMPORT_PATH}/pkg/cloud MetadataService -./bin/mockgen -package=mocks -destination=./pkg/driver/mocks/mock_mounter.go ${IMPORT_PATH}/pkg/driver Mounter - +./bin/mockgen -package mocks -destination=./pkg/cloud/mocks/mock_ec2.go -source pkg/cloud/ec2_interface.go +./bin/mockgen -package mocks -destination=./pkg/driver/mocks/mock_cloud.go -source pkg/cloud/cloud_interface.go +./bin/mockgen -package mocks -destination=./pkg/driver/mocks/mock_mount.go -source pkg/driver/mount.go diff --git a/pkg/cloud/cloud.go b/pkg/cloud/cloud.go index dbe341679a..48fa7aeb83 100644 --- a/pkg/cloud/cloud.go +++ b/pkg/cloud/cloud.go @@ -26,7 +26,6 @@ import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" - "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/ec2" dm "github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/cloud/devicemanager" @@ -207,40 +206,6 @@ type ec2ListSnapshotsResponse struct { NextToken *string } -// EC2 abstracts aws.EC2 to facilitate its mocking. -// See https://docs.aws.amazon.com/sdk-for-go/api/service/ec2/ for details -type EC2 interface { - DescribeVolumesWithContext(ctx aws.Context, input *ec2.DescribeVolumesInput, opts ...request.Option) (*ec2.DescribeVolumesOutput, error) - CreateVolumeWithContext(ctx aws.Context, input *ec2.CreateVolumeInput, opts ...request.Option) (*ec2.Volume, error) - DeleteVolumeWithContext(ctx aws.Context, input *ec2.DeleteVolumeInput, opts ...request.Option) (*ec2.DeleteVolumeOutput, error) - DetachVolumeWithContext(ctx aws.Context, input *ec2.DetachVolumeInput, opts ...request.Option) (*ec2.VolumeAttachment, error) - AttachVolumeWithContext(ctx aws.Context, input *ec2.AttachVolumeInput, opts ...request.Option) (*ec2.VolumeAttachment, error) - DescribeInstancesWithContext(ctx aws.Context, input *ec2.DescribeInstancesInput, opts ...request.Option) (*ec2.DescribeInstancesOutput, error) - CreateSnapshotWithContext(ctx aws.Context, input *ec2.CreateSnapshotInput, opts ...request.Option) (*ec2.Snapshot, error) - DeleteSnapshotWithContext(ctx aws.Context, input *ec2.DeleteSnapshotInput, opts ...request.Option) (*ec2.DeleteSnapshotOutput, error) - DescribeSnapshotsWithContext(ctx aws.Context, input *ec2.DescribeSnapshotsInput, opts ...request.Option) (*ec2.DescribeSnapshotsOutput, error) - ModifyVolumeWithContext(ctx aws.Context, input *ec2.ModifyVolumeInput, opts ...request.Option) (*ec2.ModifyVolumeOutput, error) - DescribeVolumesModificationsWithContext(ctx aws.Context, input *ec2.DescribeVolumesModificationsInput, opts ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) - DescribeAvailabilityZonesWithContext(ctx aws.Context, input *ec2.DescribeAvailabilityZonesInput, opts ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) -} - -type Cloud interface { - CreateDisk(ctx context.Context, volumeName string, diskOptions *DiskOptions) (disk *Disk, err error) - DeleteDisk(ctx context.Context, volumeID string) (success bool, err error) - AttachDisk(ctx context.Context, volumeID string, nodeID string) (devicePath string, err error) - DetachDisk(ctx context.Context, volumeID string, nodeID string) (err error) - ResizeDisk(ctx context.Context, volumeID string, reqSize int64) (newSize int64, err error) - WaitForAttachmentState(ctx context.Context, volumeID, expectedState string, expectedInstance string, expectedDevice string, alreadyAssigned bool) (*ec2.VolumeAttachment, error) - GetDiskByName(ctx context.Context, name string, capacityBytes int64) (disk *Disk, err error) - GetDiskByID(ctx context.Context, volumeID string) (disk *Disk, err error) - IsExistInstance(ctx context.Context, nodeID string) (success bool) - CreateSnapshot(ctx context.Context, volumeID string, snapshotOptions *SnapshotOptions) (snapshot *Snapshot, err error) - DeleteSnapshot(ctx context.Context, snapshotID string) (success bool, err error) - GetSnapshotByName(ctx context.Context, name string) (snapshot *Snapshot, err error) - GetSnapshotByID(ctx context.Context, snapshotID string) (snapshot *Snapshot, err error) - ListSnapshots(ctx context.Context, volumeID string, maxResults int64, nextToken string) (listSnapshotsResponse *ListSnapshotsResponse, err error) -} - type cloud struct { region string ec2 EC2 diff --git a/pkg/cloud/cloud_interface.go b/pkg/cloud/cloud_interface.go new file mode 100644 index 0000000000..77ae1f2dff --- /dev/null +++ b/pkg/cloud/cloud_interface.go @@ -0,0 +1,34 @@ +package cloud + +import ( + "context" + + "github.com/aws/aws-sdk-go/aws/arn" + "github.com/aws/aws-sdk-go/service/ec2" +) + +type Cloud interface { + CreateDisk(ctx context.Context, volumeName string, diskOptions *DiskOptions) (disk *Disk, err error) + DeleteDisk(ctx context.Context, volumeID string) (success bool, err error) + AttachDisk(ctx context.Context, volumeID string, nodeID string) (devicePath string, err error) + DetachDisk(ctx context.Context, volumeID string, nodeID string) (err error) + ResizeDisk(ctx context.Context, volumeID string, reqSize int64) (newSize int64, err error) + WaitForAttachmentState(ctx context.Context, volumeID, expectedState string, expectedInstance string, expectedDevice string, alreadyAssigned bool) (*ec2.VolumeAttachment, error) + GetDiskByName(ctx context.Context, name string, capacityBytes int64) (disk *Disk, err error) + GetDiskByID(ctx context.Context, volumeID string) (disk *Disk, err error) + IsExistInstance(ctx context.Context, nodeID string) (success bool) + CreateSnapshot(ctx context.Context, volumeID string, snapshotOptions *SnapshotOptions) (snapshot *Snapshot, err error) + DeleteSnapshot(ctx context.Context, snapshotID string) (success bool, err error) + GetSnapshotByName(ctx context.Context, name string) (snapshot *Snapshot, err error) + GetSnapshotByID(ctx context.Context, snapshotID string) (snapshot *Snapshot, err error) + ListSnapshots(ctx context.Context, volumeID string, maxResults int64, nextToken string) (listSnapshotsResponse *ListSnapshotsResponse, err error) +} + +// MetadataService represents AWS metadata service. +type MetadataService interface { + GetInstanceID() string + GetInstanceType() string + GetRegion() string + GetAvailabilityZone() string + GetOutpostArn() arn.ARN +} diff --git a/pkg/cloud/ec2_interface.go b/pkg/cloud/ec2_interface.go new file mode 100644 index 0000000000..b85d6670bd --- /dev/null +++ b/pkg/cloud/ec2_interface.go @@ -0,0 +1,48 @@ +/* +Copyright 2019 The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package cloud + +import ( + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/ec2metadata" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/ec2" +) + +// EC2 abstracts aws.EC2 to facilitate its mocking. +// See https://docs.aws.amazon.com/sdk-for-go/api/service/ec2/ for details +type EC2 interface { + DescribeVolumesWithContext(ctx aws.Context, input *ec2.DescribeVolumesInput, opts ...request.Option) (*ec2.DescribeVolumesOutput, error) + CreateVolumeWithContext(ctx aws.Context, input *ec2.CreateVolumeInput, opts ...request.Option) (*ec2.Volume, error) + DeleteVolumeWithContext(ctx aws.Context, input *ec2.DeleteVolumeInput, opts ...request.Option) (*ec2.DeleteVolumeOutput, error) + DetachVolumeWithContext(ctx aws.Context, input *ec2.DetachVolumeInput, opts ...request.Option) (*ec2.VolumeAttachment, error) + AttachVolumeWithContext(ctx aws.Context, input *ec2.AttachVolumeInput, opts ...request.Option) (*ec2.VolumeAttachment, error) + DescribeInstancesWithContext(ctx aws.Context, input *ec2.DescribeInstancesInput, opts ...request.Option) (*ec2.DescribeInstancesOutput, error) + CreateSnapshotWithContext(ctx aws.Context, input *ec2.CreateSnapshotInput, opts ...request.Option) (*ec2.Snapshot, error) + DeleteSnapshotWithContext(ctx aws.Context, input *ec2.DeleteSnapshotInput, opts ...request.Option) (*ec2.DeleteSnapshotOutput, error) + DescribeSnapshotsWithContext(ctx aws.Context, input *ec2.DescribeSnapshotsInput, opts ...request.Option) (*ec2.DescribeSnapshotsOutput, error) + ModifyVolumeWithContext(ctx aws.Context, input *ec2.ModifyVolumeInput, opts ...request.Option) (*ec2.ModifyVolumeOutput, error) + DescribeVolumesModificationsWithContext(ctx aws.Context, input *ec2.DescribeVolumesModificationsInput, opts ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) + DescribeAvailabilityZonesWithContext(ctx aws.Context, input *ec2.DescribeAvailabilityZonesInput, opts ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) +} + +type EC2Metadata interface { + Available() bool + // ec2 instance metadata endpoints: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html + GetMetadata(string) (string, error) + GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) +} diff --git a/pkg/cloud/metadata.go b/pkg/cloud/metadata.go index 60f6cf78c8..b1bc9727f7 100644 --- a/pkg/cloud/metadata.go +++ b/pkg/cloud/metadata.go @@ -28,22 +28,6 @@ import ( "k8s.io/klog" ) -type EC2Metadata interface { - Available() bool - // ec2 instance metadata endpoints: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html - GetMetadata(string) (string, error) - GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) -} - -// MetadataService represents AWS metadata service. -type MetadataService interface { - GetInstanceID() string - GetInstanceType() string - GetRegion() string - GetAvailabilityZone() string - GetOutpostArn() arn.ARN -} - type Metadata struct { InstanceID string InstanceType string diff --git a/pkg/cloud/mocks/mock_ec2.go b/pkg/cloud/mocks/mock_ec2.go index 82d3da1384..fae1bd29b6 100644 --- a/pkg/cloud/mocks/mock_ec2.go +++ b/pkg/cloud/mocks/mock_ec2.go @@ -1,13 +1,14 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/cloud (interfaces: EC2) +// Source: pkg/cloud/ec2_interface.go // Package mocks is a generated GoMock package. package mocks import ( - context "context" reflect "reflect" + aws "github.com/aws/aws-sdk-go/aws" + ec2metadata "github.com/aws/aws-sdk-go/aws/ec2metadata" request "github.com/aws/aws-sdk-go/aws/request" ec2 "github.com/aws/aws-sdk-go/service/ec2" gomock "github.com/golang/mock/gomock" @@ -37,10 +38,10 @@ func (m *MockEC2) EXPECT() *MockEC2MockRecorder { } // AttachVolumeWithContext mocks base method. -func (m *MockEC2) AttachVolumeWithContext(arg0 context.Context, arg1 *ec2.AttachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { +func (m *MockEC2) AttachVolumeWithContext(ctx aws.Context, input *ec2.AttachVolumeInput, opts ...request.Option) (*ec2.VolumeAttachment, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AttachVolumeWithContext", varargs...) @@ -50,17 +51,17 @@ func (m *MockEC2) AttachVolumeWithContext(arg0 context.Context, arg1 *ec2.Attach } // AttachVolumeWithContext indicates an expected call of AttachVolumeWithContext. -func (mr *MockEC2MockRecorder) AttachVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) AttachVolumeWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).AttachVolumeWithContext), varargs...) } // CreateSnapshotWithContext mocks base method. -func (m *MockEC2) CreateSnapshotWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotInput, arg2 ...request.Option) (*ec2.Snapshot, error) { +func (m *MockEC2) CreateSnapshotWithContext(ctx aws.Context, input *ec2.CreateSnapshotInput, opts ...request.Option) (*ec2.Snapshot, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...) @@ -70,17 +71,17 @@ func (m *MockEC2) CreateSnapshotWithContext(arg0 context.Context, arg1 *ec2.Crea } // CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext. -func (mr *MockEC2MockRecorder) CreateSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) CreateSnapshotWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSnapshotWithContext), varargs...) } // CreateVolumeWithContext mocks base method. -func (m *MockEC2) CreateVolumeWithContext(arg0 context.Context, arg1 *ec2.CreateVolumeInput, arg2 ...request.Option) (*ec2.Volume, error) { +func (m *MockEC2) CreateVolumeWithContext(ctx aws.Context, input *ec2.CreateVolumeInput, opts ...request.Option) (*ec2.Volume, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateVolumeWithContext", varargs...) @@ -90,17 +91,17 @@ func (m *MockEC2) CreateVolumeWithContext(arg0 context.Context, arg1 *ec2.Create } // CreateVolumeWithContext indicates an expected call of CreateVolumeWithContext. -func (mr *MockEC2MockRecorder) CreateVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) CreateVolumeWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVolumeWithContext), varargs...) } // DeleteSnapshotWithContext mocks base method. -func (m *MockEC2) DeleteSnapshotWithContext(arg0 context.Context, arg1 *ec2.DeleteSnapshotInput, arg2 ...request.Option) (*ec2.DeleteSnapshotOutput, error) { +func (m *MockEC2) DeleteSnapshotWithContext(ctx aws.Context, input *ec2.DeleteSnapshotInput, opts ...request.Option) (*ec2.DeleteSnapshotOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...) @@ -110,17 +111,17 @@ func (m *MockEC2) DeleteSnapshotWithContext(arg0 context.Context, arg1 *ec2.Dele } // DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext. -func (mr *MockEC2MockRecorder) DeleteSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DeleteSnapshotWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSnapshotWithContext), varargs...) } // DeleteVolumeWithContext mocks base method. -func (m *MockEC2) DeleteVolumeWithContext(arg0 context.Context, arg1 *ec2.DeleteVolumeInput, arg2 ...request.Option) (*ec2.DeleteVolumeOutput, error) { +func (m *MockEC2) DeleteVolumeWithContext(ctx aws.Context, input *ec2.DeleteVolumeInput, opts ...request.Option) (*ec2.DeleteVolumeOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteVolumeWithContext", varargs...) @@ -130,17 +131,17 @@ func (m *MockEC2) DeleteVolumeWithContext(arg0 context.Context, arg1 *ec2.Delete } // DeleteVolumeWithContext indicates an expected call of DeleteVolumeWithContext. -func (mr *MockEC2MockRecorder) DeleteVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DeleteVolumeWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVolumeWithContext), varargs...) } // DescribeAvailabilityZonesWithContext mocks base method. -func (m *MockEC2) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) { +func (m *MockEC2) DescribeAvailabilityZonesWithContext(ctx aws.Context, input *ec2.DescribeAvailabilityZonesInput, opts ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", varargs...) @@ -150,17 +151,17 @@ func (m *MockEC2) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg } // DescribeAvailabilityZonesWithContext indicates an expected call of DescribeAvailabilityZonesWithContext. -func (mr *MockEC2MockRecorder) DescribeAvailabilityZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DescribeAvailabilityZonesWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAvailabilityZonesWithContext), varargs...) } // DescribeInstancesWithContext mocks base method. -func (m *MockEC2) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.Option) (*ec2.DescribeInstancesOutput, error) { +func (m *MockEC2) DescribeInstancesWithContext(ctx aws.Context, input *ec2.DescribeInstancesInput, opts ...request.Option) (*ec2.DescribeInstancesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...) @@ -170,17 +171,17 @@ func (m *MockEC2) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.D } // DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DescribeInstancesWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesWithContext), varargs...) } // DescribeSnapshotsWithContext mocks base method. -func (m *MockEC2) DescribeSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeSnapshotsOutput, error) { +func (m *MockEC2) DescribeSnapshotsWithContext(ctx aws.Context, input *ec2.DescribeSnapshotsInput, opts ...request.Option) (*ec2.DescribeSnapshotsOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...) @@ -190,17 +191,17 @@ func (m *MockEC2) DescribeSnapshotsWithContext(arg0 context.Context, arg1 *ec2.D } // DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext. -func (mr *MockEC2MockRecorder) DescribeSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DescribeSnapshotsWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotsWithContext), varargs...) } // DescribeVolumesModificationsWithContext mocks base method. -func (m *MockEC2) DescribeVolumesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) { +func (m *MockEC2) DescribeVolumesModificationsWithContext(ctx aws.Context, input *ec2.DescribeVolumesModificationsInput, opts ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeVolumesModificationsWithContext", varargs...) @@ -210,17 +211,17 @@ func (m *MockEC2) DescribeVolumesModificationsWithContext(arg0 context.Context, } // DescribeVolumesModificationsWithContext indicates an expected call of DescribeVolumesModificationsWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumesModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DescribeVolumesModificationsWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesModificationsWithContext), varargs...) } // DescribeVolumesWithContext mocks base method. -func (m *MockEC2) DescribeVolumesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.Option) (*ec2.DescribeVolumesOutput, error) { +func (m *MockEC2) DescribeVolumesWithContext(ctx aws.Context, input *ec2.DescribeVolumesInput, opts ...request.Option) (*ec2.DescribeVolumesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeVolumesWithContext", varargs...) @@ -230,17 +231,17 @@ func (m *MockEC2) DescribeVolumesWithContext(arg0 context.Context, arg1 *ec2.Des } // DescribeVolumesWithContext indicates an expected call of DescribeVolumesWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DescribeVolumesWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesWithContext), varargs...) } // DetachVolumeWithContext mocks base method. -func (m *MockEC2) DetachVolumeWithContext(arg0 context.Context, arg1 *ec2.DetachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { +func (m *MockEC2) DetachVolumeWithContext(ctx aws.Context, input *ec2.DetachVolumeInput, opts ...request.Option) (*ec2.VolumeAttachment, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DetachVolumeWithContext", varargs...) @@ -250,17 +251,17 @@ func (m *MockEC2) DetachVolumeWithContext(arg0 context.Context, arg1 *ec2.Detach } // DetachVolumeWithContext indicates an expected call of DetachVolumeWithContext. -func (mr *MockEC2MockRecorder) DetachVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) DetachVolumeWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).DetachVolumeWithContext), varargs...) } // ModifyVolumeWithContext mocks base method. -func (m *MockEC2) ModifyVolumeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeInput, arg2 ...request.Option) (*ec2.ModifyVolumeOutput, error) { +func (m *MockEC2) ModifyVolumeWithContext(ctx aws.Context, input *ec2.ModifyVolumeInput, opts ...request.Option) (*ec2.ModifyVolumeOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, input} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ModifyVolumeWithContext", varargs...) @@ -270,8 +271,75 @@ func (m *MockEC2) ModifyVolumeWithContext(arg0 context.Context, arg1 *ec2.Modify } // ModifyVolumeWithContext indicates an expected call of ModifyVolumeWithContext. -func (mr *MockEC2MockRecorder) ModifyVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockEC2MockRecorder) ModifyVolumeWithContext(ctx, input interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, input}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVolumeWithContext), varargs...) } + +// MockEC2Metadata is a mock of EC2Metadata interface. +type MockEC2Metadata struct { + ctrl *gomock.Controller + recorder *MockEC2MetadataMockRecorder +} + +// MockEC2MetadataMockRecorder is the mock recorder for MockEC2Metadata. +type MockEC2MetadataMockRecorder struct { + mock *MockEC2Metadata +} + +// NewMockEC2Metadata creates a new mock instance. +func NewMockEC2Metadata(ctrl *gomock.Controller) *MockEC2Metadata { + mock := &MockEC2Metadata{ctrl: ctrl} + mock.recorder = &MockEC2MetadataMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEC2Metadata) EXPECT() *MockEC2MetadataMockRecorder { + return m.recorder +} + +// Available mocks base method. +func (m *MockEC2Metadata) Available() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Available") + ret0, _ := ret[0].(bool) + return ret0 +} + +// Available indicates an expected call of Available. +func (mr *MockEC2MetadataMockRecorder) Available() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Available", reflect.TypeOf((*MockEC2Metadata)(nil).Available)) +} + +// GetInstanceIdentityDocument mocks base method. +func (m *MockEC2Metadata) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceIdentityDocument") + ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetInstanceIdentityDocument indicates an expected call of GetInstanceIdentityDocument. +func (mr *MockEC2MetadataMockRecorder) GetInstanceIdentityDocument() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceIdentityDocument", reflect.TypeOf((*MockEC2Metadata)(nil).GetInstanceIdentityDocument)) +} + +// GetMetadata mocks base method. +func (m *MockEC2Metadata) GetMetadata(arg0 string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetMetadata", arg0) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetMetadata indicates an expected call of GetMetadata. +func (mr *MockEC2MetadataMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockEC2Metadata)(nil).GetMetadata), arg0) +} diff --git a/pkg/cloud/mocks/mock_ec2metadata.go b/pkg/cloud/mocks/mock_ec2metadata.go deleted file mode 100644 index 42afe920f8..0000000000 --- a/pkg/cloud/mocks/mock_ec2metadata.go +++ /dev/null @@ -1,79 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/cloud (interfaces: EC2Metadata) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - ec2metadata "github.com/aws/aws-sdk-go/aws/ec2metadata" - gomock "github.com/golang/mock/gomock" -) - -// MockEC2Metadata is a mock of EC2Metadata interface. -type MockEC2Metadata struct { - ctrl *gomock.Controller - recorder *MockEC2MetadataMockRecorder -} - -// MockEC2MetadataMockRecorder is the mock recorder for MockEC2Metadata. -type MockEC2MetadataMockRecorder struct { - mock *MockEC2Metadata -} - -// NewMockEC2Metadata creates a new mock instance. -func NewMockEC2Metadata(ctrl *gomock.Controller) *MockEC2Metadata { - mock := &MockEC2Metadata{ctrl: ctrl} - mock.recorder = &MockEC2MetadataMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockEC2Metadata) EXPECT() *MockEC2MetadataMockRecorder { - return m.recorder -} - -// Available mocks base method. -func (m *MockEC2Metadata) Available() bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Available") - ret0, _ := ret[0].(bool) - return ret0 -} - -// Available indicates an expected call of Available. -func (mr *MockEC2MetadataMockRecorder) Available() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Available", reflect.TypeOf((*MockEC2Metadata)(nil).Available)) -} - -// GetInstanceIdentityDocument mocks base method. -func (m *MockEC2Metadata) GetInstanceIdentityDocument() (ec2metadata.EC2InstanceIdentityDocument, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceIdentityDocument") - ret0, _ := ret[0].(ec2metadata.EC2InstanceIdentityDocument) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInstanceIdentityDocument indicates an expected call of GetInstanceIdentityDocument. -func (mr *MockEC2MetadataMockRecorder) GetInstanceIdentityDocument() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceIdentityDocument", reflect.TypeOf((*MockEC2Metadata)(nil).GetInstanceIdentityDocument)) -} - -// GetMetadata mocks base method. -func (m *MockEC2Metadata) GetMetadata(arg0 string) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMetadata", arg0) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetMetadata indicates an expected call of GetMetadata. -func (mr *MockEC2MetadataMockRecorder) GetMetadata(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetadata", reflect.TypeOf((*MockEC2Metadata)(nil).GetMetadata), arg0) -} diff --git a/pkg/driver/mocks/mock_cloud.go b/pkg/driver/mocks/mock_cloud.go index 654d8ff090..0b70a9ef9f 100644 --- a/pkg/driver/mocks/mock_cloud.go +++ b/pkg/driver/mocks/mock_cloud.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/cloud (interfaces: Cloud) +// Source: pkg/cloud/cloud_interface.go // Package mocks is a generated GoMock package. package mocks @@ -8,6 +8,7 @@ import ( context "context" reflect "reflect" + arn "github.com/aws/aws-sdk-go/aws/arn" ec2 "github.com/aws/aws-sdk-go/service/ec2" gomock "github.com/golang/mock/gomock" cloud "github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/cloud" @@ -37,209 +38,302 @@ func (m *MockCloud) EXPECT() *MockCloudMockRecorder { } // AttachDisk mocks base method. -func (m *MockCloud) AttachDisk(arg0 context.Context, arg1, arg2 string) (string, error) { +func (m *MockCloud) AttachDisk(ctx context.Context, volumeID, nodeID string) (string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachDisk", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "AttachDisk", ctx, volumeID, nodeID) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // AttachDisk indicates an expected call of AttachDisk. -func (mr *MockCloudMockRecorder) AttachDisk(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) AttachDisk(ctx, volumeID, nodeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachDisk", reflect.TypeOf((*MockCloud)(nil).AttachDisk), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachDisk", reflect.TypeOf((*MockCloud)(nil).AttachDisk), ctx, volumeID, nodeID) } // CreateDisk mocks base method. -func (m *MockCloud) CreateDisk(arg0 context.Context, arg1 string, arg2 *cloud.DiskOptions) (*cloud.Disk, error) { +func (m *MockCloud) CreateDisk(ctx context.Context, volumeName string, diskOptions *cloud.DiskOptions) (*cloud.Disk, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDisk", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "CreateDisk", ctx, volumeName, diskOptions) ret0, _ := ret[0].(*cloud.Disk) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateDisk indicates an expected call of CreateDisk. -func (mr *MockCloudMockRecorder) CreateDisk(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) CreateDisk(ctx, volumeName, diskOptions interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDisk", reflect.TypeOf((*MockCloud)(nil).CreateDisk), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDisk", reflect.TypeOf((*MockCloud)(nil).CreateDisk), ctx, volumeName, diskOptions) } // CreateSnapshot mocks base method. -func (m *MockCloud) CreateSnapshot(arg0 context.Context, arg1 string, arg2 *cloud.SnapshotOptions) (*cloud.Snapshot, error) { +func (m *MockCloud) CreateSnapshot(ctx context.Context, volumeID string, snapshotOptions *cloud.SnapshotOptions) (*cloud.Snapshot, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSnapshot", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "CreateSnapshot", ctx, volumeID, snapshotOptions) ret0, _ := ret[0].(*cloud.Snapshot) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateSnapshot indicates an expected call of CreateSnapshot. -func (mr *MockCloudMockRecorder) CreateSnapshot(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) CreateSnapshot(ctx, volumeID, snapshotOptions interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockCloud)(nil).CreateSnapshot), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockCloud)(nil).CreateSnapshot), ctx, volumeID, snapshotOptions) } // DeleteDisk mocks base method. -func (m *MockCloud) DeleteDisk(arg0 context.Context, arg1 string) (bool, error) { +func (m *MockCloud) DeleteDisk(ctx context.Context, volumeID string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDisk", arg0, arg1) + ret := m.ctrl.Call(m, "DeleteDisk", ctx, volumeID) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteDisk indicates an expected call of DeleteDisk. -func (mr *MockCloudMockRecorder) DeleteDisk(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) DeleteDisk(ctx, volumeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDisk", reflect.TypeOf((*MockCloud)(nil).DeleteDisk), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDisk", reflect.TypeOf((*MockCloud)(nil).DeleteDisk), ctx, volumeID) } // DeleteSnapshot mocks base method. -func (m *MockCloud) DeleteSnapshot(arg0 context.Context, arg1 string) (bool, error) { +func (m *MockCloud) DeleteSnapshot(ctx context.Context, snapshotID string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSnapshot", arg0, arg1) + ret := m.ctrl.Call(m, "DeleteSnapshot", ctx, snapshotID) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteSnapshot indicates an expected call of DeleteSnapshot. -func (mr *MockCloudMockRecorder) DeleteSnapshot(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) DeleteSnapshot(ctx, snapshotID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockCloud)(nil).DeleteSnapshot), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockCloud)(nil).DeleteSnapshot), ctx, snapshotID) } // DetachDisk mocks base method. -func (m *MockCloud) DetachDisk(arg0 context.Context, arg1, arg2 string) error { +func (m *MockCloud) DetachDisk(ctx context.Context, volumeID, nodeID string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachDisk", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "DetachDisk", ctx, volumeID, nodeID) ret0, _ := ret[0].(error) return ret0 } // DetachDisk indicates an expected call of DetachDisk. -func (mr *MockCloudMockRecorder) DetachDisk(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) DetachDisk(ctx, volumeID, nodeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockCloud)(nil).DetachDisk), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockCloud)(nil).DetachDisk), ctx, volumeID, nodeID) } // GetDiskByID mocks base method. -func (m *MockCloud) GetDiskByID(arg0 context.Context, arg1 string) (*cloud.Disk, error) { +func (m *MockCloud) GetDiskByID(ctx context.Context, volumeID string) (*cloud.Disk, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDiskByID", arg0, arg1) + ret := m.ctrl.Call(m, "GetDiskByID", ctx, volumeID) ret0, _ := ret[0].(*cloud.Disk) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDiskByID indicates an expected call of GetDiskByID. -func (mr *MockCloudMockRecorder) GetDiskByID(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) GetDiskByID(ctx, volumeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskByID", reflect.TypeOf((*MockCloud)(nil).GetDiskByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskByID", reflect.TypeOf((*MockCloud)(nil).GetDiskByID), ctx, volumeID) } // GetDiskByName mocks base method. -func (m *MockCloud) GetDiskByName(arg0 context.Context, arg1 string, arg2 int64) (*cloud.Disk, error) { +func (m *MockCloud) GetDiskByName(ctx context.Context, name string, capacityBytes int64) (*cloud.Disk, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDiskByName", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "GetDiskByName", ctx, name, capacityBytes) ret0, _ := ret[0].(*cloud.Disk) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDiskByName indicates an expected call of GetDiskByName. -func (mr *MockCloudMockRecorder) GetDiskByName(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) GetDiskByName(ctx, name, capacityBytes interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskByName", reflect.TypeOf((*MockCloud)(nil).GetDiskByName), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskByName", reflect.TypeOf((*MockCloud)(nil).GetDiskByName), ctx, name, capacityBytes) } // GetSnapshotByID mocks base method. -func (m *MockCloud) GetSnapshotByID(arg0 context.Context, arg1 string) (*cloud.Snapshot, error) { +func (m *MockCloud) GetSnapshotByID(ctx context.Context, snapshotID string) (*cloud.Snapshot, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSnapshotByID", arg0, arg1) + ret := m.ctrl.Call(m, "GetSnapshotByID", ctx, snapshotID) ret0, _ := ret[0].(*cloud.Snapshot) ret1, _ := ret[1].(error) return ret0, ret1 } // GetSnapshotByID indicates an expected call of GetSnapshotByID. -func (mr *MockCloudMockRecorder) GetSnapshotByID(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) GetSnapshotByID(ctx, snapshotID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByID", reflect.TypeOf((*MockCloud)(nil).GetSnapshotByID), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByID", reflect.TypeOf((*MockCloud)(nil).GetSnapshotByID), ctx, snapshotID) } // GetSnapshotByName mocks base method. -func (m *MockCloud) GetSnapshotByName(arg0 context.Context, arg1 string) (*cloud.Snapshot, error) { +func (m *MockCloud) GetSnapshotByName(ctx context.Context, name string) (*cloud.Snapshot, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSnapshotByName", arg0, arg1) + ret := m.ctrl.Call(m, "GetSnapshotByName", ctx, name) ret0, _ := ret[0].(*cloud.Snapshot) ret1, _ := ret[1].(error) return ret0, ret1 } // GetSnapshotByName indicates an expected call of GetSnapshotByName. -func (mr *MockCloudMockRecorder) GetSnapshotByName(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) GetSnapshotByName(ctx, name interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByName", reflect.TypeOf((*MockCloud)(nil).GetSnapshotByName), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByName", reflect.TypeOf((*MockCloud)(nil).GetSnapshotByName), ctx, name) } // IsExistInstance mocks base method. -func (m *MockCloud) IsExistInstance(arg0 context.Context, arg1 string) bool { +func (m *MockCloud) IsExistInstance(ctx context.Context, nodeID string) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsExistInstance", arg0, arg1) + ret := m.ctrl.Call(m, "IsExistInstance", ctx, nodeID) ret0, _ := ret[0].(bool) return ret0 } // IsExistInstance indicates an expected call of IsExistInstance. -func (mr *MockCloudMockRecorder) IsExistInstance(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) IsExistInstance(ctx, nodeID interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExistInstance", reflect.TypeOf((*MockCloud)(nil).IsExistInstance), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsExistInstance", reflect.TypeOf((*MockCloud)(nil).IsExistInstance), ctx, nodeID) } // ListSnapshots mocks base method. -func (m *MockCloud) ListSnapshots(arg0 context.Context, arg1 string, arg2 int64, arg3 string) (*cloud.ListSnapshotsResponse, error) { +func (m *MockCloud) ListSnapshots(ctx context.Context, volumeID string, maxResults int64, nextToken string) (*cloud.ListSnapshotsResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSnapshots", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "ListSnapshots", ctx, volumeID, maxResults, nextToken) ret0, _ := ret[0].(*cloud.ListSnapshotsResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // ListSnapshots indicates an expected call of ListSnapshots. -func (mr *MockCloudMockRecorder) ListSnapshots(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) ListSnapshots(ctx, volumeID, maxResults, nextToken interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockCloud)(nil).ListSnapshots), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockCloud)(nil).ListSnapshots), ctx, volumeID, maxResults, nextToken) } // ResizeDisk mocks base method. -func (m *MockCloud) ResizeDisk(arg0 context.Context, arg1 string, arg2 int64) (int64, error) { +func (m *MockCloud) ResizeDisk(ctx context.Context, volumeID string, reqSize int64) (int64, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResizeDisk", arg0, arg1, arg2) + ret := m.ctrl.Call(m, "ResizeDisk", ctx, volumeID, reqSize) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) return ret0, ret1 } // ResizeDisk indicates an expected call of ResizeDisk. -func (mr *MockCloudMockRecorder) ResizeDisk(arg0, arg1, arg2 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) ResizeDisk(ctx, volumeID, reqSize interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeDisk", reflect.TypeOf((*MockCloud)(nil).ResizeDisk), arg0, arg1, arg2) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeDisk", reflect.TypeOf((*MockCloud)(nil).ResizeDisk), ctx, volumeID, reqSize) } // WaitForAttachmentState mocks base method. -func (m *MockCloud) WaitForAttachmentState(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 bool) (*ec2.VolumeAttachment, error) { +func (m *MockCloud) WaitForAttachmentState(ctx context.Context, volumeID, expectedState, expectedInstance, expectedDevice string, alreadyAssigned bool) (*ec2.VolumeAttachment, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitForAttachmentState", arg0, arg1, arg2, arg3, arg4, arg5) + ret := m.ctrl.Call(m, "WaitForAttachmentState", ctx, volumeID, expectedState, expectedInstance, expectedDevice, alreadyAssigned) ret0, _ := ret[0].(*ec2.VolumeAttachment) ret1, _ := ret[1].(error) return ret0, ret1 } // WaitForAttachmentState indicates an expected call of WaitForAttachmentState. -func (mr *MockCloudMockRecorder) WaitForAttachmentState(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { +func (mr *MockCloudMockRecorder) WaitForAttachmentState(ctx, volumeID, expectedState, expectedInstance, expectedDevice, alreadyAssigned interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAttachmentState", reflect.TypeOf((*MockCloud)(nil).WaitForAttachmentState), arg0, arg1, arg2, arg3, arg4, arg5) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForAttachmentState", reflect.TypeOf((*MockCloud)(nil).WaitForAttachmentState), ctx, volumeID, expectedState, expectedInstance, expectedDevice, alreadyAssigned) +} + +// MockMetadataService is a mock of MetadataService interface. +type MockMetadataService struct { + ctrl *gomock.Controller + recorder *MockMetadataServiceMockRecorder +} + +// MockMetadataServiceMockRecorder is the mock recorder for MockMetadataService. +type MockMetadataServiceMockRecorder struct { + mock *MockMetadataService +} + +// NewMockMetadataService creates a new mock instance. +func NewMockMetadataService(ctrl *gomock.Controller) *MockMetadataService { + mock := &MockMetadataService{ctrl: ctrl} + mock.recorder = &MockMetadataServiceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMetadataService) EXPECT() *MockMetadataServiceMockRecorder { + return m.recorder +} + +// GetAvailabilityZone mocks base method. +func (m *MockMetadataService) GetAvailabilityZone() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAvailabilityZone") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetAvailabilityZone indicates an expected call of GetAvailabilityZone. +func (mr *MockMetadataServiceMockRecorder) GetAvailabilityZone() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAvailabilityZone", reflect.TypeOf((*MockMetadataService)(nil).GetAvailabilityZone)) +} + +// GetInstanceID mocks base method. +func (m *MockMetadataService) GetInstanceID() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceID") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetInstanceID indicates an expected call of GetInstanceID. +func (mr *MockMetadataServiceMockRecorder) GetInstanceID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceID", reflect.TypeOf((*MockMetadataService)(nil).GetInstanceID)) +} + +// GetInstanceType mocks base method. +func (m *MockMetadataService) GetInstanceType() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetInstanceType") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetInstanceType indicates an expected call of GetInstanceType. +func (mr *MockMetadataServiceMockRecorder) GetInstanceType() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceType", reflect.TypeOf((*MockMetadataService)(nil).GetInstanceType)) +} + +// GetOutpostArn mocks base method. +func (m *MockMetadataService) GetOutpostArn() arn.ARN { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOutpostArn") + ret0, _ := ret[0].(arn.ARN) + return ret0 +} + +// GetOutpostArn indicates an expected call of GetOutpostArn. +func (mr *MockMetadataServiceMockRecorder) GetOutpostArn() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOutpostArn", reflect.TypeOf((*MockMetadataService)(nil).GetOutpostArn)) +} + +// GetRegion mocks base method. +func (m *MockMetadataService) GetRegion() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRegion") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetRegion indicates an expected call of GetRegion. +func (mr *MockMetadataServiceMockRecorder) GetRegion() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegion", reflect.TypeOf((*MockMetadataService)(nil).GetRegion)) } diff --git a/pkg/driver/mocks/mock_metadata_service.go b/pkg/driver/mocks/mock_metadata_service.go deleted file mode 100644 index 791487b1da..0000000000 --- a/pkg/driver/mocks/mock_metadata_service.go +++ /dev/null @@ -1,105 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/cloud (interfaces: MetadataService) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - arn "github.com/aws/aws-sdk-go/aws/arn" - gomock "github.com/golang/mock/gomock" -) - -// MockMetadataService is a mock of MetadataService interface. -type MockMetadataService struct { - ctrl *gomock.Controller - recorder *MockMetadataServiceMockRecorder -} - -// MockMetadataServiceMockRecorder is the mock recorder for MockMetadataService. -type MockMetadataServiceMockRecorder struct { - mock *MockMetadataService -} - -// NewMockMetadataService creates a new mock instance. -func NewMockMetadataService(ctrl *gomock.Controller) *MockMetadataService { - mock := &MockMetadataService{ctrl: ctrl} - mock.recorder = &MockMetadataServiceMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockMetadataService) EXPECT() *MockMetadataServiceMockRecorder { - return m.recorder -} - -// GetAvailabilityZone mocks base method. -func (m *MockMetadataService) GetAvailabilityZone() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAvailabilityZone") - ret0, _ := ret[0].(string) - return ret0 -} - -// GetAvailabilityZone indicates an expected call of GetAvailabilityZone. -func (mr *MockMetadataServiceMockRecorder) GetAvailabilityZone() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAvailabilityZone", reflect.TypeOf((*MockMetadataService)(nil).GetAvailabilityZone)) -} - -// GetInstanceID mocks base method. -func (m *MockMetadataService) GetInstanceID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceID") - ret0, _ := ret[0].(string) - return ret0 -} - -// GetInstanceID indicates an expected call of GetInstanceID. -func (mr *MockMetadataServiceMockRecorder) GetInstanceID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceID", reflect.TypeOf((*MockMetadataService)(nil).GetInstanceID)) -} - -// GetInstanceType mocks base method. -func (m *MockMetadataService) GetInstanceType() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceType") - ret0, _ := ret[0].(string) - return ret0 -} - -// GetInstanceType indicates an expected call of GetInstanceType. -func (mr *MockMetadataServiceMockRecorder) GetInstanceType() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceType", reflect.TypeOf((*MockMetadataService)(nil).GetInstanceType)) -} - -// GetOutpostArn mocks base method. -func (m *MockMetadataService) GetOutpostArn() arn.ARN { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetOutpostArn") - ret0, _ := ret[0].(arn.ARN) - return ret0 -} - -// GetOutpostArn indicates an expected call of GetOutpostArn. -func (mr *MockMetadataServiceMockRecorder) GetOutpostArn() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOutpostArn", reflect.TypeOf((*MockMetadataService)(nil).GetOutpostArn)) -} - -// GetRegion mocks base method. -func (m *MockMetadataService) GetRegion() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRegion") - ret0, _ := ret[0].(string) - return ret0 -} - -// GetRegion indicates an expected call of GetRegion. -func (mr *MockMetadataServiceMockRecorder) GetRegion() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegion", reflect.TypeOf((*MockMetadataService)(nil).GetRegion)) -} diff --git a/pkg/driver/mocks/mock_mounter.go b/pkg/driver/mocks/mock_mount.go similarity index 58% rename from pkg/driver/mocks/mock_mounter.go rename to pkg/driver/mocks/mock_mount.go index e69b6e90c7..7e556e4737 100644 --- a/pkg/driver/mocks/mock_mounter.go +++ b/pkg/driver/mocks/mock_mount.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/kubernetes-sigs/aws-ebs-csi-driver/pkg/driver (interfaces: Mounter) +// Source: pkg/driver/mount.go // Package mocks is a generated GoMock package. package mocks @@ -37,10 +37,10 @@ func (m *MockMounter) EXPECT() *MockMounterMockRecorder { } // Command mocks base method. -func (m *MockMounter) Command(arg0 string, arg1 ...string) exec.Cmd { +func (m *MockMounter) Command(cmd string, args ...string) exec.Cmd { m.ctrl.T.Helper() - varargs := []interface{}{arg0} - for _, a := range arg1 { + varargs := []interface{}{cmd} + for _, a := range args { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Command", varargs...) @@ -49,17 +49,17 @@ func (m *MockMounter) Command(arg0 string, arg1 ...string) exec.Cmd { } // Command indicates an expected call of Command. -func (mr *MockMounterMockRecorder) Command(arg0 interface{}, arg1 ...interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) Command(cmd interface{}, args ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0}, arg1...) + varargs := append([]interface{}{cmd}, args...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockMounter)(nil).Command), varargs...) } // CommandContext mocks base method. -func (m *MockMounter) CommandContext(arg0 context.Context, arg1 string, arg2 ...string) exec.Cmd { +func (m *MockMounter) CommandContext(ctx context.Context, cmd string, args ...string) exec.Cmd { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { + varargs := []interface{}{ctx, cmd} + for _, a := range args { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CommandContext", varargs...) @@ -68,30 +68,30 @@ func (m *MockMounter) CommandContext(arg0 context.Context, arg1 string, arg2 ... } // CommandContext indicates an expected call of CommandContext. -func (mr *MockMounterMockRecorder) CommandContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) CommandContext(ctx, cmd interface{}, args ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) + varargs := append([]interface{}{ctx, cmd}, args...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandContext", reflect.TypeOf((*MockMounter)(nil).CommandContext), varargs...) } // FormatAndMount mocks base method. -func (m *MockMounter) FormatAndMount(arg0, arg1, arg2 string, arg3 []string) error { +func (m *MockMounter) FormatAndMount(source, target, fstype string, options []string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FormatAndMount", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "FormatAndMount", source, target, fstype, options) ret0, _ := ret[0].(error) return ret0 } // FormatAndMount indicates an expected call of FormatAndMount. -func (mr *MockMounterMockRecorder) FormatAndMount(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) FormatAndMount(source, target, fstype, options interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FormatAndMount", reflect.TypeOf((*MockMounter)(nil).FormatAndMount), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FormatAndMount", reflect.TypeOf((*MockMounter)(nil).FormatAndMount), source, target, fstype, options) } // GetDeviceNameFromMount mocks base method. -func (m *MockMounter) GetDeviceNameFromMount(arg0 string) (string, int, error) { +func (m *MockMounter) GetDeviceNameFromMount(mountPath string) (string, int, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDeviceNameFromMount", arg0) + ret := m.ctrl.Call(m, "GetDeviceNameFromMount", mountPath) ret0, _ := ret[0].(string) ret1, _ := ret[1].(int) ret2, _ := ret[2].(error) @@ -99,39 +99,39 @@ func (m *MockMounter) GetDeviceNameFromMount(arg0 string) (string, int, error) { } // GetDeviceNameFromMount indicates an expected call of GetDeviceNameFromMount. -func (mr *MockMounterMockRecorder) GetDeviceNameFromMount(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) GetDeviceNameFromMount(mountPath interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceNameFromMount", reflect.TypeOf((*MockMounter)(nil).GetDeviceNameFromMount), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceNameFromMount", reflect.TypeOf((*MockMounter)(nil).GetDeviceNameFromMount), mountPath) } // GetMountRefs mocks base method. -func (m *MockMounter) GetMountRefs(arg0 string) ([]string, error) { +func (m *MockMounter) GetMountRefs(pathname string) ([]string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetMountRefs", arg0) + ret := m.ctrl.Call(m, "GetMountRefs", pathname) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // GetMountRefs indicates an expected call of GetMountRefs. -func (mr *MockMounterMockRecorder) GetMountRefs(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) GetMountRefs(pathname interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMountRefs", reflect.TypeOf((*MockMounter)(nil).GetMountRefs), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMountRefs", reflect.TypeOf((*MockMounter)(nil).GetMountRefs), pathname) } // IsLikelyNotMountPoint mocks base method. -func (m *MockMounter) IsLikelyNotMountPoint(arg0 string) (bool, error) { +func (m *MockMounter) IsLikelyNotMountPoint(file string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsLikelyNotMountPoint", arg0) + ret := m.ctrl.Call(m, "IsLikelyNotMountPoint", file) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // IsLikelyNotMountPoint indicates an expected call of IsLikelyNotMountPoint. -func (mr *MockMounterMockRecorder) IsLikelyNotMountPoint(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) IsLikelyNotMountPoint(file interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLikelyNotMountPoint", reflect.TypeOf((*MockMounter)(nil).IsLikelyNotMountPoint), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsLikelyNotMountPoint", reflect.TypeOf((*MockMounter)(nil).IsLikelyNotMountPoint), file) } // List mocks base method. @@ -150,115 +150,115 @@ func (mr *MockMounterMockRecorder) List() *gomock.Call { } // LookPath mocks base method. -func (m *MockMounter) LookPath(arg0 string) (string, error) { +func (m *MockMounter) LookPath(file string) (string, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LookPath", arg0) + ret := m.ctrl.Call(m, "LookPath", file) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // LookPath indicates an expected call of LookPath. -func (mr *MockMounterMockRecorder) LookPath(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) LookPath(file interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookPath", reflect.TypeOf((*MockMounter)(nil).LookPath), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookPath", reflect.TypeOf((*MockMounter)(nil).LookPath), file) } // MakeDir mocks base method. -func (m *MockMounter) MakeDir(arg0 string) error { +func (m *MockMounter) MakeDir(path string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MakeDir", arg0) + ret := m.ctrl.Call(m, "MakeDir", path) ret0, _ := ret[0].(error) return ret0 } // MakeDir indicates an expected call of MakeDir. -func (mr *MockMounterMockRecorder) MakeDir(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) MakeDir(path interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeDir", reflect.TypeOf((*MockMounter)(nil).MakeDir), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeDir", reflect.TypeOf((*MockMounter)(nil).MakeDir), path) } // MakeFile mocks base method. -func (m *MockMounter) MakeFile(arg0 string) error { +func (m *MockMounter) MakeFile(path string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MakeFile", arg0) + ret := m.ctrl.Call(m, "MakeFile", path) ret0, _ := ret[0].(error) return ret0 } // MakeFile indicates an expected call of MakeFile. -func (mr *MockMounterMockRecorder) MakeFile(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) MakeFile(path interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeFile", reflect.TypeOf((*MockMounter)(nil).MakeFile), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeFile", reflect.TypeOf((*MockMounter)(nil).MakeFile), path) } // Mount mocks base method. -func (m *MockMounter) Mount(arg0, arg1, arg2 string, arg3 []string) error { +func (m *MockMounter) Mount(source, target, fstype string, options []string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Mount", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "Mount", source, target, fstype, options) ret0, _ := ret[0].(error) return ret0 } // Mount indicates an expected call of Mount. -func (mr *MockMounterMockRecorder) Mount(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) Mount(source, target, fstype, options interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mount", reflect.TypeOf((*MockMounter)(nil).Mount), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Mount", reflect.TypeOf((*MockMounter)(nil).Mount), source, target, fstype, options) } // MountSensitive mocks base method. -func (m *MockMounter) MountSensitive(arg0, arg1, arg2 string, arg3, arg4 []string) error { +func (m *MockMounter) MountSensitive(source, target, fstype string, options, sensitiveOptions []string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MountSensitive", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "MountSensitive", source, target, fstype, options, sensitiveOptions) ret0, _ := ret[0].(error) return ret0 } // MountSensitive indicates an expected call of MountSensitive. -func (mr *MockMounterMockRecorder) MountSensitive(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) MountSensitive(source, target, fstype, options, sensitiveOptions interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitive", reflect.TypeOf((*MockMounter)(nil).MountSensitive), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitive", reflect.TypeOf((*MockMounter)(nil).MountSensitive), source, target, fstype, options, sensitiveOptions) } // MountSensitiveWithoutSystemd mocks base method. -func (m *MockMounter) MountSensitiveWithoutSystemd(arg0, arg1, arg2 string, arg3, arg4 []string) error { +func (m *MockMounter) MountSensitiveWithoutSystemd(source, target, fstype string, options, sensitiveOptions []string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MountSensitiveWithoutSystemd", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "MountSensitiveWithoutSystemd", source, target, fstype, options, sensitiveOptions) ret0, _ := ret[0].(error) return ret0 } // MountSensitiveWithoutSystemd indicates an expected call of MountSensitiveWithoutSystemd. -func (mr *MockMounterMockRecorder) MountSensitiveWithoutSystemd(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) MountSensitiveWithoutSystemd(source, target, fstype, options, sensitiveOptions interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitiveWithoutSystemd", reflect.TypeOf((*MockMounter)(nil).MountSensitiveWithoutSystemd), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountSensitiveWithoutSystemd", reflect.TypeOf((*MockMounter)(nil).MountSensitiveWithoutSystemd), source, target, fstype, options, sensitiveOptions) } // PathExists mocks base method. -func (m *MockMounter) PathExists(arg0 string) (bool, error) { +func (m *MockMounter) PathExists(path string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PathExists", arg0) + ret := m.ctrl.Call(m, "PathExists", path) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // PathExists indicates an expected call of PathExists. -func (mr *MockMounterMockRecorder) PathExists(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) PathExists(path interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PathExists", reflect.TypeOf((*MockMounter)(nil).PathExists), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PathExists", reflect.TypeOf((*MockMounter)(nil).PathExists), path) } // Unmount mocks base method. -func (m *MockMounter) Unmount(arg0 string) error { +func (m *MockMounter) Unmount(target string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Unmount", arg0) + ret := m.ctrl.Call(m, "Unmount", target) ret0, _ := ret[0].(error) return ret0 } // Unmount indicates an expected call of Unmount. -func (mr *MockMounterMockRecorder) Unmount(arg0 interface{}) *gomock.Call { +func (mr *MockMounterMockRecorder) Unmount(target interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmount", reflect.TypeOf((*MockMounter)(nil).Unmount), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unmount", reflect.TypeOf((*MockMounter)(nil).Unmount), target) }