WIP: Capture warnings using custom client

Author: theobarberbany

pkg/admissionpolicy/testutils/util.go

@@ -17,11 +17,13 @@ limitations under the License.
 package testutils
 
 import (
+	"context"
 	"errors"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 
 	corev1 "k8s.io/api/core/v1"
 
@@ -32,6 +34,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/yaml"
 	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/rest"
 
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
@@ -261,3 +264,55 @@ func LoadTransportConfigMaps() map[string][]client.Object {
 
 	return mapObjs
 }
+
+// WarningCollector is to provide a way to collect
+// kube client warnings, intended for testing VAPs that return warnings.
+type WarningCollector struct {
+	sync.Mutex
+	messages []string
+}
+
+// HandleWarningHeaderWithContext implements rest.WarningHandlerWithContext.
+func (w *WarningCollector) HandleWarningHeaderWithContext(_ context.Context, code int, _ string, message string) {
+	w.Lock()
+	w.messages = append(w.messages, message)
+	w.Unlock()
+}
+
+// Messages returns messages collected by a warning collector.
+func (w *WarningCollector) Messages() []string {
+	w.Lock()
+	defer w.Unlock()
+
+	// return a copy for thread-safety
+	out := make([]string, len(w.messages))
+	copy(out, w.messages)
+
+	return out
+}
+
+// Reset clears the messages, used betwen tests to reset state.
+func (w *WarningCollector) Reset() {
+	w.Lock()
+	w.messages = nil
+	w.Unlock()
+}
+
+// SetupClientWithWarningCollector creates a new client.Client, with a warning handler that writes to a WarningCollector that is also returned.
+// TODO: english good.
+func SetupClientWithWarningCollector(cfg *rest.Config, scheme *runtime.Scheme) (client.Client, *WarningCollector, error) {
+	warnSink := &WarningCollector{}
+	// copy to avoid mutating the passed-in config
+	newcfg := rest.CopyConfig(cfg)
+
+	// Use the per-config handler (preferred in modern client-go)
+	newcfg.WarningHandlerWithContext = warnSink
+
+	// Build the client with this config
+	client, err := client.New(newcfg, client.Options{Scheme: scheme})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return client, warnSink, nil
+}

pkg/controllers/machinesync/machine_sync_controller_test.go

@@ -1365,6 +1365,8 @@ var _ = Describe("With a running MachineSync Reconciler", func() {
 		})
 
 		FContext("Updates to MAPI machine warns user if the Synchronized condition is set to false", func() {
+			var warnClient client.Client
+			var warnSink *admissiontestutils.WarningCollector
 			BeforeEach(func() {
 				By("Waiting for VAP to be ready")
 				machineVap = &admissionregistrationv1.ValidatingAdmissionPolicy{}
@@ -1406,14 +1408,20 @@ var _ = Describe("With a running MachineSync Reconciler", func() {
 				sentinelMachine := mapiMachineBuilder.WithName("sentinel-machine").WithAuthoritativeAPI(mapiv1beta1.MachineAuthorityClusterAPI).Build()
 				Eventually(k8sClient.Create(ctx, sentinelMachine), timeout).Should(Succeed())
 
-				capiSentinelMachine := clusterv1resourcebuilder.Machine().WithName("sentinel-machine").WithNamespace(capiNamespace.Name).Build()
-				Expect(k8sClient.Create(ctx, capiSentinelMachine)).To(Succeed())
+				var err error
+				warnClient, warnSink, err = admissiontestutils.SetupClientWithWarningCollector(cfg, testScheme)
+				Expect(err).To(Not(HaveOccurred()))
 
-				Eventually(k.Get(capiSentinelMachine)).Should(Succeed())
+				// TODO: I don't know if doing this, or setting the komega client
+				// to be the warnClient (then unsetting it with DeferCleanup()) is better
+				Eventually(func(g Gomega) {
+					warnSink.Reset() // keep each probe self-contained
 
-				Eventually(k.Update(sentinelMachine, func() {
 					sentinelMachine.ObjectMeta.Labels = map[string]string{"test-sentinel": "fubar"}
-				}), timeout).Should(Succeed())
+					g.Expect(warnClient.Update(ctx, sentinelMachine)).To(Succeed())
+					g.Expect(warnSink.Messages()).To(ContainElement(ContainSubstring("policy in place")))
+				}, timeout).Should(Succeed())
+
 			})
 
 			It("warns the user when the machine is still synchronzing", func() {
@@ -1430,10 +1438,14 @@ var _ = Describe("With a running MachineSync Reconciler", func() {
 					}
 				})).Should(Succeed())
 
-				By("Attempting to update the authoritativeAPI should be blocked")
-				Eventually(k.Update(mapiMachine, func() {
+				By("Attempting to update the authoritativeAPI should emit a warning")
+				Eventually(func(g Gomega) {
+					warnSink.Reset() // keep each probe self-contained
+
 					mapiMachine.Spec.AuthoritativeAPI = mapiv1beta1.MachineAuthorityClusterAPI
-				}), timeout).Should(Succeed()) // This should succeed but show a warning?
+					g.Expect(warnClient.Update(ctx, mapiMachine)).To(Succeed())
+					g.Expect(warnSink.Messages()).To(ContainElement(ContainSubstring("updating .spec.authoritativeAPI when Synchronized=false on resource means changes may not take effect")))
+				}, timeout).Should(Succeed())
 			})
 
 		})