Enable depguard in tests/framework/framework.go

Signed-off-by: Arthur Silva Sens <arthur.sens@coralogix.com>

.golangci.yml

@@ -49,6 +49,7 @@ linters-settings:
         - "**/versionutil/*.go"
         - "**/webconfig/*.go"
         - "**/e2e/*.go"
+        - "**/framework/framework.go"
         deny:
         - pkg: "github.com/pkg/errors"
           dsc: Should be replaced with standard lib errors or fmt.Errorf

test/framework/framework.go

@@ -25,7 +25,6 @@ import (
 
 	"github.com/blang/semver/v4"
 	"github.com/gogo/protobuf/proto"
-	"github.com/pkg/errors"
 	appsv1 "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
@@ -81,37 +80,37 @@ type Framework struct {
 func New(kubeconfig, opImage, exampleDir, resourcesDir string, operatorVersion semver.Version) (*Framework, error) {
 	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
 	if err != nil {
-		return nil, errors.Wrap(err, "build config from flags failed")
+		return nil, fmt.Errorf("build config from flags failed: %w", err)
 	}
 
 	cli, err := kubernetes.NewForConfig(config)
 	if err != nil {
-		return nil, errors.Wrap(err, "creating new kube-client failed")
+		return nil, fmt.Errorf("creating new kube-client failed: %w", err)
 	}
 
 	apiCli, err := apiclient.NewForConfig(config)
 	if err != nil {
-		return nil, errors.Wrap(err, "creating new kube-client failed")
+		return nil, fmt.Errorf("creating new kube-client failed: %w", err)
 	}
 
 	httpc := cli.CoreV1().RESTClient().(*rest.RESTClient).Client
 	if err != nil {
-		return nil, errors.Wrap(err, "creating http-client failed")
+		return nil, fmt.Errorf("creating http-client failed: %w", err)
 	}
 
 	mClientV1, err := v1monitoringclient.NewForConfig(config)
 	if err != nil {
-		return nil, errors.Wrap(err, "creating v1 monitoring client failed")
+		return nil, fmt.Errorf("creating v1 monitoring client failed: %w", err)
 	}
 
 	mClientv1alpha1, err := v1alpha1monitoringclient.NewForConfig(config)
 	if err != nil {
-		return nil, errors.Wrap(err, "creating v1alpha1 monitoring client failed")
+		return nil, fmt.Errorf("creating v1alpha1 monitoring client failed: %w", err)
 	}
 
 	mClientv1beta1, err := v1beta1monitoringclient.NewForConfig(config)
 	if err != nil {
-		return nil, errors.Wrap(err, "creating v1beta1 monitoring client failed")
+		return nil, fmt.Errorf("creating v1beta1 monitoring client failed: %w", err)
 	}
 
 	f := &Framework{
@@ -252,24 +251,24 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 		fmt.Sprintf("%s/rbac/prometheus-operator/prometheus-operator-service-account.yaml", f.exampleDir),
 	)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create or update prometheus operator service account")
+		return nil, fmt.Errorf("failed to create or update prometheus operator service account: %w", err)
 	}
 
 	clusterRole, err := f.CreateOrUpdateClusterRole(ctx, fmt.Sprintf("%s/rbac/prometheus-operator/prometheus-operator-cluster-role.yaml", f.exampleDir))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to create or update prometheus cluster role")
+		return nil, fmt.Errorf("failed to create or update prometheus cluster role: %w", err)
 	}
 
 	// Add CRD rbac rules
 	clusterRole.Rules = append(clusterRole.Rules, CRDCreateRule, CRDMonitoringRule)
 	if err := f.UpdateClusterRole(ctx, clusterRole); err != nil {
-		return nil, errors.Wrap(err, "failed to update prometheus cluster role")
+		return nil, fmt.Errorf("failed to update prometheus cluster role: %w", err)
 	}
 
 	if opts.ClusterRoleBindings {
 		// Grant permissions on all namespaces.
 		if _, err := f.createOrUpdateClusterRoleBinding(ctx, opts.Namespace, fmt.Sprintf("%s/rbac/prometheus-operator/prometheus-operator-cluster-role-binding.yaml", f.exampleDir)); err != nil {
-			return nil, errors.Wrap(err, "failed to create or update prometheus cluster role binding")
+			return nil, fmt.Errorf("failed to create or update prometheus cluster role binding: %w", err)
 		}
 	} else {
 		// Grant permissions on specific namespaces.
@@ -280,7 +279,7 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 
 		for _, n := range namespaces {
 			if _, err := f.CreateOrUpdateRoleBindingForSubjectNamespace(ctx, n, opts.Namespace, fmt.Sprintf("%s/prometheus-operator-role-binding.yaml", f.resourcesDir)); err != nil {
-				return nil, errors.Wrap(err, "failed to create or update prometheus operator role binding")
+				return nil, fmt.Errorf("failed to create or update prometheus operator role binding: %w", err)
 			}
 		}
 	}
@@ -289,70 +288,70 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 		return f.MonClientV1.Alertmanagers(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize Alertmanager CRD")
+		return nil, fmt.Errorf("initialize Alertmanager CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1.PodMonitorName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1.PodMonitors(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize PodMonitor CRD")
+		return nil, fmt.Errorf("initialize PodMonitor CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1.ProbeName, func(opts metav1.ListOptions) (object runtime.Object, err error) {
 		return f.MonClientV1.Probes(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize Probe CRD")
+		return nil, fmt.Errorf("initialize Probe CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1.PrometheusName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1.Prometheuses(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize Prometheus CRD")
+		return nil, fmt.Errorf("initialize Prometheus CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1.PrometheusRuleName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1.PrometheusRules(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize PrometheusRule CRD")
+		return nil, fmt.Errorf("initialize PrometheusRule CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1.ServiceMonitorName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1.ServiceMonitors(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize ServiceMonitor CRD")
+		return nil, fmt.Errorf("initialize ServiceMonitor CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1.ThanosRulerName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1.ThanosRulers(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize ThanosRuler CRD")
+		return nil, fmt.Errorf("initialize ThanosRuler CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1alpha1.AlertmanagerConfigName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1alpha1.AlertmanagerConfigs(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize AlertmanagerConfig v1alpha1 CRD")
+		return nil, fmt.Errorf("initialize AlertmanagerConfig v1alpha1 CRD: %w", err)
 	}
 
 	err = WaitForCRDReady(func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1beta1.AlertmanagerConfigs(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "wait for AlertmanagerConfig v1beta1 CRD")
+		return nil, fmt.Errorf("wait for AlertmanagerConfig v1beta1 CRD: %w", err)
 	}
 
 	err = f.CreateOrUpdateCRDAndWaitUntilReady(ctx, monitoringv1alpha1.PrometheusAgentName, func(opts metav1.ListOptions) (runtime.Object, error) {
 		return f.MonClientV1alpha1.PrometheusAgents(v1.NamespaceAll).List(ctx, opts)
 	})
 	if err != nil {
-		return nil, errors.Wrap(err, "initialize PrometheusAgent v1alpha1 CRD")
+		return nil, fmt.Errorf("initialize PrometheusAgent v1alpha1 CRD: %w", err)
 	}
 
 	if opts.EnableScrapeConfigs {
@@ -360,17 +359,17 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 			return f.MonClientV1alpha1.ScrapeConfigs(v1.NamespaceAll).List(ctx, opts)
 		})
 		if err != nil {
-			return nil, errors.Wrap(err, "initialize ScrapeConfig v1alpha1 CRD")
+			return nil, fmt.Errorf("initialize ScrapeConfig v1alpha1 CRD: %w", err)
 		}
 	}
 
 	certBytes, keyBytes, err := certutil.GenerateSelfSignedCertKey(fmt.Sprintf("%s.%s.svc", prometheusOperatorServiceDeploymentName, opts.Namespace), nil, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to generate certificate and key")
+		return nil, fmt.Errorf("failed to generate certificate and key: %w", err)
 	}
 
 	if err := f.CreateOrUpdateSecretWithCert(ctx, certBytes, keyBytes, opts.Namespace, prometheusOperatorCertsSecretName); err != nil {
-		return nil, errors.Wrap(err, "failed to create or update prometheus-operator TLS secret")
+		return nil, fmt.Errorf("failed to create or update prometheus-operator TLS secret: %w", err)
 	}
 
 	deploy, err := MakeDeployment(fmt.Sprintf("%s/rbac/prometheus-operator/prometheus-operator-deployment.yaml", f.exampleDir))
@@ -389,7 +388,7 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 		deploy.Spec.Template.Spec.Containers[0].Image = f.opImage
 		repoAndTag := strings.Split(f.opImage, ":")
 		if len(repoAndTag) != 2 {
-			return nil, errors.Errorf(
+			return nil, fmt.Errorf(
 				"expected operator image '%v' split by colon to result in two substrings but got '%v'",
 				f.opImage,
 				repoAndTag,
@@ -467,7 +466,7 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 
 	service, err := MakeService(fmt.Sprintf("%s/rbac/prometheus-operator/prometheus-operator-service.yaml", f.exampleDir))
 	if err != nil {
-		return finalizers, errors.Wrap(err, "cannot parse service file")
+		return finalizers, fmt.Errorf("cannot parse service file: %w", err)
 	}
 
 	service.Namespace = opts.Namespace
@@ -475,36 +474,36 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 	service.Spec.Ports = []v1.ServicePort{{Name: "https", Port: 443, TargetPort: intstr.FromInt(8443)}}
 
 	if _, err := f.CreateOrUpdateServiceAndWaitUntilReady(ctx, opts.Namespace, service); err != nil {
-		return finalizers, errors.Wrap(err, "failed to create or update prometheus operator service")
+		return finalizers, fmt.Errorf("failed to create or update prometheus operator service: %w", err)
 	}
 
 	if opts.EnableAdmissionWebhook {
 		webhookService, b, err := f.CreateOrUpdateAdmissionWebhookServer(ctx, opts.Namespace, webhookServerImage)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to create webhook server")
+			return nil, fmt.Errorf("failed to create webhook server: %w", err)
 		}
 
 		finalizer, err := f.createOrUpdateMutatingHook(ctx, b, opts.Namespace, fmt.Sprintf("%s/prometheus-operator-mutatingwebhook.yaml", f.resourcesDir))
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to create or update mutating webhook for PrometheusRule objects")
+			return nil, fmt.Errorf("failed to create or update mutating webhook for PrometheusRule objects: %w", err)
 		}
 		finalizers = append(finalizers, finalizer)
 
 		finalizer, err = f.createOrUpdateValidatingHook(ctx, b, opts.Namespace, fmt.Sprintf("%s/prometheus-operator-validatingwebhook.yaml", f.resourcesDir))
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to create or update validating webhook for PrometheusRule objects")
+			return nil, fmt.Errorf("failed to create or update validating webhook for PrometheusRule objects: %w", err)
 		}
 		finalizers = append(finalizers, finalizer)
 
 		finalizer, err = f.createOrUpdateValidatingHook(ctx, b, opts.Namespace, fmt.Sprintf("%s/alertmanager-config-validating-webhook.yaml", f.resourcesDir))
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to create or update validating webhook for AlertManagerConfig objects")
+			return nil, fmt.Errorf("failed to create or update validating webhook for AlertManagerConfig objects: %w", err)
 		}
 		finalizers = append(finalizers, finalizer)
 
 		finalizer, err = f.configureAlertmanagerConfigConversion(ctx, webhookService, b)
 		if err != nil {
-			return nil, errors.Wrap(err, "failed to configure conversion webhook for AlertManagerConfig objects")
+			return nil, fmt.Errorf("failed to configure conversion webhook for AlertManagerConfig objects: %w", err)
 		}
 		finalizers = append(finalizers, finalizer)
 	}
@@ -517,108 +516,108 @@ func (f *Framework) CreateOrUpdatePrometheusOperatorWithOpts(
 func (f *Framework) DeletePrometheusOperatorClusterResource(ctx context.Context) error {
 	err := f.DeleteClusterRole(ctx, fmt.Sprintf("%s/rbac/prometheus-operator/prometheus-operator-cluster-role.yaml", f.exampleDir))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete prometheus cluster role")
+		return fmt.Errorf("failed to delete prometheus cluster role: %w", err)
 	}
 
 	group := monitoring.GroupName
 
 	alertmanagerCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.AlertmanagerName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make alertmanager CRD")
+		return fmt.Errorf("failed to make alertmanager CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", alertmanagerCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete alertmanager CRD")
+		return fmt.Errorf("failed to delete alertmanager CRD: %w", err)
 	}
 
 	podMonitorCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.PodMonitorName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make podMonitor CRD")
+		return fmt.Errorf("failed to make podMonitor CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", podMonitorCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete podMonitor CRD")
+		return fmt.Errorf("failed to delete podMonitor CRD: %w", err)
 	}
 
 	probeCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.ProbeName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make probe CRD")
+		return fmt.Errorf("failed to make probe CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", probeCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete probe CRD")
+		return fmt.Errorf("failed to delete probe CRD: %w", err)
 	}
 
 	prometheusCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.PrometheusName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make prometheus CRD")
+		return fmt.Errorf("failed to make prometheus CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", prometheusCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete prometheus CRD")
+		return fmt.Errorf("failed to delete prometheus CRD: %w", err)
 	}
 
 	prometheusRuleCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.PrometheusRuleName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make prometheusRule CRD")
+		return fmt.Errorf("failed to make prometheusRule CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", prometheusRuleCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete prometheusRule CRD")
+		return fmt.Errorf("failed to delete prometheusRule CRD: %w", err)
 	}
 
 	serviceMonitorCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.ServiceMonitorName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make serviceMonitor CRD")
+		return fmt.Errorf("failed to make serviceMonitor CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", serviceMonitorCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete serviceMonitor CRD")
+		return fmt.Errorf("failed to delete serviceMonitor CRD: %w", err)
 	}
 
 	thanosRulerCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1.ThanosRulerName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make thanosRuler CRD")
+		return fmt.Errorf("failed to make thanosRuler CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", thanosRulerCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete thanosRuler CRD")
+		return fmt.Errorf("failed to delete thanosRuler CRD: %w", err)
 	}
 
 	alertmanagerConfigCRD, err := f.MakeCRD(fmt.Sprintf("%s/prometheus-operator-crd/%s_%s.yaml", f.exampleDir, group, monitoringv1alpha1.AlertmanagerConfigName))
 	if err != nil {
-		return errors.Wrap(err, "failed to make alertmanagerConfig CRD")
+		return fmt.Errorf("failed to make alertmanagerConfig CRD: %w", err)
 	}
 	err = f.DeleteCRD(ctx, fmt.Sprintf("%s.%s", alertmanagerConfigCRD.Name, group))
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete alertmanagerConfig CRD")
+		return fmt.Errorf("failed to delete alertmanagerConfig CRD: %w", err)
 	}
 
 	operatorMutatingHook, err := parseMutatingHookYaml(fmt.Sprintf("%s/prometheus-operator-mutatingwebhook.yaml", f.resourcesDir))
 	if err != nil {
-		return errors.Wrap(err, "failed to parse operator mutatingwebhook")
+		return fmt.Errorf("failed to parse operator mutatingwebhook: %w", err)
 	}
 	err = f.deleteMutatingWebhook(ctx, operatorMutatingHook.Name)
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete operator mutatingwebhook")
+		return fmt.Errorf("failed to delete operator mutatingwebhook: %w", err)
 	}
 
 	operatorValidatingHook, err := parseValidatingHookYaml(fmt.Sprintf("%s/prometheus-operator-validatingwebhook.yaml", f.resourcesDir))
 	if err != nil {
-		return errors.Wrap(err, "failed to parse operator validatingwebhook")
+		return fmt.Errorf("failed to parse operator validatingwebhook: %w", err)
 	}
 	err = f.deleteValidatingWebhook(ctx, operatorValidatingHook.Name)
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete operator mutatingwebhook")
+		return fmt.Errorf("failed to delete operator mutatingwebhook: %w", err)
 	}
 
 	AlertmanagerConfigValidatingHook, err := parseValidatingHookYaml(fmt.Sprintf("%s/alertmanager-config-validating-webhook.yaml", f.resourcesDir))
 	if err != nil {
-		return errors.Wrap(err, "failed to parse alertmanager config mutatingwebhook")
+		return fmt.Errorf("failed to parse alertmanager config mutatingwebhook: %w", err)
 	}
 	err = f.deleteValidatingWebhook(ctx, AlertmanagerConfigValidatingHook.Name)
 	if err != nil && !apierrors.IsNotFound(err) {
-		return errors.Wrap(err, "failed to delete alertmanager config mutatingwebhook")
+		return fmt.Errorf("failed to delete alertmanager config mutatingwebhook: %w", err)
 	}
 
 	return nil
@@ -629,7 +628,7 @@ func (f *Framework) SetupPrometheusRBAC(ctx context.Context, t *testing.T, testC
 		t.Fatalf("failed to create or update prometheus cluster role: %v", err)
 	}
 	if finalizerFn, err := f.createOrUpdateServiceAccount(ctx, ns, fmt.Sprintf("%s/rbac/prometheus/prometheus-service-account.yaml", f.exampleDir)); err != nil {
-		t.Fatal(errors.Wrap(err, "failed to create or update prometheus service account"))
+		t.Fatal(fmt.Errorf("failed to create or update prometheus service account: %w", err))
 	} else {
 		if testCtx != nil {
 			testCtx.AddFinalizerFn(finalizerFn)
@@ -638,7 +637,7 @@ func (f *Framework) SetupPrometheusRBAC(ctx context.Context, t *testing.T, testC
 	}
 
 	if finalizerFn, err := f.CreateOrUpdateRoleBinding(ctx, ns, fmt.Sprintf("%s/prometheus-role-binding.yml", f.resourcesDir)); err != nil {
-		t.Fatal(errors.Wrap(err, "failed to create prometheus role binding"))
+		t.Fatal(fmt.Errorf("failed to create prometheus role binding: %w", err))
 	} else {
 		if testCtx != nil {
 			testCtx.AddFinalizerFn(finalizerFn)
@@ -651,13 +650,13 @@ func (f *Framework) SetupPrometheusRBACGlobal(ctx context.Context, t *testing.T,
 		t.Fatalf("failed to create or update prometheus cluster role: %v", err)
 	}
 	if finalizerFn, err := f.createOrUpdateServiceAccount(ctx, ns, "../../example/rbac/prometheus/prometheus-service-account.yaml"); err != nil {
-		t.Fatal(errors.Wrap(err, "failed to create or update prometheus service account"))
+		t.Fatal(fmt.Errorf("failed to create or update prometheus service account: %w", err))
 	} else {
 		testCtx.AddFinalizerFn(finalizerFn)
 	}
 
 	if finalizerFn, err := f.createOrUpdateClusterRoleBinding(ctx, ns, "../../example/rbac/prometheus/prometheus-cluster-role-binding.yaml"); err != nil && !apierrors.IsAlreadyExists(err) {
-		t.Fatal(errors.Wrap(err, "failed to create or update prometheus cluster role binding"))
+		t.Fatal(fmt.Errorf("failed to create or update prometheus cluster role binding: %w", err))
 	} else {
 		testCtx.AddFinalizerFn(finalizerFn)
 	}
@@ -746,11 +745,11 @@ func (f *Framework) CreateOrUpdateAdmissionWebhookServer(
 		nil,
 	)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "failed to generate certificate and key")
+		return nil, nil, fmt.Errorf("failed to generate certificate and key: %w", err)
 	}
 
 	if err := f.CreateOrUpdateSecretWithCert(ctx, certBytes, keyBytes, namespace, standaloneAdmissionHookSecretName); err != nil {
-		return nil, nil, errors.Wrap(err, "failed to create or update admission webhook secret")
+		return nil, nil, fmt.Errorf("failed to create or update admission webhook secret: %w", err)
 	}
 
 	deploy, err := MakeDeployment(fmt.Sprintf("%s/admission-webhook/deployment.yaml", f.exampleDir))
@@ -771,7 +770,7 @@ func (f *Framework) CreateOrUpdateAdmissionWebhookServer(
 		deploy.Spec.Template.Spec.Containers[0].Image = image
 		repoAndTag := strings.Split(image, ":")
 		if len(repoAndTag) != 2 {
-			return nil, nil, errors.Errorf(
+			return nil, nil, fmt.Errorf(
 				"expected image '%v' split by colon to result in two substrings but got '%v'",
 				image,
 				repoAndTag,
@@ -791,12 +790,12 @@ func (f *Framework) CreateOrUpdateAdmissionWebhookServer(
 
 	service, err := MakeService(fmt.Sprintf("%s/admission-webhook/service.yaml", f.exampleDir))
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "cannot parse service file")
+		return nil, nil, fmt.Errorf("cannot parse service file: %w", err)
 	}
 
 	service.Namespace = namespace
 	if _, err := f.CreateOrUpdateServiceAndWaitUntilReady(ctx, namespace, service); err != nil {
-		return nil, nil, errors.Wrap(err, "failed to create or update admission webhook server service")
+		return nil, nil, fmt.Errorf("failed to create or update admission webhook server service: %w", err)
 	}
 
 	return service, certBytes, nil