fix: oneOfs with enums and strings can not be parsed

Author: marceljk

templates/go/custom/model_oneof_test.mustache

@@ -0,0 +1,54 @@
+{{! NOTE: This is a custom STACKIT template which is not present in upsteam to support testing of oneOf models}}
+
+
+{{! tests only the adjusted cases in the Generator of UnmarshalJSON}}
+{{#useOneOfDiscriminatorLookup}}
+{{^discriminator}}
+// isOneOf
+
+{{#composedSchemas.oneOf}}
+{{#-first}}
+func Test{{{classname}}}_UnmarshalJSON(t *testing.T) {
+	type args struct {
+		src []byte
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+{{/-first}}
+    {{#allowableValues.values}}
+        {
+            name: "success - {{dataType}} {{.}}",
+            args: args{
+                src: []byte(`"{{.}}"`),
+            },
+            wantErr: false,
+        },
+    {{/allowableValues.values}}
+    {{^allowableValues.values}}{{^isModel}}
+        {
+            name: "success - {{dataType}} {{example}}",
+            args: args{
+                src: []byte(`"{{example}}"`),
+            },
+            wantErr: false,
+        },
+    {{/isModel}}{{/allowableValues.values}}
+{{#-last}}
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := &{{{classname}}}{}
+			if err := v.UnmarshalJSON(tt.args.src); (err != nil) != tt.wantErr {
+				t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+{{/-last}}
+{{/composedSchemas.oneOf}}
+
+{{/discriminator}}
+{{/useOneOfDiscriminatorLookup}}

templates/go/custom/model_test.mustache

@@ -12,6 +12,9 @@ import (
 
 {{#model}}
 {{^isEnum}}
+{{#oneOf}}
+{{#-first}}{{>custom/model_oneof_test}}{{/-first}}
+{{/oneOf}}
 {{^oneOf}}{{^anyOf}}
 {{>custom/model_simple_test}}
 {{/anyOf}}{{/oneOf}}

templates/go/model_oneof.mustache

@@ -54,21 +54,36 @@ func (dst *{{classname}}) UnmarshalJSON(data []byte) error {
 	{{/discriminator}}
 	{{^discriminator}}
 	match := 0
-	{{#oneOf}}
+    {{! Workaround in case oneOf contains enums and strings. The enum value would match with both. }}
+    {{! The workaround adds a regex check for the string (in case the api spec provides a regex) }}
+	{{#composedSchemas.oneOf}}
+        {{#dataType}}
 	// try to unmarshal data into {{#lambda.type-to-name}}{{{.}}}{{/lambda.type-to-name}}
 	err = json.Unmarshal(data, &dst.{{#lambda.type-to-name}}{{{.}}}{{/lambda.type-to-name}})
 	if err == nil {
 		json{{{.}}}, _ := json.Marshal(dst.{{#lambda.type-to-name}}{{{.}}}{{/lambda.type-to-name}})
+        {{#pattern}}
+        regex := `{{.}}`
+        regex = regexp.MustCompile("^\\/|\\/$").ReplaceAllString(regex, "$1") // Remove beginning slash and ending slash
+        regex = regexp.MustCompile("\\\\(.)").ReplaceAllString(regex, "$1") // Remove duplicate escaping char for dots
+        rawString := strings.Trim(*dst.String, "\"")
+        {{/pattern}}
 		if string(json{{{.}}}) == "{}" { // empty struct
 			dst.{{#lambda.type-to-name}}{{{.}}}{{/lambda.type-to-name}} = nil
-		} else {
+        {{#pattern}}
+        } else if matched, _ := regexp.MatchString(regex, rawString); matched  {
+        {{/pattern}}
+        {{^pattern}}
+        } else {
+        {{/pattern}}
 			match++
 		}
 	} else {
 		dst.{{#lambda.type-to-name}}{{{.}}}{{/lambda.type-to-name}} = nil
 	}
 
-	{{/oneOf}}
+        {{/dataType}}
+	{{/composedSchemas.oneOf}}
 	if match > 1 { // more than 1 match
 		// reset to nil
 		{{#oneOf}}