@scalar/oas-utils 0.2.140 → 0.2.141

package/dist/spec-getters/get-example-from-schema.test.js

@@ -0,0 +1,1092 @@
+import { describe, expect, it } from "vitest";
+import { getExampleFromSchema } from "./get-example-from-schema.js";
+describe("getExampleFromSchema", () => {
+  it("sets example values", () => {
+    expect(
+      getExampleFromSchema({
+        example: 10
+      })
+    ).toMatchObject(10);
+  });
+  it("uses first example, if multiple are configured", () => {
+    expect(
+      getExampleFromSchema({
+        examples: [10]
+      })
+    ).toMatchObject(10);
+  });
+  it("takes the first enum as example", () => {
+    expect(
+      getExampleFromSchema({
+        enum: ["available", "pending", "sold"]
+      })
+    ).toBe("available");
+  });
+  it("uses empty quotes as a fallback for strings", () => {
+    expect(
+      getExampleFromSchema({
+        type: "string"
+      })
+    ).toBe("");
+  });
+  it("only includes required attributes and attributes with example values", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          type: "object",
+          required: ["first_name"],
+          properties: {
+            first_name: {
+              type: "string"
+            },
+            last_name: {
+              type: "string",
+              required: true
+            },
+            position: {
+              type: "string",
+              examples: ["Developer"]
+            },
+            description: {
+              type: "string",
+              example: "A developer"
+            },
+            age: {
+              type: "number"
+            }
+          }
+        },
+        {
+          omitEmptyAndOptionalProperties: true
+        }
+      )
+    ).toStrictEqual({
+      first_name: "",
+      last_name: "",
+      position: "Developer",
+      description: "A developer"
+    });
+  });
+  it("includes every available attributes", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          type: "object",
+          required: ["first_name"],
+          properties: {
+            first_name: {
+              type: "string"
+            },
+            last_name: {
+              type: "string",
+              required: true
+            },
+            position: {
+              type: "string",
+              examples: ["Developer"]
+            },
+            description: {
+              type: "string",
+              example: "A developer"
+            },
+            age: {
+              type: "number"
+            }
+          }
+        },
+        {
+          omitEmptyAndOptionalProperties: false
+        }
+      )
+    ).toStrictEqual({
+      first_name: "",
+      last_name: "",
+      position: "Developer",
+      description: "A developer",
+      age: 1
+    });
+  });
+  it("uses example value for first type in non-null union types", () => {
+    expect(
+      getExampleFromSchema({
+        type: ["string", "number"]
+      })
+    ).toBe("");
+  });
+  it("uses null for nullable union types", () => {
+    expect(
+      getExampleFromSchema({
+        type: ["string", "null"]
+      })
+    ).toBeNull();
+  });
+  it("sets example values", () => {
+    expect(
+      getExampleFromSchema({
+        example: 10
+      })
+    ).toMatchObject(10);
+  });
+  it("goes through properties recursively with objects", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        properties: {
+          category: {
+            type: "object",
+            properties: {
+              id: {
+                example: 1
+              },
+              name: {
+                example: "Dogs"
+              },
+              attributes: {
+                type: "object",
+                properties: {
+                  size: {
+                    enum: ["small", "medium", "large"]
+                  }
+                }
+              }
+            }
+          }
+        }
+      })
+    ).toMatchObject({
+      category: {
+        id: 1,
+        name: "Dogs",
+        attributes: {
+          size: "small"
+        }
+      }
+    });
+  });
+  it("goes through properties recursively with arrays", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        properties: {
+          tags: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: {
+                  example: 1
+                }
+              }
+            }
+          }
+        }
+      })
+    ).toMatchObject({
+      tags: [
+        {
+          id: 1
+        }
+      ]
+    });
+  });
+  it("uses empty [] as a fallback for arrays", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        properties: {
+          title: {
+            type: "array"
+          }
+        }
+      })
+    ).toMatchObject({
+      title: []
+    });
+  });
+  it("uses given fallback for strings", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          type: "string"
+        },
+        {
+          emptyString: "\u2026"
+        }
+      )
+    ).toBe("\u2026");
+  });
+  it("returns emails as an example value", () => {
+    const result = getExampleFromSchema(
+      {
+        type: "string",
+        format: "email"
+      },
+      {
+        emptyString: "\u2026"
+      }
+    );
+    function isEmail(text) {
+      return !!text.match(/^.+@.+\..+$/);
+    }
+    expect(isEmail(result)).toBe(true);
+  });
+  it("uses variables as an example value", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          "type": "string",
+          "x-variable": "id"
+        },
+        {
+          variables: {
+            id: "foobar"
+          }
+        }
+      )
+    ).toBe("foobar");
+  });
+  it("uses true as a fallback for booleans", () => {
+    expect(
+      getExampleFromSchema({
+        type: "boolean"
+      })
+    ).toMatchObject(true);
+  });
+  it("uses 1 as a fallback for integers", () => {
+    expect(
+      getExampleFromSchema({
+        type: "integer"
+      })
+    ).toMatchObject(1);
+  });
+  it("returns an array if the schema type is array", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array"
+      })
+    ).toMatchObject([]);
+  });
+  it("uses array example values", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        example: ["foobar"],
+        items: {
+          type: "string"
+        }
+      })
+    ).toMatchObject(["foobar"]);
+  });
+  it("uses specified object as array default", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            foo: {
+              type: "number"
+            },
+            bar: {
+              type: "string"
+            }
+          }
+        }
+      })
+    ).toMatchObject([
+      {
+        foo: 1,
+        bar: ""
+      }
+    ]);
+  });
+  it("uses the first example in object anyOf", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        anyOf: [
+          {
+            type: "object",
+            properties: {
+              foo: { type: "number" }
+            }
+          },
+          {
+            type: "object",
+            properties: {
+              bar: { type: "string" }
+            }
+          }
+        ]
+      })
+    ).toMatchObject({ foo: 1 });
+  });
+  it("uses the first example in object oneOf", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              foo: { type: "number" }
+            }
+          },
+          {
+            type: "object",
+            properties: {
+              bar: { type: "string" }
+            }
+          }
+        ]
+      })
+    ).toMatchObject({ foo: 1 });
+  });
+  it("uses the first example in object anyOf when type is not defined", () => {
+    expect(
+      getExampleFromSchema({
+        anyOf: [
+          {
+            type: "object",
+            properties: {
+              foo: { type: "number" }
+            }
+          },
+          {
+            type: "object",
+            properties: {
+              bar: { type: "string" }
+            }
+          }
+        ]
+      })
+    ).toMatchObject({ foo: 1 });
+  });
+  it("uses the first example in object oneOf when type is not defined", () => {
+    expect(
+      getExampleFromSchema({
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              foo: { type: "number" }
+            }
+          },
+          {
+            type: "object",
+            properties: {
+              bar: { type: "string" }
+            }
+          }
+        ]
+      })
+    ).toMatchObject({ foo: 1 });
+  });
+  it("uses all examples in object allOf", () => {
+    expect(
+      getExampleFromSchema({
+        allOf: [
+          {
+            type: "object",
+            properties: {
+              foo: { type: "number" }
+            }
+          },
+          {
+            type: "object",
+            properties: {
+              bar: { type: "string" }
+            }
+          }
+        ]
+      })
+    ).toMatchObject({ foo: 1, bar: "" });
+  });
+  it("merges allOf items in arrays", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        items: {
+          allOf: [
+            {
+              type: "object",
+              properties: {
+                foobar: { type: "string" },
+                foo: { type: "number" }
+              }
+            },
+            {
+              type: "object",
+              properties: {
+                bar: { type: "string" }
+              }
+            }
+          ]
+        }
+      })
+    ).toMatchObject([{ foobar: "", foo: 1, bar: "" }]);
+  });
+  it("handles array items with allOf containing objects", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        items: {
+          allOf: [
+            {
+              type: "object",
+              properties: {
+                id: { type: "number", example: 1 }
+              }
+            },
+            {
+              type: "object",
+              properties: {
+                name: { type: "string", example: "test" }
+              }
+            }
+          ]
+        }
+      })
+    ).toMatchObject([
+      {
+        id: 1,
+        name: "test"
+      }
+    ]);
+  });
+  it("uses the first example in array anyOf", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        items: {
+          anyOf: [
+            {
+              type: "string",
+              example: "foobar"
+            },
+            {
+              type: "string",
+              example: "barfoo"
+            }
+          ]
+        }
+      })
+    ).toMatchObject(["foobar"]);
+  });
+  it("uses one example in array oneOf", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        items: {
+          oneOf: [
+            {
+              type: "string",
+              example: "foobar"
+            },
+            {
+              type: "string",
+              example: "barfoo"
+            }
+          ]
+        }
+      })
+    ).toMatchObject(["foobar"]);
+  });
+  it("uses all examples in array allOf", () => {
+    expect(
+      getExampleFromSchema({
+        type: "array",
+        items: {
+          allOf: [
+            {
+              type: "string",
+              example: "foobar"
+            },
+            {
+              type: "string",
+              example: "barfoo"
+            }
+          ]
+        }
+      })
+    ).toMatchObject(["foobar", "barfoo"]);
+  });
+  it("uses the default value", () => {
+    const schema = {
+      type: "string",
+      default: "BAD_REQUEST_EXCEPTION"
+    };
+    expect(getExampleFromSchema(schema)).toBe("BAD_REQUEST_EXCEPTION");
+  });
+  it("uses 1 as the default for a number", () => {
+    expect(
+      getExampleFromSchema({
+        type: "number"
+      })
+    ).toMatchObject(1);
+  });
+  it("uses min as the default for a number", () => {
+    expect(
+      getExampleFromSchema({
+        type: "number",
+        min: 200
+      })
+    ).toMatchObject(200);
+  });
+  it("returns plaintext", () => {
+    expect(
+      getExampleFromSchema({
+        type: "string",
+        example: "foobar"
+      })
+    ).toEqual("foobar");
+  });
+  it("converts a whole schema to an example response", () => {
+    const schema = {
+      required: ["name", "photoUrls"],
+      type: "object",
+      properties: {
+        id: {
+          type: "integer",
+          format: "int64",
+          example: 10
+        },
+        name: {
+          type: "string",
+          example: "doggie"
+        },
+        category: {
+          type: "object",
+          properties: {
+            id: {
+              type: "integer",
+              format: "int64",
+              example: 1
+            },
+            name: {
+              type: "string",
+              example: "Dogs"
+            }
+          },
+          xml: {
+            name: "category"
+          }
+        },
+        photoUrls: {
+          type: "array",
+          xml: {
+            wrapped: true
+          },
+          items: {
+            type: "string",
+            xml: {
+              name: "photoUrl"
+            }
+          }
+        },
+        tags: {
+          type: "array",
+          xml: {
+            wrapped: true
+          },
+          items: {
+            type: "object",
+            properties: {
+              id: {
+                type: "integer",
+                format: "int64"
+              },
+              name: {
+                type: "string"
+              }
+            },
+            xml: {
+              name: "tag"
+            }
+          }
+        },
+        status: {
+          type: "string",
+          description: "pet status in the store",
+          enum: ["available", "pending", "sold"]
+        }
+      },
+      xml: {
+        name: "pet"
+      }
+    };
+    expect(getExampleFromSchema(schema)).toMatchObject({
+      id: 10,
+      name: "doggie",
+      category: {
+        id: 1,
+        name: "Dogs"
+      },
+      photoUrls: [""],
+      tags: [
+        {
+          id: 1,
+          name: ""
+        }
+      ],
+      status: "available"
+    });
+  });
+  it("outputs XML", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          type: "object",
+          properties: {
+            id: {
+              example: 1,
+              xml: {
+                name: "foo"
+              }
+            }
+          }
+        },
+        { xml: true }
+      )
+    ).toMatchObject({
+      foo: 1
+    });
+  });
+  it("add XML wrappers where needed", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          type: "object",
+          properties: {
+            photoUrls: {
+              type: "array",
+              xml: {
+                wrapped: true
+              },
+              items: {
+                type: "string",
+                example: "https://example.com",
+                xml: {
+                  name: "photoUrl"
+                }
+              }
+            }
+          }
+        },
+        { xml: true }
+      )
+    ).toMatchObject({
+      photoUrls: [{ photoUrl: "https://example.com" }]
+    });
+  });
+  it("doesn\u2019t wrap items when not needed", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          type: "object",
+          properties: {
+            photoUrls: {
+              type: "array",
+              items: {
+                type: "string",
+                example: "https://example.com",
+                xml: {
+                  name: "photoUrl"
+                }
+              }
+            }
+          }
+        },
+        { xml: true }
+      )
+    ).toMatchObject({
+      photoUrls: ["https://example.com"]
+    });
+  });
+  it("use the first item of oneOf", () => {
+    expect(
+      getExampleFromSchema({
+        oneOf: [
+          {
+            maxLength: 255,
+            type: "string"
+          },
+          {
+            type: "null"
+          }
+        ]
+      })
+    ).toBe("");
+  });
+  it("works with allOf", () => {
+    expect(
+      getExampleFromSchema({
+        allOf: [
+          {
+            type: "string"
+          }
+        ]
+      })
+    ).toBe("");
+  });
+  it("uses all schemas in allOf", () => {
+    expect(
+      getExampleFromSchema({
+        allOf: [
+          {
+            type: "object",
+            properties: {
+              id: {
+                example: 10
+              }
+            }
+          },
+          {
+            type: "object",
+            properties: {
+              title: {
+                example: "Foobar"
+              }
+            }
+          }
+        ]
+      })
+    ).toMatchObject({
+      id: 10,
+      title: "Foobar"
+    });
+  });
+  it("returns null for unknown types", () => {
+    expect(
+      getExampleFromSchema({
+        type: "fantasy"
+      })
+    ).toBe(null);
+  });
+  it("returns readOnly attributes by default", () => {
+    expect(
+      getExampleFromSchema({
+        example: "foobar",
+        readOnly: true
+      })
+    ).toBe("foobar");
+  });
+  it("returns readOnly attributes in read mode", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          example: "foobar",
+          readOnly: true
+        },
+        {
+          mode: "read"
+        }
+      )
+    ).toBe("foobar");
+  });
+  it("doesn\u2019t return readOnly attributes in write mode", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          example: "foobar",
+          readOnly: true
+        },
+        {
+          mode: "write"
+        }
+      )
+    ).toBe(void 0);
+  });
+  it("returns writeOnly attributes by default", () => {
+    expect(
+      getExampleFromSchema({
+        example: "foobar",
+        writeOnly: true
+      })
+    ).toBe("foobar");
+  });
+  it("returns writeOnly attributes in write mode", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          example: "foobar",
+          writeOnly: true
+        },
+        {
+          mode: "write"
+        }
+      )
+    ).toBe("foobar");
+  });
+  it("doesn\u2019t return writeOnly attributes in read mode", () => {
+    expect(
+      getExampleFromSchema(
+        {
+          example: "foobar",
+          writeOnly: true
+        },
+        {
+          mode: "read"
+        }
+      )
+    ).toBe(void 0);
+  });
+  it("allows any additonalProperty", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: {}
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: "anything"
+    });
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: true
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: "anything"
+    });
+  });
+  it("adds an additionalProperty with specific types", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: {
+          type: "integer"
+        }
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: 1
+    });
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: {
+          type: "boolean"
+        }
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: true
+    });
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: {
+          type: "boolean",
+          default: false
+        }
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: false
+    });
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: {
+          type: "string"
+        }
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: ""
+    });
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        additionalProperties: {
+          type: "object",
+          properties: {
+            foo: {
+              type: "string"
+            }
+          }
+        }
+      })
+    ).toMatchObject({
+      ANY_ADDITIONAL_PROPERTY: {
+        foo: ""
+      }
+    });
+  });
+  it("works with anyOf", () => {
+    expect(
+      getExampleFromSchema({
+        title: "Foo",
+        type: "object",
+        anyOf: [
+          {
+            type: "object",
+            required: ["a"],
+            properties: {
+              a: {
+                type: "integer",
+                format: "int32"
+              }
+            }
+          },
+          {
+            type: "object",
+            required: ["b"],
+            properties: {
+              b: {
+                type: "string"
+              }
+            }
+          }
+        ],
+        required: ["c"],
+        properties: {
+          c: {
+            type: "boolean"
+          }
+        }
+      })
+    ).toStrictEqual({
+      a: 1,
+      c: true
+    });
+  });
+  it("handles patternProperties", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        patternProperties: {
+          "^(.*)$": {
+            type: "object",
+            properties: {
+              dataId: {
+                type: "string"
+              },
+              link: {
+                anyOf: [
+                  {
+                    format: "uri",
+                    type: "string",
+                    example: "https://example.com"
+                  },
+                  {
+                    type: "null"
+                  }
+                ]
+              }
+            },
+            required: ["dataId", "link"]
+          }
+        }
+      })
+    ).toStrictEqual({
+      "^(.*)$": {
+        dataId: "",
+        link: "https://example.com"
+      }
+    });
+  });
+  describe("circular references", () => {
+    it("deals with circular references", () => {
+      const schema = {
+        type: "object",
+        properties: {
+          foobar: {}
+        }
+      };
+      schema.properties.foobar = schema;
+      expect(getExampleFromSchema(schema)).toStrictEqual({
+        foobar: {
+          foobar: {
+            foobar: {
+              foobar: {
+                foobar: {
+                  foobar: "[Circular Reference]"
+                }
+              }
+            }
+          }
+        }
+      });
+    });
+    it("deals with circular references that expand horizontally", () => {
+      const schema = {
+        type: "object",
+        properties: {
+          a: {},
+          b: {},
+          c: {},
+          d: {},
+          e: {},
+          f: {},
+          g: {},
+          h: {},
+          i: {},
+          j: {},
+          k: {},
+          l: {},
+          m: {},
+          n: {},
+          o: {},
+          p: {},
+          q: {},
+          r: {},
+          s: {},
+          t: {},
+          u: {},
+          v: {},
+          w: {},
+          x: {},
+          y: {},
+          z: {}
+        }
+      };
+      schema.properties.a = schema;
+      schema.properties.b = schema;
+      schema.properties.c = schema;
+      schema.properties.d = schema;
+      schema.properties.e = schema;
+      schema.properties.f = schema;
+      schema.properties.g = schema;
+      schema.properties.h = schema;
+      schema.properties.i = schema;
+      schema.properties.j = schema;
+      schema.properties.k = schema;
+      schema.properties.l = schema;
+      schema.properties.m = schema;
+      schema.properties.n = schema;
+      schema.properties.o = schema;
+      schema.properties.p = schema;
+      schema.properties.q = schema;
+      schema.properties.r = schema;
+      schema.properties.s = schema;
+      schema.properties.t = schema;
+      schema.properties.u = schema;
+      schema.properties.v = schema;
+      schema.properties.w = schema;
+      schema.properties.x = schema;
+      schema.properties.y = schema;
+      schema.properties.z = schema;
+      const example = getExampleFromSchema(schema);
+      expect(example).toBeInstanceOf(Object);
+      expect(Object.keys(example).length).toBe(26);
+    });
+  });
+  it("omits deprecated properties", () => {
+    expect(
+      getExampleFromSchema({
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            example: "test"
+          },
+          oldField: {
+            type: "string",
+            example: "should not appear",
+            deprecated: true
+          }
+        }
+      })
+    ).toStrictEqual({
+      name: "test"
+    });
+  });
+});
+//# sourceMappingURL=get-example-from-schema.test.js.map