Fakeclient: Patching an object that has allowUnconditionalUpdate=false where the patched version has no RV should succeed

[alvaroaleman]

Easiest to show with a testcase, the following test should pass but does not:

--- a/pkg/client/fake/client_test.go
+++ b/pkg/client/fake/client_test.go
@@ -359,6 +359,33 @@ var _ = Describe("Fake client", func() {
                        Expect(list.Items).To(ConsistOf(*dep2))
                })

+               FIt("should not return a conflict error from a patch operation with an empty RV and allowsUnconditionalUpdate=false", func() {
+                       schemeBuilder := &scheme.Builder{GroupVersion: schema.GroupVersion{Group: "test", Version: "v1"}}
+                       schemeBuilder.Register(&WithPointerMeta{}, &WithPointerMetaList{})
+                       scheme := runtime.NewScheme()
+                       Expect(schemeBuilder.AddToScheme(scheme)).NotTo(HaveOccurred())
+                       cl := NewClientBuilder().WithScheme(scheme).Build()
+                       original := &WithPointerMeta{ObjectMeta: &metav1.ObjectMeta{
+                               Name:      "obj",
+                               Namespace: "ns2",
+                       }}
+                       err := cl.Create(context.Background(), original)
+                       Expect(err).ToNot(HaveOccurred())
+
+                       newObj := &WithPointerMeta{ObjectMeta: &metav1.ObjectMeta{
+                               Name:      original.Name,
+                               Namespace: original.Namespace,
+                               Annotations: map[string]string{
+                                       "foo": "bar",
+                               },
+                       }}
+                       Expect(cl.Patch(context.Background(), newObj, client.MergeFrom(original))).To(Succeed())
+
+                       patched := &WithPointerMeta{}
+                       Expect(cl.Get(context.Background(), client.ObjectKeyFromObject(original), patched)).To(Succeed())
+                       Expect(patched.Annotations).To(Equal(map[string]string{"foo": "bar"}))
+               })
+
                It("should be able to Create", func() {
                        By("Creating a new configmap")
                        newcm := &corev1.ConfigMap{

We never noticed this, because all the tests use built-in resoruces and they all allowUnconditionalUpdate

[alvaroaleman]

Actually, at least that precise testcase is wrong as it will end up generating a patch that explicitly sets ResourceVersion to null which is indeed getting rejected by the server.

[sbueringer]

Actually, at least that precise testcase is wrong as it will end up generating a patch that explicitly sets ResourceVersion to null which is indeed getting rejected by the server.

Talked to Alvaro.

Just to clarify. The goal is that the fake client allows a patch which sets resourceVersion to nil.

Verified that the real apiserver behaves the same via envtest:

It("should update an existing object non-namespace object from a go struct", func() {
    cl, err := client.New(cfg, client.Options{})
    Expect(err).NotTo(HaveOccurred())
    Expect(cl).NotTo(BeNil())

    node, err := clientset.CoreV1().Nodes().Create(ctx, node, metav1.CreateOptions{})
    Expect(err).NotTo(HaveOccurred())
    original := node.DeepCopy()

    By("updating the object")
    node.Annotations = map[string]string{"foo": "bar"}
    node.ObjectMeta.ResourceVersion = ""
    err = cl.Patch(context.TODO(), node, client.MergeFrom(original))
    Expect(err).NotTo(HaveOccurred())

    By("validate updated Node had new annotation")
    actual, err := clientset.CoreV1().Nodes().Get(ctx, node.Name, metav1.GetOptions{})
    Expect(err).NotTo(HaveOccurred())
    Expect(actual).NotTo(BeNil())
    Expect(actual.Annotations["foo"]).To(Equal("bar"))
})

[alvaroaleman]

This got fixed in #2725, closing