diff --git a/bootstrap/kubeadm/api/v1alpha4/kubeadm_types_test.go b/bootstrap/kubeadm/api/v1alpha4/kubeadm_types_test.go index 03cd38ef7b34..9c2fdc6e5034 100644 --- a/bootstrap/kubeadm/api/v1alpha4/kubeadm_types_test.go +++ b/bootstrap/kubeadm/api/v1alpha4/kubeadm_types_test.go @@ -71,7 +71,7 @@ func TestUnmarshalJSON(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(newbts).To(Equal(rt.bts)) + g.Expect(newbts).To(BeComparableTo(rt.bts)) }) } } @@ -182,7 +182,7 @@ func TestNewBootstrapTokenString(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(actual).To(Equal(rt.bts)) + g.Expect(actual).To(BeComparableTo(rt.bts)) }) } } diff --git a/bootstrap/kubeadm/api/v1beta1/kubeadm_types_test.go b/bootstrap/kubeadm/api/v1beta1/kubeadm_types_test.go index 9f87544e8515..98aacc8852ea 100644 --- a/bootstrap/kubeadm/api/v1beta1/kubeadm_types_test.go +++ b/bootstrap/kubeadm/api/v1beta1/kubeadm_types_test.go @@ -129,7 +129,7 @@ func TestBootstrapTokenStringUnmarshalJSON(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(newbts).To(Equal(rt.bts)) + g.Expect(newbts).To(BeComparableTo(rt.bts)) }) } } @@ -240,7 +240,7 @@ func TestNewBootstrapTokenString(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(actual).To(Equal(rt.bts)) + g.Expect(actual).To(BeComparableTo(rt.bts)) }) } } diff --git a/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go b/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go index 374b269fae8a..ef334b2eda94 100644 --- a/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go +++ b/bootstrap/kubeadm/internal/controllers/kubeadmconfig_controller_test.go @@ -338,7 +338,7 @@ func TestKubeadmConfigReconciler_ReturnEarlyIfClusterInfraNotReady(t *testing.T) expectedResult := reconcile.Result{} actualResult, actualError := k.Reconcile(ctx, request) - g.Expect(actualResult).To(Equal(expectedResult)) + g.Expect(actualResult).To(BeComparableTo(expectedResult)) g.Expect(actualError).ToNot(HaveOccurred()) assertHasFalseCondition(g, myclient, request, bootstrapv1.DataSecretAvailableCondition, clusterv1.ConditionSeverityInfo, bootstrapv1.WaitingForClusterInfrastructureReason) } @@ -1566,7 +1566,7 @@ func TestKubeadmConfigReconciler_Reconcile_DiscoveryReconcileFailureBehaviors(t g := NewWithT(t) res, err := k.reconcileDiscovery(ctx, tc.cluster, tc.config, secret.Certificates{}) - g.Expect(res).To(Equal(tc.result)) + g.Expect(res).To(BeComparableTo(tc.result)) if tc.err == nil { g.Expect(err).ToNot(HaveOccurred()) } else { @@ -2084,7 +2084,7 @@ func TestKubeadmConfigReconciler_ResolveFiles(t *testing.T) { files, err := k.resolveFiles(ctx, tc.cfg) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(files).To(Equal(tc.expect)) + g.Expect(files).To(BeComparableTo(tc.expect)) for _, file := range tc.cfg.Spec.Files { if contentFrom[file.Path] { g.Expect(file.ContentFrom).NotTo(BeNil()) @@ -2211,7 +2211,7 @@ func TestKubeadmConfigReconciler_ResolveUsers(t *testing.T) { users, err := k.resolveUsers(ctx, tc.cfg) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(users).To(Equal(tc.expect)) + g.Expect(users).To(BeComparableTo(tc.expect)) for _, user := range tc.cfg.Spec.Users { if passwdFrom[user.Name] { g.Expect(user.PasswdFrom).NotTo(BeNil()) diff --git a/bootstrap/kubeadm/types/upstreamv1beta1/bootstraptokenstring_test.go b/bootstrap/kubeadm/types/upstreamv1beta1/bootstraptokenstring_test.go index eef137afde43..1b7c5804b801 100644 --- a/bootstrap/kubeadm/types/upstreamv1beta1/bootstraptokenstring_test.go +++ b/bootstrap/kubeadm/types/upstreamv1beta1/bootstraptokenstring_test.go @@ -71,7 +71,7 @@ func TestUnmarshalJSON(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(newbts).To(Equal(rt.bts)) + g.Expect(newbts).To(BeComparableTo(rt.bts)) }) } } @@ -182,7 +182,7 @@ func TestNewBootstrapTokenString(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(actual).To(Equal(rt.bts)) + g.Expect(actual).To(BeComparableTo(rt.bts)) }) } } @@ -217,7 +217,7 @@ func TestNewBootstrapTokenStringFromIDAndSecret(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(actual).To(Equal(rt.bts)) + g.Expect(actual).To(BeComparableTo(rt.bts)) }) } } diff --git a/bootstrap/kubeadm/types/upstreamv1beta2/bootstraptokenstring_test.go b/bootstrap/kubeadm/types/upstreamv1beta2/bootstraptokenstring_test.go index 78c2b98a7766..154ab8540ef1 100644 --- a/bootstrap/kubeadm/types/upstreamv1beta2/bootstraptokenstring_test.go +++ b/bootstrap/kubeadm/types/upstreamv1beta2/bootstraptokenstring_test.go @@ -71,7 +71,7 @@ func TestUnmarshalJSON(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(newbts).To(Equal(rt.bts)) + g.Expect(newbts).To(BeComparableTo(rt.bts)) }) } } @@ -182,7 +182,7 @@ func TestNewBootstrapTokenString(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(actual).To(Equal(rt.bts)) + g.Expect(actual).To(BeComparableTo(rt.bts)) }) } } @@ -217,7 +217,7 @@ func TestNewBootstrapTokenStringFromIDAndSecret(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(actual).To(Equal(rt.bts)) + g.Expect(actual).To(BeComparableTo(rt.bts)) }) } } diff --git a/bootstrap/kubeadm/types/utils_test.go b/bootstrap/kubeadm/types/utils_test.go index 62a0a72d48f5..25af247aa3a4 100644 --- a/bootstrap/kubeadm/types/utils_test.go +++ b/bootstrap/kubeadm/types/utils_test.go @@ -139,7 +139,7 @@ func TestKubeVersionToKubeadmAPIGroupVersion(t *testing.T) { return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } @@ -496,7 +496,7 @@ func TestUnmarshalClusterConfiguration(t *testing.T) { return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want), cmp.Diff(tt.want, got)) + g.Expect(got).To(BeComparableTo(tt.want), cmp.Diff(tt.want, got)) }) } } @@ -551,7 +551,7 @@ func TestUnmarshalClusterStatus(t *testing.T) { return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want), cmp.Diff(tt.want, got)) + g.Expect(got).To(BeComparableTo(tt.want), cmp.Diff(tt.want, got)) }) } } @@ -610,7 +610,7 @@ func TestUnmarshalInitConfiguration(t *testing.T) { return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want), cmp.Diff(tt.want, got)) + g.Expect(got).To(BeComparableTo(tt.want), cmp.Diff(tt.want, got)) }) } } @@ -669,7 +669,7 @@ func TestUnmarshalJoinConfiguration(t *testing.T) { return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want), cmp.Diff(tt.want, got)) + g.Expect(got).To(BeComparableTo(tt.want), cmp.Diff(tt.want, got)) }) } } diff --git a/cmd/clusterctl/api/v1alpha3/metadata_type_test.go b/cmd/clusterctl/api/v1alpha3/metadata_type_test.go index ce71a64343a9..6aaa734bd294 100644 --- a/cmd/clusterctl/api/v1alpha3/metadata_type_test.go +++ b/cmd/clusterctl/api/v1alpha3/metadata_type_test.go @@ -65,7 +65,7 @@ func TestGetReleaseSeriesForContract(t *testing.T) { g := NewWithT(t) m := &Metadata{ReleaseSeries: test.releaseSeries} - g.Expect(m.GetReleaseSeriesForContract(test.contract)).To(Equal(test.expectedReleaseSeries)) + g.Expect(m.GetReleaseSeriesForContract(test.contract)).To(BeComparableTo(test.expectedReleaseSeries)) }) } } diff --git a/cmd/clusterctl/client/cluster/cert_manager_test.go b/cmd/clusterctl/client/cluster/cert_manager_test.go index 5e8ecad9e2fc..e85ae5d828e2 100644 --- a/cmd/clusterctl/client/cluster/cert_manager_test.go +++ b/cmd/clusterctl/client/cluster/cert_manager_test.go @@ -715,7 +715,7 @@ func Test_certManagerClient_PlanUpgrade(t *testing.T) { actualPlan, err := cm.PlanUpgrade() if tt.expectErr { g.Expect(err).To(HaveOccurred()) - g.Expect(actualPlan).To(Equal(CertManagerUpgradePlan{})) + g.Expect(actualPlan).To(BeComparableTo(CertManagerUpgradePlan{})) return } g.Expect(err).ToNot(HaveOccurred()) diff --git a/cmd/clusterctl/client/cluster/mover_test.go b/cmd/clusterctl/client/cluster/mover_test.go index 823ffb432990..a5832887c31b 100644 --- a/cmd/clusterctl/client/cluster/mover_test.go +++ b/cmd/clusterctl/client/cluster/mover_test.go @@ -912,7 +912,7 @@ func Test_objectMover_restoreTargetObject(t *testing.T) { g.Expect(oAfter.GetName()).Should(Equal(oTo.GetName())) g.Expect(oAfter.GetCreationTimestamp()).Should(Equal(oTo.GetCreationTimestamp())) g.Expect(oAfter.GetUID()).Should(Equal(oTo.GetUID())) - g.Expect(oAfter.GetOwnerReferences()).Should(Equal(oTo.GetOwnerReferences())) + g.Expect(oAfter.GetOwnerReferences()).Should(BeComparableTo(oTo.GetOwnerReferences())) } }) } diff --git a/cmd/clusterctl/client/cluster/topology_test.go b/cmd/clusterctl/client/cluster/topology_test.go index 56ce0ac4f803..ee97af34defd 100644 --- a/cmd/clusterctl/client/cluster/topology_test.go +++ b/cmd/clusterctl/client/cluster/topology_test.go @@ -300,7 +300,7 @@ func Test_topologyClient_Plan(t *testing.T) { g.Expect(res.ReconciledCluster).To(BeNil()) } else { g.Expect(res.ReconciledCluster).NotTo(BeNil()) - g.Expect(*res.ReconciledCluster).To(Equal(*tt.want.reconciledCluster)) + g.Expect(*res.ReconciledCluster).To(BeComparableTo(*tt.want.reconciledCluster)) } // Check the created objects. diff --git a/cmd/clusterctl/client/cluster/upgrader_test.go b/cmd/clusterctl/client/cluster/upgrader_test.go index 975313e3a93a..8c93a536e51a 100644 --- a/cmd/clusterctl/client/cluster/upgrader_test.go +++ b/cmd/clusterctl/client/cluster/upgrader_test.go @@ -400,7 +400,7 @@ func Test_providerUpgrader_Plan(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want), cmp.Diff(got, tt.want)) + g.Expect(got).To(BeComparableTo(tt.want), cmp.Diff(got, tt.want)) }) } } @@ -869,7 +869,7 @@ func Test_providerUpgrader_createCustomPlan(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/cmd/clusterctl/client/config/reader_memory_test.go b/cmd/clusterctl/client/config/reader_memory_test.go index 0ea0232a5d97..ebff5a6c8ae8 100644 --- a/cmd/clusterctl/client/config/reader_memory_test.go +++ b/cmd/clusterctl/client/config/reader_memory_test.go @@ -64,11 +64,11 @@ func TestMemoryReader(t *testing.T) { providersOut := []configProvider{} g.Expect(f.UnmarshalKey("providers", &providersOut)).To(Succeed()) - g.Expect(providersOut).To(Equal(tt.providers)) + g.Expect(providersOut).To(BeComparableTo(tt.providers)) imagesOut := map[string]imageMeta{} g.Expect(f.UnmarshalKey("images", &imagesOut)).To(Succeed()) - g.Expect(imagesOut).To(Equal(tt.imageMetas)) + g.Expect(imagesOut).To(BeComparableTo(tt.imageMetas)) for n, v := range tt.variables { outV, err := f.Get(n) diff --git a/cmd/clusterctl/client/delete_test.go b/cmd/clusterctl/client/delete_test.go index 8c61d0945394..8a65f7aedc0d 100644 --- a/cmd/clusterctl/client/delete_test.go +++ b/cmd/clusterctl/client/delete_test.go @@ -187,7 +187,7 @@ func Test_clusterctlClient_Delete(t *testing.T) { gotProvidersSet.Insert(gotProvider.Name) } - g.Expect(gotProvidersSet).To(Equal(tt.wantProviders)) + g.Expect(gotProvidersSet).To(BeComparableTo(tt.wantProviders)) }) } } diff --git a/cmd/clusterctl/client/repository/components_test.go b/cmd/clusterctl/client/repository/components_test.go index adfc470d440b..46beda4a39e5 100644 --- a/cmd/clusterctl/client/repository/components_test.go +++ b/cmd/clusterctl/client/repository/components_test.go @@ -682,7 +682,7 @@ func Test_addCommonLabels(t *testing.T) { g := NewWithT(t) got := addCommonLabels(tt.args.objs, config.NewProvider(tt.args.name, "", tt.args.providerType)) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } @@ -721,5 +721,5 @@ func TestAlterComponents(t *testing.T) { if err := AlterComponents(c, alterFn); err != nil { t.Errorf("AlterComponents() error = %v", err) } - g.Expect(c.objs).To(Equal(want)) + g.Expect(c.objs).To(BeComparableTo(want)) } diff --git a/cmd/clusterctl/client/repository/metadata_client_test.go b/cmd/clusterctl/client/repository/metadata_client_test.go index e5d5be486e0e..7fd178877022 100644 --- a/cmd/clusterctl/client/repository/metadata_client_test.go +++ b/cmd/clusterctl/client/repository/metadata_client_test.go @@ -128,7 +128,7 @@ func Test_metadataClient_Get(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/cmd/clusterctl/client/tree/tree_test.go b/cmd/clusterctl/client/tree/tree_test.go index d92bb1caf84e..9b3253958d58 100644 --- a/cmd/clusterctl/client/tree/tree_test.go +++ b/cmd/clusterctl/client/tree/tree_test.go @@ -290,7 +290,7 @@ func Test_createGroupNode(t *testing.T) { want.SetName(got.GetName()) want.SetUID(got.GetUID()) - g.Expect(got).To(Equal(want)) + g.Expect(got).To(BeComparableTo(want)) } func Test_updateGroupNode(t *testing.T) { @@ -367,7 +367,7 @@ func Test_updateGroupNode(t *testing.T) { g := NewWithT(t) updateGroupNode(group, GetReadyCondition(group), obj, GetReadyCondition(obj)) - g.Expect(group).To(Equal(want)) + g.Expect(group).To(BeComparableTo(want)) } func Test_Add_setsShowObjectConditionsAnnotation(t *testing.T) { diff --git a/cmd/clusterctl/client/upgrade_test.go b/cmd/clusterctl/client/upgrade_test.go index 74097042c79c..22eaa7a0d924 100644 --- a/cmd/clusterctl/client/upgrade_test.go +++ b/cmd/clusterctl/client/upgrade_test.go @@ -81,11 +81,11 @@ func Test_clusterctlClient_PlanCertUpgrade(t *testing.T) { actualPlan, err := tt.client.PlanCertManagerUpgrade(options) if tt.expectErr { g.Expect(err).To(HaveOccurred()) - g.Expect(actualPlan).To(Equal(CertManagerUpgradePlan{})) + g.Expect(actualPlan).To(BeComparableTo(CertManagerUpgradePlan{})) return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(actualPlan).To(Equal(certManagerPlan)) + g.Expect(actualPlan).To(BeComparableTo(certManagerPlan)) }) } } @@ -300,7 +300,7 @@ func Test_clusterctlClient_ApplyUpgrade(t *testing.T) { for i := range gotProviders.Items { tt.wantProviders.Items[i].ResourceVersion = gotProviders.Items[i].ResourceVersion } - g.Expect(gotProviders).To(Equal(tt.wantProviders), cmp.Diff(gotProviders, tt.wantProviders)) + g.Expect(gotProviders).To(BeComparableTo(tt.wantProviders), cmp.Diff(gotProviders, tt.wantProviders)) }) } } @@ -476,7 +476,7 @@ func Test_parseUpgradeItem(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/cmd/clusterctl/cmd/version_checker_test.go b/cmd/clusterctl/cmd/version_checker_test.go index 26218a573a32..aa78ab54f537 100644 --- a/cmd/clusterctl/cmd/version_checker_test.go +++ b/cmd/clusterctl/cmd/version_checker_test.go @@ -294,7 +294,7 @@ func TestVersionChecker_WriteStateFile(t *testing.T) { g.Expect(err).ToNot(HaveOccurred()) var actualVersionState VersionState g.Expect(yaml.Unmarshal(fb, &actualVersionState)).To(Succeed()) - g.Expect(actualVersionState.LatestRelease).To(Equal(*release)) + g.Expect(actualVersionState.LatestRelease).To(BeComparableTo(*release)) } func TestVersionChecker_ReadFromStateFile(t *testing.T) { diff --git a/controllers/external/util_test.go b/controllers/external/util_test.go index 4c25196cef48..012445478e8a 100644 --- a/controllers/external/util_test.go +++ b/controllers/external/util_test.go @@ -65,7 +65,7 @@ func TestGetResourceFound(t *testing.T) { fakeClient := fake.NewClientBuilder().WithObjects(testResource.DeepCopy()).Build() got, err := Get(ctx, fakeClient, testResourceReference, metav1.NamespaceDefault) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(testResource)) + g.Expect(got).To(BeComparableTo(testResource)) } func TestGetResourceNotFound(t *testing.T) { @@ -203,7 +203,7 @@ func TestCloneTemplateResourceFound(t *testing.T) { cloneSpec, ok, err := unstructured.NestedMap(clone.UnstructuredContent(), "spec") g.Expect(err).ToNot(HaveOccurred()) g.Expect(ok).To(BeTrue()) - g.Expect(cloneSpec).To(Equal(expectedSpec)) + g.Expect(cloneSpec).To(BeComparableTo(expectedSpec)) cloneLabels := clone.GetLabels() g.Expect(cloneLabels).To(HaveKeyWithValue(clusterv1.ClusterNameLabel, testClusterName)) @@ -284,7 +284,7 @@ func TestCloneTemplateResourceFoundNoOwner(t *testing.T) { cloneSpec, ok, err := unstructured.NestedMap(clone.UnstructuredContent(), "spec") g.Expect(err).ToNot(HaveOccurred()) g.Expect(ok).To(BeTrue()) - g.Expect(cloneSpec).To(Equal(expectedSpec)) + g.Expect(cloneSpec).To(BeComparableTo(expectedSpec)) } func TestCloneTemplateMissingSpecTemplate(t *testing.T) { diff --git a/controllers/noderefutil/util_test.go b/controllers/noderefutil/util_test.go index a071e27efb4d..0e35e2aebed9 100644 --- a/controllers/noderefutil/util_test.go +++ b/controllers/noderefutil/util_test.go @@ -222,7 +222,7 @@ func TestGetReadyCondition(t *testing.T) { t.Run(test.name, func(t *testing.T) { g := NewWithT(t) - g.Expect(GetReadyCondition(test.nodeStatus)).To(Equal(test.expectedCondition)) + g.Expect(GetReadyCondition(test.nodeStatus)).To(BeComparableTo(test.expectedCondition)) }) } } diff --git a/controlplane/kubeadm/internal/controllers/controller_test.go b/controlplane/kubeadm/internal/controllers/controller_test.go index 1798fe43dad9..b075f89948cc 100644 --- a/controlplane/kubeadm/internal/controllers/controller_test.go +++ b/controlplane/kubeadm/internal/controllers/controller_test.go @@ -94,7 +94,7 @@ func TestClusterToKubeadmControlPlane(t *testing.T) { } got := r.ClusterToKubeadmControlPlane(ctx, cluster) - g.Expect(got).To(Equal(expectedResult)) + g.Expect(got).To(BeComparableTo(expectedResult)) } func TestClusterToKubeadmControlPlaneNoControlPlane(t *testing.T) { @@ -158,7 +158,7 @@ func TestReconcileReturnErrorWhenOwnerClusterIsMissing(t *testing.T) { result, err := r.Reconcile(ctx, ctrl.Request{NamespacedName: util.ObjectKey(kcp)}) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) // calling reconcile should return error g.Expect(env.CleanupAndWait(ctx, cluster)).To(Succeed()) @@ -202,7 +202,7 @@ func TestReconcileUpdateObservedGeneration(t *testing.T) { // call reconcile the first time, so we can check if observedGeneration is set when adding a finalizer result, err := r.Reconcile(ctx, ctrl.Request{NamespacedName: util.ObjectKey(kcp)}) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Eventually(func() int64 { errGettingObject = env.Get(ctx, util.ObjectKey(kcp), kcp) @@ -264,7 +264,7 @@ func TestReconcileNoClusterOwnerRef(t *testing.T) { result, err := r.Reconcile(ctx, ctrl.Request{NamespacedName: util.ObjectKey(kcp)}) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) machineList := &clusterv1.MachineList{} g.Expect(fakeClient.List(ctx, machineList, client.InNamespace(metav1.NamespaceDefault))).To(Succeed()) @@ -454,14 +454,14 @@ func TestReconcileClusterNoEndpoints(t *testing.T) { result, err := r.Reconcile(ctx, ctrl.Request{NamespacedName: util.ObjectKey(kcp)}) g.Expect(err).ToNot(HaveOccurred()) // this first requeue is to add finalizer - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(r.Client.Get(ctx, util.ObjectKey(kcp), kcp)).To(Succeed()) g.Expect(kcp.Finalizers).To(ContainElement(controlplanev1.KubeadmControlPlaneFinalizer)) result, err = r.Reconcile(ctx, ctrl.Request{NamespacedName: util.ObjectKey(kcp)}) g.Expect(err).ToNot(HaveOccurred()) // TODO: this should stop to re-queue as soon as we have a proper remote cluster cache in place. - g.Expect(result).To(Equal(ctrl.Result{Requeue: false, RequeueAfter: 20 * time.Second})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: false, RequeueAfter: 20 * time.Second})) g.Expect(r.Client.Get(ctx, util.ObjectKey(kcp), kcp)).To(Succeed()) // Always expect that the Finalizer is set on the passed in resource @@ -1339,7 +1339,7 @@ kubernetesVersion: metav1.16.1`, result, err := r.Reconcile(ctx, ctrl.Request{NamespacedName: util.ObjectKey(kcp)}) g.Expect(err).ToNot(HaveOccurred()) // this first requeue is to add finalizer - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(env.GetAPIReader().Get(ctx, util.ObjectKey(kcp), kcp)).To(Succeed()) g.Expect(kcp.Finalizers).To(ContainElement(controlplanev1.KubeadmControlPlaneFinalizer)) @@ -1748,22 +1748,22 @@ func TestKubeadmControlPlaneReconciler_syncMachines(t *testing.T) { // Verify Node timeout values g.Expect(updatedInplaceMutatingMachine.Spec.NodeDrainTimeout).Should(And( Not(BeNil()), - HaveValue(Equal(*kcp.Spec.MachineTemplate.NodeDrainTimeout)), + HaveValue(BeComparableTo(*kcp.Spec.MachineTemplate.NodeDrainTimeout)), )) g.Expect(updatedInplaceMutatingMachine.Spec.NodeDeletionTimeout).Should(And( Not(BeNil()), - HaveValue(Equal(*kcp.Spec.MachineTemplate.NodeDeletionTimeout)), + HaveValue(BeComparableTo(*kcp.Spec.MachineTemplate.NodeDeletionTimeout)), )) g.Expect(updatedInplaceMutatingMachine.Spec.NodeVolumeDetachTimeout).Should(And( Not(BeNil()), - HaveValue(Equal(*kcp.Spec.MachineTemplate.NodeVolumeDetachTimeout)), + HaveValue(BeComparableTo(*kcp.Spec.MachineTemplate.NodeVolumeDetachTimeout)), )) // Verify that the non in-place mutating fields remain the same. g.Expect(updatedInplaceMutatingMachine.Spec.FailureDomain).Should(Equal(inPlaceMutatingMachine.Spec.FailureDomain)) g.Expect(updatedInplaceMutatingMachine.Spec.ProviderID).Should(Equal(inPlaceMutatingMachine.Spec.ProviderID)) g.Expect(updatedInplaceMutatingMachine.Spec.Version).Should(Equal(inPlaceMutatingMachine.Spec.Version)) - g.Expect(updatedInplaceMutatingMachine.Spec.InfrastructureRef).Should(Equal(inPlaceMutatingMachine.Spec.InfrastructureRef)) - g.Expect(updatedInplaceMutatingMachine.Spec.Bootstrap).Should(Equal(inPlaceMutatingMachine.Spec.Bootstrap)) + g.Expect(updatedInplaceMutatingMachine.Spec.InfrastructureRef).Should(BeComparableTo(inPlaceMutatingMachine.Spec.InfrastructureRef)) + g.Expect(updatedInplaceMutatingMachine.Spec.Bootstrap).Should(BeComparableTo(inPlaceMutatingMachine.Spec.Bootstrap)) // Verify in-place mutable fields are updated on InfrastructureMachine updatedInfraMachine = existingInfraMachine.DeepCopy() @@ -1783,7 +1783,7 @@ func TestKubeadmControlPlaneReconciler_syncMachines(t *testing.T) { // Verify Annotations g.Expect(updatedKubeadmConfig.GetAnnotations()).Should(Equal(kcp.Spec.MachineTemplate.ObjectMeta.Annotations)) // Verify spec remains the same - g.Expect(updatedKubeadmConfig.Spec).Should(Equal(existingKubeadmConfig.Spec)) + g.Expect(updatedKubeadmConfig.Spec).Should(BeComparableTo(existingKubeadmConfig.Spec)) // The deleting machine should not change. updatedDeletingMachine := deletingMachine.DeepCopy() @@ -1803,7 +1803,7 @@ func TestKubeadmControlPlaneReconciler_syncMachines(t *testing.T) { g.Expect(updatedDeletingMachine.Labels).Should(Equal(deletingMachine.Labels)) g.Expect(updatedDeletingMachine.Annotations).Should(Equal(deletingMachine.Annotations)) // Verify the machine spec is unchanged. - g.Expect(updatedDeletingMachine.Spec).Should(Equal(deletingMachine.Spec)) + g.Expect(updatedDeletingMachine.Spec).Should(BeComparableTo(deletingMachine.Spec)) } func TestKubeadmControlPlaneReconciler_updateCoreDNS(t *testing.T) { @@ -2130,7 +2130,7 @@ func TestKubeadmControlPlaneReconciler_reconcileDelete(t *testing.T) { } result, err = r.reconcileDelete(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(err).ToNot(HaveOccurred()) g.Expect(kcp.Finalizers).To(BeEmpty()) }) @@ -2179,7 +2179,7 @@ func TestKubeadmControlPlaneReconciler_reconcileDelete(t *testing.T) { } result, err := r.reconcileDelete(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{RequeueAfter: deleteRequeueAfter})) + g.Expect(result).To(BeComparableTo(ctrl.Result{RequeueAfter: deleteRequeueAfter})) g.Expect(err).ToNot(HaveOccurred()) g.Expect(kcp.Finalizers).To(ContainElement(controlplanev1.KubeadmControlPlaneFinalizer)) @@ -2237,7 +2237,7 @@ func TestKubeadmControlPlaneReconciler_reconcileDelete(t *testing.T) { } result, err := r.reconcileDelete(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{RequeueAfter: deleteRequeueAfter})) + g.Expect(result).To(BeComparableTo(ctrl.Result{RequeueAfter: deleteRequeueAfter})) g.Expect(err).ToNot(HaveOccurred()) g.Expect(kcp.Finalizers).To(ContainElement(controlplanev1.KubeadmControlPlaneFinalizer)) @@ -2274,7 +2274,7 @@ func TestKubeadmControlPlaneReconciler_reconcileDelete(t *testing.T) { } result, err := r.reconcileDelete(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(err).ToNot(HaveOccurred()) g.Expect(kcp.Finalizers).To(BeEmpty()) }) diff --git a/controlplane/kubeadm/internal/controllers/helpers_test.go b/controlplane/kubeadm/internal/controllers/helpers_test.go index 0992245495b1..8ce3ca4957d7 100644 --- a/controlplane/kubeadm/internal/controllers/helpers_test.go +++ b/controlplane/kubeadm/internal/controllers/helpers_test.go @@ -141,7 +141,7 @@ func TestReconcileKubeconfigMissingCACertificate(t *testing.T) { result, err := r.reconcileKubeconfig(ctx, controlPlane) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{RequeueAfter: dependentCertRequeueAfter})) + g.Expect(result).To(BeComparableTo(ctrl.Result{RequeueAfter: dependentCertRequeueAfter})) kubeconfigSecret := &corev1.Secret{} secretName := client.ObjectKey{ @@ -279,7 +279,7 @@ func TestKubeadmControlPlaneReconciler_reconcileKubeconfig(t *testing.T) { result, err := r.reconcileKubeconfig(ctx, controlPlane) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) kubeconfigSecret := &corev1.Secret{} secretName := client.ObjectKey{ @@ -548,7 +548,7 @@ func TestKubeadmControlPlaneReconciler_computeDesiredMachine(t *testing.T) { g.Expect(createdMachine.Namespace).To(Equal(kcp.Namespace)) g.Expect(createdMachine.OwnerReferences).To(HaveLen(1)) g.Expect(createdMachine.OwnerReferences).To(ContainElement(*metav1.NewControllerRef(kcp, controlplanev1.GroupVersion.WithKind("KubeadmControlPlane")))) - g.Expect(createdMachine.Spec).To(Equal(expectedMachineSpec)) + g.Expect(createdMachine.Spec).To(BeComparableTo(expectedMachineSpec)) // Verify that the machineTemplate.ObjectMeta has been propagated to the Machine. // Verify labels. @@ -624,7 +624,7 @@ func TestKubeadmControlPlaneReconciler_computeDesiredMachine(t *testing.T) { g.Expect(updatedMachine.Namespace).To(Equal(kcp.Namespace)) g.Expect(updatedMachine.OwnerReferences).To(HaveLen(1)) g.Expect(updatedMachine.OwnerReferences).To(ContainElement(*metav1.NewControllerRef(kcp, controlplanev1.GroupVersion.WithKind("KubeadmControlPlane")))) - g.Expect(updatedMachine.Spec).To(Equal(expectedMachineSpec)) + g.Expect(updatedMachine.Spec).To(BeComparableTo(expectedMachineSpec)) // Verify the Name and UID of the Machine remain unchanged g.Expect(updatedMachine.Name).To(Equal(machineName)) @@ -701,7 +701,7 @@ func TestKubeadmControlPlaneReconciler_generateKubeadmConfig(t *testing.T) { g.Expect(fakeClient.Get(ctx, key, bootstrapConfig)).To(Succeed()) g.Expect(bootstrapConfig.OwnerReferences).To(HaveLen(1)) g.Expect(bootstrapConfig.OwnerReferences).To(ContainElement(expectedOwner)) - g.Expect(bootstrapConfig.Spec).To(Equal(spec)) + g.Expect(bootstrapConfig.Spec).To(BeComparableTo(spec)) } func TestKubeadmControlPlaneReconciler_adoptKubeconfigSecret(t *testing.T) { diff --git a/controlplane/kubeadm/internal/controllers/scale_test.go b/controlplane/kubeadm/internal/controllers/scale_test.go index 393e08de4f65..f40396259389 100644 --- a/controlplane/kubeadm/internal/controllers/scale_test.go +++ b/controlplane/kubeadm/internal/controllers/scale_test.go @@ -79,7 +79,7 @@ func TestKubeadmControlPlaneReconciler_initializeControlPlane(t *testing.T) { } result, err := r.initializeControlPlane(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) g.Expect(err).ToNot(HaveOccurred()) machineList := &clusterv1.MachineList{} @@ -156,7 +156,7 @@ func TestKubeadmControlPlaneReconciler_scaleUpControlPlane(t *testing.T) { } result, err := r.scaleUpControlPlane(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) g.Expect(err).ToNot(HaveOccurred()) controlPlaneMachines := clusterv1.MachineList{} @@ -221,7 +221,7 @@ func TestKubeadmControlPlaneReconciler_scaleUpControlPlane(t *testing.T) { result, err := r.scaleUpControlPlane(context.Background(), controlPlane) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{RequeueAfter: preflightFailedRequeueAfter})) + g.Expect(result).To(BeComparableTo(ctrl.Result{RequeueAfter: preflightFailedRequeueAfter})) // scaleUpControlPlane is never called due to health check failure and new machine is not created to scale up. controlPlaneMachines := &clusterv1.MachineList{} @@ -235,7 +235,7 @@ func TestKubeadmControlPlaneReconciler_scaleUpControlPlane(t *testing.T) { for _, m := range endMachines { bm, ok := beforeMachines[m.Name] g.Expect(ok).To(BeTrue()) - g.Expect(m).To(Equal(bm)) + g.Expect(m).To(BeComparableTo(bm)) } }) } @@ -275,7 +275,7 @@ func TestKubeadmControlPlaneReconciler_scaleDownControlPlane_NoError(t *testing. result, err := r.scaleDownControlPlane(context.Background(), controlPlane, controlPlane.Machines) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) controlPlaneMachines := clusterv1.MachineList{} g.Expect(fakeClient.List(context.Background(), &controlPlaneMachines)).To(Succeed()) @@ -317,7 +317,7 @@ func TestKubeadmControlPlaneReconciler_scaleDownControlPlane_NoError(t *testing. result, err := r.scaleDownControlPlane(context.Background(), controlPlane, controlPlane.Machines) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) controlPlaneMachines := clusterv1.MachineList{} g.Expect(fakeClient.List(context.Background(), &controlPlaneMachines)).To(Succeed()) @@ -355,7 +355,7 @@ func TestKubeadmControlPlaneReconciler_scaleDownControlPlane_NoError(t *testing. result, err := r.scaleDownControlPlane(context.Background(), controlPlane, controlPlane.Machines) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{RequeueAfter: preflightFailedRequeueAfter})) + g.Expect(result).To(BeComparableTo(ctrl.Result{RequeueAfter: preflightFailedRequeueAfter})) controlPlaneMachines := clusterv1.MachineList{} g.Expect(fakeClient.List(context.Background(), &controlPlaneMachines)).To(Succeed()) @@ -580,7 +580,7 @@ func TestPreflightChecks(t *testing.T) { } result, err := r.preflightChecks(context.TODO(), controlPlane) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(tt.expectResult)) + g.Expect(result).To(BeComparableTo(tt.expectResult)) }) } } diff --git a/controlplane/kubeadm/internal/controllers/upgrade_test.go b/controlplane/kubeadm/internal/controllers/upgrade_test.go index 78e4db4e9eec..a5173b6a519e 100644 --- a/controlplane/kubeadm/internal/controllers/upgrade_test.go +++ b/controlplane/kubeadm/internal/controllers/upgrade_test.go @@ -104,7 +104,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleUp(t *testing.T) { controlPlane.InjectTestManagementCluster(r.managementCluster) result, err := r.initializeControlPlane(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) g.Expect(err).ToNot(HaveOccurred()) // initial setup @@ -126,7 +126,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleUp(t *testing.T) { needingUpgrade := collections.FromMachineList(initialMachine) controlPlane.Machines = needingUpgrade result, err = r.upgradeControlPlane(ctx, controlPlane, needingUpgrade) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) g.Expect(err).ToNot(HaveOccurred()) bothMachines := &clusterv1.MachineList{} g.Eventually(func(g Gomega) { @@ -146,7 +146,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleUp(t *testing.T) { result, err = r.reconcile(context.Background(), controlPlane) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{RequeueAfter: preflightFailedRequeueAfter})) + g.Expect(result).To(BeComparableTo(ctrl.Result{RequeueAfter: preflightFailedRequeueAfter})) g.Eventually(func(g Gomega) { g.Expect(env.List(context.Background(), bothMachines, client.InNamespace(cluster.Namespace))).To(Succeed()) g.Expect(bothMachines.Items).To(HaveLen(2)) @@ -169,7 +169,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleUp(t *testing.T) { // run upgrade the second time, expect we scale down result, err = r.upgradeControlPlane(ctx, controlPlane, machinesRequireUpgrade) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) finalMachine := &clusterv1.MachineList{} g.Eventually(func(g Gomega) { g.Expect(env.List(ctx, finalMachine, client.InNamespace(cluster.Namespace))).To(Succeed()) @@ -242,7 +242,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleDown(t *testing.T) { controlPlane.InjectTestManagementCluster(r.managementCluster) result, err := r.reconcile(ctx, controlPlane) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(err).ToNot(HaveOccurred()) machineList := &clusterv1.MachineList{} @@ -260,7 +260,7 @@ func TestKubeadmControlPlaneReconciler_RolloutStrategy_ScaleDown(t *testing.T) { controlPlane.Machines = needingUpgrade result, err = r.upgradeControlPlane(ctx, controlPlane, needingUpgrade) - g.Expect(result).To(Equal(ctrl.Result{Requeue: true})) + g.Expect(result).To(BeComparableTo(ctrl.Result{Requeue: true})) g.Expect(err).ToNot(HaveOccurred()) remainingMachines := &clusterv1.MachineList{} g.Expect(fakeClient.List(ctx, remainingMachines, client.InNamespace(cluster.Namespace))).To(Succeed()) diff --git a/controlplane/kubeadm/internal/etcd_client_generator_test.go b/controlplane/kubeadm/internal/etcd_client_generator_test.go index bf9348690c34..394d0142e5f2 100644 --- a/controlplane/kubeadm/internal/etcd_client_generator_test.go +++ b/controlplane/kubeadm/internal/etcd_client_generator_test.go @@ -99,7 +99,7 @@ func TestFirstAvailableNode(t *testing.T) { g.Expect(err).To(HaveOccurred()) g.Expect(err.Error()).Should(Equal(tt.expectedErr)) } else { - g.Expect(*client).Should(Equal(tt.expectedClient)) + g.Expect(*client).Should(BeComparableTo(tt.expectedClient)) } }) } @@ -221,7 +221,7 @@ func TestForLeader(t *testing.T) { g.Expect(err).To(HaveOccurred()) g.Expect(err.Error()).Should(Equal(tt.expectedErr)) } else { - g.Expect(*client).Should(Equal(tt.expectedClient)) + g.Expect(*client).Should(BeComparableTo(tt.expectedClient)) } }) } diff --git a/controlplane/kubeadm/internal/filters_test.go b/controlplane/kubeadm/internal/filters_test.go index b110b058828f..0cef8e855846 100644 --- a/controlplane/kubeadm/internal/filters_test.go +++ b/controlplane/kubeadm/internal/filters_test.go @@ -191,8 +191,8 @@ func TestCleanupConfigFields(t *testing.T) { }, } cleanupConfigFields(kcpConfig, machineConfig) - g.Expect(kcpConfig.JoinConfiguration.Discovery).To(Equal(bootstrapv1.Discovery{})) - g.Expect(machineConfig.Spec.JoinConfiguration.Discovery).To(Equal(bootstrapv1.Discovery{})) + g.Expect(kcpConfig.JoinConfiguration.Discovery).To(BeComparableTo(bootstrapv1.Discovery{})) + g.Expect(machineConfig.Spec.JoinConfiguration.Discovery).To(BeComparableTo(bootstrapv1.Discovery{})) }) t.Run("JoinConfiguration.ControlPlane gets removed from MachineConfig if it was not derived by KCPConfig", func(t *testing.T) { g := NewWithT(t) @@ -228,7 +228,7 @@ func TestCleanupConfigFields(t *testing.T) { } cleanupConfigFields(kcpConfig, machineConfig) g.Expect(kcpConfig.JoinConfiguration).ToNot(BeNil()) - g.Expect(machineConfig.Spec.JoinConfiguration.NodeRegistration).To(Equal(bootstrapv1.NodeRegistrationOptions{})) + g.Expect(machineConfig.Spec.JoinConfiguration.NodeRegistration).To(BeComparableTo(bootstrapv1.NodeRegistrationOptions{})) }) t.Run("InitConfiguration.TypeMeta gets removed from MachineConfig", func(t *testing.T) { g := NewWithT(t) @@ -247,7 +247,7 @@ func TestCleanupConfigFields(t *testing.T) { } cleanupConfigFields(kcpConfig, machineConfig) g.Expect(kcpConfig.InitConfiguration).ToNot(BeNil()) - g.Expect(machineConfig.Spec.InitConfiguration.TypeMeta).To(Equal(metav1.TypeMeta{})) + g.Expect(machineConfig.Spec.InitConfiguration.TypeMeta).To(BeComparableTo(metav1.TypeMeta{})) }) t.Run("JoinConfiguration.TypeMeta gets removed from MachineConfig", func(t *testing.T) { g := NewWithT(t) @@ -266,7 +266,7 @@ func TestCleanupConfigFields(t *testing.T) { } cleanupConfigFields(kcpConfig, machineConfig) g.Expect(kcpConfig.JoinConfiguration).ToNot(BeNil()) - g.Expect(machineConfig.Spec.JoinConfiguration.TypeMeta).To(Equal(metav1.TypeMeta{})) + g.Expect(machineConfig.Spec.JoinConfiguration.TypeMeta).To(BeComparableTo(metav1.TypeMeta{})) }) } diff --git a/controlplane/kubeadm/internal/workload_cluster_coredns_test.go b/controlplane/kubeadm/internal/workload_cluster_coredns_test.go index 38e6aa1f4c4b..a2f9954912b1 100644 --- a/controlplane/kubeadm/internal/workload_cluster_coredns_test.go +++ b/controlplane/kubeadm/internal/workload_cluster_coredns_test.go @@ -567,7 +567,7 @@ func TestUpdateCoreDNS(t *testing.T) { g.Eventually(func() []rbacv1.PolicyRule { g.Expect(env.Get(ctx, client.ObjectKey{Name: coreDNSClusterRoleName}, &actualClusterRole)).To(Succeed()) return actualClusterRole.Rules - }, "5s").Should(Equal(tt.expectRules)) + }, "5s").Should(BeComparableTo(tt.expectRules)) } } }) @@ -760,7 +760,7 @@ func TestUpdateCoreDNSClusterRole(t *testing.T) { var actualClusterRole rbacv1.ClusterRole g.Expect(fakeClient.Get(ctx, client.ObjectKey{Name: coreDNSClusterRoleName, Namespace: metav1.NamespaceSystem}, &actualClusterRole)).To(Succeed()) - g.Expect(actualClusterRole.Rules).To(Equal(tt.expectCoreDNSPolicyRules)) + g.Expect(actualClusterRole.Rules).To(BeComparableTo(tt.expectCoreDNSPolicyRules)) }) } } @@ -1394,7 +1394,7 @@ func TestGetCoreDNSInfo(t *testing.T) { tt.expectedInfo.Corefile = expectedCorefile tt.expectedInfo.Deployment = actualDepl - g.Expect(actualInfo).To(Equal(&tt.expectedInfo)) + g.Expect(actualInfo).To(BeComparableTo(&tt.expectedInfo)) }) } }) @@ -1676,7 +1676,7 @@ func TestPatchCoreDNSDeploymentTolerations(t *testing.T) { patchCoreDNSDeploymentTolerations(d, tt.kubernetesVersion) - g.Expect(d.Spec.Template.Spec.Tolerations).To(Equal(tt.expectedTolerations)) + g.Expect(d.Spec.Template.Spec.Tolerations).To(BeComparableTo(tt.expectedTolerations)) }) } } diff --git a/controlplane/kubeadm/internal/workload_cluster_rbac_test.go b/controlplane/kubeadm/internal/workload_cluster_rbac_test.go index 3463e10ad742..666f2829063d 100644 --- a/controlplane/kubeadm/internal/workload_cluster_rbac_test.go +++ b/controlplane/kubeadm/internal/workload_cluster_rbac_test.go @@ -122,7 +122,7 @@ func TestCluster_ReconcileKubeletRBACBinding_NoError(t *testing.T) { // Role exists g.Expect(tt.client.Get(ctx, tt.want.role, r)).To(Succeed()) // Role ensure grants for the KubeletConfig config map - g.Expect(r.Rules).To(Equal([]rbacv1.PolicyRule{ + g.Expect(r.Rules).To(BeComparableTo([]rbacv1.PolicyRule{ { Verbs: []string{"get"}, APIGroups: []string{""}, diff --git a/exp/addons/api/v1beta1/clusterresourcesetbinding_types_test.go b/exp/addons/api/v1beta1/clusterresourcesetbinding_types_test.go index d4ec081625f1..a13b93403c9a 100644 --- a/exp/addons/api/v1beta1/clusterresourcesetbinding_types_test.go +++ b/exp/addons/api/v1beta1/clusterresourcesetbinding_types_test.go @@ -145,7 +145,7 @@ func TestResourceSetBindingGetResourceBinding(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { gs := NewWithT(t) - gs.Expect(tt.resourceSetBinding.GetResource(tt.resourceRef)).To(Equal(tt.want)) + gs.Expect(tt.resourceSetBinding.GetResource(tt.resourceRef)).To(BeComparableTo(tt.want)) }) } } diff --git a/exp/addons/internal/controllers/clusterresourceset_helpers_test.go b/exp/addons/internal/controllers/clusterresourceset_helpers_test.go index 5844f42a3a2a..53d5604d5d63 100644 --- a/exp/addons/internal/controllers/clusterresourceset_helpers_test.go +++ b/exp/addons/internal/controllers/clusterresourceset_helpers_test.go @@ -159,7 +159,7 @@ func TestGetSecretFromNamespacedName(t *testing.T) { } gs.Expect(err).ToNot(HaveOccurred()) - gs.Expect(*got).To(Equal(*tt.want)) + gs.Expect(*got).To(BeComparableTo(*tt.want)) }) } } @@ -216,7 +216,7 @@ func TestGetConfigMapFromNamespacedName(t *testing.T) { } gs.Expect(err).ToNot(HaveOccurred()) - gs.Expect(*got).To(Equal(*tt.want)) + gs.Expect(*got).To(BeComparableTo(*tt.want)) }) } } diff --git a/exp/internal/controllers/machinepool_controller_noderef_test.go b/exp/internal/controllers/machinepool_controller_noderef_test.go index e9abaed44c79..41605d5b757d 100644 --- a/exp/internal/controllers/machinepool_controller_noderef_test.go +++ b/exp/internal/controllers/machinepool_controller_noderef_test.go @@ -425,7 +425,7 @@ func TestMachinePoolPatchNodes(t *testing.T) { err := fakeClient.Get(ctx, client.ObjectKey{Name: expected.Name}, node) g.Expect(err).ToNot(HaveOccurred()) g.Expect(node.Annotations).To(Equal(expected.Annotations)) - g.Expect(node.Spec.Taints).To(Equal(expected.Spec.Taints)) + g.Expect(node.Spec.Taints).To(BeComparableTo(expected.Spec.Taints)) } }) } diff --git a/exp/internal/controllers/machinepool_controller_phases_test.go b/exp/internal/controllers/machinepool_controller_phases_test.go index 27f875343867..2c4642795913 100644 --- a/exp/internal/controllers/machinepool_controller_phases_test.go +++ b/exp/internal/controllers/machinepool_controller_phases_test.go @@ -757,7 +757,7 @@ func TestReconcileMachinePoolBootstrap(t *testing.T) { } res, err := r.reconcileBootstrap(ctx, defaultCluster, tc.machinepool) - g.Expect(res).To(Equal(tc.expectResult)) + g.Expect(res).To(BeComparableTo(tc.expectResult)) if tc.expectError { g.Expect(err).To(HaveOccurred()) } else { diff --git a/exp/internal/controllers/machinepool_controller_test.go b/exp/internal/controllers/machinepool_controller_test.go index 1d2b5e2a166d..29bdda8d34ef 100644 --- a/exp/internal/controllers/machinepool_controller_test.go +++ b/exp/internal/controllers/machinepool_controller_test.go @@ -235,7 +235,7 @@ func TestMachinePoolOwnerReference(t *testing.T) { // this first requeue is to add finalizer result, err := mr.Reconcile(ctx, tc.request) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(mr.Client.Get(ctx, key, &actual)).To(Succeed()) g.Expect(actual.Finalizers).To(ContainElement(expv1.MachinePoolFinalizer)) @@ -243,7 +243,7 @@ func TestMachinePoolOwnerReference(t *testing.T) { if len(tc.expectedOR) > 0 { g.Expect(mr.Client.Get(ctx, key, &actual)).To(Succeed()) - g.Expect(actual.OwnerReferences).To(Equal(tc.expectedOR)) + g.Expect(actual.OwnerReferences).To(BeComparableTo(tc.expectedOR)) } else { g.Expect(actual.OwnerReferences).To(BeEmpty()) } @@ -434,7 +434,7 @@ func TestReconcileMachinePoolRequest(t *testing.T) { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(result).To(Equal(tc.expected.result)) + g.Expect(result).To(BeComparableTo(tc.expected.result)) }) } } diff --git a/exp/runtime/catalog/test/catalog_test.go b/exp/runtime/catalog/test/catalog_test.go index eddb87c3ae5b..20c2c9603b1b 100644 --- a/exp/runtime/catalog/test/catalog_test.go +++ b/exp/runtime/catalog/test/catalog_test.go @@ -47,19 +47,19 @@ func TestCatalog(t *testing.T) { // Test GroupVersionHook hookGVH, err := c.GroupVersionHook(hook) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(hookGVH.GroupVersion()).To(Equal(expectedGV)) + g.Expect(hookGVH.GroupVersion()).To(BeComparableTo(expectedGV)) g.Expect(hookGVH.Hook).To(Equal("FakeHook")) // Test Request requestGVK, err := c.Request(hookGVH) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(requestGVK.GroupVersion()).To(Equal(expectedGV)) + g.Expect(requestGVK.GroupVersion()).To(BeComparableTo(expectedGV)) g.Expect(requestGVK.Kind).To(Equal("FakeRequest")) // Test Response responseGVK, err := c.Response(hookGVH) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(responseGVK.GroupVersion()).To(Equal(expectedGV)) + g.Expect(responseGVK.GroupVersion()).To(BeComparableTo(expectedGV)) g.Expect(responseGVK.Kind).To(Equal("FakeResponse")) // Test NewRequest diff --git a/exp/runtime/topologymutation/logRef_test.go b/exp/runtime/topologymutation/logRef_test.go index 92dc473b41f4..e49a0958473b 100644 --- a/exp/runtime/topologymutation/logRef_test.go +++ b/exp/runtime/topologymutation/logRef_test.go @@ -34,5 +34,5 @@ func Test_Log(t *testing.T) { } g.Expect(l.String()).To(Equal("group/version/kind/namespace/name")) - g.Expect(l.MarshalLog()).To(Equal(logRefWithoutStringFunc(*l))) + g.Expect(l.MarshalLog()).To(BeComparableTo(logRefWithoutStringFunc(*l))) } diff --git a/exp/runtime/topologymutation/variables_test.go b/exp/runtime/topologymutation/variables_test.go index 0350fe9276a5..d357ee1c6cf3 100644 --- a/exp/runtime/topologymutation/variables_test.go +++ b/exp/runtime/topologymutation/variables_test.go @@ -66,7 +66,7 @@ func Test_GetRawTemplateVariable(t *testing.T) { t.Run(tt.name, func(t *testing.T) { value, found, err := GetVariable(tt.variables, tt.variableName) - g.Expect(value).To(Equal(tt.expectedValue)) + g.Expect(value).To(BeComparableTo(tt.expectedValue)) g.Expect(found).To(Equal(tt.expectedFound)) if tt.expectedErr { g.Expect(err).To(HaveOccurred()) diff --git a/internal/contract/controlplane_test.go b/internal/contract/controlplane_test.go index 6858d1e33fdd..d1210bf7fcec 100644 --- a/internal/contract/controlplane_test.go +++ b/internal/contract/controlplane_test.go @@ -198,7 +198,7 @@ func TestControlPlane(t *testing.T) { got, err := ControlPlane().MachineTemplate().Metadata().Get(obj) g.Expect(err).ToNot(HaveOccurred()) g.Expect(got).ToNot(BeNil()) - g.Expect(got).To(Equal(metadata)) + g.Expect(got).To(BeComparableTo(metadata)) }) t.Run("Manages spec.machineTemplate.nodeDrainTimeout", func(t *testing.T) { diff --git a/internal/contract/infrastructure_cluster_test.go b/internal/contract/infrastructure_cluster_test.go index d70506d1e1fa..94b37d604128 100644 --- a/internal/contract/infrastructure_cluster_test.go +++ b/internal/contract/infrastructure_cluster_test.go @@ -94,7 +94,7 @@ func TestInfrastructureCluster(t *testing.T) { got, err := InfrastructureCluster().FailureDomains().Get(obj) g.Expect(err).ToNot(HaveOccurred()) g.Expect(got).ToNot(BeNil()) - g.Expect(*got).To(Equal(failureDomains)) + g.Expect(*got).To(BeComparableTo(failureDomains)) }) } diff --git a/internal/contract/infrastructure_machine_test.go b/internal/contract/infrastructure_machine_test.go index a446a0acb053..0d438ef70337 100644 --- a/internal/contract/infrastructure_machine_test.go +++ b/internal/contract/infrastructure_machine_test.go @@ -101,7 +101,7 @@ func TestInfrastructureMachine(t *testing.T) { got, err := InfrastructureMachine().Addresses().Get(obj) g.Expect(err).ToNot(HaveOccurred()) g.Expect(got).ToNot(BeNil()) - g.Expect(*got).To(Equal(addresses)) + g.Expect(*got).To(BeComparableTo(addresses)) }) t.Run("Manages optional spec.failureDomain", func(t *testing.T) { g := NewWithT(t) diff --git a/internal/contract/metadata_test.go b/internal/contract/metadata_test.go index 9721c4f9f526..c05115b2ad2b 100644 --- a/internal/contract/metadata_test.go +++ b/internal/contract/metadata_test.go @@ -49,7 +49,7 @@ func TestMetadata(t *testing.T) { got, err := m.Get(obj) g.Expect(err).ToNot(HaveOccurred()) g.Expect(got).ToNot(BeNil()) - g.Expect(got).To(Equal(metadata)) + g.Expect(got).To(BeComparableTo(metadata)) }) t.Run("Manages empty metadata", func(t *testing.T) { g := NewWithT(t) @@ -68,6 +68,6 @@ func TestMetadata(t *testing.T) { got, err := m.Get(obj) g.Expect(err).ToNot(HaveOccurred()) g.Expect(got).ToNot(BeNil()) - g.Expect(got).To(Equal(metadata)) + g.Expect(got).To(BeComparableTo(metadata)) }) } diff --git a/internal/controllers/cluster/cluster_controller_phases_test.go b/internal/controllers/cluster/cluster_controller_phases_test.go index eaa1cfec0e4f..998cf744d628 100644 --- a/internal/controllers/cluster/cluster_controller_phases_test.go +++ b/internal/controllers/cluster/cluster_controller_phases_test.go @@ -143,7 +143,7 @@ func TestClusterReconcilePhases(t *testing.T) { } res, err := r.reconcileInfrastructure(ctx, tt.cluster) - g.Expect(res).To(Equal(tt.expectResult)) + g.Expect(res).To(BeComparableTo(tt.expectResult)) if tt.expectErr { g.Expect(err).To(HaveOccurred()) } else { diff --git a/internal/controllers/cluster/cluster_controller_test.go b/internal/controllers/cluster/cluster_controller_test.go index 5d5ec9ed7233..f6a35071c5a0 100644 --- a/internal/controllers/cluster/cluster_controller_test.go +++ b/internal/controllers/cluster/cluster_controller_test.go @@ -531,7 +531,7 @@ func TestClusterReconcilerNodeRef(t *testing.T) { UnstructuredCachingClient: c, } requests := r.controlPlaneMachineToCluster(ctx, tt.o) - g.Expect(requests).To(Equal(tt.want)) + g.Expect(requests).To(BeComparableTo(tt.want)) }) } }) @@ -739,7 +739,7 @@ func TestFilterOwnedDescendants(t *testing.T) { &m6ControlPlaneOwnedByCluster, } - g.Expect(actual).To(Equal(expected)) + g.Expect(actual).To(BeComparableTo(expected)) } func TestDescendantsLength(t *testing.T) { diff --git a/internal/controllers/clusterclass/clusterclass_controller_test.go b/internal/controllers/clusterclass/clusterclass_controller_test.go index 4e8bd455f726..0180bbf799eb 100644 --- a/internal/controllers/clusterclass/clusterclass_controller_test.go +++ b/internal/controllers/clusterclass/clusterclass_controller_test.go @@ -541,7 +541,7 @@ func TestReconciler_reconcileVariables(t *testing.T) { return } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(tt.clusterClass.Status.Variables).To(Equal(tt.want), cmp.Diff(tt.clusterClass.Status.Variables, tt.want)) + g.Expect(tt.clusterClass.Status.Variables).To(BeComparableTo(tt.want), cmp.Diff(tt.clusterClass.Status.Variables, tt.want)) }) } } diff --git a/internal/controllers/machine/machine_controller_phases_test.go b/internal/controllers/machine/machine_controller_phases_test.go index 7ea6907c220c..efbff31dab1e 100644 --- a/internal/controllers/machine/machine_controller_phases_test.go +++ b/internal/controllers/machine/machine_controller_phases_test.go @@ -913,7 +913,7 @@ func TestReconcileBootstrap(t *testing.T) { s := &scope{cluster: defaultCluster, machine: tc.machine} res, err := r.reconcileBootstrap(ctx, s) - g.Expect(res).To(Equal(tc.expectResult)) + g.Expect(res).To(BeComparableTo(tc.expectResult)) if tc.expectError { g.Expect(err).To(HaveOccurred()) } else { @@ -1126,7 +1126,7 @@ func TestReconcileInfrastructure(t *testing.T) { s := &scope{cluster: defaultCluster, machine: tc.machine} result, err := r.reconcileInfrastructure(ctx, s) r.reconcilePhase(ctx, tc.machine) - g.Expect(result).To(Equal(tc.expectResult)) + g.Expect(result).To(BeComparableTo(tc.expectResult)) if tc.expectError { g.Expect(err).To(HaveOccurred()) } else { diff --git a/internal/controllers/machine/machine_controller_test.go b/internal/controllers/machine/machine_controller_test.go index 4be31cbc97f7..630350dfc3e1 100644 --- a/internal/controllers/machine/machine_controller_test.go +++ b/internal/controllers/machine/machine_controller_test.go @@ -569,7 +569,7 @@ func TestMachineOwnerReference(t *testing.T) { // this first requeue is to add finalizer result, err := mr.Reconcile(ctx, tc.request) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(ctrl.Result{})) + g.Expect(result).To(BeComparableTo(ctrl.Result{})) g.Expect(mr.Client.Get(ctx, key, &actual)).To(Succeed()) g.Expect(actual.Finalizers).To(ContainElement(clusterv1.MachineFinalizer)) @@ -577,7 +577,7 @@ func TestMachineOwnerReference(t *testing.T) { if len(tc.expectedOR) > 0 { g.Expect(mr.Client.Get(ctx, key, &actual)).To(Succeed()) - g.Expect(actual.OwnerReferences).To(Equal(tc.expectedOR)) + g.Expect(actual.OwnerReferences).To(BeComparableTo(tc.expectedOR)) } else { g.Expect(actual.OwnerReferences).To(BeEmpty()) } @@ -743,7 +743,7 @@ func TestReconcileRequest(t *testing.T) { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(result).To(Equal(tc.expected.result)) + g.Expect(result).To(BeComparableTo(tc.expected.result)) }) } } @@ -1076,7 +1076,7 @@ func TestReconcileDeleteExternal(t *testing.T) { } obj, err := r.reconcileDeleteExternal(ctx, machine, machine.Spec.Bootstrap.ConfigRef) - g.Expect(obj).To(Equal(tc.expected)) + g.Expect(obj).To(BeComparableTo(tc.expected)) if tc.expectError { g.Expect(err).To(HaveOccurred()) } else { diff --git a/internal/controllers/machinedeployment/machinedeployment_controller_test.go b/internal/controllers/machinedeployment/machinedeployment_controller_test.go index 6bbb40b5be58..bdf04e410181 100644 --- a/internal/controllers/machinedeployment/machinedeployment_controller_test.go +++ b/internal/controllers/machinedeployment/machinedeployment_controller_test.go @@ -736,7 +736,7 @@ func TestMachineSetToDeployments(t *testing.T) { for _, tc := range testsCases { got := r.MachineSetToDeployments(ctx, tc.mapObject) - g.Expect(got).To(Equal(tc.expected)) + g.Expect(got).To(BeComparableTo(tc.expected)) } } @@ -804,7 +804,7 @@ func TestGetMachineDeploymentsForMachineSet(t *testing.T) { for _, x := range r.getMachineDeploymentsForMachineSet(ctx, &tc.machineSet) { got = append(got, x) } - g.Expect(got).To(Equal(tc.expected)) + g.Expect(got).To(BeComparableTo(tc.expected)) } } diff --git a/internal/controllers/machinedeployment/machinedeployment_sync_test.go b/internal/controllers/machinedeployment/machinedeployment_sync_test.go index eb5ecfbf7265..0367d3d0cbe0 100644 --- a/internal/controllers/machinedeployment/machinedeployment_sync_test.go +++ b/internal/controllers/machinedeployment/machinedeployment_sync_test.go @@ -229,7 +229,7 @@ func TestCalculateStatus(t *testing.T) { g := NewWithT(t) actualStatus := calculateStatus(test.machineSets, test.newMachineSet, test.deployment) - g.Expect(actualStatus).To(Equal(test.expectedStatus)) + g.Expect(actualStatus).To(BeComparableTo(test.expectedStatus)) }) } } @@ -765,7 +765,7 @@ func assertMachineSet(g *WithT, actualMS *clusterv1.MachineSet, expectedMS *clus g.Expect(actualMS.Spec.DeletePolicy).Should(Equal(expectedMS.Spec.DeletePolicy)) // Check MachineTemplateSpec - g.Expect(actualMS.Spec.Template.Spec).Should(Equal(expectedMS.Spec.Template.Spec)) + g.Expect(actualMS.Spec.Template.Spec).Should(BeComparableTo(expectedMS.Spec.Template.Spec)) } // asserts the conditions set on the Getter object. diff --git a/internal/controllers/machinedeployment/mdutil/util_test.go b/internal/controllers/machinedeployment/mdutil/util_test.go index 897c33b5f25c..84ba151627a6 100644 --- a/internal/controllers/machinedeployment/mdutil/util_test.go +++ b/internal/controllers/machinedeployment/mdutil/util_test.go @@ -162,7 +162,7 @@ func TestMachineSetsByDecreasingReplicas(t *testing.T) { // sort the machine sets and verify the sorted list g := NewWithT(t) sort.Sort(MachineSetsByDecreasingReplicas(tt.machineSets)) - g.Expect(tt.machineSets).To(Equal(tt.want)) + g.Expect(tt.machineSets).To(BeComparableTo(tt.want)) }) } } @@ -389,7 +389,7 @@ func TestFindNewMachineSet(t *testing.T) { g := NewWithT(t) ms := FindNewMachineSet(&test.deployment, test.msList, test.reconciliationTime) - g.Expect(ms).To(Equal(test.expected)) + g.Expect(ms).To(BeComparableTo(test.expected)) }) } } diff --git a/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go b/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go index 9ad91664c9bc..3cbea665c728 100644 --- a/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go +++ b/internal/controllers/machinehealthcheck/machinehealthcheck_controller_test.go @@ -2077,7 +2077,7 @@ func TestNodeToMachineHealthCheck(t *testing.T) { } return m.Status } - gs.Eventually(checkStatus).Should(Equal(o.Status)) + gs.Eventually(checkStatus).Should(BeComparableTo(o.Status)) } got := r.nodeToMachineHealthCheck(ctx, tc.object) diff --git a/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go b/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go index da94b56d157e..cf1feb8355aa 100644 --- a/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go +++ b/internal/controllers/machinehealthcheck/machinehealthcheck_targets_test.go @@ -176,9 +176,9 @@ func TestGetTargetsFromMHC(t *testing.T) { gs.Expect(targets).To(HaveLen(len(tc.expectedTargets))) for i, target := range targets { expectedTarget := tc.expectedTargets[i] - gs.Expect(target.Machine).To(Equal(expectedTarget.Machine)) - gs.Expect(target.MHC).To(Equal(expectedTarget.MHC)) - gs.Expect(target.Node).To(Equal(expectedTarget.Node)) + gs.Expect(target.Machine).To(BeComparableTo(expectedTarget.Machine)) + gs.Expect(target.MHC).To(BeComparableTo(expectedTarget.MHC)) + gs.Expect(target.Node).To(BeComparableTo(expectedTarget.Node)) } }) } diff --git a/internal/controllers/machineset/machineset_controller_test.go b/internal/controllers/machineset/machineset_controller_test.go index 439b9fc24711..a1254e4a9c87 100644 --- a/internal/controllers/machineset/machineset_controller_test.go +++ b/internal/controllers/machineset/machineset_controller_test.go @@ -487,7 +487,7 @@ func TestMachineSetOwnerReference(t *testing.T) { var actual clusterv1.MachineSet if len(tc.expectedOR) > 0 { g.Expect(msr.Client.Get(ctx, key, &actual)).To(Succeed()) - g.Expect(actual.OwnerReferences).To(Equal(tc.expectedOR)) + g.Expect(actual.OwnerReferences).To(BeComparableTo(tc.expectedOR)) } else { g.Expect(actual.OwnerReferences).To(BeEmpty()) } @@ -527,7 +527,7 @@ func TestMachineSetReconcile(t *testing.T) { } result, err := msr.Reconcile(ctx, request) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(result).To(Equal(reconcile.Result{})) + g.Expect(result).To(BeComparableTo(reconcile.Result{})) }) t.Run("records event if reconcile fails", func(t *testing.T) { @@ -665,7 +665,7 @@ func TestMachineSetToMachines(t *testing.T) { gs := NewWithT(t) got := r.MachineToMachineSets(ctx, tc.mapObject) - gs.Expect(got).To(Equal(tc.expected)) + gs.Expect(got).To(BeComparableTo(tc.expected)) }) } } @@ -811,7 +811,7 @@ func TestAdoptOrphan(t *testing.T) { g.Expect(r.Client.Get(ctx, key, &tc.machine)).To(Succeed()) got := tc.machine.GetOwnerReferences() - g.Expect(got).To(Equal(tc.expected)) + g.Expect(got).To(BeComparableTo(tc.expected)) } } @@ -1684,7 +1684,7 @@ func assertMachine(g *WithT, actualMachine *clusterv1.Machine, expectedMachine * g.Expect(actualMachine.Annotations).Should(HaveKeyWithValue(k, v)) } // Check Spec - g.Expect(actualMachine.Spec).Should(Equal(expectedMachine.Spec)) + g.Expect(actualMachine.Spec).Should(BeComparableTo(expectedMachine.Spec)) // Check Finalizer if expectedMachine.Finalizers != nil { g.Expect(actualMachine.Finalizers).Should(Equal(expectedMachine.Finalizers)) diff --git a/internal/controllers/machineset/machineset_delete_policy_test.go b/internal/controllers/machineset/machineset_delete_policy_test.go index eb550a218bfc..6764c8aa540b 100644 --- a/internal/controllers/machineset/machineset_delete_policy_test.go +++ b/internal/controllers/machineset/machineset_delete_policy_test.go @@ -229,7 +229,7 @@ func TestMachineToDelete(t *testing.T) { g := NewWithT(t) result := getMachinesToDeletePrioritized(test.machines, test.diff, randomDeletePolicy) - g.Expect(result).To(Equal(test.expect)) + g.Expect(result).To(BeComparableTo(test.expect)) }) } } @@ -371,7 +371,7 @@ func TestMachineNewestDelete(t *testing.T) { g := NewWithT(t) result := getMachinesToDeletePrioritized(test.machines, test.diff, newestDeletePriority) - g.Expect(result).To(Equal(test.expect)) + g.Expect(result).To(BeComparableTo(test.expect)) }) } } @@ -520,7 +520,7 @@ func TestMachineOldestDelete(t *testing.T) { g := NewWithT(t) result := getMachinesToDeletePrioritized(test.machines, test.diff, oldestDeletePriority) - g.Expect(result).To(Equal(test.expect)) + g.Expect(result).To(BeComparableTo(test.expect)) }) } } @@ -612,7 +612,7 @@ func TestMachineDeleteMultipleSamePriority(t *testing.T) { } result := getMachinesToDeletePrioritized(shuffledMachines, test.diff, test.deletePriority) - g.Expect(result).To(Equal(machines[:test.diff])) + g.Expect(result).To(BeComparableTo(machines[:test.diff])) }) } } diff --git a/internal/controllers/topology/cluster/blueprint_test.go b/internal/controllers/topology/cluster/blueprint_test.go index 21cbbbb4743f..621328b62a49 100644 --- a/internal/controllers/topology/cluster/blueprint_test.go +++ b/internal/controllers/topology/cluster/blueprint_test.go @@ -332,8 +332,8 @@ func TestGetBlueprint(t *testing.T) { // is enough to establish inequality. g.Expect(tt.want.ClusterClass).To(EqualObject(got.ClusterClass, IgnoreAutogeneratedMetadata)) g.Expect(tt.want.InfrastructureClusterTemplate).To(EqualObject(got.InfrastructureClusterTemplate), cmp.Diff(got.InfrastructureClusterTemplate, tt.want.InfrastructureClusterTemplate)) - g.Expect(got.ControlPlane).To(Equal(tt.want.ControlPlane), cmp.Diff(got.ControlPlane, tt.want.ControlPlane)) - g.Expect(tt.want.MachineDeployments).To(Equal(got.MachineDeployments), got.MachineDeployments, tt.want.MachineDeployments) + g.Expect(got.ControlPlane).To(BeComparableTo(tt.want.ControlPlane), cmp.Diff(got.ControlPlane, tt.want.ControlPlane)) + g.Expect(tt.want.MachineDeployments).To(BeComparableTo(got.MachineDeployments), got.MachineDeployments, tt.want.MachineDeployments) }) } } diff --git a/internal/controllers/topology/cluster/cluster_controller_test.go b/internal/controllers/topology/cluster/cluster_controller_test.go index 7fa5e722c7a1..2d0317a3c087 100644 --- a/internal/controllers/topology/cluster/cluster_controller_test.go +++ b/internal/controllers/topology/cluster/cluster_controller_test.go @@ -539,7 +539,7 @@ func TestClusterReconciler_reconcileDelete(t *testing.T) { g.Expect(err).To(HaveOccurred()) } else { g.Expect(err).ToNot(HaveOccurred()) - g.Expect(res).To(Equal(tt.wantResult)) + g.Expect(res).To(BeComparableTo(tt.wantResult)) g.Expect(hooks.IsOkToDelete(tt.cluster)).To(Equal(tt.wantOkToDelete)) g.Expect(fakeRuntimeClient.CallAllCount(runtimehooksv1.BeforeClusterDelete) == 1).To(Equal(tt.wantHookToBeCalled)) } @@ -683,7 +683,7 @@ func TestReconciler_callBeforeClusterCreateHook(t *testing.T) { g.Expect(err).To(HaveOccurred()) } else { g.Expect(err).ToNot(HaveOccurred()) - g.Expect(res).To(Equal(tt.wantResult)) + g.Expect(res).To(BeComparableTo(tt.wantResult)) } }) } diff --git a/internal/controllers/topology/cluster/current_state_test.go b/internal/controllers/topology/cluster/current_state_test.go index d840bb799aa3..cea202a5e82e 100644 --- a/internal/controllers/topology/cluster/current_state_test.go +++ b/internal/controllers/topology/cluster/current_state_test.go @@ -837,8 +837,8 @@ func TestGetCurrentState(t *testing.T) { // good enough to establish equality. g.Expect(got.Cluster).To(EqualObject(tt.want.Cluster, IgnoreAutogeneratedMetadata)) g.Expect(got.InfrastructureCluster).To(EqualObject(tt.want.InfrastructureCluster)) - g.Expect(got.ControlPlane).To(Equal(tt.want.ControlPlane), cmp.Diff(got.ControlPlane, tt.want.ControlPlane)) - g.Expect(got.MachineDeployments).To(Equal(tt.want.MachineDeployments)) + g.Expect(got.ControlPlane).To(BeComparableTo(tt.want.ControlPlane), cmp.Diff(got.ControlPlane, tt.want.ControlPlane)) + g.Expect(got.MachineDeployments).To(BeComparableTo(tt.want.MachineDeployments)) }) } } @@ -937,7 +937,7 @@ func TestAlignRefAPIVersion(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/internal/controllers/topology/cluster/desired_state_test.go b/internal/controllers/topology/cluster/desired_state_test.go index 49a621b07aac..b2edb1d7b645 100644 --- a/internal/controllers/topology/cluster/desired_state_test.go +++ b/internal/controllers/topology/cluster/desired_state_test.go @@ -481,7 +481,7 @@ func TestComputeControlPlane(t *testing.T) { expectedLabels := util.MergeMap(s.Current.Cluster.Spec.Topology.ControlPlane.Metadata.Labels, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Labels, controlPlaneMachineTemplateLabels) expectedLabels[clusterv1.ClusterNameLabel] = cluster.Name expectedLabels[clusterv1.ClusterTopologyOwnedLabel] = "" - g.Expect(gotMetadata).To(Equal(&clusterv1.ObjectMeta{ + g.Expect(gotMetadata).To(BeComparableTo(&clusterv1.ObjectMeta{ Labels: expectedLabels, Annotations: util.MergeMap(s.Current.Cluster.Spec.Topology.ControlPlane.Metadata.Annotations, blueprint.ClusterClass.Spec.ControlPlane.Metadata.Annotations, controlPlaneMachineTemplateAnnotations), })) @@ -1288,8 +1288,8 @@ func TestComputeCluster(t *testing.T) { g.Expect(obj.GetLabels()).To(HaveKeyWithValue(clusterv1.ClusterTopologyOwnedLabel, "")) // Spec - g.Expect(obj.Spec.InfrastructureRef).To(Equal(contract.ObjToRef(infrastructureCluster))) - g.Expect(obj.Spec.ControlPlaneRef).To(Equal(contract.ObjToRef(controlPlane))) + g.Expect(obj.Spec.InfrastructureRef).To(BeComparableTo(contract.ObjToRef(infrastructureCluster))) + g.Expect(obj.Spec.ControlPlaneRef).To(BeComparableTo(contract.ObjToRef(controlPlane))) } func TestComputeMachineDeployment(t *testing.T) { @@ -1431,7 +1431,7 @@ func TestComputeMachineDeployment(t *testing.T) { actualMd := actual.Object g.Expect(*actualMd.Spec.Replicas).To(Equal(replicas)) g.Expect(*actualMd.Spec.MinReadySeconds).To(Equal(topologyMinReadySeconds)) - g.Expect(*actualMd.Spec.Strategy).To(Equal(topologyStrategy)) + g.Expect(*actualMd.Spec.Strategy).To(BeComparableTo(topologyStrategy)) g.Expect(*actualMd.Spec.Template.Spec.FailureDomain).To(Equal(topologyFailureDomain)) g.Expect(*actualMd.Spec.Template.Spec.NodeDrainTimeout).To(Equal(topologyDuration)) g.Expect(*actualMd.Spec.Template.Spec.NodeVolumeDetachTimeout).To(Equal(topologyDuration)) @@ -1446,7 +1446,7 @@ func TestComputeMachineDeployment(t *testing.T) { g.Expect(actualMd.Annotations).To(Equal(expectedAnnotations)) g.Expect(actualMd.Spec.Template.ObjectMeta.Annotations).To(Equal(expectedAnnotations)) - g.Expect(actualMd.Labels).To(Equal(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ + g.Expect(actualMd.Labels).To(BeComparableTo(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ clusterv1.ClusterNameLabel: cluster.Name, clusterv1.ClusterTopologyOwnedLabel: "", clusterv1.ClusterTopologyMachineDeploymentNameLabel: "big-pool-of-machines", @@ -1456,7 +1456,7 @@ func TestComputeMachineDeployment(t *testing.T) { clusterv1.ClusterTopologyOwnedLabel: "", clusterv1.ClusterTopologyMachineDeploymentNameLabel: "big-pool-of-machines", })) - g.Expect(actualMd.Spec.Template.ObjectMeta.Labels).To(Equal(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ + g.Expect(actualMd.Spec.Template.ObjectMeta.Labels).To(BeComparableTo(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ clusterv1.ClusterNameLabel: cluster.Name, clusterv1.ClusterTopologyOwnedLabel: "", clusterv1.ClusterTopologyMachineDeploymentNameLabel: "big-pool-of-machines", @@ -1486,7 +1486,7 @@ func TestComputeMachineDeployment(t *testing.T) { // checking only values from CC defaults actualMd := actual.Object g.Expect(*actualMd.Spec.MinReadySeconds).To(Equal(clusterClassMinReadySeconds)) - g.Expect(*actualMd.Spec.Strategy).To(Equal(clusterClassStrategy)) + g.Expect(*actualMd.Spec.Strategy).To(BeComparableTo(clusterClassStrategy)) g.Expect(*actualMd.Spec.Template.Spec.FailureDomain).To(Equal(clusterClassFailureDomain)) g.Expect(*actualMd.Spec.Template.Spec.NodeDrainTimeout).To(Equal(clusterClassDuration)) g.Expect(*actualMd.Spec.Template.Spec.NodeVolumeDetachTimeout).To(Equal(clusterClassDuration)) @@ -1539,17 +1539,17 @@ func TestComputeMachineDeployment(t *testing.T) { g.Expect(actualMd.Annotations).To(Equal(expectedAnnotations)) g.Expect(actualMd.Spec.Template.ObjectMeta.Annotations).To(Equal(expectedAnnotations)) - g.Expect(actualMd.Labels).To(Equal(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ + g.Expect(actualMd.Labels).To(BeComparableTo(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ clusterv1.ClusterNameLabel: cluster.Name, clusterv1.ClusterTopologyOwnedLabel: "", clusterv1.ClusterTopologyMachineDeploymentNameLabel: "big-pool-of-machines", }))) - g.Expect(actualMd.Spec.Selector.MatchLabels).To(Equal(map[string]string{ + g.Expect(actualMd.Spec.Selector.MatchLabels).To(BeComparableTo(map[string]string{ clusterv1.ClusterNameLabel: cluster.Name, clusterv1.ClusterTopologyOwnedLabel: "", clusterv1.ClusterTopologyMachineDeploymentNameLabel: "big-pool-of-machines", })) - g.Expect(actualMd.Spec.Template.ObjectMeta.Labels).To(Equal(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ + g.Expect(actualMd.Spec.Template.ObjectMeta.Labels).To(BeComparableTo(util.MergeMap(mdTopology.Metadata.Labels, md1.Template.Metadata.Labels, map[string]string{ clusterv1.ClusterNameLabel: cluster.Name, clusterv1.ClusterTopologyOwnedLabel: "", clusterv1.ClusterTopologyMachineDeploymentNameLabel: "big-pool-of-machines", @@ -1704,7 +1704,7 @@ func TestComputeMachineDeployment(t *testing.T) { g.Expect(err).ToNot(HaveOccurred()) // Check that the ClusterName and selector are set properly for the MachineHealthCheck. g.Expect(actual.MachineHealthCheck.Spec.ClusterName).To(Equal(cluster.Name)) - g.Expect(actual.MachineHealthCheck.Spec.Selector).To(Equal(metav1.LabelSelector{MatchLabels: map[string]string{ + g.Expect(actual.MachineHealthCheck.Spec.Selector).To(BeComparableTo(metav1.LabelSelector{MatchLabels: map[string]string{ clusterv1.ClusterTopologyOwnedLabel: actual.Object.Spec.Selector.MatchLabels[clusterv1.ClusterTopologyOwnedLabel], clusterv1.ClusterTopologyMachineDeploymentNameLabel: actual.Object.Spec.Selector.MatchLabels[clusterv1.ClusterTopologyMachineDeploymentNameLabel], }})) @@ -1713,7 +1713,7 @@ func TestComputeMachineDeployment(t *testing.T) { g.Expect(actual.MachineHealthCheck.Spec.NodeStartupTimeout).To(Equal(nodeTimeoutDuration)) // Check that UnhealthyConditions are set as expected. - g.Expect(actual.MachineHealthCheck.Spec.UnhealthyConditions).To(Equal(unhealthyConditions)) + g.Expect(actual.MachineHealthCheck.Spec.UnhealthyConditions).To(BeComparableTo(unhealthyConditions)) }) } @@ -2163,7 +2163,7 @@ func assertTemplateToTemplate(g *WithT, in assertTemplateInput) { cloneSpec, ok, err := unstructured.NestedMap(in.obj.UnstructuredContent(), "spec") g.Expect(err).ToNot(HaveOccurred()) g.Expect(ok).To(BeTrue()) - g.Expect(cloneSpec).To(Equal(expectedSpec)) + g.Expect(cloneSpec).To(BeComparableTo(expectedSpec)) } func assertNestedField(g *WithT, obj *unstructured.Unstructured, value interface{}, fields ...string) { @@ -2171,7 +2171,7 @@ func assertNestedField(g *WithT, obj *unstructured.Unstructured, value interface g.Expect(err).ToNot(HaveOccurred()) g.Expect(ok).To(BeTrue()) - g.Expect(v).To(Equal(value)) + g.Expect(v).To(BeComparableTo(value)) } func assertNestedFieldUnset(g *WithT, obj *unstructured.Unstructured, fields ...string) { @@ -2280,7 +2280,7 @@ func Test_computeMachineHealthCheck(t *testing.T) { got := computeMachineHealthCheck(ctx, healthCheckTarget, selector, clusterName, mhcSpec) - g.Expect(got).To(Equal(want), cmp.Diff(got, want)) + g.Expect(got).To(BeComparableTo(want), cmp.Diff(got, want)) }) } @@ -2411,7 +2411,7 @@ func TestCalculateRefDesiredAPIVersion(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/internal/controllers/topology/cluster/patches/inline/json_patch_generator_test.go b/internal/controllers/topology/cluster/patches/inline/json_patch_generator_test.go index 072cd1593b57..f470ee44644b 100644 --- a/internal/controllers/topology/cluster/patches/inline/json_patch_generator_test.go +++ b/internal/controllers/topology/cluster/patches/inline/json_patch_generator_test.go @@ -342,7 +342,7 @@ func TestGenerate(t *testing.T) { got, err := NewGenerator(tt.patch).Generate(context.Background(), &clusterv1.Cluster{ObjectMeta: metav1.ObjectMeta{Namespace: "default"}}, tt.req) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) g.Expect(err).ToNot(HaveOccurred()) }) } @@ -1516,7 +1516,7 @@ func TestCalculateValue(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } @@ -1920,7 +1920,7 @@ func TestCalculateTemplateData(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/internal/controllers/topology/cluster/patches/patch_test.go b/internal/controllers/topology/cluster/patches/patch_test.go index 93f42cbab9bc..cdfcd90c41d0 100644 --- a/internal/controllers/topology/cluster/patches/patch_test.go +++ b/internal/controllers/topology/cluster/patches/patch_test.go @@ -364,7 +364,7 @@ func TestCopySpec(t *testing.T) { } g.Expect(err).ToNot(HaveOccurred()) - g.Expect(tt.input.dest).To(Equal(tt.want)) + g.Expect(tt.input.dest).To(BeComparableTo(tt.want)) }) } } diff --git a/internal/controllers/topology/cluster/patches/variables/variables_test.go b/internal/controllers/topology/cluster/patches/variables/variables_test.go index c0db57b1ddb1..3086bcec76cf 100644 --- a/internal/controllers/topology/cluster/patches/variables/variables_test.go +++ b/internal/controllers/topology/cluster/patches/variables/variables_test.go @@ -395,7 +395,7 @@ func TestGlobal(t *testing.T) { got, err := Global(tt.clusterTopology, tt.cluster, tt.forPatch, tt.variableDefinitionsForPatch) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } @@ -481,7 +481,7 @@ func TestControlPlane(t *testing.T) { got, err := ControlPlane(tt.controlPlaneTopology, tt.controlPlane, tt.controlPlaneInfrastructureMachineTemplate) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } @@ -848,7 +848,7 @@ func TestMachineDeployment(t *testing.T) { got, err := MachineDeployment(tt.mdTopology, tt.md, tt.mdBootstrapTemplate, tt.mdInfrastructureMachineTemplate, tt.forPatch, tt.variableDefinitionsForPatch) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } diff --git a/internal/controllers/topology/cluster/reconcile_state_test.go b/internal/controllers/topology/cluster/reconcile_state_test.go index 2633bc527635..52cbcf05e079 100644 --- a/internal/controllers/topology/cluster/reconcile_state_test.go +++ b/internal/controllers/topology/cluster/reconcile_state_test.go @@ -1987,7 +1987,7 @@ func TestReconcileMachineDeployments(t *testing.T) { // Compare MachineDeployment. // Note: We're intentionally only comparing Spec as otherwise we would have to account for // empty vs. filled out TypeMeta. - g.Expect(gotMachineDeployment.Spec).To(Equal(wantMachineDeploymentState.Object.Spec)) + g.Expect(gotMachineDeployment.Spec).To(BeComparableTo(wantMachineDeploymentState.Object.Spec)) // Compare BootstrapTemplate. gotBootstrapTemplateRef := gotMachineDeployment.Spec.Template.Spec.Bootstrap.ConfigRef diff --git a/internal/controllers/topology/cluster/scope/blueprint_test.go b/internal/controllers/topology/cluster/scope/blueprint_test.go index aee89cf40b6e..712563ed43cb 100644 --- a/internal/controllers/topology/cluster/scope/blueprint_test.go +++ b/internal/controllers/topology/cluster/scope/blueprint_test.go @@ -242,7 +242,7 @@ func TestControlPlaneMachineHealthCheckClass(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := NewWithT(t) - g.Expect(tt.blueprint.ControlPlaneMachineHealthCheckClass()).To(Equal(tt.want)) + g.Expect(tt.blueprint.ControlPlaneMachineHealthCheckClass()).To(BeComparableTo(tt.want)) }) } } @@ -390,7 +390,7 @@ func TestIsMachineDeploymentMachineHealthCheckEnabled(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := NewWithT(t) - g.Expect(tt.blueprint.IsMachineDeploymentMachineHealthCheckEnabled(tt.mdTopology)).To(Equal(tt.want)) + g.Expect(tt.blueprint.IsMachineDeploymentMachineHealthCheckEnabled(tt.mdTopology)).To(BeComparableTo(tt.want)) }) } } @@ -461,7 +461,7 @@ func TestMachineDeploymentMachineHealthCheckClass(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { g := NewWithT(t) - g.Expect(tt.blueprint.MachineDeploymentMachineHealthCheckClass(tt.mdTopology)).To(Equal(tt.want)) + g.Expect(tt.blueprint.MachineDeploymentMachineHealthCheckClass(tt.mdTopology)).To(BeComparableTo(tt.want)) }) } } diff --git a/internal/controllers/topology/cluster/structuredmerge/drop_diff_test.go b/internal/controllers/topology/cluster/structuredmerge/drop_diff_test.go index dc77f88b0bcb..566563d39187 100644 --- a/internal/controllers/topology/cluster/structuredmerge/drop_diff_test.go +++ b/internal/controllers/topology/cluster/structuredmerge/drop_diff_test.go @@ -161,7 +161,7 @@ func Test_dropDiffForNotAllowedPaths(t *testing.T) { dropDiff(tt.ctx) - g.Expect(tt.ctx.modified).To(Equal(tt.wantModified)) + g.Expect(tt.ctx.modified).To(BeComparableTo(tt.wantModified)) }) } } @@ -268,7 +268,7 @@ func Test_dropDiffForIgnoredPaths(t *testing.T) { dropDiff(tt.ctx) - g.Expect(tt.ctx.modified).To(Equal(tt.wantModified)) + g.Expect(tt.ctx.modified).To(BeComparableTo(tt.wantModified)) }) } } diff --git a/internal/controllers/topology/cluster/structuredmerge/serversidepathhelper_test.go b/internal/controllers/topology/cluster/structuredmerge/serversidepathhelper_test.go index e04cdf709671..c0d5e85a96c8 100644 --- a/internal/controllers/topology/cluster/structuredmerge/serversidepathhelper_test.go +++ b/internal/controllers/topology/cluster/structuredmerge/serversidepathhelper_test.go @@ -675,7 +675,7 @@ func TestServerSideApplyWithDefaulting(t *testing.T) { // Ensure patchKCT was defaulted. g.Expect(env.Get(ctx, client.ObjectKeyFromObject(kct), patchKCT)).To(Succeed()) - g.Expect(patchKCT.Spec.Template.Spec.Users).To(Equal([]bootstrapv1.User{{Name: "default-user"}})) + g.Expect(patchKCT.Spec.Template.Spec.Users).To(BeComparableTo([]bootstrapv1.User{{Name: "default-user"}})) }, 5*time.Second).Should(Succeed()) } // Get original for the update. diff --git a/internal/topology/variables/cluster_variable_defaulting_test.go b/internal/topology/variables/cluster_variable_defaulting_test.go index 57ed0c356e1f..f441264e6bd2 100644 --- a/internal/topology/variables/cluster_variable_defaulting_test.go +++ b/internal/topology/variables/cluster_variable_defaulting_test.go @@ -656,7 +656,7 @@ func Test_DefaultClusterVariables(t *testing.T) { return } g.Expect(errList).To(BeEmpty()) - g.Expect(vars).To(Equal(tt.want)) + g.Expect(vars).To(BeComparableTo(tt.want)) }) } } @@ -1195,7 +1195,7 @@ func Test_DefaultClusterVariable(t *testing.T) { } g.Expect(errList).To(BeEmpty()) - g.Expect(defaultedVariable).To(Equal(tt.want)) + g.Expect(defaultedVariable).To(BeComparableTo(tt.want)) }) } } @@ -1337,6 +1337,6 @@ func Test_getAllVariables(t *testing.T) { valuesIndex, err := newValuesIndex(values) g.Expect(err).ToNot(HaveOccurred()) got := getAllVariables(values, valuesIndex, definitions) - g.Expect(got).To(Equal(expectedValues)) + g.Expect(got).To(BeComparableTo(expectedValues)) }) } diff --git a/internal/util/ssa/filterintent_test.go b/internal/util/ssa/filterintent_test.go index 1487e85ce5c1..820047e1f82e 100644 --- a/internal/util/ssa/filterintent_test.go +++ b/internal/util/ssa/filterintent_test.go @@ -111,7 +111,7 @@ func Test_filterNotAllowedPaths(t *testing.T) { FilterIntent(tt.ctx) - g.Expect(tt.ctx.Value).To(Equal(tt.wantValue)) + g.Expect(tt.ctx.Value).To(BeComparableTo(tt.wantValue)) }) } } @@ -195,7 +195,7 @@ func Test_filterIgnoredPaths(t *testing.T) { FilterIntent(tt.ctx) - g.Expect(tt.ctx.Value).To(Equal(tt.wantValue)) + g.Expect(tt.ctx.Value).To(BeComparableTo(tt.wantValue)) }) } } diff --git a/internal/util/taints/taints_test.go b/internal/util/taints/taints_test.go index 2777a79e30dd..2b6e3f766cb4 100644 --- a/internal/util/taints/taints_test.go +++ b/internal/util/taints/taints_test.go @@ -72,7 +72,7 @@ func TestRemoveNodeTaint(t *testing.T) { g := NewWithT(t) got := RemoveNodeTaint(tt.node, tt.dropTaint) g.Expect(got).To(Equal(tt.wantModified)) - g.Expect(tt.node.Spec.Taints).To(Equal(tt.wantTaints)) + g.Expect(tt.node.Spec.Taints).To(BeComparableTo(tt.wantTaints)) }) } } diff --git a/internal/webhooks/machinehealthcheck_test.go b/internal/webhooks/machinehealthcheck_test.go index d05fe57938b4..8476439cd673 100644 --- a/internal/webhooks/machinehealthcheck_test.go +++ b/internal/webhooks/machinehealthcheck_test.go @@ -56,7 +56,7 @@ func TestMachineHealthCheckDefault(t *testing.T) { g.Expect(mhc.Labels[clusterv1.ClusterNameLabel]).To(Equal(mhc.Spec.ClusterName)) g.Expect(mhc.Spec.MaxUnhealthy.String()).To(Equal("100%")) g.Expect(mhc.Spec.NodeStartupTimeout).ToNot(BeNil()) - g.Expect(*mhc.Spec.NodeStartupTimeout).To(Equal(metav1.Duration{Duration: 10 * time.Minute})) + g.Expect(*mhc.Spec.NodeStartupTimeout).To(BeComparableTo(metav1.Duration{Duration: 10 * time.Minute})) g.Expect(mhc.Spec.RemediationTemplate.Namespace).To(Equal(mhc.Namespace)) } diff --git a/internal/webhooks/runtime/extensionconfig_webhook_test.go b/internal/webhooks/runtime/extensionconfig_webhook_test.go index b6fbd0afefb6..2905fefb5574 100644 --- a/internal/webhooks/runtime/extensionconfig_webhook_test.go +++ b/internal/webhooks/runtime/extensionconfig_webhook_test.go @@ -129,8 +129,8 @@ func TestExtensionConfigDefault(t *testing.T) { t.Run("for Extension", util.CustomDefaultValidateTest(ctx, extensionConfig, extensionConfigWebhook)) g.Expect(extensionConfigWebhook.Default(ctx, extensionConfig)).To(Succeed()) - g.Expect(extensionConfig.Spec.NamespaceSelector).To(Equal(&metav1.LabelSelector{})) - g.Expect(extensionConfig.Spec.ClientConfig.Service.Port).To(Equal(pointer.Int32(443))) + g.Expect(extensionConfig.Spec.NamespaceSelector).To(BeComparableTo(&metav1.LabelSelector{})) + g.Expect(extensionConfig.Spec.ClientConfig.Service.Port).To(BeComparableTo(pointer.Int32(443))) } func TestExtensionConfigValidate(t *testing.T) { diff --git a/test/e2e/clusterclass_changes.go b/test/e2e/clusterclass_changes.go index a0cad1b83227..d9a309a3c3f1 100644 --- a/test/e2e/clusterclass_changes.go +++ b/test/e2e/clusterclass_changes.go @@ -456,7 +456,7 @@ func assertMachineDeploymentTopologyFields(g Gomega, md clusterv1.MachineDeploym } if mdTopology.Strategy != nil { - g.Expect(md.Spec.Strategy).To(Equal(mdTopology.Strategy)) + g.Expect(md.Spec.Strategy).To(BeComparableTo(mdTopology.Strategy)) } if mdTopology.FailureDomain != nil { diff --git a/test/extension/handlers/topologymutation/handler_test.go b/test/extension/handlers/topologymutation/handler_test.go index 7d84842680f4..e843adbfbd9c 100644 --- a/test/extension/handlers/topologymutation/handler_test.go +++ b/test/extension/handlers/topologymutation/handler_test.go @@ -92,7 +92,7 @@ func Test_patchDockerClusterTemplate(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(tt.template).To(Equal(tt.expectedTemplate)) + g.Expect(tt.template).To(BeComparableTo(tt.expectedTemplate)) }) } } @@ -189,7 +189,7 @@ func Test_patchKubeadmControlPlaneTemplate(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(tt.template).To(Equal(tt.expectedTemplate)) + g.Expect(tt.template).To(BeComparableTo(tt.expectedTemplate)) }) } } @@ -283,7 +283,7 @@ func Test_patchKubeadmConfigTemplate(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(tt.template).To(Equal(tt.expectedTemplate)) + g.Expect(tt.template).To(BeComparableTo(tt.expectedTemplate)) }) } } @@ -334,7 +334,7 @@ func Test_patchDockerMachineTemplate(t *testing.T) { } else { g.Expect(err).ToNot(HaveOccurred()) } - g.Expect(tt.template).To(Equal(tt.expectedTemplate)) + g.Expect(tt.template).To(BeComparableTo(tt.expectedTemplate)) }) } } diff --git a/test/framework/machinedeployment_helpers.go b/test/framework/machinedeployment_helpers.go index 5596d128d917..e39312f8441c 100644 --- a/test/framework/machinedeployment_helpers.go +++ b/test/framework/machinedeployment_helpers.go @@ -325,7 +325,7 @@ func UpgradeMachineDeploymentInfrastructureRefAndWait(ctx context.Context, input g.Expect(*newMachineSet.Spec.Replicas).To(Equal(newMachineSet.Status.AvailableReplicas)) // MachineSet should have the same infrastructureRef as the MachineDeployment. - g.Expect(newMachineSet.Spec.Template.Spec.InfrastructureRef).To(Equal(deployment.Spec.Template.Spec.InfrastructureRef)) + g.Expect(newMachineSet.Spec.Template.Spec.InfrastructureRef).To(BeComparableTo(deployment.Spec.Template.Spec.InfrastructureRef)) }, input.WaitForMachinesToBeUpgraded...).Should(Succeed()) } } diff --git a/test/infrastructure/docker/internal/provisioning/cloudinit/runcmd_test.go b/test/infrastructure/docker/internal/provisioning/cloudinit/runcmd_test.go index 3050b9ec51d8..039dbffc3be3 100644 --- a/test/infrastructure/docker/internal/provisioning/cloudinit/runcmd_test.go +++ b/test/infrastructure/docker/internal/provisioning/cloudinit/runcmd_test.go @@ -38,10 +38,10 @@ runcmd: g.Expect(r.Cmds).To(HaveLen(2)) expected0 := provisioning.Cmd{Cmd: "ls", Args: []string{"-l", "/"}} - g.Expect(r.Cmds[0]).To(Equal(expected0)) + g.Expect(r.Cmds[0]).To(BeComparableTo(expected0)) expected1 := provisioning.Cmd{Cmd: "/bin/sh", Args: []string{"-c", "ls -l /"}} - g.Expect(r.Cmds[1]).To(Equal(expected1)) + g.Expect(r.Cmds[1]).To(BeComparableTo(expected1)) } func TestRunCmdRun(t *testing.T) { @@ -82,7 +82,7 @@ func TestRunCmdRun(t *testing.T) { commands, err := rt.r.Commands() g.Expect(err).ToNot(HaveOccurred()) - g.Expect(rt.expectedCmds).To(Equal(commands)) + g.Expect(rt.expectedCmds).To(BeComparableTo(commands)) }) } } @@ -102,10 +102,10 @@ runcmd: r.Cmds[0] = hackKubeadmIgnoreErrors(r.Cmds[0]) expected0 := provisioning.Cmd{Cmd: "/bin/sh", Args: []string{"-c", "kubeadm init --ignore-preflight-errors=SystemVerification,Swap,FileContent--proc-sys-net-bridge-bridge-nf-call-iptables --config=/run/kubeadm/kubeadm.yaml"}} - g.Expect(r.Cmds[0]).To(Equal(expected0)) + g.Expect(r.Cmds[0]).To(BeComparableTo(expected0)) r.Cmds[1] = hackKubeadmIgnoreErrors(r.Cmds[1]) expected1 := provisioning.Cmd{Cmd: "kubeadm", Args: []string{"join", "--ignore-preflight-errors=SystemVerification,Swap,FileContent--proc-sys-net-bridge-bridge-nf-call-iptables", "--config=/run/kubeadm/kubeadm-controlplane-join-config.yaml"}} - g.Expect(r.Cmds[1]).To(Equal(expected1)) + g.Expect(r.Cmds[1]).To(BeComparableTo(expected1)) } diff --git a/test/infrastructure/docker/internal/provisioning/cloudinit/writefiles_test.go b/test/infrastructure/docker/internal/provisioning/cloudinit/writefiles_test.go index 28902c292825..95ce798658ef 100644 --- a/test/infrastructure/docker/internal/provisioning/cloudinit/writefiles_test.go +++ b/test/infrastructure/docker/internal/provisioning/cloudinit/writefiles_test.go @@ -96,7 +96,7 @@ func TestWriteFiles(t *testing.T) { cmds, err := rt.w.Commands() g.Expect(err).ToNot(HaveOccurred()) - g.Expect(rt.expectedCmds).To(Equal(cmds)) + g.Expect(rt.expectedCmds).To(BeComparableTo(cmds)) }) } } diff --git a/test/infrastructure/inmemory/internal/cloud/runtime/cache/client_test.go b/test/infrastructure/inmemory/internal/cloud/runtime/cache/client_test.go index 5508f644b128..24416549b5c1 100644 --- a/test/infrastructure/inmemory/internal/cloud/runtime/cache/client_test.go +++ b/test/infrastructure/inmemory/internal/cloud/runtime/cache/client_test.go @@ -102,7 +102,7 @@ func Test_cache_client(t *testing.T) { g.Expect(c.resourceGroups["foo"].objects[cloudv1.GroupVersion.WithKind(cloudv1.CloudMachineKind)]).To(HaveKey(key), "Object bar must exists in object tracker for foo") r := c.resourceGroups["foo"].objects[cloudv1.GroupVersion.WithKind(cloudv1.CloudMachineKind)][key] - g.Expect(r.GetObjectKind().GroupVersionKind()).To(Equal(cloudv1.GroupVersion.WithKind(cloudv1.CloudMachineKind)), "gvk must be set") + g.Expect(r.GetObjectKind().GroupVersionKind()).To(BeComparableTo(cloudv1.GroupVersion.WithKind(cloudv1.CloudMachineKind)), "gvk must be set") g.Expect(r.GetName()).To(Equal("bar"), "name must be equal to object tracker key") g.Expect(r.GetResourceVersion()).To(Equal("v1"), "resourceVersion must be set") g.Expect(r.GetCreationTimestamp()).ToNot(BeZero(), "creation timestamp must be set") @@ -269,7 +269,7 @@ func Test_cache_client(t *testing.T) { g.Expect(err).ToNot(HaveOccurred()) // Check all the computed fields are as expected. - g.Expect(obj.GetObjectKind().GroupVersionKind()).To(Equal(cloudv1.GroupVersion.WithKind(cloudv1.CloudMachineKind)), "gvk must be set") + g.Expect(obj.GetObjectKind().GroupVersionKind()).To(BeComparableTo(cloudv1.GroupVersion.WithKind(cloudv1.CloudMachineKind)), "gvk must be set") g.Expect(obj.GetName()).To(Equal("bar"), "name must be equal to object tracker key") g.Expect(obj.GetResourceVersion()).To(Equal("v1"), "resourceVersion must be set") g.Expect(obj.GetCreationTimestamp()).ToNot(BeZero(), "creation timestamp must be set") @@ -412,7 +412,7 @@ func Test_cache_client(t *testing.T) { err = c.Update("foo", objUpdate) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(objBefore).To(Equal(objUpdate), "obj before and after must be the same") + g.Expect(objBefore).To(BeComparableTo(objUpdate), "obj before and after must be the same") g.Expect(h.Events()).ToNot(ContainElement("foo, CloudMachine=bar, Updated")) }) @@ -435,7 +435,7 @@ func Test_cache_client(t *testing.T) { g.Expect(objBefore.GetResourceVersion()).ToNot(Equal(objUpdate.GetResourceVersion()), "Object version must be changed") objBefore.SetResourceVersion(objUpdate.GetResourceVersion()) objBefore.Labels = objUpdate.Labels - g.Expect(objBefore).To(Equal(objUpdate), "everything else must be the same") + g.Expect(objBefore).To(BeComparableTo(objUpdate), "everything else must be the same") g.Expect(h.Events()).To(ContainElement("foo, CloudMachine=baz, Updated")) }) @@ -670,7 +670,7 @@ func Test_cache_client(t *testing.T) { g.Expect(objBefore.GetResourceVersion()).ToNot(Equal(objAfterUpdate.GetResourceVersion()), "Object version must be changed") objBefore.SetResourceVersion(objAfterUpdate.GetResourceVersion()) objBefore.Labels = objAfterUpdate.Labels - g.Expect(objBefore).To(Equal(objAfterUpdate), "everything else must be the same") + g.Expect(objBefore).To(BeComparableTo(objAfterUpdate), "everything else must be the same") g.Expect(h.Events()).To(ContainElement("foo, CloudMachine=baz, Deleted")) diff --git a/test/infrastructure/inmemory/internal/server/mux_test.go b/test/infrastructure/inmemory/internal/server/mux_test.go index 7072df7a9518..ff5c60c9daef 100644 --- a/test/infrastructure/inmemory/internal/server/mux_test.go +++ b/test/infrastructure/inmemory/internal/server/mux_test.go @@ -188,7 +188,7 @@ func TestAPI_corev1_CRUD(t *testing.T) { node := &corev1.Node{} g.Expect(c.Get(ctx, client.ObjectKeyFromObject(n3), node)).To(Succeed()) - g.Expect(node.Spec.Taints).To(Equal(taints)) + g.Expect(node.Spec.Taints).To(BeComparableTo(taints)) // delete diff --git a/test/infrastructure/kind/mapper_test.go b/test/infrastructure/kind/mapper_test.go index 8636691120bb..bd6ab73978bd 100644 --- a/test/infrastructure/kind/mapper_test.go +++ b/test/infrastructure/kind/mapper_test.go @@ -115,7 +115,7 @@ func TestGetMapping(t *testing.T) { got := GetMapping(tc.k8sVersion, tc.customImage) tc.expectedMapping.KubernetesVersion = tc.k8sVersion - g.Expect(got).To(Equal(tc.expectedMapping)) + g.Expect(got).To(BeComparableTo(tc.expectedMapping)) }) } } diff --git a/util/conditions/patch_test.go b/util/conditions/patch_test.go index 968d605ff2b0..eda543bef3ef 100644 --- a/util/conditions/patch_test.go +++ b/util/conditions/patch_test.go @@ -124,7 +124,7 @@ func TestNewPatch(t *testing.T) { return } g.Expect(err).To(Not(HaveOccurred())) - g.Expect(got).To(Equal(tt.want)) + g.Expect(got).To(BeComparableTo(tt.want)) }) } } @@ -337,5 +337,5 @@ func TestApplyDoesNotAlterLastTransitionTime(t *testing.T) { err = diff.Apply(latest) g.Expect(err).ToNot(HaveOccurred()) - g.Expect(latest.GetConditions()).To(Equal(after.GetConditions())) + g.Expect(latest.GetConditions()).To(BeComparableTo(after.GetConditions())) } diff --git a/util/conditions/unstructured_test.go b/util/conditions/unstructured_test.go index 578fd63b313b..acaca1230475 100644 --- a/util/conditions/unstructured_test.go +++ b/util/conditions/unstructured_test.go @@ -84,5 +84,5 @@ func TestUnstructuredSetConditions(t *testing.T) { s := UnstructuredSetter(u) s.SetConditions(conditions) - g.Expect(s.GetConditions()).To(Equal(conditions)) + g.Expect(s.GetConditions()).To(BeComparableTo(conditions)) } diff --git a/util/kubeconfig/kubeconfig_test.go b/util/kubeconfig/kubeconfig_test.go index e65fa51ec3e6..320b01f57ca4 100644 --- a/util/kubeconfig/kubeconfig_test.go +++ b/util/kubeconfig/kubeconfig_test.go @@ -173,7 +173,7 @@ func TestNew(t *testing.T) { g.Expect(actualConfig.Clusters[tc.cluster]).NotTo(BeNil()) g.Expect(actualConfig.Contexts[tc.expectedConfig.CurrentContext]).NotTo(BeNil()) g.Expect(actualConfig.CurrentContext).To(Equal(tc.expectedConfig.CurrentContext)) - g.Expect(actualConfig.Contexts).To(Equal(tc.expectedConfig.Contexts)) + g.Expect(actualConfig.Contexts).To(BeComparableTo(tc.expectedConfig.Contexts)) } } @@ -199,7 +199,7 @@ func TestGenerateSecretWithOwner(t *testing.T) { ) g.Expect(kubeconfigSecret).NotTo(BeNil()) - g.Expect(kubeconfigSecret).To(Equal(expectedSecret)) + g.Expect(kubeconfigSecret).To(BeComparableTo(expectedSecret)) } func TestGenerateSecret(t *testing.T) { diff --git a/util/util_test.go b/util/util_test.go index 748ca0cbcd61..7d36aac8b2a3 100644 --- a/util/util_test.go +++ b/util/util_test.go @@ -104,7 +104,7 @@ func TestMachineToInfrastructureMapFunc(t *testing.T) { t.Run(tc.name, func(t *testing.T) { fn := MachineToInfrastructureMapFunc(tc.input) out := fn(ctx, tc.request) - g.Expect(out).To(Equal(tc.output)) + g.Expect(out).To(BeComparableTo(tc.output)) }) } } @@ -226,7 +226,7 @@ func TestClusterToInfrastructureMapFunc(t *testing.T) { fn := ClusterToInfrastructureMapFunc(context.Background(), tc.input, clientBuilder.Build(), referenceObject) out := fn(ctx, tc.request) - g.Expect(out).To(Equal(tc.output)) + g.Expect(out).To(BeComparableTo(tc.output)) }) } } diff --git a/util/version/version_test.go b/util/version/version_test.go index abe9501b08f8..416ce61c23f2 100644 --- a/util/version/version_test.go +++ b/util/version/version_test.go @@ -71,7 +71,7 @@ func TestParseMajorMinorPatch(t *testing.T) { t.Run(tc.name, func(t *testing.T) { out, err := ParseMajorMinorPatch(tc.input) g.Expect(err != nil).To(Equal(tc.expectError)) - g.Expect(out).To(Equal(tc.output)) + g.Expect(out).To(BeComparableTo(tc.output)) }) } } @@ -119,7 +119,7 @@ func TestParseMajorMinorPatchTolerant(t *testing.T) { t.Run(tc.name, func(t *testing.T) { out, err := ParseMajorMinorPatchTolerant(tc.input) g.Expect(err != nil).To(Equal(tc.expectError)) - g.Expect(out).To(Equal(tc.output)) + g.Expect(out).To(BeComparableTo(tc.output)) }) } }