Reversible (Un)Serialization

schema/any_test.go

@@ -111,15 +111,21 @@ func TestAny(t *testing.T) {
 
 	anyType := schema.NewAnySchema()
 	for name, val := range validValues {
+		testCase := val
 		t.Run(name, func(t *testing.T) {
-			unserialized, err := anyType.Unserialize(val.input)
+			unserialized, err := anyType.Unserialize(testCase.input)
 			assert.NoError(t, err)
-			assert.Equals(t, unserialized, val.unserialized)
-			err = anyType.Validate(val.unserialized)
+			assert.Equals(t, unserialized, testCase.unserialized)
+			err = anyType.Validate(testCase.unserialized)
 			assert.NoError(t, err)
-			serialized, err := anyType.Serialize(val.unserialized)
+			serialized, err := anyType.Serialize(testCase.unserialized)
 			assert.NoError(t, err)
-			assert.Equals(t, serialized, val.serialized)
+			assert.Equals(t, serialized, testCase.serialized)
+
+			unserialized2, err := anyType.Unserialize(serialized)
+			assert.NoError(t, err)
+			// test unserialize and serialize are reversible
+			assert.Equals(t, unserialized2, unserialized)
 		})
 	}
 

schema/list_test.go

@@ -181,3 +181,24 @@ func TestListVerifyCompatibility(t *testing.T) {
 	assert.NoError(t, intListSchema.ValidateCompatibility([]any{schema.NewIntSchema(nil, nil, nil)}))
 	assert.Error(t, intListSchema.ValidateCompatibility([]any{schema.NewStringSchema(nil, nil, nil)}))
 }
+
+func TestList_UnSerialize_Reversible(t *testing.T) {
+	listType := schema.NewTypedListSchema[string](
+		schema.NewStringSchema(
+			nil,
+			nil,
+			nil,
+		),
+		nil,
+		nil,
+	)
+	input := []any{"foo", "bar", "baz"}
+	unserialized, err := listType.Unserialize(input)
+	assert.NoError(t, err)
+	serialized, err := listType.Serialize(unserialized)
+	assert.NoError(t, err)
+	unserialized2, err := listType.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, unserialized)
+}

schema/map_test.go

@@ -344,3 +344,21 @@ func TestMapCompatibilityValidation(t *testing.T) {
 	assert.Error(t, s1.ValidateCompatibility(true))
 	assert.Error(t, s1.ValidateCompatibility([]string{}))
 }
+
+func TestMap_UnSerialize_Reversible(t *testing.T) {
+	mapType := schema.NewTypedMapSchema[string, string](
+		schema.NewStringSchema(nil, nil, nil),
+		schema.NewStringSchema(nil, nil, nil),
+		nil,
+		nil,
+	)
+	input := map[any]any{"foo": "foo", "bar": "bar", "baz": "baz"}
+	unserialized, err := mapType.Unserialize(input)
+	assert.NoError(t, err)
+	serialized, err := mapType.Serialize(unserialized)
+	assert.NoError(t, err)
+	unserialized2, err := mapType.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, unserialized)
+}

schema/object_test.go

@@ -368,9 +368,22 @@ func TestTypedString(t *testing.T) {
 	result, err := o.Unserialize(map[string]any{"t1": "Hello world!"})
 	assert.NoError(t, err)
 	assert.Equals(t, result.(testStruct).T1, "Hello world!")
+	serialized, err := o.Serialize(result)
+	assert.NoError(t, err)
+	unserialized2, err := o.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, result)
+
 	result, err = o.Unserialize(map[string]any{"t2": "Hello world!"})
 	assert.NoError(t, err)
 	assert.Equals(t, *result.(testStruct).T2, "Hello world!")
+	serialized, err = o.Serialize(result)
+	assert.NoError(t, err)
+	unserialized2, err = o.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, result)
 }
 
 func TestNonDefaultSerialization(t *testing.T) {
@@ -396,6 +409,13 @@ func TestNonDefaultSerialization(t *testing.T) {
 	serializedData, err := s.Serialize(TestData{&text})
 	assert.NoError(t, err)
 	assert.Equals(t, serializedData.(map[string]any)["foo"].(string), text)
+
+	unserialized, err := s.Unserialize(serializedData)
+	assert.NoError(t, err)
+	serialized2, err := s.Serialize(unserialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, serialized2, serializedData)
 }
 
 func TestTypedObjectSchema_Any(t *testing.T) {
@@ -425,6 +445,13 @@ func TestTypedObjectSchema_Any(t *testing.T) {
 
 	_, err = anyObject.SerializeType(text)
 	assert.Error(t, err)
+
+	unserialized, err := s.Unserialize(serializedData)
+	assert.NoError(t, err)
+	serialized2, err := s.Serialize(unserialized)
+	assert.NoError(t, err)
+	// test reversibility
+	assert.Equals(t, serialized2, serializedData)
 }
 
 func TestDefaultsStructSerialization(t *testing.T) {
@@ -466,6 +493,11 @@ func TestDefaultsStructSerialization(t *testing.T) {
 	assert.Equals(t,
 		actual_value.(string),
 		default_foo_value)
+
+	unserialized2, err := s.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test unserialize and serialize are reversible
+	assert.Equals(t, unserialized2, unserialized)
 }
 
 func TestDefaultsObjectSerialization(t *testing.T) {
@@ -505,6 +537,11 @@ func TestDefaultsObjectSerialization(t *testing.T) {
 	actual_value := assert.MapContainsKey[string](
 		t, foo_key, serialized.(map[string]any))
 	assert.Equals(t, actual_value.(string), default_foo_value)
+
+	unserialized2, err := s.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test unserialize and serialize are reversible
+	assert.Equals(t, unserialized2, unserialized)
 }
 
 var testStructScope = schema.NewScopeSchema(&testStructSchema.ObjectSchema)

schema/scope_test.go

@@ -185,19 +185,37 @@ func TestUnserialization(t *testing.T) {
 	assert.NoError(t, err)
 	assert.InstanceOf[scopeTestObjectA](t, result.(scopeTestObjectA))
 	assert.Equals(t, result.(scopeTestObjectA).B.C, "Hello world!")
+	serialized, err := scopeTestObjectAType.Serialize(result)
+	assert.NoError(t, err)
+	unserialized2, err := scopeTestObjectAType.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, result)
 
 	// Now as a ptr
 	resultPtr, err := scopeTestObjectATypePtr.Unserialize(input)
 	assert.NoError(t, err)
 	assert.InstanceOf[*scopeTestObjectAPtr](t, resultPtr.(*scopeTestObjectAPtr))
 	assert.Equals(t, resultPtr.(*scopeTestObjectAPtr).B.C, "Hello world!")
+	serialized, err = scopeTestObjectATypePtr.Serialize(resultPtr)
+	assert.NoError(t, err)
+	unserialized2, err = scopeTestObjectATypePtr.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, resultPtr)
 
 	// Test empty object
 	data = `{}`
 	assert.NoError(t, json.Unmarshal([]byte(data), &input))
 	result, err = scopeTestObjectEmptySchema.Unserialize(input)
 	assert.NoError(t, err)
 	assert.InstanceOf[scopeTestObjectEmpty](t, result.(scopeTestObjectEmpty))
+	serialized, err = scopeTestObjectEmptySchema.Serialize(result)
+	assert.NoError(t, err)
+	unserialized2, err = scopeTestObjectEmptySchema.Unserialize(serialized)
+	assert.NoError(t, err)
+	// test reversiblity
+	assert.Equals(t, unserialized2, result)
 }
 
 func TestValidation(t *testing.T) {
@@ -278,6 +296,13 @@ func TestSerialization(t *testing.T) {
 	})
 	assert.NoError(t, err)
 	assert.Equals(t, serialized.(map[string]any)["b"].(map[string]any)["c"].(string), "Hello world!")
+	unserialized, err := scopeTestObjectAType.Unserialize(serialized)
+	assert.NoError(t, err)
+	serialized2, err := scopeTestObjectAType.Serialize(unserialized)
+	assert.NoError(t, err)
+
+	// test reversiblity
+	assert.Equals(t, serialized2, serialized)
 }
 
 func TestSelfSerialization(t *testing.T) {

schema/string_test.go

@@ -151,6 +151,11 @@ func testStringSerialization(
 	if val2 != validValue {
 		t.Fatalf("Incorrect value after unserialize: %s", val)
 	}
+
+	unserialized2, err := stringType.Unserialize(val2)
+	assert.NoError(t, err)
+	// test unserialize and serialize are reversible
+	assert.Equals(t, unserialized2, val)
 }
 
 func TestStringParameters(t *testing.T) {