Additional unit tests for OpenAPIObjectContainer (#24)

### Motivation

Trying to encode an `OpenAPIValueContainer` would previously throw an
`EncodingError` if the untyped container contained nested dictionary or
array structures. (e.g. `{"dict": {"foo": "bar"}}`) Data could be
decoded into this format, but it could not be re-encoded successfully.

### Modifications

When encoding the value of a nested JSON array or object in
`OpenAPIValueContainer`, we now handle arrays and dicts by wrapping the
inner value in `OpenAPIValueContainer` before passing it to the encoder.
(note: Based on the rest of the `encode()` implementation, it seems that
this may have been expected to happen previously during decoding. Let me
know if making changes on the decode side of things is preferable.)

### Result

Additional unit tests added to validate that encoder generates correct
output for nested data structures in `OpenAPIValueContainer`, and that
these data structures can be decoded and successfully re-endcoded
afterward.

### Test Plan

Run `Test_CodableExtensions` tests, see all tests pass.

Co-authored-by: Honza Dvorsky <[email protected]>

Author: rboyce

Tests/OpenAPIRuntimeTests/Base/Test_OpenAPIValue.swift

@@ -193,4 +193,96 @@ final class Test_OpenAPIValue: Test_Runtime {
         XCTAssertEqual(value[0] as? String, "one")
         XCTAssertEqual(value[1] as? [String: Int], ["two": 2])
     }
+
+    func testEncoding_objectNested_success() throws {
+
+        struct Foo: Encodable {
+            var bar: String
+            var dict: OpenAPIObjectContainer = .init()
+        }
+
+        do {
+            let value = Foo(
+                bar: "hi",
+                dict: try .init(unvalidatedValue: [
+                    "baz": "bar",
+                    "number": 1,
+                    "nestedArray": [
+                        1,
+                        [
+                            "k": "v"
+                        ],
+                    ] as [(any Sendable)?],
+                    "nestedDict": [
+                        "nested": 2
+                    ],
+                ])
+            )
+            let encoder: JSONEncoder = .init()
+            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+            let data = try encoder.encode(value)
+            XCTAssertEqual(
+                String(decoding: data, as: UTF8.self),
+                #"""
+                {
+                  "bar" : "hi",
+                  "dict" : {
+                    "baz" : "bar",
+                    "nestedArray" : [
+                      1,
+                      {
+                        "k" : "v"
+                      }
+                    ],
+                    "nestedDict" : {
+                      "nested" : 2
+                    },
+                    "number" : 1
+                  }
+                }
+                """#
+            )
+        }
+    }
+
+    func testDecodeEncodeRoundTrip_objectNested_success() throws {
+
+        struct Foo: Codable {
+            var bar: String
+            var dict: OpenAPIObjectContainer = .init()
+        }
+
+        do {
+            let data = Data(
+                #"""
+                {
+                  "bar" : "hi",
+                  "dict" : {
+                    "baz" : "bar",
+                    "nestedArray" : [
+                      1,
+                      {
+                        "k" : "v"
+                      }
+                    ],
+                    "nestedDict" : {
+                      "nested" : 2
+                    },
+                    "number" : 1
+                  }
+                }
+                """#
+                .utf8
+            )
+            let decoded = try JSONDecoder().decode(Foo.self, from: data)
+            let nestedDict = try XCTUnwrap(decoded.dict.value["nestedDict"] as? [String: Any?])
+            let nestedValue = try XCTUnwrap(nestedDict["nested"] as? Int)
+            XCTAssertEqual(nestedValue, 2)
+
+            let encoder: JSONEncoder = .init()
+            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+            let encodedData = try encoder.encode(decoded)
+            XCTAssertEqual(encodedData, data)
+        }
+    }
 }