fix: all tests passing wonderfully now

Author: BelfordZ

src/integration-tests/expecteds/go/openrpc.go

@@ -255,7 +255,16 @@ func (o DependenciesSet) MarshalJSON() ([]byte, error) {
 }
 type Dependencies map[string]interface{}
 type Enum []AlwaysTrue
-type SimpleTypes interface{}
+type SimpleTypes string
+const (
+	SimpleTypesEnum0 SimpleTypes = "array"
+	SimpleTypesEnum1 SimpleTypes = "boolean"
+	SimpleTypesEnum2 SimpleTypes = "integer"
+	SimpleTypesEnum3 SimpleTypes = "null"
+	SimpleTypesEnum4 SimpleTypes = "number"
+	SimpleTypesEnum5 SimpleTypes = "object"
+	SimpleTypesEnum6 SimpleTypes = "string"
+)
 type ArrayOfSimpleTypes []SimpleTypes
 type Type struct {
 	SimpleTypes        *SimpleTypes
@@ -727,4 +736,4 @@ type OpenrpcDocument struct {
 	Methods      *Methods                     `json:"methods"`
 	Components   *Components                  `json:"components,omitempty"`
 	Schema       *MetaSchema                  `json:"$schema,omitempty"`
-}
+}

src/integration-tests/expecteds/py/openrpc.py

@@ -206,7 +206,14 @@ class MethodObjectParamStructure(Enum):
 
 Enum = NewType("Enum", List[AlwaysTrue])
 
-SimpleTypes = NewType("SimpleTypes", Any)
+class SimpleTypes(Enum):
+    Array = 0
+    Boolean = 1
+    Integer = 2
+    Null = 3
+    Number = 4
+    Object = 5
+    String = 6
 
 ArrayOfSimpleTypes = NewType("ArrayOfSimpleTypes", List[SimpleTypes])
 
@@ -425,4 +432,4 @@ class OpenrpcDocument(TypedDict):
     servers: Optional[Servers]
     methods: undefined
     components: Optional[Components]
-    $schema: Optional[MetaSchema]
+    $schema: Optional[MetaSchema]

src/integration-tests/expecteds/rs/openrpc.rs

@@ -278,7 +278,23 @@ pub enum DependenciesSet {
 }
 pub type Dependencies = HashMap<String, DependenciesSet>;
 pub type Enum = Vec<AlwaysTrue>;
-pub type SimpleTypes = serde_json::Value;
+#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
+pub enum SimpleTypes {
+    #[serde(rename = "array")]
+    Array,
+    #[serde(rename = "boolean")]
+    Boolean,
+    #[serde(rename = "integer")]
+    Integer,
+    #[serde(rename = "null")]
+    Null,
+    #[serde(rename = "number")]
+    Number,
+    #[serde(rename = "object")]
+    Object,
+    #[serde(rename = "string")]
+    String,
+}
 pub type ArrayOfSimpleTypes = Vec<SimpleTypes>;
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(untagged)]
@@ -642,4 +658,4 @@ pub struct OpenrpcDocument {
     pub components: Option<Components>,
     #[serde(rename = "$schema", skip_serializing_if = "Option::is_none")]
     pub schema: Option<MetaSchema>,
-}
+}

src/integration-tests/expecteds/ts/openrpc.ts

@@ -161,7 +161,7 @@ export interface PatternProperties { [key: string]: any; }
 export type DependenciesSet = JSONSchema | StringArray;
 export interface Dependencies { [key: string]: any; }
 export type Enum = AlwaysTrue[];
-export type SimpleTypes = any;
+export type SimpleTypes = "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
 export type ArrayOfSimpleTypes = SimpleTypes[];
 export type Type = SimpleTypes | ArrayOfSimpleTypes;
 export type Format = string;
@@ -378,4 +378,4 @@ export interface OpenrpcDocument {
   components?: Components;
   $schema?: MetaSchema;
   [regex: string]: SpecificationExtension | any;
-}
+}

src/integration-tests/runner.test.ts

@@ -40,7 +40,7 @@ const getTestCaseBase = async (names: string[], languages: string[]): Promise<Te
     // if (language !== "ts") { return; }
 
     names.forEach((name) => {
-      // if (name !== "json-schema") { return; }
+      // if (name !== "boolean-schemas") { return; }
 
       promises.push(readFile(`${testCaseDir}/${name}.json`, "utf8")
         .then((fileContents) => {
@@ -69,14 +69,21 @@ const addExpectedTypings = async (tcs: TestCase[]): Promise<TestCase[]> => {
 };
 
 const derefTestCases = async (tcs: TestCase[]): Promise<TestCase[]> => {
-  const derefPromises: any[] = [];
-
-  tcs.forEach((tc) => {
-    const dereffer = new Dereferencer(tc.schema);
-    derefPromises.push(dereffer.resolve().then((s) => tc.schema = s));
-  });
+  for (const tc of tcs) {
+    let s = tc.schema as JSONSchema[];
+    const wasArray = tc.schema instanceof Array;
+    if (wasArray === false) {
+      s = [s];
+    }
+    tc.schema = await Promise.all(s.map((_s) => {
+      const dereffer = new Dereferencer(_s);
+      return dereffer.resolve();
+    }));
 
-  await Promise.all(derefPromises);
+    if (wasArray === false) {
+      tc.schema = tc.schema[0];
+    }
+  }
 
   return tcs;
 };