Merge pull request #80 from apelisse/oneof-lists

Oneof lists

Author: k8s-ci-robot

merge/union_test.go

@@ -39,13 +39,24 @@ var unionFieldsParser = func() typed.ParseableType {
     - name: type
       type:
         scalar: string
-    union:
-      discriminator: type
+    - name: fieldA
+      type:
+        scalar: string
+    - name: fieldB
+      type:
+        scalar: string
+    unions:
+    - discriminator: type
       fields:
       - fieldName: numeric
         discriminatedBy: Numeric
       - fieldName: string
-        discriminatedBy: String`)
+        discriminatedBy: String
+    - fields:
+      - fieldName: fieldA
+        discriminatedBy: FieldA
+      - fieldName: fieldB
+        discriminatedBy: FieldB`)
 	if err != nil {
 		panic(err)
 	}
@@ -123,6 +134,31 @@ func TestUnion(t *testing.T) {
 				},
 			},
 		},
+		"union_apply_multiple_unions": {
+			Ops: []Operation{
+				Apply{
+					Manager:    "default",
+					APIVersion: "v1",
+					Object: `
+						string: "some string"
+						fieldA: "fieldA string"
+					`,
+				},
+				Apply{
+					Manager:    "default",
+					APIVersion: "v1",
+					Object: `
+						numeric: 0
+						fieldB: "fieldB string"
+					`,
+				},
+			},
+			Object: `
+				type: Numeric
+				numeric: 0
+				fieldB: "fieldB string"
+			`,
+		},
 	}
 
 	for name, test := range tests {

schema/elements.go

@@ -88,10 +88,12 @@ type Struct struct {
 	// this list defines the canonical field ordering.
 	Fields []StructField `yaml:"fields,omitempty"`
 
-	// Union is a grouping of fields with special rules. It may refer to
+	// A Union is a grouping of fields with special rules. It may refer to
 	// one or more fields in the above list. A given field from the above
 	// list may be referenced in exactly 0 or 1 places in the below list.
-	Union *Union `yaml:"union,omitempty"`
+	// One can have multiple unions in the same struct, but the fields can't
+	// overlap between unions.
+	Unions []Union `yaml:"unions,omitempty"`
 
 	// ElementRelationship states the relationship between the struct's items.
 	// * `separable` (or unset) implies that each element is 100% independent.

schema/schemaschema.go

@@ -84,9 +84,12 @@ var SchemaSchemaYAML = `types:
             namedType: structField
           elementRelationship: associative
           keys: [ "name" ]
-    - name: union
+    - name: unions
       type:
-        namedType: union
+        list:
+          elementType:
+            namedType: union
+          elementRelationship: atomic
     - name: elementRelationship
       type:
         scalar: string

typed/typed.go

@@ -163,7 +163,7 @@ func (tv TypedValue) NormalizeUnions(new *TypedValue) (*TypedValue, error) {
 			v := *w.rhs
 			w.out = &v
 		}
-		if err := normalizeUnion(w); err != nil {
+		if err := normalizeUnions(w); err != nil {
 			errs = append(errs, w.error(err)...)
 		}
 	}

typed/union.go

@@ -24,21 +24,26 @@ import (
 	"sigs.k8s.io/structured-merge-diff/value"
 )
 
-func normalizeUnion(w *mergingWalker) error {
+func normalizeUnions(w *mergingWalker) error {
 	atom, found := w.schema.Resolve(w.typeRef)
 	if !found {
 		panic(fmt.Sprintf("Unable to resolve schema in normalize union: %v/%v", w.schema, w.typeRef))
 	}
 	// Unions can only be in structures, and the struct must not have been removed
-	if atom.Struct == nil || atom.Struct.Union == nil || w.out == nil {
+	if atom.Struct == nil || w.out == nil {
 		return nil
 	}
 
 	old := &value.Map{}
 	if w.lhs != nil {
 		old = w.lhs.MapValue
 	}
-	return newUnion(atom.Struct.Union).Normalize(old, w.rhs.MapValue, w.out.MapValue)
+	for _, union := range atom.Struct.Unions {
+		if err := newUnion(&union).Normalize(old, w.rhs.MapValue, w.out.MapValue); err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
 type discriminated string

typed/union_test.go

@@ -39,21 +39,6 @@ var unionParser = func() typed.ParseableType {
     - name: three
       type:
         scalar: numeric
-    - name: nodisc
-      type:
-        namedType: nondiscriminated
-    union:
-      discriminator: discriminator
-      fields:
-      - fieldName: one
-        discriminatedBy: One
-      - fieldName: two
-        discriminatedBy: TWO
-      - fieldName: three
-        discriminatedBy: three
-- name: nondiscriminated
-  struct:
-    fields:
     - name: a
       type:
         scalar: numeric
@@ -63,14 +48,22 @@ var unionParser = func() typed.ParseableType {
     - name: c
       type:
         scalar: numeric
-    union:
+    unions:
+    - discriminator: discriminator
       fields:
+      - fieldName: one
+        discriminatedBy: One
+      - fieldName: two
+        discriminatedBy: TWO
+      - fieldName: three
+        discriminatedBy: three
+    - fields:
       - fieldName: a
         discriminatedBy: A
       - fieldName: b
         discriminatedBy: B
       - fieldName: c
-        discriminatedBy: C]`)
+        discriminatedBy: C`)
 	if err != nil {
 		panic(err)
 	}
@@ -98,9 +91,9 @@ func TestNormalizeUnions(t *testing.T) {
 		},
 		{
 			name: "proper union update, no discriminator",
-			old:  `{"nodisc": {"a": 1}}`,
-			new:  `{"nodisc": {"b": 1}}`,
-			out:  `{"nodisc": {"b": 1}}`,
+			old:  `{"a": 1}`,
+			new:  `{"b": 1}`,
+			out:  `{"b": 1}`,
 		},
 		{
 			name: "proper union update from not-set, setting discriminator",
@@ -111,8 +104,8 @@ func TestNormalizeUnions(t *testing.T) {
 		{
 			name: "proper union update from not-set, no discriminator",
 			old:  `{}`,
-			new:  `{"nodisc": {"b": 1}}`,
-			out:  `{"nodisc": {"b": 1}}`,
+			new:  `{"b": 1}`,
+			out:  `{"b": 1}`,
 		},
 		{
 			name: "remove union, with discriminator",
@@ -134,15 +127,15 @@ func TestNormalizeUnions(t *testing.T) {
 		},
 		{
 			name: "remove union, no discriminator",
-			old:  `{"nodisc": {"b": 1}}`,
+			old:  `{"b": 1}`,
 			new:  `{}`,
 			out:  `{}`,
 		},
 		{
 			name: "dumb client update, no discriminator",
-			old:  `{"nodisc": {"a": 1}}`,
-			new:  `{"nodisc": {"a": 2, "b": 1}}`,
-			out:  `{"nodisc": {"b": 1}}`,
+			old:  `{"a": 1}`,
+			new:  `{"a": 2, "b": 1}`,
+			out:  `{"b": 1}`,
 		},
 		{
 			name: "dumb client update, sets discriminator",
@@ -158,9 +151,9 @@ func TestNormalizeUnions(t *testing.T) {
 		},
 		{
 			name: "multi-discriminator at the same time",
-			old:  `{"one": 1, "nodisc": {"a": 1}}`,
-			new:  `{"one": 1, "three": 1, "nodisc": {"a": 1, "b": 1}}`,
-			out:  `{"three": 1, "discriminator": "three", "nodisc": {"b": 1}}`,
+			old:  `{"one": 1, "a": 1}`,
+			new:  `{"one": 1, "three": 1, "a": 1, "b": 1}`,
+			out:  `{"three": 1, "discriminator": "three", "b": 1}`,
 		},
 		{
 			name: "change discriminator, nothing else",