[#175498392] Handle enum for boolean type in openapi definition (#208)

Author: infantesimone

__mocks__/api.yaml

@@ -302,6 +302,55 @@ definitions:
           - value1
           - value2
           - value3
+  EnumTrueTest:
+    type: object
+    properties:
+      flag:
+        type: boolean
+        enum:
+          - true
+  EnumFalseTest:
+    type: object
+    properties:
+      flag:
+        type: boolean
+        enum:
+          - false
+  EnabledUserTest:
+    type: object
+    properties:
+      description:
+        type: string   
+      enabled:
+        type: boolean
+        enum:
+          - true
+      username:
+        type: string
+    required:
+      - enabled 
+      - description
+      - username
+  DisabledUserTest:
+    type: object
+    properties:
+      enabled:
+        type: boolean
+        enum:
+          - false
+      reason:
+         type: string    
+      username:
+        type: string
+    required:
+      - enabled
+      - reason 
+      - username      
+  DisjointUnionsUserTest: 
+    x-one-of: true
+    allOf:
+      - $ref: "#/definitions/EnabledUserTest"
+      - $ref: "#/definitions/DisabledUserTest"                 
   MessageContent:
     type: object
     properties:

e2e/src/__tests__/test-api/definitions.test.ts

@@ -20,6 +20,12 @@ import { WithinRangeIntegerTest } from "../../generated/testapi/WithinRangeInteg
 import { WithinRangeNumberTest } from "../../generated/testapi/WithinRangeNumberTest";
 import { WithinRangeStringTest } from "../../generated/testapi/WithinRangeStringTest";
 
+import { DisabledUserTest } from "../../generated/testapi/DisabledUserTest";
+import { DisjointUnionsUserTest } from "../../generated/testapi/DisjointUnionsUserTest";
+import { EnabledUserTest } from "../../generated/testapi/EnabledUserTest";
+import { EnumFalseTest } from "../../generated/testapi/EnumFalseTest";
+import { EnumTrueTest } from "../../generated/testapi/EnumTrueTest";
+
 const { generatedFilesDir, isSpecEnabled } = config.specs.testapi;
 
 // if there's no need for this suite in this particular run, just skip it
@@ -288,3 +294,84 @@ describe("WithinRangeStringTest defintion", () => {
     }
   );
 });
+
+describe("EnumTrueTest definition", () => {
+  const statusOk = { flag: true };
+  const statusKo = { flag: false };
+
+  it("should decode statusOk with EnumTrueTest", () => {
+    const result = EnumTrueTest.decode(statusOk);
+    expect(result.isRight()).toBe(true);
+  });
+
+  it("should not decode statusKo with EnumTrueTest", () => {
+    const result = EnumTrueTest.decode(statusKo);
+
+    expect(result.isLeft()).toBe(true);
+  });
+});
+
+describe("EnumFalseTest definition", () => {
+  const statusOk = { flag: false };
+  const statusKo = { flag: true };
+
+  it("should decode statusOk with EnumFalseTest", () => {
+    const result = EnumFalseTest.decode(statusOk);
+    expect(result.isRight()).toBe(true);
+  });
+
+  it("should not decode statusKo with EnumFalseTest", () => {
+    const result = EnumFalseTest.decode(statusKo);
+
+    expect(result.isLeft()).toBe(true);
+  });
+});
+
+describe("DisjointUnionsUserTest definition", () => {
+  const enabledUser = {
+    description: "Description for the user",
+    enabled: true,
+    username: "user"
+  };
+  const disabledUser = {
+    enabled: false,
+    reason: "reason for the user",
+    username: "user"
+  };
+
+  const invalidUser = {
+    description: "Description for the user",
+    enabled: false,
+    username: "user"
+  };
+
+  it("should decode enabledUser with DisjointUnionsUserTest", () => {
+    const userTest = DisjointUnionsUserTest.decode(enabledUser);
+    const enabledUserTest = EnabledUserTest.decode(enabledUser);
+    const disabledUserTest = DisabledUserTest.decode(enabledUser);
+
+    expect(userTest.isRight()).toBe(true);
+    expect(enabledUserTest.isRight()).toBe(true);
+    expect(disabledUserTest.isLeft()).toBe(true);
+  });
+
+  it("should decode disabledUser with DisjointUnionsUserTest", () => {
+    const userTest = DisjointUnionsUserTest.decode(disabledUser);
+    const enabledUserTest = EnabledUserTest.decode(disabledUser);
+    const disabledUserTest = DisabledUserTest.decode(disabledUser);
+
+    expect(userTest.isRight()).toBe(true);
+    expect(disabledUserTest.isRight()).toBe(true);
+    expect(enabledUserTest.isLeft()).toBe(true);
+  });
+
+  it("should not decode invalidUser with DisjointUnionsUserTest", () => {
+    const userTest = DisjointUnionsUserTest.decode(invalidUser);
+    const enabledUserTest = EnabledUserTest.decode(invalidUser);
+    const disabledUserTest = DisabledUserTest.decode(invalidUser);
+
+    expect(userTest.isLeft()).toBe(true);
+    expect(disabledUserTest.isLeft()).toBe(true);
+    expect(enabledUserTest.isLeft()).toBe(true);
+  });
+});

templates/macros.njk

@@ -215,7 +215,11 @@
  # defines a boolean property
  #}
 {% macro defineBoolean(definitionName, definition, inline = false) -%}
-  {% set typedef %}t.boolean{% endset %}
+  {% if definition["enum"] and definition["enum"] | length == 1%}    
+    {% set typedef %}t.literal({{definition["enum"][0]}}){% endset %}
+  {% else %}
+    {% set typedef %}t.boolean{% endset %}
+  {% endif %}
   {{ defineConst(definition.default, definitionName, typedef, false, inline) }}
 {% endmacro %}