Remove dependency of the legacy client code from pkg/cmd directory pa…

…rt 2.

Signed-off-by: Xun Jiang <[email protected]>

changelogs/unreleased/6497-blackpiglet

@@ -0,0 +1 @@
+Remove dependency of the legacy client code from pkg/cmd directory part 2

pkg/cmd/cli/backup/download_test.go

@@ -27,22 +27,20 @@ import (
 	flag "github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"sigs.k8s.io/controller-runtime/pkg/client/fake"
 
 	"github.com/vmware-tanzu/velero/pkg/builder"
+	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
 	cmdtest "github.com/vmware-tanzu/velero/pkg/cmd/test"
-	"github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/scheme"
+	velerotest "github.com/vmware-tanzu/velero/pkg/test"
 	veleroexec "github.com/vmware-tanzu/velero/pkg/util/exec"
-
-	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
 )
 
 func TestNewDownloadCommand(t *testing.T) {
 	// create a factory
 	f := &factorymocks.Factory{}
 
 	backupName := "backup-1"
-	kbclient := fake.NewClientBuilder().WithScheme(scheme.Scheme).Build()
+	kbclient := velerotest.NewFakeControllerRuntimeClient(t)
 	err := kbclient.Create(context.Background(), builder.ForBackup(cmdtest.VeleroNameSpace, backupName).Result())
 	require.NoError(t, err)
 	err = kbclient.Create(context.Background(), builder.ForBackup(cmdtest.VeleroNameSpace, "bk-to-be-download").Result())

pkg/cmd/cli/backup/get.go

@@ -21,6 +21,8 @@ import (
 
 	"github.com/spf13/cobra"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
+	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/client"
@@ -38,19 +40,24 @@ func NewGetCommand(f client.Factory, use string) *cobra.Command {
 			err := output.ValidateFlags(c)
 			cmd.CheckError(err)
 
-			veleroClient, err := f.Client()
+			kbClient, err := f.KubebuilderClient()
 			cmd.CheckError(err)
 
-			var backups *api.BackupList
+			backups := new(api.BackupList)
 			if len(args) > 0 {
-				backups = new(api.BackupList)
 				for _, name := range args {
-					backup, err := veleroClient.VeleroV1().Backups(f.Namespace()).Get(context.TODO(), name, metav1.GetOptions{})
+					backup := new(api.Backup)
+					err := kbClient.Get(context.TODO(), kbclient.ObjectKey{Namespace: f.Namespace(), Name: name}, backup)
 					cmd.CheckError(err)
 					backups.Items = append(backups.Items, *backup)
 				}
 			} else {
-				backups, err = veleroClient.VeleroV1().Backups(f.Namespace()).List(context.TODO(), listOptions)
+				parsedSelector, err := labels.Parse(listOptions.LabelSelector)
+				cmd.CheckError(err)
+				err = kbClient.List(context.TODO(), backups, &kbclient.ListOptions{
+					LabelSelector: parsedSelector,
+					Namespace:     f.Namespace(),
+				})
 				cmd.CheckError(err)
 			}
 

pkg/cmd/cli/backup/get_test.go

@@ -17,22 +17,22 @@ limitations under the License.
 package backup
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
+	"github.com/vmware-tanzu/velero/pkg/builder"
+	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
 	cmdtest "github.com/vmware-tanzu/velero/pkg/cmd/test"
+	velerotest "github.com/vmware-tanzu/velero/pkg/test"
 	veleroexec "github.com/vmware-tanzu/velero/pkg/util/exec"
-
-	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
-	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
-	versionedmocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/mocks"
-	velerov1mocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1/mocks"
 )
 
 func TestNewGetCommand(t *testing.T) {
@@ -41,18 +41,16 @@ func TestNewGetCommand(t *testing.T) {
 	// create a factory
 	f := &factorymocks.Factory{}
 
-	backups := &velerov1mocks.BackupInterface{}
-	veleroV1 := &velerov1mocks.VeleroV1Interface{}
-	client := &versionedmocks.Interface{}
-	bk := &velerov1api.Backup{}
-	bkList := &velerov1api.BackupList{}
-
-	backups.On("List", mock.Anything, mock.Anything).Return(bkList, nil)
-	backups.On("Get", mock.Anything, mock.Anything, mock.Anything).Return(bk, nil)
-	veleroV1.On("Backups", mock.Anything).Return(backups, nil)
-	client.On("VeleroV1").Return(veleroV1, nil)
-	f.On("Client").Return(client, nil)
-	f.On("Namespace").Return(mock.Anything)
+	client := velerotest.NewFakeControllerRuntimeClient(t)
+
+	for _, backupName := range args {
+		backup := builder.ForBackup(cmdtest.VeleroNameSpace, backupName).Result()
+		err := client.Create(context.Background(), backup, &kbclient.CreateOptions{})
+		require.NoError(t, err)
+	}
+
+	f.On("KubebuilderClient").Return(client, nil)
+	f.On("Namespace").Return(cmdtest.VeleroNameSpace)
 
 	// create command
 	c := NewGetCommand(f, "velero backup get")

pkg/cmd/cli/backup/logs.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/spf13/cobra"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
 	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	"github.com/vmware-tanzu/velero/pkg/client"
@@ -49,13 +49,11 @@ func NewLogsCommand(f client.Factory) *cobra.Command {
 		Run: func(c *cobra.Command, args []string) {
 			backupName := args[0]
 
-			veleroClient, err := f.Client()
-			cmd.CheckError(err)
-
 			kbClient, err := f.KubebuilderClient()
 			cmd.CheckError(err)
 
-			backup, err := veleroClient.VeleroV1().Backups(f.Namespace()).Get(context.TODO(), backupName, metav1.GetOptions{})
+			backup := new(velerov1api.Backup)
+			err = kbClient.Get(context.TODO(), kbclient.ObjectKey{Namespace: f.Namespace(), Name: backupName}, backup)
 			if apierrors.IsNotFound(err) {
 				cmd.Exit("Backup %q does not exist.", backupName)
 			} else if err != nil {

pkg/cmd/cli/backup/logs_test.go

@@ -17,21 +17,20 @@ limitations under the License.
 package backup
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"os/exec"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+	"github.com/stretchr/testify/require"
+	kbclient "sigs.k8s.io/controller-runtime/pkg/client"
 
-	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
+	"github.com/vmware-tanzu/velero/pkg/builder"
 	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
 	cmdtest "github.com/vmware-tanzu/velero/pkg/cmd/test"
-	versionedmocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/mocks"
-	"github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/scheme"
-	velerov1mocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1/mocks"
+	velerotest "github.com/vmware-tanzu/velero/pkg/test"
 	veleroexec "github.com/vmware-tanzu/velero/pkg/util/exec"
 )
 
@@ -41,20 +40,13 @@ func TestNewLogsCommand(t *testing.T) {
 	// create a factory
 	f := &factorymocks.Factory{}
 
-	backups := &velerov1mocks.BackupInterface{}
-	veleroV1 := &velerov1mocks.VeleroV1Interface{}
-	client := &versionedmocks.Interface{}
-	bk := &velerov1api.Backup{}
-	bkList := &velerov1api.BackupList{}
-	kbclient := fake.NewClientBuilder().WithScheme(scheme.Scheme).Build()
+	kbClient := velerotest.NewFakeControllerRuntimeClient(t)
+	backup := builder.ForBackup(cmdtest.VeleroNameSpace, backupName).Result()
+	err := kbClient.Create(context.Background(), backup, &kbclient.CreateOptions{})
+	require.NoError(t, err)
 
-	backups.On("List", mock.Anything, mock.Anything).Return(bkList, nil)
-	backups.On("Get", mock.Anything, mock.Anything, mock.Anything).Return(bk, nil)
-	veleroV1.On("Backups", mock.Anything).Return(backups, nil)
-	client.On("VeleroV1").Return(veleroV1, nil)
-	f.On("Client").Return(client, nil)
-	f.On("Namespace").Return(mock.Anything)
-	f.On("KubebuilderClient").Return(kbclient, nil)
+	f.On("Namespace").Return(cmdtest.VeleroNameSpace)
+	f.On("KubebuilderClient").Return(kbClient, nil)
 
 	c := NewLogsCommand(f)
 	assert.Equal(t, "Get backup logs", c.Short)

pkg/cmd/cli/backuplocation/create_test.go

@@ -29,16 +29,9 @@ import (
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-	veleroflag "github.com/vmware-tanzu/velero/pkg/cmd/util/flag"
-	"github.com/vmware-tanzu/velero/pkg/test"
-
-	"sigs.k8s.io/controller-runtime/pkg/client/fake"
-
-	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
-	versionedmocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/mocks"
-	"github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/scheme"
-	velerov1mocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1/mocks"
+	veleroflag "github.com/vmware-tanzu/velero/pkg/cmd/util/flag"
+	velerotest "github.com/vmware-tanzu/velero/pkg/test"
 )
 
 func TestBuildBackupStorageLocationSetsNamespace(t *testing.T) {
@@ -149,16 +142,7 @@ func TestCreateCommand_Run(t *testing.T) {
 
 	args := []string{name, "arg2"}
 
-	backups := &velerov1mocks.BackupInterface{}
-	veleroV1 := &velerov1mocks.VeleroV1Interface{}
-	client := &versionedmocks.Interface{}
-	bk := &velerov1api.Backup{}
-	kbclient := fake.NewClientBuilder().WithScheme(scheme.Scheme).Build()
-
-	backups.On("Create", mock.Anything, mock.Anything, mock.Anything).Return(bk, nil)
-	veleroV1.On("Backups", mock.Anything).Return(backups, nil)
-	client.On("VeleroV1").Return(veleroV1, nil)
-	f.On("Client").Return(client, nil)
+	kbclient := velerotest.NewFakeControllerRuntimeClient(t)
 	f.On("Namespace").Return(mock.Anything)
 	f.On("KubebuilderClient").Return(kbclient, nil)
 
@@ -179,7 +163,7 @@ func TestCreateCommand_Run(t *testing.T) {
 	assert.Equal(t, backupSyncPeriod, o.BackupSyncPeriod.String())
 	assert.Equal(t, validationFrequency, o.ValidationFrequency.String())
 	assert.Equal(t, true, reflect.DeepEqual(bslConfig, o.Config))
-	assert.Equal(t, true, test.CompareSlice(strings.Split(labels, ","), strings.Split(o.Labels.String(), ",")))
+	assert.Equal(t, true, velerotest.CompareSlice(strings.Split(labels, ","), strings.Split(o.Labels.String(), ",")))
 	assert.Equal(t, caCertFile, o.CACertFile)
 	assert.Equal(t, accessMode, o.AccessMode.String())
 

pkg/cmd/cli/backuplocation/set_test.go

@@ -29,31 +29,19 @@ import (
 
 	cmdtest "github.com/vmware-tanzu/velero/pkg/cmd/test"
 	veleroflag "github.com/vmware-tanzu/velero/pkg/cmd/util/flag"
+	velerotest "github.com/vmware-tanzu/velero/pkg/test"
 
-	"sigs.k8s.io/controller-runtime/pkg/client/fake"
-
-	velerov1api "github.com/vmware-tanzu/velero/pkg/apis/velero/v1"
 	factorymocks "github.com/vmware-tanzu/velero/pkg/client/mocks"
-	versionedmocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/mocks"
-	"github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/scheme"
-	velerov1mocks "github.com/vmware-tanzu/velero/pkg/generated/clientset/versioned/typed/velero/v1/mocks"
 	veleroexec "github.com/vmware-tanzu/velero/pkg/util/exec"
 )
 
 func TestNewSetCommand(t *testing.T) {
 	backupName := "arg2"
 	// create a config for factory
 	f := &factorymocks.Factory{}
-	backups := &velerov1mocks.BackupInterface{}
-	veleroV1 := &velerov1mocks.VeleroV1Interface{}
-	client := &versionedmocks.Interface{}
-	bk := &velerov1api.Backup{}
-	kbclient := fake.NewClientBuilder().WithScheme(scheme.Scheme).Build()
-
-	backups.On("Create", mock.Anything, mock.Anything, mock.Anything).Return(bk, nil)
-	veleroV1.On("Backups", mock.Anything).Return(backups, nil)
-	client.On("VeleroV1").Return(veleroV1, nil)
-	f.On("Client").Return(client, nil)
+
+	kbclient := velerotest.NewFakeControllerRuntimeClient(t)
+
 	f.On("Namespace").Return(mock.Anything)
 	f.On("KubebuilderClient").Return(kbclient, nil)
 
@@ -97,16 +85,9 @@ func TestSetCommand_Execute(t *testing.T) {
 	if os.Getenv(cmdtest.CaptureFlag) == "1" {
 		// create a config for factory
 		f := &factorymocks.Factory{}
-		backups := &velerov1mocks.BackupInterface{}
-		veleroV1 := &velerov1mocks.VeleroV1Interface{}
-		client := &versionedmocks.Interface{}
-		bk := &velerov1api.Backup{}
-		kbclient := fake.NewClientBuilder().WithScheme(scheme.Scheme).Build()
-
-		backups.On("Create", mock.Anything, mock.Anything, mock.Anything).Return(bk, nil)
-		veleroV1.On("Backups", mock.Anything).Return(backups, nil)
-		client.On("VeleroV1").Return(veleroV1, nil)
-		f.On("Client").Return(client, nil)
+
+		kbclient := velerotest.NewFakeControllerRuntimeClient(t)
+
 		f.On("Namespace").Return(mock.Anything)
 		f.On("KubebuilderClient").Return(kbclient, nil)