mockery to mockgen conversion

2025-09-20 09:33:52 +00:00 · 2021-09-11 08:50:25 +00:00
parent 4e30c058c4
commit 0de4397490
34 changed files with 2594 additions and 1244 deletions
--- a/pkg/kubelet/apis/podresources/server_v1_test.go
+++ b/pkg/kubelet/apis/podresources/server_v1_test.go
@@ -22,16 +22,15 @@ import (
 	"sort"
 	"testing"

-	"k8s.io/api/core/v1"
+	"github.com/golang/mock/gomock"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	podresourcesapi "k8s.io/kubelet/pkg/apis/podresources/v1"
 	pkgfeatures "k8s.io/kubernetes/pkg/features"
-	"k8s.io/kubernetes/pkg/kubelet/cm/cpuset"
-	"k8s.io/kubernetes/pkg/kubelet/cm/devicemanager"
-	"k8s.io/kubernetes/pkg/kubelet/cm/memorymanager/state"
+	podresourcetest "k8s.io/kubernetes/pkg/kubelet/apis/podresources/testing"
 )

 func TestListPodResourcesV1(t *testing.T) {
@@ -41,6 +40,9 @@ func TestListPodResourcesV1(t *testing.T) {
 	containerName := "container-name"
 	numaID := int64(1)

+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	devs := []*podresourcesapi.ContainerDevices{
 		{
 			ResourceName: "resource",
@@ -156,16 +158,21 @@ func TestListPodResourcesV1(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			m := new(mockProvider)
-			m.On("GetPods").Return(tc.pods)
-			m.On("GetDevices", string(podUID), containerName).Return(tc.devices)
-			m.On("GetCPUs", string(podUID), containerName).Return(tc.cpus)
-			m.On("GetMemory", string(podUID), containerName).Return(tc.memory)
-			m.On("UpdateAllocatedDevices").Return()
-			m.On("GetAllocatableCPUs").Return(cpuset.CPUSet{})
-			m.On("GetAllocatableDevices").Return(devicemanager.NewResourceDeviceInstances())
-			m.On("GetAllocatableMemory").Return([]state.Block{})
-			server := NewV1PodResourcesServer(m, m, m, m)
+			mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl)
+			mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl)
+			mockCPUsProvider := podresourcetest.NewMockCPUsProvider(mockCtrl)
+			mockMemoryProvider := podresourcetest.NewMockMemoryProvider(mockCtrl)
+
+			mockPodsProvider.EXPECT().GetPods().Return(tc.pods).AnyTimes().AnyTimes()
+			mockDevicesProvider.EXPECT().GetDevices(string(podUID), containerName).Return(tc.devices).AnyTimes()
+			mockCPUsProvider.EXPECT().GetCPUs(string(podUID), containerName).Return(tc.cpus).AnyTimes()
+			mockMemoryProvider.EXPECT().GetMemory(string(podUID), containerName).Return(tc.memory).AnyTimes()
+			mockDevicesProvider.EXPECT().UpdateAllocatedDevices().Return().AnyTimes()
+			mockCPUsProvider.EXPECT().GetAllocatableCPUs().Return([]int64{}).AnyTimes()
+			mockDevicesProvider.EXPECT().GetAllocatableDevices().Return([]*podresourcesapi.ContainerDevices{}).AnyTimes()
+			mockMemoryProvider.EXPECT().GetAllocatableMemory().Return([]*podresourcesapi.ContainerMemory{}).AnyTimes()
+
+			server := NewV1PodResourcesServer(mockPodsProvider, mockDevicesProvider, mockCPUsProvider, mockMemoryProvider)
 			resp, err := server.List(context.TODO(), &podresourcesapi.ListPodResourcesRequest{})
 			if err != nil {
 				t.Errorf("want err = %v, got %q", nil, err)
@@ -180,6 +187,9 @@ func TestListPodResourcesV1(t *testing.T) {
 func TestAllocatableResources(t *testing.T) {
 	defer featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, pkgfeatures.KubeletPodResourcesGetAllocatable, true)()

+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	allDevs := []*podresourcesapi.ContainerDevices{
 		{
 			ResourceName: "resource",
@@ -436,15 +446,20 @@ func TestAllocatableResources(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			m := new(mockProvider)
-			m.On("GetDevices", "", "").Return([]*podresourcesapi.ContainerDevices{})
-			m.On("GetCPUs", "", "").Return([]int64{})
-			m.On("GetMemory", "", "").Return([]*podresourcesapi.ContainerMemory{})
-			m.On("UpdateAllocatedDevices").Return()
-			m.On("GetAllocatableDevices").Return(tc.allDevices)
-			m.On("GetAllocatableCPUs").Return(tc.allCPUs)
-			m.On("GetAllocatableMemory").Return(tc.allMemory)
-			server := NewV1PodResourcesServer(m, m, m, m)
+			mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl)
+			mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl)
+			mockCPUsProvider := podresourcetest.NewMockCPUsProvider(mockCtrl)
+			mockMemoryProvider := podresourcetest.NewMockMemoryProvider(mockCtrl)
+
+			mockDevicesProvider.EXPECT().GetDevices("", "").Return([]*podresourcesapi.ContainerDevices{}).AnyTimes()
+			mockCPUsProvider.EXPECT().GetCPUs("", "").Return([]int64{}).AnyTimes()
+			mockMemoryProvider.EXPECT().GetMemory("", "").Return([]*podresourcesapi.ContainerMemory{}).AnyTimes()
+			mockDevicesProvider.EXPECT().UpdateAllocatedDevices().Return().AnyTimes()
+			mockDevicesProvider.EXPECT().GetAllocatableDevices().Return(tc.allDevices).AnyTimes()
+			mockCPUsProvider.EXPECT().GetAllocatableCPUs().Return(tc.allCPUs).AnyTimes()
+			mockMemoryProvider.EXPECT().GetAllocatableMemory().Return(tc.allMemory).AnyTimes()
+
+			server := NewV1PodResourcesServer(mockPodsProvider, mockDevicesProvider, mockCPUsProvider, mockMemoryProvider)

 			resp, err := server.GetAllocatableResources(context.TODO(), &podresourcesapi.AllocatableResourcesRequest{})
 			if err != nil {
--- a/pkg/kubelet/apis/podresources/server_v1alpha1_test.go
+++ b/pkg/kubelet/apis/podresources/server_v1alpha1_test.go
@@ -20,58 +20,15 @@ import (
 	"context"
 	"testing"

-	"github.com/stretchr/testify/mock"
-
-	"k8s.io/api/core/v1"
+	"github.com/golang/mock/gomock"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	podresourcesv1 "k8s.io/kubelet/pkg/apis/podresources/v1"
 	"k8s.io/kubelet/pkg/apis/podresources/v1alpha1"
+	podresourcetest "k8s.io/kubernetes/pkg/kubelet/apis/podresources/testing"
 )

-type mockProvider struct {
-	mock.Mock
-}
-
-func (m *mockProvider) GetPods() []*v1.Pod {
-	args := m.Called()
-	return args.Get(0).([]*v1.Pod)
-}
-
-func (m *mockProvider) GetDevices(podUID, containerName string) []*podresourcesv1.ContainerDevices {
-	args := m.Called(podUID, containerName)
-	return args.Get(0).([]*podresourcesv1.ContainerDevices)
-}
-
-func (m *mockProvider) GetCPUs(podUID, containerName string) []int64 {
-	args := m.Called(podUID, containerName)
-	return args.Get(0).([]int64)
-}
-
-func (m *mockProvider) GetMemory(podUID, containerName string) []*podresourcesv1.ContainerMemory {
-	args := m.Called(podUID, containerName)
-	return args.Get(0).([]*podresourcesv1.ContainerMemory)
-}
-
-func (m *mockProvider) UpdateAllocatedDevices() {
-	m.Called()
-}
-
-func (m *mockProvider) GetAllocatableDevices() []*podresourcesv1.ContainerDevices {
-	args := m.Called()
-	return args.Get(0).([]*podresourcesv1.ContainerDevices)
-}
-
-func (m *mockProvider) GetAllocatableCPUs() []int64 {
-	args := m.Called()
-	return args.Get(0).([]int64)
-}
-
-func (m *mockProvider) GetAllocatableMemory() []*podresourcesv1.ContainerMemory {
-	args := m.Called()
-	return args.Get(0).([]*podresourcesv1.ContainerMemory)
-}
-
 func TestListPodResourcesV1alpha1(t *testing.T) {
 	podName := "pod-name"
 	podNamespace := "pod-namespace"
@@ -85,6 +42,9 @@ func TestListPodResourcesV1alpha1(t *testing.T) {
 		},
 	}

+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
 	for _, tc := range []struct {
 		desc             string
 		pods             []*v1.Pod
@@ -167,11 +127,14 @@ func TestListPodResourcesV1alpha1(t *testing.T) {
 		},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
-			m := new(mockProvider)
-			m.On("GetPods").Return(tc.pods)
-			m.On("GetDevices", string(podUID), containerName).Return(tc.devices)
-			m.On("UpdateAllocatedDevices").Return()
-			server := NewV1alpha1PodResourcesServer(m, m)
+			mockDevicesProvider := podresourcetest.NewMockDevicesProvider(mockCtrl)
+			mockPodsProvider := podresourcetest.NewMockPodsProvider(mockCtrl)
+
+			mockPodsProvider.EXPECT().GetPods().Return(tc.pods).AnyTimes()
+			mockDevicesProvider.EXPECT().GetDevices(string(podUID), containerName).Return(tc.devices).AnyTimes()
+			mockDevicesProvider.EXPECT().UpdateAllocatedDevices().Return().AnyTimes()
+
+			server := NewV1alpha1PodResourcesServer(mockPodsProvider, mockDevicesProvider)
 			resp, err := server.List(context.TODO(), &v1alpha1.ListPodResourcesRequest{})
 			if err != nil {
 				t.Errorf("want err = %v, got %q", nil, err)
--- a/pkg/kubelet/apis/podresources/testing/provider_mock.go
+++ b/pkg/kubelet/apis/podresources/testing/provider_mock.go
@@ -0,0 +1,230 @@
+/*
+Copyright 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.
+*/
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: types.go
+
+// Package testing is a generated GoMock package.
+package testing
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	v1 "k8s.io/api/core/v1"
+	v10 "k8s.io/kubelet/pkg/apis/podresources/v1"
+	reflect "reflect"
+)
+
+// MockDevicesProvider is a mock of DevicesProvider interface
+type MockDevicesProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockDevicesProviderMockRecorder
+}
+
+// MockDevicesProviderMockRecorder is the mock recorder for MockDevicesProvider
+type MockDevicesProviderMockRecorder struct {
+	mock *MockDevicesProvider
+}
+
+// NewMockDevicesProvider creates a new mock instance
+func NewMockDevicesProvider(ctrl *gomock.Controller) *MockDevicesProvider {
+	mock := &MockDevicesProvider{ctrl: ctrl}
+	mock.recorder = &MockDevicesProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockDevicesProvider) EXPECT() *MockDevicesProviderMockRecorder {
+	return m.recorder
+}
+
+// UpdateAllocatedDevices mocks base method
+func (m *MockDevicesProvider) UpdateAllocatedDevices() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "UpdateAllocatedDevices")
+}
+
+// UpdateAllocatedDevices indicates an expected call of UpdateAllocatedDevices
+func (mr *MockDevicesProviderMockRecorder) UpdateAllocatedDevices() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAllocatedDevices", reflect.TypeOf((*MockDevicesProvider)(nil).UpdateAllocatedDevices))
+}
+
+// GetDevices mocks base method
+func (m *MockDevicesProvider) GetDevices(podUID, containerName string) []*v10.ContainerDevices {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDevices", podUID, containerName)
+	ret0, _ := ret[0].([]*v10.ContainerDevices)
+	return ret0
+}
+
+// GetDevices indicates an expected call of GetDevices
+func (mr *MockDevicesProviderMockRecorder) GetDevices(podUID, containerName interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevices", reflect.TypeOf((*MockDevicesProvider)(nil).GetDevices), podUID, containerName)
+}
+
+// GetAllocatableDevices mocks base method
+func (m *MockDevicesProvider) GetAllocatableDevices() []*v10.ContainerDevices {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllocatableDevices")
+	ret0, _ := ret[0].([]*v10.ContainerDevices)
+	return ret0
+}
+
+// GetAllocatableDevices indicates an expected call of GetAllocatableDevices
+func (mr *MockDevicesProviderMockRecorder) GetAllocatableDevices() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllocatableDevices", reflect.TypeOf((*MockDevicesProvider)(nil).GetAllocatableDevices))
+}
+
+// MockPodsProvider is a mock of PodsProvider interface
+type MockPodsProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockPodsProviderMockRecorder
+}
+
+// MockPodsProviderMockRecorder is the mock recorder for MockPodsProvider
+type MockPodsProviderMockRecorder struct {
+	mock *MockPodsProvider
+}
+
+// NewMockPodsProvider creates a new mock instance
+func NewMockPodsProvider(ctrl *gomock.Controller) *MockPodsProvider {
+	mock := &MockPodsProvider{ctrl: ctrl}
+	mock.recorder = &MockPodsProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockPodsProvider) EXPECT() *MockPodsProviderMockRecorder {
+	return m.recorder
+}
+
+// GetPods mocks base method
+func (m *MockPodsProvider) GetPods() []*v1.Pod {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPods")
+	ret0, _ := ret[0].([]*v1.Pod)
+	return ret0
+}
+
+// GetPods indicates an expected call of GetPods
+func (mr *MockPodsProviderMockRecorder) GetPods() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPods", reflect.TypeOf((*MockPodsProvider)(nil).GetPods))
+}
+
+// MockCPUsProvider is a mock of CPUsProvider interface
+type MockCPUsProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockCPUsProviderMockRecorder
+}
+
+// MockCPUsProviderMockRecorder is the mock recorder for MockCPUsProvider
+type MockCPUsProviderMockRecorder struct {
+	mock *MockCPUsProvider
+}
+
+// NewMockCPUsProvider creates a new mock instance
+func NewMockCPUsProvider(ctrl *gomock.Controller) *MockCPUsProvider {
+	mock := &MockCPUsProvider{ctrl: ctrl}
+	mock.recorder = &MockCPUsProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockCPUsProvider) EXPECT() *MockCPUsProviderMockRecorder {
+	return m.recorder
+}
+
+// GetCPUs mocks base method
+func (m *MockCPUsProvider) GetCPUs(podUID, containerName string) []int64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCPUs", podUID, containerName)
+	ret0, _ := ret[0].([]int64)
+	return ret0
+}
+
+// GetCPUs indicates an expected call of GetCPUs
+func (mr *MockCPUsProviderMockRecorder) GetCPUs(podUID, containerName interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCPUs", reflect.TypeOf((*MockCPUsProvider)(nil).GetCPUs), podUID, containerName)
+}
+
+// GetAllocatableCPUs mocks base method
+func (m *MockCPUsProvider) GetAllocatableCPUs() []int64 {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllocatableCPUs")
+	ret0, _ := ret[0].([]int64)
+	return ret0
+}
+
+// GetAllocatableCPUs indicates an expected call of GetAllocatableCPUs
+func (mr *MockCPUsProviderMockRecorder) GetAllocatableCPUs() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllocatableCPUs", reflect.TypeOf((*MockCPUsProvider)(nil).GetAllocatableCPUs))
+}
+
+// MockMemoryProvider is a mock of MemoryProvider interface
+type MockMemoryProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockMemoryProviderMockRecorder
+}
+
+// MockMemoryProviderMockRecorder is the mock recorder for MockMemoryProvider
+type MockMemoryProviderMockRecorder struct {
+	mock *MockMemoryProvider
+}
+
+// NewMockMemoryProvider creates a new mock instance
+func NewMockMemoryProvider(ctrl *gomock.Controller) *MockMemoryProvider {
+	mock := &MockMemoryProvider{ctrl: ctrl}
+	mock.recorder = &MockMemoryProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockMemoryProvider) EXPECT() *MockMemoryProviderMockRecorder {
+	return m.recorder
+}
+
+// GetMemory mocks base method
+func (m *MockMemoryProvider) GetMemory(podUID, containerName string) []*v10.ContainerMemory {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetMemory", podUID, containerName)
+	ret0, _ := ret[0].([]*v10.ContainerMemory)
+	return ret0
+}
+
+// GetMemory indicates an expected call of GetMemory
+func (mr *MockMemoryProviderMockRecorder) GetMemory(podUID, containerName interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemory", reflect.TypeOf((*MockMemoryProvider)(nil).GetMemory), podUID, containerName)
+}
+
+// GetAllocatableMemory mocks base method
+func (m *MockMemoryProvider) GetAllocatableMemory() []*v10.ContainerMemory {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllocatableMemory")
+	ret0, _ := ret[0].([]*v10.ContainerMemory)
+	return ret0
+}
+
+// GetAllocatableMemory indicates an expected call of GetAllocatableMemory
+func (mr *MockMemoryProviderMockRecorder) GetAllocatableMemory() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllocatableMemory", reflect.TypeOf((*MockMemoryProvider)(nil).GetAllocatableMemory))
+}
--- a/pkg/kubelet/apis/podresources/types.go
+++ b/pkg/kubelet/apis/podresources/types.go
@@ -14,10 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */

+//go:generate mockgen -source=types.go -destination=testing/provider_mock.go -package=testing DevicesProvider,PodsProvider,CPUsProvider,MemoryProvider
 package podresources

 import (
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	podresourcesapi "k8s.io/kubelet/pkg/apis/podresources/v1"
 )