fix: improve serialize-nulls in additional properties

This commit improves the behavior of the DynamicModelTypeAdapterFactory's
serialization function so that we support the serialization of null values
found within additional properties in a more accurate way.
1. A null-valued additional property will be serialized as null in the JSON.
2. A null-valued normal property that is set as an additional property
will NOT be serialized as a null.
3. The above "serialize nulls" behavior also applies to additional property
values which are model instances.

Author: padamstx

src/main/java/com/ibm/cloud/sdk/core/util/DynamicModelTypeAdapterFactory.java

@@ -24,6 +24,7 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.logging.Logger;
 
 import com.google.gson.Gson;
@@ -290,12 +291,14 @@ public static class Adapter<T> extends TypeAdapter<T> {
     private Map<String, BoundField> boundFields;
     private Gson gson;
     private TypeAdapter<?> mapValueObjectTypeAdapter;
+    private Set<String> boundFieldNames;
 
     Adapter(Gson gson, Constructor<?> ctor, Map<String, BoundField> boundFields) {
       this.gson = gson;
       this.ctor = ctor;
       this.boundFields = boundFields;
       this.mapValueObjectTypeAdapter = new MapValueObjectTypeAdapter(gson);
+      this.boundFieldNames = boundFields.keySet();
     }
 
     /*
@@ -336,12 +339,27 @@ public void write(JsonWriter out, T value) throws IOException {
         // Next, serialize each of the map entries.
         // When serializing the map entries (i.e. additional/dynamic properties) we want
         // to explicitly serialize null values regardless of the global Gson "serialize nulls" setting.
+        // In order to ensure that the "serialize nulls" behavior is not inadvertently pushed down into
+        // recursive serialization steps (i.e. "mapValue" is a model instance), we'll only set the
+        // "serialize nulls" option if the dynamic property's value is null AND the dynamic property's name
+        // is not one of the explicitly-defined properties.
         boolean serializeNulls = out.getSerializeNulls();
-        out.setSerializeNulls(true);
         try {
           for (String key : ((DynamicModel<?>) value).getPropertyNames()) {
-            out.name(String.valueOf(key));
-            mapValueTypeAdapter.write(out, ((DynamicModel<?>) value).get(key));
+            Object mapValue = ((DynamicModel<?>) value).get(key);
+
+            // If this dynamic property is NOT an explicitly-defined property AND the value is null,
+            // then temporarily enable the "serializeNulls" Gson option.
+            if (!boundFieldNames.contains(key) && mapValue == null) {
+              out.setSerializeNulls(true);
+            }
+
+            // Now serialize the key and value.
+            out.name(key);
+            mapValueTypeAdapter.write(out, mapValue);
+
+            // Restore the original "serializeNulls" option value.
+            out.setSerializeNulls(serializeNulls);
           }
         } finally {
           out.setSerializeNulls(serializeNulls);

src/test/java/com/ibm/cloud/sdk/core/test/model/DynamicModelSerializationTest.java

@@ -60,6 +60,10 @@ private void display(String msg) {
     }
   }
 
+  private String trimWhitespace(String s) {
+    return s.replaceAll("\\s+", "");
+  }
+
   private <T> void testSerDeser(DynamicModel<?> model, Class<T> clazz) {
     String jsonString = serialize(model);
 
@@ -204,9 +208,49 @@ public void testNoCtor() {
 
   @Test
   public void testNullValues() {
-    ModelAPFoo model = createModelAPFoo();
+    ModelAPFoo model;
+    Foo foo;
+    String json;
+
+    // A simple empty model instance (all props null, no additional properties)
+    // should produce "{}"
+    model = new ModelAPFoo();
+    json = serialize(model);
+    assertEquals(trimWhitespace(json), "{}");
+
+    // Explicitly setting a property to null should also produce "{}"
+    model = new ModelAPFoo();
     model.setProp1(null);
-    testSerDeser(model, ModelAPFoo.class);
+    json = serialize(model);
+    assertEquals(trimWhitespace(json), "{}");
+
+    // Explicitly setting an additional property to null should
+    // cause that property to be serialized as a null.
+    model = new ModelAPFoo();
+    model.put("foo", null);
+    json = serialize(model);
+    assertEquals(trimWhitespace(json), "{\"foo\":null}");
+
+    // Setting a normal property as an additional property should
+    // NOT produce a "null" value in the JSON.
+    model = new ModelAPFoo();
+    model.put("prop1", null);
+    json = serialize(model);
+    assertEquals(trimWhitespace(json), "{}");
+
+    // Setting three additional properties - foo1, foo2, foo3
+    // foo1 is a model instance with a null property (should NOT be serialized as null)
+    // foo2 is null and should be serialized as null
+    // foo3 is a model instance with both properties null (should be serialized as "{}"
+    model = new ModelAPFoo();
+    model.setProp1("value1");
+    foo = new Foo();
+    foo.setBar(38);
+    model.put("foo1", foo);
+    model.put("foo2", null);
+    model.put("foo3", new Foo());
+    json = serialize(model);
+    assertEquals(trimWhitespace(json), "{\"prop1\":\"value1\",\"foo1\":{\"bar\":38},\"foo2\":null,\"foo3\":{}}");
   }
 
   @Test