AddTagToOperationIdsTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.throws(
  () => new AddTagToOperationIdsTransformer(null),
  TypeError,
);
openapi 3 only tag to operationId prefix
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get3({
    tags: ['MyTag'],
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    tags: ['MyTag'],
    operationId: 'MyTag_getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 first tag to operationId prefix
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get3({
    tags: ['MyTag1', 'MyTag2'],
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    tags: ['MyTag1', 'MyTag2'],
    operationId: 'MyTag1_getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 no tag to operationId prefix
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get3({
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 empty tag to operationId prefix
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get3({
    tags: [],
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    tags: [],
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 no operationId
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get3({
    tags: ['MyTag'],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    tags: ['MyTag'],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 empty operationId
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get3({
    tags: ['MyTag'],
    operationId: '',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    tags: ['MyTag'],
    operationId: '',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 options.tagSuffix appended to tag before operationId
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
const transformer =
  new AddTagToOperationIdsTransformer({ tagSuffix: 'Api' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(get3({
    tags: ['MyTag'],
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    tags: ['MyTag'],
    operationId: 'MyTagApi_getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
swagger 2 only tag to operationId prefix
/home/kevin/src/node-projects/openapi-transformers/test/add-tag-to-operation-ids.js
assert.deepStrictEqual(
  new AddTagToOperationIdsTransformer().transformOpenApi(deepFreeze(get2({
    tags: ['MyTag'],
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get2({
    tags: ['MyTag'],
    operationId: 'MyTag_getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);

AddXMsEnumNameTransformer

openapi 3 without x-ms-enum in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-name.js
assert.deepStrictEqual(
  new AddXMsEnumNameTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
  }))),
  schema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-ms-enum': {
      name: 'Test',
    },
  }),
);
openapi 3 without x-ms-enum.name in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-name.js
assert.deepStrictEqual(
  new AddXMsEnumNameTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-ms-enum': {
      values: [
        {
          name: 'Value1',
          value: 'value1',
        },
        {
          name: 'Value2',
          value: 'value2',
        },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-ms-enum': {
      name: 'Test',
      values: [
        {
          name: 'Value1',
          value: 'value1',
        },
        {
          name: 'Value2',
          value: 'value2',
        },
      ],
    },
  }),
);
openapi 3 property without x-ms-enum in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-name.js
assert.deepStrictEqual(
  new AddXMsEnumNameTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      myenum: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      myenum: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
      },
    },
  }),
);
openapi 3 requestBody without x-ms-enum
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-name.js
assert.deepStrictEqual(
  new AddXMsEnumNameTransformer().transformOpenApi(deepFreeze(post3({
    requestBody: {
      content: {
        'application/json': {
          schema: {
            type: 'string',
            enum: [
              'value1',
              'value2',
            ],
          },
        },
      },
    },
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  post3({
    requestBody: {
      content: {
        'application/json': {
          schema: {
            type: 'string',
            enum: [
              'value1',
              'value2',
            ],
          },
        },
      },
    },
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 response without x-ms-enum
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-name.js
assert.deepStrictEqual(
  new AddXMsEnumNameTransformer().transformOpenApi(deepFreeze(
    responseSchema3({
      type: 'string',
      enum: [
        'value1',
        'value2',
      ],
    }),
  )),
  responseSchema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
  }),
);
swagger 2 without x-ms-enum in definitions
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-name.js
assert.deepStrictEqual(
  new AddXMsEnumNameTransformer().transformOpenApi(deepFreeze(schema2({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
  }))),
  schema2({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-ms-enum': {
      name: 'Test',
    },
  }),
);

AddXMsEnumValueNamesTransformer

openapi 3 with x-ms-enum.name in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'string',
      enum: [
        'my value1',
        'my value2',
      ],
      'x-ms-enum': {
        name: 'StringEnum',
      },
    }),
  )),
  schema3({
    type: 'string',
    enum: [
      'my value1',
      'my value2',
    ],
    'x-ms-enum': {
      name: 'StringEnum',
      values: [
        { name: 'MyValue1', value: 'my value1' },
        { name: 'MyValue2', value: 'my value2' },
      ],
    },
  }),
);
openapi 3 without x-ms-enum in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'string',
      enum: [
        'my value1',
        'my value2',
      ],
    }),
  )),
  schema3({
    type: 'string',
    enum: [
      'my value1',
      'my value2',
    ],
  }),
);
openapi 3 with x-ms-enum.values without name in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'string',
      enum: [
        'my value1',
        'my value2',
      ],
      'x-ms-enum': {
        name: 'StringEnum',
        values: [
          { value: 'my value1' },
          { value: 'my value2' },
        ],
      },
    }),
  )),
  schema3({
    type: 'string',
    enum: [
      'my value1',
      'my value2',
    ],
    'x-ms-enum': {
      name: 'StringEnum',
      values: [
        { name: 'MyValue1', value: 'my value1' },
        { name: 'MyValue2', value: 'my value2' },
      ],
    },
  }),
);
openapi 3 with x-ms-enum.values with some names in components
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'string',
      enum: [
        'my value1',
        'my value2',
      ],
      'x-ms-enum': {
        name: 'StringEnum',
        values: [
          { value: 'my value1' },
          { name: 'MyValue', value: 'my value2' },
        ],
      },
    }),
  )),
  schema3({
    type: 'string',
    enum: [
      'my value1',
      'my value2',
    ],
    'x-ms-enum': {
      name: 'StringEnum',
      values: [
        { name: 'MyValue1', value: 'my value1' },
        { name: 'MyValue', value: 'my value2' },
      ],
    },
  }),
);
openapi 3 with x-ms-enum.name in parameter schema
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(get3({
    parameters: [
      {
        name: 'myquery',
        in: 'query',
        schema: {
          type: 'string',
          enum: [
            'my value1',
            'my value2',
          ],
          'x-ms-enum': {
            name: 'StringEnum',
          },
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    parameters: [
      {
        name: 'myquery',
        in: 'query',
        schema: {
          type: 'string',
          enum: [
            'my value1',
            'my value2',
          ],
          'x-ms-enum': {
            name: 'StringEnum',
            values: [
              { name: 'MyValue1', value: 'my value1' },
              { name: 'MyValue2', value: 'my value2' },
            ],
          },
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 with x-ms-enum.name in parameter content
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(get3({
    parameters: [
      {
        name: 'myquery',
        in: 'query',
        content: {
          'application/json': {
            schema: {
              type: 'string',
              enum: [
                'my value1',
                'my value2',
              ],
              'x-ms-enum': {
                name: 'StringEnum',
              },
            },
          },
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get3({
    parameters: [
      {
        name: 'myquery',
        in: 'query',
        content: {
          'application/json': {
            schema: {
              type: 'string',
              enum: [
                'my value1',
                'my value2',
              ],
              'x-ms-enum': {
                name: 'StringEnum',
                values: [
                  { name: 'MyValue1', value: 'my value1' },
                  { name: 'MyValue2', value: 'my value2' },
                ],
              },
            },
          },
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 requestBody with x-ms-enum.name
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(post3({
    requestBody: {
      content: {
        'application/json': {
          schema: {
            type: 'string',
            enum: [
              'my value1',
              'my value2',
            ],
            'x-ms-enum': {
              name: 'StringEnum',
            },
          },
        },
      },
    },
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  post3({
    requestBody: {
      content: {
        'application/json': {
          schema: {
            type: 'string',
            enum: [
              'my value1',
              'my value2',
            ],
            'x-ms-enum': {
              name: 'StringEnum',
              values: [
                { name: 'MyValue1', value: 'my value1' },
                { name: 'MyValue2', value: 'my value2' },
              ],
            },
          },
        },
      },
    },
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
openapi 3 response with x-ms-enum.name
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(
    responseSchema3({
      type: 'string',
      enum: [
        'my value1',
        'my value2',
      ],
      'x-ms-enum': {
        name: 'StringEnum',
      },
    }),
  )),
  responseSchema3({
    type: 'string',
    enum: [
      'my value1',
      'my value2',
    ],
    'x-ms-enum': {
      name: 'StringEnum',
      values: [
        { name: 'MyValue1', value: 'my value1' },
        { name: 'MyValue2', value: 'my value2' },
      ],
    },
  }),
);
swagger 2 parameter with x-ms-enum.name
/home/kevin/src/node-projects/openapi-transformers/test/add-x-ms-enum-value-names.js
assert.deepStrictEqual(
  new AddXMsEnumValueNamesTransformer().transformOpenApi(deepFreeze(get2({
    parameters: [
      {
        in: 'query',
        name: 'myquery',
        type: 'string',
        enum: [
          'my value1',
          'my value2',
        ],
        'x-ms-enum': {
          name: 'StringEnum',
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  get2({
    parameters: [
      {
        in: 'query',
        name: 'myquery',
        type: 'string',
        enum: [
          'my value1',
          'my value2',
        ],
        'x-ms-enum': {
          name: 'StringEnum',
          values: [
            { name: 'MyValue1', value: 'my value1' },
            { name: 'MyValue2', value: 'my value2' },
          ],
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);

AdditionalPropertiesToObjectTransformer

openapi 3 additionalProperties: true to {} in components
/home/kevin/src/node-projects/openapi-transformers/test/additional-properties-to-object.js
const transformer = new AdditionalPropertiesToObjectTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    additionalProperties: true,
  }))),
  schema3({
    type: 'object',
    additionalProperties: {},
  }),
);
swagger 2 additionalProperties: true to {} in definitions
/home/kevin/src/node-projects/openapi-transformers/test/additional-properties-to-object.js
const transformer = new AdditionalPropertiesToObjectTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema2({
    type: 'object',
    additionalProperties: true,
  }))),
  schema2({
    type: 'object',
    additionalProperties: {},
  }),
);

AdditionalPropertiesToUnconstrainedTransformer

string additionalProperties to any on schema with properties
/home/kevin/src/node-projects/openapi-transformers/test/additional-properties-to-unconstrained.js
const transformer = new AdditionalPropertiesToUnconstrainedTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    // Generates class with Myprop property and
    // [JsonExtensionData] Map<string,string> AdditionalProperties
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
      },
    },
    additionalProperties: {
      type: 'string',
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
      },
    },
    additionalProperties: {},
  }),
);
does not change additionalProperties without properties
/home/kevin/src/node-projects/openapi-transformers/test/additional-properties-to-unconstrained.js
const transformer = new AdditionalPropertiesToUnconstrainedTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    // Generates Map<string,string>, no JsonExtensionData
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
  }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
  }),
);
does not change additionalProperties with empty properties
/home/kevin/src/node-projects/openapi-transformers/test/additional-properties-to-unconstrained.js
const transformer = new AdditionalPropertiesToUnconstrainedTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    // Generates Map<string,string>, no JsonExtensionData
    type: 'object',
    properties: {},
    additionalProperties: {
      type: 'string',
    },
  }))),
  schema3({
    type: 'object',
    properties: {},
    additionalProperties: {
      type: 'string',
    },
  }),
);

AnyOfNullToNullableTransformer

preserves non-object schema
/home/kevin/src/node-projects/openapi-transformers/test/any-of-null-to-nullable.js
assert.deepStrictEqual(
  new AnyOfNullToNullableTransformer().transformOpenApi(schema3(1)),
  schema3(1),
);
preserves non-object anyOf
/home/kevin/src/node-projects/openapi-transformers/test/any-of-null-to-nullable.js
assert.deepStrictEqual(
  new AnyOfNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: 1,
  }, '3.1.0'))),
  schema3({
    anyOf: 1,
  }, '3.1.0'),
);
preserves empty anyOf
/home/kevin/src/node-projects/openapi-transformers/test/any-of-null-to-nullable.js
assert.deepStrictEqual(
  new AnyOfNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: [],
  }, '3.1.0'))),
  schema3({
    anyOf: [],
  }, '3.1.0'),
);
preserves anyOf with only `type: null`
/home/kevin/src/node-projects/openapi-transformers/test/any-of-null-to-nullable.js
assert.deepStrictEqual(
  new AnyOfNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: [
      { type: 'null' },
    ],
  }, '3.1.0'))),
  schema3({
    anyOf: [
      { type: 'null' },
    ],
  }, '3.1.0'),
);
adds `nullable: true`, removes `type: null` from anyOf
/home/kevin/src/node-projects/openapi-transformers/test/any-of-null-to-nullable.js
assert.deepStrictEqual(
  new AnyOfNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: [
      { type: 'number' },
      { type: 'null' },
    ],
  }, '3.1.0'))),
  schema3({
    anyOf: [
      { type: 'number' },
    ],
    nullable: true,
  }, '3.1.0'),
);
adds `nullable: true`, removes multiple `type: null` from anyOf
/home/kevin/src/node-projects/openapi-transformers/test/any-of-null-to-nullable.js
assert.deepStrictEqual(
  new AnyOfNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: [
      { type: 'null' },
      { type: 'number' },
      { type: 'null' },
    ],
  }, '3.1.0'))),
  schema3({
    anyOf: [
      { type: 'number' },
    ],
    nullable: true,
  }, '3.1.0'),
);

AssertPropertiesTransformer

does not throw Error for no props
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.deepStrictEqual(
  new AssertPropertiesTransformer({ schema: { excludes: [] } })
    .transformOpenApi(deepFreeze(schema3({}))),
  schema3({}),
);
does not throw Error for no matching props
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.deepStrictEqual(
  new AssertPropertiesTransformer({ schema: { excludes: [] } })
    .transformOpenApi(deepFreeze(schema3({ type: 'string' }))),
  schema3({ type: 'string' }),
);
throws Error for matching prop
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer({
    schema: {
      excludes: ['minimum'],
    },
  })
    .transformOpenApi(deepFreeze(schema3({ minimum: 1 }))),
  /minimum/,
);
throws Error for matching nested prop
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer({
    schema: {
      excludes: ['minimum'],
    },
  })
    .transformOpenApi(deepFreeze(schema3({ allOf: [{ minimum: 1 }] }))),
  /minimum/,
);
does not throw Error for inherited prop
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.deepStrictEqual(
  new AssertPropertiesTransformer({ schema: { excludes: ['prototype'] } })
    .transformOpenApi(deepFreeze(schema3({}))),
  schema3({}),
);
does not throw Error for undefined prop
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.deepStrictEqual(
  new AssertPropertiesTransformer({ schema: { excludes: ['minimum'] } })
    .transformOpenApi(deepFreeze(schema3({ minimum: undefined }))),
  schema3({ minimum: undefined }),
);

constructor

throws TypeError without options
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer(),
  TypeError,
);
throws TypeError without options.schema
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer({}),
  TypeError,
);
throws TypeError without options.schema.excludes
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer({ schema: {} }),
  TypeError,
);
throws TypeError for non-Array options.schema.excludes
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer({ schema: { excludes: {} } }),
  TypeError,
);
throws TypeError for non-string options.schema.excludes item
/home/kevin/src/node-projects/openapi-transformers/test/assert-properties.js
assert.throws(
  () => new AssertPropertiesTransformer({ schema: { excludes: [1] } }),
  TypeError,
);

BinaryStringToFileTransformer

openapi 3 with format: binary in components
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
    format: 'binary',
  }))),
  schema3({
    type: 'file',
  }),
);
openapi 3 with format: file in components
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
    format: 'file',
  }))),
  schema3({
    type: 'file',
  }),
);
openapi 3 without format in components
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
  }))),
  schema3({
    type: 'string',
  }),
);
swagger 2 format: binary in parameter schema
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(post2({
    parameters: [
      {
        in: 'body',
        name: 'myfile',
        schema: {
          type: 'string',
          format: 'binary',
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  post2({
    parameters: [
      {
        in: 'body',
        name: 'myfile',
        schema: {
          type: 'file',
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
swagger 2 format: file in parameter schema
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(post2({
    parameters: [
      {
        in: 'body',
        name: 'myfile',
        schema: {
          type: 'string',
          format: 'file',
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  post2({
    parameters: [
      {
        in: 'body',
        name: 'myfile',
        schema: {
          type: 'file',
        },
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
swagger 2 format: binary in parameter
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(post2({
    parameters: [
      {
        in: 'formData',
        name: 'myfile',
        type: 'string',
        format: 'binary',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  post2({
    parameters: [
      {
        in: 'formData',
        name: 'myfile',
        type: 'file',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
swagger 2 format: file in parameter
/home/kevin/src/node-projects/openapi-transformers/test/binary-string-to-file.js
assert.deepStrictEqual(
  new BinaryStringToFileTransformer().transformOpenApi(deepFreeze(post2({
    parameters: [
      {
        in: 'formData',
        name: 'myfile',
        type: 'string',
        format: 'file',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  post2({
    parameters: [
      {
        in: 'formData',
        name: 'myfile',
        type: 'file',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);

BoolEnumToBoolTransformer

removes enum: [true, false] from type: boolean
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'boolean',
    enum: [true, false],
  }))),
  schema3({
    type: 'boolean',
  }),
);
removes enum: [false, true] from type: boolean
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'boolean',
    enum: [false, true],
  }))),
  schema3({
    type: 'boolean',
  }),
);
does not remove enum: ["true", "false"] outside string context
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: ['true', 'false'],
  }))),
  schema3({
    type: 'string',
    enum: ['true', 'false'],
  }),
);
removes enum: ["true", "false"] in components header
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      headers: {
        Example: {
          schema: {
            type: 'string',
            enum: ['true', 'false'],
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      headers: {
        Example: {
          schema: {
            type: 'boolean',
          },
        },
      },
    },
    paths: {},
  },
);
removes enum: ["true", "false"] in components path parameter
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'path',
          schema: {
            type: 'string',
            enum: ['true', 'false'],
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'path',
          schema: {
            type: 'boolean',
          },
        },
      },
    },
    paths: {},
  },
);
removes enum: ["true", "false"] in components query parameter
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'query',
          schema: {
            type: 'string',
            enum: ['true', 'false'],
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'query',
          schema: {
            type: 'boolean',
          },
        },
      },
    },
    paths: {},
  },
);
removes mixed enum in components query parameter
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'query',
          schema: {
            type: ['boolean', 'string'],
            enum: ['true', 'false', true, false],
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'query',
          schema: {
            type: 'boolean',
          },
        },
      },
    },
    paths: {},
  },
);
removes enum: ["true", "false"] in components cookie parameter
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'cookie',
          schema: {
            type: 'string',
            enum: ['true', 'false'],
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'cookie',
          schema: {
            type: 'boolean',
          },
        },
      },
    },
    paths: {},
  },
);
does not remove enum: ["true", "false"] in JSON cookie
/home/kevin/src/node-projects/openapi-transformers/test/bool-enum-to-bool.js
assert.deepStrictEqual(
  new BoolEnumToBoolTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'cookie',
          content: {
            'application/json': {
              schema: {
                type: 'string',
                enum: ['true', 'false'],
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      parameters: {
        Example: {
          name: 'example',
          in: 'cookie',
          content: {
            'application/json': {
              schema: {
                type: 'string',
                enum: ['true', 'false'],
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);

ClearHtmlResponseSchemaTransformer

removes schema for text/html response in openapi 3
/home/kevin/src/node-projects/openapi-transformers/test/clear-html-response-schema.js
assert.deepStrictEqual(
  new ClearHtmlResponseSchemaTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    type: 'string',
                    format: 'binary',
                  },
                },
              },
            },
          },
        },
      },
      '/html': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'text/html': {
                  schema: {
                    type: 'string',
                    format: 'binary',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    type: 'string',
                    format: 'binary',
                  },
                },
              },
            },
          },
        },
      },
      '/html': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'text/html': {},
              },
            },
          },
        },
      },
    },
  },
);
removes schema for text/html;charset response in openapi 3
/home/kevin/src/node-projects/openapi-transformers/test/clear-html-response-schema.js
assert.deepStrictEqual(
  new ClearHtmlResponseSchemaTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    type: 'string',
                    format: 'binary',
                  },
                },
              },
            },
          },
        },
      },
      '/html': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'text/html;charset=utf-8': {
                  schema: {
                    type: 'string',
                    format: 'binary',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    type: 'string',
                    format: 'binary',
                  },
                },
              },
            },
          },
        },
      },
      '/html': {
        get: {
          responses: {
            default: {
              description: 'Example response',
              content: {
                'text/html;charset=utf-8': {},
              },
            },
          },
        },
      },
    },
  },
);
removes schema for text/html response in swagger 2
/home/kevin/src/node-projects/openapi-transformers/test/clear-html-response-schema.js
assert.deepStrictEqual(
  new ClearHtmlResponseSchemaTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/': {
        get: {
          produces: ['application/json'],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'file',
              },
            },
          },
        },
      },
      '/html': {
        get: {
          produces: ['text/html'],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'file',
              },
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/': {
        get: {
          produces: ['application/json'],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'file',
              },
            },
          },
        },
      },
      '/html': {
        get: {
          produces: ['text/html'],
          responses: {
            default: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

ClientParamsToGlobalTransformer

openapi 3 client parameter
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze(get3({
    parameters: [
      {
        name: 'myquery',
        in: 'query',
        schema: {
          type: 'string',
        },
        'x-ms-parameter-location': 'client',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  {
    ...openapi,
    components: {
      parameters: {
        myquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/myquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 combines same client parameter
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        get: {
          parameters: [
            {
              name: 'myquery',
              in: 'query',
              schema: {
                type: 'string',
              },
              'x-ms-parameter-location': 'client',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/b': {
        get: {
          parameters: [
            {
              'x-ms-parameter-location': 'client',
              in: 'query',
              schema: {
                type: 'string',
              },
              name: 'myquery',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      parameters: {
        myquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/myquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/b': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/myquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 references existing parameter of same name
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        myquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            {
              name: 'myquery',
              in: 'query',
              schema: {
                type: 'string',
              },
              'x-ms-parameter-location': 'client',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      parameters: {
        myquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/myquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 references existing parameter of different name
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        notmyquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            {
              name: 'myquery',
              in: 'query',
              schema: {
                type: 'string',
              },
              'x-ms-parameter-location': 'client',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      parameters: {
        notmyquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/notmyquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 references existing parameter without x-ms-p-l
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      parameters: {
        notmyquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            {
              name: 'myquery',
              in: 'query',
              schema: {
                type: 'string',
              },
              'x-ms-parameter-location': 'client',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      parameters: {
        notmyquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/notmyquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 does not combine different client parameter
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        get: {
          parameters: [
            {
              name: 'myquery',
              in: 'query',
              schema: {
                type: 'string',
              },
              'x-ms-parameter-location': 'client',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/b': {
        get: {
          parameters: [
            {
              name: 'myquery',
              in: 'query',
              schema: {
                type: 'number',
              },
              'x-ms-parameter-location': 'client',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      parameters: {
        myquery: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
        myquery2: {
          name: 'myquery',
          in: 'query',
          schema: {
            type: 'number',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/a': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/myquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/b': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/myquery2' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 client parameter JSON Pointer-encodes name in $ref
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze(get3({
    parameters: [
      {
        name: 'my~query/thing',
        in: 'query',
        schema: {
          type: 'string',
        },
        'x-ms-parameter-location': 'client',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  {
    ...openapi,
    components: {
      parameters: {
        'my~query/thing': {
          name: 'my~query/thing',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/my~0query~1thing' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 client parameter percent-encodes name in $ref
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze(get3({
    parameters: [
      {
        name: 'my?query#thing',
        in: 'query',
        schema: {
          type: 'string',
        },
        'x-ms-parameter-location': 'client',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  {
    ...openapi,
    components: {
      parameters: {
        'my?query#thing': {
          name: 'my?query#thing',
          in: 'query',
          schema: {
            type: 'string',
          },
          'x-ms-parameter-location': 'client',
        },
      },
    },
    paths: {
      '/': {
        get: {
          parameters: [
            { $ref: '#/components/parameters/my%3Fquery%23thing' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
swagger 2 client parameter
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze(get2({
    parameters: [
      {
        name: 'myquery',
        in: 'query',
        type: 'string',
        'x-ms-parameter-location': 'client',
      },
    ],
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }))),
  {
    ...swagger,
    parameters: {
      myquery: {
        name: 'myquery',
        in: 'query',
        type: 'string',
        'x-ms-parameter-location': 'client',
      },
    },
    paths: {
      '/': {
        get: {
          parameters: [
            { $ref: '#/parameters/myquery' },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
swagger 2 client parameter in x-ms-parameterized-host
/home/kevin/src/node-projects/openapi-transformers/test/client-params-to-global.js
assert.deepStrictEqual(
  new ClientParamsToGlobalTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {},
    'x-ms-parameterized-host': {
      hostTemplate: 'example.{tld}',
      parameters: [
        {
          name: 'tld',
          in: 'path',
          type: 'string',
          'x-ms-parameter-location': 'client',
        },
      ],
    },
  })),
  {
    ...swagger,
    parameters: {
      tld: {
        name: 'tld',
        in: 'path',
        type: 'string',
        'x-ms-parameter-location': 'client',
      },
    },
    paths: {},
    'x-ms-parameterized-host': {
      hostTemplate: 'example.{tld}',
      parameters: [
        { $ref: '#/parameters/tld' },
      ],
    },
  },
);

ConstToEnumTransformer

const: 1 to enum: [1]
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    const: 1,
  }, '3.1.0'))),
  schema3({
    enum: [1],
  }, '3.1.0'),
);
const: null to enum: [null]
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    const: null,
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }, '3.1.0'),
);
removes const with matching enum
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    const: 1,
    enum: [1],
  }, '3.1.0'))),
  schema3({
    enum: [1],
  }, '3.1.0'),
);
narrows matching enum to only const value
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    const: 2,
    enum: [1, 2, 3],
  }, '3.1.0'))),
  schema3({
    enum: [2],
  }, '3.1.0'),
);
narrows matching enum to only null const value
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    const: null,
    enum: [1, null],
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }, '3.1.0'),
);
returns empty enum for non-matching enum
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    const: 2,
    enum: [1, 3],
  }, '3.1.0'))),
  schema3({
    enum: [],
  }, '3.1.0'),
);
returns null schema unchanged
/home/kevin/src/node-projects/openapi-transformers/test/const-to-enum.js
assert.deepStrictEqual(
  new ConstToEnumTransformer().transformOpenApi(deepFreeze(
    schema3(null, '3.1.0'),
  )),
  schema3(null, '3.1.0'),
);

EscapeEnumValuesTransformer

throws TypeError without options
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
assert.throws(
  () => new EscapeEnumValuesTransformer(),
  TypeError,
);
throws TypeError without options.language
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
assert.throws(
  () => new EscapeEnumValuesTransformer({}),
  TypeError,
);
throws TypeError with number options.language
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
assert.throws(
  () => new EscapeEnumValuesTransformer({ language: 5 }),
  TypeError,
);
throws RangeError with unrecognized options.language
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
assert.throws(
  () => new EscapeEnumValuesTransformer({ language: 'unrecognized' }),
  RangeError,
);
escapes x-ms-enum values for csharp
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'csharp' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '\\"' },
        { value: "'" },
        { value: '\\\\' },
        { value: '\\r\\n' },
      ],
    },
  }),
);
escapes x-ms-enum values for go
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'go' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '\\"' },
        { value: "'" },
        { value: '\\\\' },
        { value: '\\r\\n' },
      ],
    },
  }),
);
escapes x-ms-enum values for java
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'java' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '\\"' },
        { value: "'" },
        { value: '\\\\' },
        { value: '\\r\\n' },
      ],
    },
  }),
);
escapes x-ms-enum values for nodejs
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'nodejs' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '\\"' },
        { value: "\\'" },
        { value: '\\\\' },
        { value: '\\r\\n' },
      ],
    },
  }),
);
escapes x-ms-enum values for php
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'php' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '\\"' },
        { value: "'" },
        { value: '\\\\' },
        { value: '\\r\\n' },
      ],
    },
  }),
);
escapes x-ms-enum values for python
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'python' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '\\"' },
        { value: "\\'" },
        { value: '\\\\' },
        { value: '\\r\\n' },
      ],
    },
  }),
);
escapes x-ms-enum values for ruby
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'ruby' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "'" },
        { value: '\\' },
        { value: '\r\n' },
      ],
    },
  }))),
  schema3({
    type: 'string',
    enum: [
      '"',
      "'",
      '\\',
      '\r\n',
    ],
    'x-ms-enum': {
      name: 'MyEnum',
      values: [
        { value: '"' },
        { value: "\\'" },
        { value: '\\\\' },
        { value: '\r\n' },
      ],
    },
  }),
);
escapes swagger parameter x-ms-enum values for csharp
/home/kevin/src/node-projects/openapi-transformers/test/escape-enum-values.js
const transformer =
  new EscapeEnumValuesTransformer({ language: 'csharp' });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...swagger,
    parameters: {
      myparam: {
        type: 'string',
        enum: [
          '"',
          "'",
          '\\',
          '\r\n',
        ],
        'x-ms-enum': {
          name: 'MyEnum',
          values: [
            { value: '"' },
            { value: "'" },
            { value: '\\' },
            { value: '\r\n' },
          ],
        },
      },
    },
    paths: {},
  })),
  {
    ...swagger,
    parameters: {
      myparam: {
        type: 'string',
        enum: [
          '"',
          "'",
          '\\',
          '\r\n',
        ],
        'x-ms-enum': {
          name: 'MyEnum',
          values: [
            { value: '\\"' },
            { value: "'" },
            { value: '\\\\' },
            { value: '\\r\\n' },
          ],
        },
      },
    },
    paths: {},
  },
);

ExclusiveMinMaxToBoolTransformer

transforms exclusiveMaximum: 1 to bool
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      { exclusiveMaximum: 1 },
      '3.1.0',
    ),
  )),
  schema3(
    {
      exclusiveMaximum: true,
      maximum: 1,
    },
    '3.1.0',
  ),
);
transforms exclusiveMinimum: 1 to bool
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      { exclusiveMinimum: 1 },
      '3.1.0',
    ),
  )),
  schema3(
    {
      exclusiveMinimum: true,
      minimum: 1,
    },
    '3.1.0',
  ),
);
removes exclusiveMaximum > maximum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      {
        exclusiveMaximum: 1,
        maximum: 0,
      },
      '3.1.0',
    ),
  )),
  schema3(
    { maximum: 0 },
    '3.1.0',
  ),
);
removes exclusiveMinimum < minimum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      {
        exclusiveMinimum: 0,
        minimum: 1,
      },
      '3.1.0',
    ),
  )),
  schema3(
    { minimum: 1 },
    '3.1.0',
  ),
);
replaces exclusiveMaximum < maximum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      {
        exclusiveMaximum: 0,
        maximum: 1,
      },
      '3.1.0',
    ),
  )),
  schema3(
    {
      exclusiveMaximum: true,
      maximum: 0,
    },
    '3.1.0',
  ),
);
replaces exclusiveMinimum > minimum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      {
        exclusiveMinimum: 1,
        minimum: 0,
      },
      '3.1.0',
    ),
  )),
  schema3(
    {
      exclusiveMinimum: true,
      minimum: 1,
    },
    '3.1.0',
  ),
);
replaces exclusiveMaximum == maximum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      {
        exclusiveMaximum: 1,
        maximum: 1,
      },
      '3.1.0',
    ),
  )),
  schema3(
    {
      exclusiveMaximum: true,
      maximum: 1,
    },
    '3.1.0',
  ),
);
replaces exclusiveMinimum == minimum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      {
        exclusiveMinimum: 1,
        minimum: 1,
      },
      '3.1.0',
    ),
  )),
  schema3(
    {
      exclusiveMinimum: true,
      minimum: 1,
    },
    '3.1.0',
  ),
);
ignores non-numeric exclusiveMaximum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      { exclusiveMaximum: 'test' },
      '3.1.0',
    ),
  )),
  schema3(
    { exclusiveMaximum: 'test' },
    '3.1.0',
  ),
);
ignores non-numeric exclusiveMinimum
/home/kevin/src/node-projects/openapi-transformers/test/exclusive-min-max-to-bool.js
assert.deepStrictEqual(
  new ExclusiveMinMaxToBoolTransformer().transformOpenApi(deepFreeze(
    schema3(
      { exclusiveMinimum: 'test' },
      '3.1.0',
    ),
  )),
  schema3({
    exclusiveMinimum: 'test',
  }, '3.1.0'),
);

FormatToTypeTransformer

openapi 3 format: decimal to type number in components
/home/kevin/src/node-projects/openapi-transformers/test/format-to-type.js
assert.deepStrictEqual(
  new FormatToTypeTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      prop: {
        type: 'string',
        format,
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      prop: {
        type,
        // format is removed if format === type
        ...format === type ? undefined : { format },
      },
    },
  }),
);
openapi 3 format: double to type number in components
/home/kevin/src/node-projects/openapi-transformers/test/format-to-type.js
assert.deepStrictEqual(
  new FormatToTypeTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      prop: {
        type: 'string',
        format,
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      prop: {
        type,
        // format is removed if format === type
        ...format === type ? undefined : { format },
      },
    },
  }),
);
openapi 3 format: float to type number in components
/home/kevin/src/node-projects/openapi-transformers/test/format-to-type.js
assert.deepStrictEqual(
  new FormatToTypeTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      prop: {
        type: 'string',
        format,
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      prop: {
        type,
        // format is removed if format === type
        ...format === type ? undefined : { format },
      },
    },
  }),
);
openapi 3 format: integer to type integer in components
/home/kevin/src/node-projects/openapi-transformers/test/format-to-type.js
assert.deepStrictEqual(
  new FormatToTypeTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      prop: {
        type: 'string',
        format,
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      prop: {
        type,
        // format is removed if format === type
        ...format === type ? undefined : { format },
      },
    },
  }),
);
openapi 3 format: int32 to type integer in components
/home/kevin/src/node-projects/openapi-transformers/test/format-to-type.js
assert.deepStrictEqual(
  new FormatToTypeTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      prop: {
        type: 'string',
        format,
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      prop: {
        type,
        // format is removed if format === type
        ...format === type ? undefined : { format },
      },
    },
  }),
);
openapi 3 format: int64 to type integer in components
/home/kevin/src/node-projects/openapi-transformers/test/format-to-type.js
assert.deepStrictEqual(
  new FormatToTypeTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      prop: {
        type: 'string',
        format,
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      prop: {
        type,
        // format is removed if format === type
        ...format === type ? undefined : { format },
      },
    },
  }),
);

InlineNonObjectSchemaTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/inline-non-object-schemas.js
assert.throws(
  () => new InlineNonObjectSchemaTransformer(null),
  TypeError,
);
throws TypeError with number options.resolveRef
/home/kevin/src/node-projects/openapi-transformers/test/inline-non-object-schemas.js
assert.throws(
  () => new InlineNonObjectSchemaTransformer({ resolveRef: 1 }),
  TypeError,
);
inlines non-object schema with constraints by default
/home/kevin/src/node-projects/openapi-transformers/test/inline-non-object-schemas.js
assert.deepStrictEqual(
  new InlineNonObjectSchemaTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        Weight: {
          type: 'number',
          minimum: 0,
        },
        Example: {
          type: 'object',
          properties: {
            weight: {
              $ref: '#/components/schemas/Weight',
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      schemas: {
        Weight: {
          type: 'number',
          minimum: 0,
        },
        Example: {
          type: 'object',
          properties: {
            weight: {
              type: 'number',
              minimum: 0,
            },
          },
        },
      },
    },
    paths: {},
  },
);
does not inline non-object schema without constraints by default
/home/kevin/src/node-projects/openapi-transformers/test/inline-non-object-schemas.js
assert.deepStrictEqual(
  new InlineNonObjectSchemaTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        Weight: {
          type: 'number',
        },
        Example: {
          type: 'object',
          properties: {
            weight: {
              $ref: '#/components/schemas/Weight',
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      schemas: {
        Weight: {
          type: 'number',
        },
        Example: {
          type: 'object',
          properties: {
            weight: {
              $ref: '#/components/schemas/Weight',
            },
          },
        },
      },
    },
    paths: {},
  },
);
inlines non-object schema without constraints with inlineAll
/home/kevin/src/node-projects/openapi-transformers/test/inline-non-object-schemas.js
const transformer =
  new InlineNonObjectSchemaTransformer({ inlineAll: true });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        Weight: {
          type: 'number',
        },
        Example: {
          type: 'object',
          properties: {
            weight: {
              $ref: '#/components/schemas/Weight',
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      schemas: {
        Weight: {
          type: 'number',
        },
        Example: {
          type: 'object',
          properties: {
            weight: {
              type: 'number',
            },
          },
        },
      },
    },
    paths: {},
  },
);
uses options.resolveRef to resolve $ref
/home/kevin/src/node-projects/openapi-transformers/test/inline-non-object-schemas.js
function resolveRef($ref) {
  assert.strictEqual($ref, '#/components/schemas/Weight');
  return {
    type: 'number',
    minimum: 0,
  };
}
const transformer = new InlineNonObjectSchemaTransformer({ resolveRef });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      weight: {
        $ref: '#/components/schemas/Weight',
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      weight: {
        type: 'number',
        minimum: 0,
      },
    },
  }),
);

ComponentManager

constructor

throws TypeError without args
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
assert.throws(
  () => new ComponentManager(),
  TypeError,
);
throws TypeError for null
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
assert.throws(
  () => new ComponentManager(null),
  TypeError,
);
throws TypeError for Array
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
assert.throws(
  () => new ComponentManager([]),
  TypeError,
);

#add()

sets component[name] to value when no conflict
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const value = {};
const component = {};
const newName = new ComponentManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], value);
sets component[name+2] to value when name exists
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const value = {};
const component = { [name]: false };
const newName = new ComponentManager(component).add(value, name);
assert.strictEqual(newName, `${name}2`);
assert.strictEqual(component[newName], value);
assert.strictEqual(component[name], false);
overwrites component[name] when name is undefined
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const value = {};
const component = { [name]: undefined };
const newName = new ComponentManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], value);
returns name without overwrite when equal
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const value = {};
const origValue = {};
const component = { [name]: origValue };
const newName = new ComponentManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], origValue);
assert.ok(!Object.hasOwn(component, `${name}2`));
does not return name of equal value with different name
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const value = {};
const component = { other: value };
const newName = new ComponentManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], value);
sets component.undefined to value when no conflict
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const value = {};
const component = {};
const newName = new ComponentManager(component).add(value);
assert.strictEqual(newName, 'undefined');
assert.strictEqual(component.undefined, value);
sets component[name+2] to value when name exists
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const value = {};
const component = { undefined: false };
const newName = new ComponentManager(component).add(value);
assert.strictEqual(newName, 'undefined2');
assert.strictEqual(component.undefined2, value);
assert.strictEqual(component.undefined, false);

#getNames()

can be overridden to get names for #add()
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const name2 = 'surprise';
const value = {};
const component = {};
const manager = new ComponentManager(component);
manager.getNames = function* (basename) {
  assert.strictEqual(this, manager);
  assert.strictEqual(basename, name);
  yield name2;
};
const newName = manager.add(value, name);
assert.strictEqual(newName, name2);
assert.strictEqual(component[name2], value);
causes #add() to throw if names are exhausted
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const manager = new ComponentManager({});
// eslint-disable-next-line no-empty-function
manager.getNames = function* (basename) {};
assert.throws(
  () => manager.add({}, 'name'),
  /suitable name/i,
);

#isMatch()

can be overridden for #add() matching
/home/kevin/src/node-projects/openapi-transformers/test/lib/component-manager.js
const name = 'test';
const value = 'new';
const component = { [name]: 'orig' };
const manager = new ComponentManager(component);
manager.isMatch = function(value1, value2) {
  assert.strictEqual(this, manager);
  assert.strictEqual(value1, 'orig');
  assert.strictEqual(value2, 'new');
  return true;
};
const newName = manager.add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], 'orig');
assert.ok(!Object.hasOwn(component, `${name}2`));

MatchingComponentManager

constructor

throws TypeError without args
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
assert.throws(
  () => new MatchingComponentManager(),
  TypeError,
);
throws TypeError for null
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
assert.throws(
  () => new MatchingComponentManager(null),
  TypeError,
);
throws TypeError for Array
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
assert.throws(
  () => new MatchingComponentManager([]),
  TypeError,
);

#add()

sets component[name] to value when no conflict
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
const name = 'test';
const value = {};
const component = {};
const newName = new MatchingComponentManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], value);
returns name without overwrite when equal
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
const name = 'test';
const value = {};
const origValue = {};
const component = { [name]: origValue };
const newName = new MatchingComponentManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[name], origValue);
assert.ok(!Object.hasOwn(component, `${name}2`));
returns unrelated name with equal value
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
const name = 'test';
const value = {};
const origName = 'unrelated';
const origValue = {};
const component = { [origName]: origValue };
const newName = new MatchingComponentManager(component)
  .add(value, name);
assert.strictEqual(newName, origName);
assert.strictEqual(component[newName], origValue);
assert.ok(!Object.hasOwn(component, name));

#getKey()

can be overridden to find match for #add()
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
const name = 'test';
const value = [];
const origName = 'unrelated';
const origValue = {};
const component = { [origName]: origValue };
class TestManager extends MatchingComponentManager {
  getKey(keyVal) {
    assert.ok(this instanceof TestManager);
    // Called with origValue by constructor, value by #add().
    assert.ok(keyVal === origValue || keyVal === value);
    return 'mykey';
  }
}
const newName = new TestManager(component).add(value, name);
assert.strictEqual(newName, origName);
assert.strictEqual(component[newName], origValue);
assert.ok(!Object.hasOwn(component, name));
does not match key with unequal type
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-component-manager.js
const name = 'test';
const value = [];
const origName = 'unrelated';
const origValue = {};
const component = { [origName]: origValue };
class TestManager extends MatchingComponentManager {
  // eslint-disable-next-line class-methods-use-this
  getKey(keyVal) {
    return keyVal === origValue ? 'true'
      : keyVal === value ? true
        : assert.fail('unexpected keyVal');
  }
}
const newName = new TestManager(component).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(component[newName], value);
assert.strictEqual(component[origName], origValue);

MatchingParameterMatcher

constructor

throws TypeError without args
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
assert.throws(
  () => new MatchingParameterMatcher(),
  TypeError,
);
throws TypeError for null
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
assert.throws(
  () => new MatchingParameterMatcher(null),
  TypeError,
);
throws TypeError for Array
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
assert.throws(
  () => new MatchingParameterMatcher([]),
  TypeError,
);

#add()

sets parameters[name] to value when no conflict
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {};
const parameters = {};
const newName = new MatchingParameterMatcher(parameters).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(parameters[name], value);
returns name without overwrite when equal
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {};
const origValue = {};
const parameters = { [name]: origValue };
const newName = new MatchingParameterMatcher(parameters).add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(parameters[name], origValue);
assert.ok(!Object.hasOwn(parameters, `${name}2`));
returns unrelated name with equal value
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {};
const origName = 'unrelated';
const origValue = {};
const parameters = { [origName]: origValue };
const newName = new MatchingParameterMatcher(parameters)
  .add(value, name);
assert.strictEqual(newName, origName);
assert.strictEqual(parameters[newName], origValue);
assert.ok(!Object.hasOwn(parameters, name));
returns unrelated name with x-ms-parameter-location:client
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {
  in: 'query',
};
const origName = 'unrelated';
const origValue = {
  in: 'query',
  'x-ms-parameter-location': 'client',
};
const parameters = { [origName]: origValue };
const newName = new MatchingParameterMatcher(parameters)
  .add(value, name);
assert.strictEqual(newName, origName);
assert.strictEqual(parameters[newName], origValue);
assert.ok(!Object.hasOwn(parameters, name));
returns unrelated name without x-ms-parameter-location:client
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {
  in: 'query',
  'x-ms-parameter-location': 'client',
};
const origName = 'unrelated';
const origValue = {
  in: 'query',
};
const parameters = { [origName]: origValue };
const newName = new MatchingParameterMatcher(parameters)
  .add(value, name);
assert.strictEqual(newName, origName);
assert.strictEqual(parameters[newName], origValue);
assert.ok(!Object.hasOwn(parameters, name));
does not return name with x-ms-parameter-location:method
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {
  in: 'query',
};
const origName = 'unrelated';
const origValue = {
  in: 'query',
  'x-ms-parameter-location': 'method',
};
const parameters = { [origName]: origValue };
const newName = new MatchingParameterMatcher(parameters)
  .add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(parameters[newName], value);
assert.strictEqual(parameters[origName], origValue);
does not return name without x-ms-parameter-location:method
/home/kevin/src/node-projects/openapi-transformers/test/lib/matching-parameter-manager.js
const name = 'test';
const value = {
  in: 'query',
  'x-ms-parameter-location': 'method',
};
const origName = 'unrelated';
const origValue = {
  in: 'query',
};
const parameters = { [origName]: origValue };
const newName = new MatchingParameterMatcher(parameters)
  .add(value, name);
assert.strictEqual(newName, name);
assert.strictEqual(parameters[newName], value);
assert.strictEqual(parameters[origName], origValue);

MergeAllOfTransformer

does not modify non-Object schema
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer().transformOpenApi(deepFreeze(schema3(0))),
  schema3(0),
);
does not modify non-Array
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer().transformOpenApi(deepFreeze(schema3({
    allOf: 123,
  }))),
  schema3({
    allOf: 123,
  }),
);
removes empty Array
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer().transformOpenApi(deepFreeze(schema3({
    allOf: [],
  }))),
  schema3({}),
);
intersects single element with parent
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer().transformOpenApi(deepFreeze(schema3({
    maximum: 5,
    allOf: [
      { minimum: 3 },
    ],
  }))),
  schema3({
    maximum: 5,
    minimum: 3,
  }),
);
merges recursively
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer().transformOpenApi(deepFreeze(schema3({
    maximum: 5,
    allOf: [
      {
        minimum: 3,
        allOf: [
          { multipleOf: 2 },
        ],
      },
    ],
  }))),
  schema3({
    maximum: 5,
    minimum: 3,
    multipleOf: 2,
  }),
);

with onlySingle

intersects single element with parent
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer({ onlySingle: true })
    .transformOpenApi(deepFreeze(schema3({
      maximum: 5,
      allOf: [
        { minimum: 3 },
      ],
    }))),
  schema3({
    maximum: 5,
    minimum: 3,
  }),
);
does not modify multi-element allOf
/home/kevin/src/node-projects/openapi-transformers/test/merge-all-of.js
assert.deepStrictEqual(
  new MergeAllOfTransformer({ onlySingle: true })
    .transformOpenApi(deepFreeze(schema3({
      maximum: 5,
      allOf: [
        { minimum: 3 },
        { multipleOf: 2 },
      ],
    }))),
  schema3({
    maximum: 5,
    allOf: [
      { minimum: 3 },
      { multipleOf: 2 },
    ],
  }),
);

MergeAnyOfTransformer

does not modify non-Object schema
/home/kevin/src/node-projects/openapi-transformers/test/merge-any-of.js
assert.deepStrictEqual(
  new MergeAnyOfTransformer().transformOpenApi(deepFreeze(schema3(0))),
  schema3(0),
);
does not modify non-Array
/home/kevin/src/node-projects/openapi-transformers/test/merge-any-of.js
assert.deepStrictEqual(
  new MergeAnyOfTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: 123,
  }))),
  schema3({
    anyOf: 123,
  }),
);
does not modify empty Array
/home/kevin/src/node-projects/openapi-transformers/test/merge-any-of.js
assert.deepStrictEqual(
  new MergeAnyOfTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: [],
  }))),
  schema3({
    anyOf: [],
  }),
);
intersects single element with parent
/home/kevin/src/node-projects/openapi-transformers/test/merge-any-of.js
assert.deepStrictEqual(
  new MergeAnyOfTransformer().transformOpenApi(deepFreeze(schema3({
    maximum: 5,
    anyOf: [
      { minimum: 3 },
    ],
  }))),
  schema3({
    maximum: 5,
    minimum: 3,
  }),
);
merges recursively
/home/kevin/src/node-projects/openapi-transformers/test/merge-any-of.js
assert.deepStrictEqual(
  new MergeAnyOfTransformer().transformOpenApi(deepFreeze(schema3({
    maximum: 5,
    anyOf: [
      {
        minimum: 3,
        anyOf: [
          { multipleOf: 2 },
        ],
      },
    ],
  }))),
  schema3({
    maximum: 5,
    minimum: 3,
    multipleOf: 2,
  }),
);
throws Error for multiple anyOf schemas
/home/kevin/src/node-projects/openapi-transformers/test/merge-any-of.js
assert.throws(
  () => new MergeAnyOfTransformer().transformOpenApi(deepFreeze(schema3({
    anyOf: [
      { minimum: 3 },
      { multipleOf: 2 },
    ],
  }))),
  /not (?:implemented|supported)/i,
);

MergeOneOfTransformer

does not modify non-Object schema
/home/kevin/src/node-projects/openapi-transformers/test/merge-one-of.js
assert.deepStrictEqual(
  new MergeOneOfTransformer().transformOpenApi(deepFreeze(schema3(0))),
  schema3(0),
);
does not modify non-Array
/home/kevin/src/node-projects/openapi-transformers/test/merge-one-of.js
assert.deepStrictEqual(
  new MergeOneOfTransformer().transformOpenApi(deepFreeze(schema3({
    oneOf: 123,
  }))),
  schema3({
    oneOf: 123,
  }),
);
does not modify empty Array
/home/kevin/src/node-projects/openapi-transformers/test/merge-one-of.js
assert.deepStrictEqual(
  new MergeOneOfTransformer().transformOpenApi(deepFreeze(schema3({
    oneOf: [],
  }))),
  schema3({
    oneOf: [],
  }),
);
intersects single element with parent
/home/kevin/src/node-projects/openapi-transformers/test/merge-one-of.js
assert.deepStrictEqual(
  new MergeOneOfTransformer().transformOpenApi(deepFreeze(schema3({
    maximum: 5,
    oneOf: [
      { minimum: 3 },
    ],
  }))),
  schema3({
    maximum: 5,
    minimum: 3,
  }),
);
merges recursively
/home/kevin/src/node-projects/openapi-transformers/test/merge-one-of.js
assert.deepStrictEqual(
  new MergeOneOfTransformer().transformOpenApi(deepFreeze(schema3({
    maximum: 5,
    oneOf: [
      {
        minimum: 3,
        oneOf: [
          { multipleOf: 2 },
        ],
      },
    ],
  }))),
  schema3({
    maximum: 5,
    minimum: 3,
    multipleOf: 2,
  }),
);
throws Error for multiple oneOf schemas
/home/kevin/src/node-projects/openapi-transformers/test/merge-one-of.js
assert.throws(
  () => new MergeOneOfTransformer().transformOpenApi(deepFreeze(schema3({
    oneOf: [
      { minimum: 3 },
      { multipleOf: 2 },
    ],
  }))),
  /not (?:implemented|supported)/i,
);

NullableNotRequiredTransformer

nullable required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
  }),
);
x-nullable required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema2({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          'x-nullable': true,
        },
      },
      required: ['name'],
    }))),
  schema2({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        'x-nullable': true,
      },
    },
  }),
);
nullable additionalProperties to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      additionalProperties: {
        type: 'string',
        nullable: true,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
      nullable: true,
    },
  }),
);
non-nullable additionalProperties still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      additionalProperties: {
        type: 'string',
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
    required: ['name'],
  }),
);
nullable with non-nullable additionalProperties not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      additionalProperties: {
        type: 'string',
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    additionalProperties: {
      type: 'string',
    },
  }),
);
non-nullable with nullable additionalProperties still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
        },
      },
      additionalProperties: {
        type: 'string',
        nullable: true,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
      },
    },
    additionalProperties: {
      type: 'string',
      nullable: true,
    },
    required: ['name'],
  }),
);
null required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'null',
        },
      },
      required: ['name'],
    }, '3.1.0'))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'null',
      },
    },
  }, '3.1.0'),
);
string/null required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: ['string', 'null'],
        },
      },
      required: ['name'],
    }, '3.1.0'))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: ['string', 'null'],
      },
    },
  }, '3.1.0'),
);
$ref property optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            properties: {
              name: {
                $ref: '#/components/schemas/MyString',
              },
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/components/schemas/MyString',
            },
          },
          ...requiredRef,
        },
      },
    },
  },
);
$ref additionalProperty optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            additionalProperties: {
              $ref: '#/components/schemas/MyString',
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          additionalProperties: {
            $ref: '#/components/schemas/MyString',
          },
          ...requiredRef,
        },
      },
    },
  },
);
nullable $ref property not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            properties: {
              name: {
                $ref: '#/components/schemas/MyString',
                nullable: true,
              },
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/components/schemas/MyString',
              nullable: true,
            },
          },
        },
      },
    },
  },
);
x-nullable $ref property not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...swagger,
      definitions: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/definitions/MyString',
              'x-nullable': true,
            },
          },
          required: ['name'],
        },
      },
    })),
  {
    ...swagger,
    definitions: {
      MyString: {
        type: 'string',
      },
      Test: {
        type: 'object',
        properties: {
          name: {
            $ref: '#/definitions/MyString',
            'x-nullable': true,
          },
        },
      },
    },
  },
);
$ref allOf property optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            allOf: [
              {
                type: 'object',
                properties: {
                  name: {
                    $ref: '#/components/schemas/MyString',
                  },
                },
              },
            ],
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          allOf: [
            {
              type: 'object',
              properties: {
                name: {
                  $ref: '#/components/schemas/MyString',
                },
              },
            },
          ],
          ...requiredRef,
        },
      },
    },
  },
);
unconstrained object optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    ...requiredUnconstrained,
  }),
);
unconstrained properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {},
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {},
    ...requiredUnconstrained,
  }),
);
undefined properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: undefined,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: undefined,
    },
    ...requiredUnconstrained,
  }),
);
null properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: null,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: null,
    },
    ...requiredUnconstrained,
  }),
);
nullable required allOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      allOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    allOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required allOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      allOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    allOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable and nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
non-nullable and nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable and non-nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable required anyOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
  }),
);
nullable required oneOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      oneOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    oneOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required oneOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      oneOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    oneOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
  }),
);

with refNullable

nullable required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
  }),
);
x-nullable required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema2({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          'x-nullable': true,
        },
      },
      required: ['name'],
    }))),
  schema2({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        'x-nullable': true,
      },
    },
  }),
);
nullable additionalProperties to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      additionalProperties: {
        type: 'string',
        nullable: true,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
      nullable: true,
    },
  }),
);
non-nullable additionalProperties still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      additionalProperties: {
        type: 'string',
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
    required: ['name'],
  }),
);
nullable with non-nullable additionalProperties not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      additionalProperties: {
        type: 'string',
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    additionalProperties: {
      type: 'string',
    },
  }),
);
non-nullable with nullable additionalProperties still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
        },
      },
      additionalProperties: {
        type: 'string',
        nullable: true,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
      },
    },
    additionalProperties: {
      type: 'string',
      nullable: true,
    },
    required: ['name'],
  }),
);
null required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'null',
        },
      },
      required: ['name'],
    }, '3.1.0'))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'null',
      },
    },
  }, '3.1.0'),
);
string/null required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: ['string', 'null'],
        },
      },
      required: ['name'],
    }, '3.1.0'))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: ['string', 'null'],
      },
    },
  }, '3.1.0'),
);
$ref property optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            properties: {
              name: {
                $ref: '#/components/schemas/MyString',
              },
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/components/schemas/MyString',
            },
          },
          ...requiredRef,
        },
      },
    },
  },
);
$ref additionalProperty optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            additionalProperties: {
              $ref: '#/components/schemas/MyString',
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          additionalProperties: {
            $ref: '#/components/schemas/MyString',
          },
          ...requiredRef,
        },
      },
    },
  },
);
nullable $ref property not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            properties: {
              name: {
                $ref: '#/components/schemas/MyString',
                nullable: true,
              },
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/components/schemas/MyString',
              nullable: true,
            },
          },
        },
      },
    },
  },
);
x-nullable $ref property not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...swagger,
      definitions: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/definitions/MyString',
              'x-nullable': true,
            },
          },
          required: ['name'],
        },
      },
    })),
  {
    ...swagger,
    definitions: {
      MyString: {
        type: 'string',
      },
      Test: {
        type: 'object',
        properties: {
          name: {
            $ref: '#/definitions/MyString',
            'x-nullable': true,
          },
        },
      },
    },
  },
);
$ref allOf property optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            allOf: [
              {
                type: 'object',
                properties: {
                  name: {
                    $ref: '#/components/schemas/MyString',
                  },
                },
              },
            ],
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          allOf: [
            {
              type: 'object',
              properties: {
                name: {
                  $ref: '#/components/schemas/MyString',
                },
              },
            },
          ],
          ...requiredRef,
        },
      },
    },
  },
);
unconstrained object optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    ...requiredUnconstrained,
  }),
);
unconstrained properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {},
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {},
    ...requiredUnconstrained,
  }),
);
undefined properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: undefined,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: undefined,
    },
    ...requiredUnconstrained,
  }),
);
null properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: null,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: null,
    },
    ...requiredUnconstrained,
  }),
);
nullable required allOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      allOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    allOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required allOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      allOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    allOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable and nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
non-nullable and nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable and non-nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable required anyOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
  }),
);
nullable required oneOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      oneOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    oneOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required oneOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      oneOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    oneOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
  }),
);

with requireUnconstrained

nullable required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
  }),
);
x-nullable required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema2({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          'x-nullable': true,
        },
      },
      required: ['name'],
    }))),
  schema2({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        'x-nullable': true,
      },
    },
  }),
);
nullable additionalProperties to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      additionalProperties: {
        type: 'string',
        nullable: true,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
      nullable: true,
    },
  }),
);
non-nullable additionalProperties still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      additionalProperties: {
        type: 'string',
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
    required: ['name'],
  }),
);
nullable with non-nullable additionalProperties not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      additionalProperties: {
        type: 'string',
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    additionalProperties: {
      type: 'string',
    },
  }),
);
non-nullable with nullable additionalProperties still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
        },
      },
      additionalProperties: {
        type: 'string',
        nullable: true,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
      },
    },
    additionalProperties: {
      type: 'string',
      nullable: true,
    },
    required: ['name'],
  }),
);
null required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'null',
        },
      },
      required: ['name'],
    }, '3.1.0'))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'null',
      },
    },
  }, '3.1.0'),
);
string/null required property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: ['string', 'null'],
        },
      },
      required: ['name'],
    }, '3.1.0'))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: ['string', 'null'],
      },
    },
  }, '3.1.0'),
);
$ref property optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            properties: {
              name: {
                $ref: '#/components/schemas/MyString',
              },
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/components/schemas/MyString',
            },
          },
          ...requiredRef,
        },
      },
    },
  },
);
$ref additionalProperty optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            additionalProperties: {
              $ref: '#/components/schemas/MyString',
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          additionalProperties: {
            $ref: '#/components/schemas/MyString',
          },
          ...requiredRef,
        },
      },
    },
  },
);
nullable $ref property not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            type: 'object',
            properties: {
              name: {
                $ref: '#/components/schemas/MyString',
                nullable: true,
              },
            },
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/components/schemas/MyString',
              nullable: true,
            },
          },
        },
      },
    },
  },
);
x-nullable $ref property not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...swagger,
      definitions: {
        MyString: {
          type: 'string',
        },
        Test: {
          type: 'object',
          properties: {
            name: {
              $ref: '#/definitions/MyString',
              'x-nullable': true,
            },
          },
          required: ['name'],
        },
      },
    })),
  {
    ...swagger,
    definitions: {
      MyString: {
        type: 'string',
      },
      Test: {
        type: 'object',
        properties: {
          name: {
            $ref: '#/definitions/MyString',
            'x-nullable': true,
          },
        },
      },
    },
  },
);
$ref allOf property optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze({
      ...openapi,
      components: {
        schemas: {
          MyString: {
            type: 'string',
          },
          Test: {
            allOf: [
              {
                type: 'object',
                properties: {
                  name: {
                    $ref: '#/components/schemas/MyString',
                  },
                },
              },
            ],
            required: ['name'],
          },
        },
      },
    })),
  {
    ...openapi,
    components: {
      schemas: {
        MyString: {
          type: 'string',
        },
        Test: {
          allOf: [
            {
              type: 'object',
              properties: {
                name: {
                  $ref: '#/components/schemas/MyString',
                },
              },
            },
          ],
          ...requiredRef,
        },
      },
    },
  },
);
unconstrained object optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    ...requiredUnconstrained,
  }),
);
unconstrained properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {},
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {},
    ...requiredUnconstrained,
  }),
);
undefined properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: undefined,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: undefined,
    },
    ...requiredUnconstrained,
  }),
);
null properties optionally required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: null,
      },
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: null,
    },
    ...requiredUnconstrained,
  }),
);
nullable required allOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      allOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    allOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required allOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      allOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    allOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable and nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
non-nullable and nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable and non-nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          nullable: true,
        },
      },
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        nullable: true,
      },
    },
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
    required: ['name'],
  }),
);
nullable required anyOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required anyOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      anyOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    anyOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
  }),
);
nullable required oneOf property to not required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      oneOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    oneOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
    ],
  }),
);
some nullable required oneOf property still required
/home/kevin/src/node-projects/openapi-transformers/test/nullable-not-required.js
assert.deepStrictEqual(
  new NullableNotRequiredTransformer(options)
    .transformOpenApi(deepFreeze(schema3({
      oneOf: [
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
              nullable: true,
            },
          },
        },
        {
          type: 'object',
          properties: {
            name: {
              type: 'string',
            },
          },
        },
      ],
      required: ['name'],
    }))),
  schema3({
    oneOf: [
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
            nullable: true,
          },
        },
      },
      {
        type: 'object',
        properties: {
          name: {
            type: 'string',
          },
        },
      },
    ],
  }),
);

NullableToTypeNullTransformer

adds "null" to type: "number" with nullable: true
/home/kevin/src/node-projects/openapi-transformers/test/nullable-to-type-null.js
assert.deepStrictEqual(
  new NullableToTypeNullTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'number',
    nullable: true,
  }))),
  schema3({
    type: ['number', 'null'],
  }),
);
adds "null" to type: ["number", "string"] with nullable: true
/home/kevin/src/node-projects/openapi-transformers/test/nullable-to-type-null.js
assert.deepStrictEqual(
  new NullableToTypeNullTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['number', 'string'],
    nullable: true,
  }))),
  schema3({
    type: ['number', 'string', 'null'],
  }),
);
removes nullable: true from type: ["number", "null"]
/home/kevin/src/node-projects/openapi-transformers/test/nullable-to-type-null.js
assert.deepStrictEqual(
  new NullableToTypeNullTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['number', 'null'],
    nullable: true,
  }))),
  schema3({
    type: ['number', 'null'],
  }),
);
removes nullable: true without type
/home/kevin/src/node-projects/openapi-transformers/test/nullable-to-type-null.js
assert.deepStrictEqual(
  new NullableToTypeNullTransformer().transformOpenApi(deepFreeze(schema3({
    nullable: true,
  }))),
  schema3({}),
);
adds "null" to type: "number" with x-nullable: true
/home/kevin/src/node-projects/openapi-transformers/test/nullable-to-type-null.js
assert.deepStrictEqual(
  new NullableToTypeNullTransformer().transformOpenApi(deepFreeze(schema2({
    type: 'number',
    'x-nullable': true,
  }))),
  schema2({
    type: ['number', 'null'],
  }),
);
adds "null" to type: "number" with nullable and x-nullable: true
/home/kevin/src/node-projects/openapi-transformers/test/nullable-to-type-null.js
assert.deepStrictEqual(
  new NullableToTypeNullTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'number',
    nullable: true,
    'x-nullable': true,
  }))),
  schema3({
    type: ['number', 'null'],
  }),
);

OpenApi31To30Transformer

converts schema with numeric exclusiveMaximum/exclusiveMinimum
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    exclusiveMaximum: 24,
    exclusiveMinimum: 0,
  }, '3.1.0'))),
  schema3({
    exclusiveMaximum: true,
    maximum: 24,
    exclusiveMinimum: true,
    minimum: 0,
  }),
);
converts schema with type: "null"
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    type: 'null',
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }),
);
converts schema with const: null
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    const: null,
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }),
);
converts schema with type: "null" and const: null
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    type: 'null',
    const: null,
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }),
);
converts schema with type: ["number", "null"]
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    type: ['number', 'null'],
  }, '3.1.0'))),
  schema3({
    type: 'number',
    nullable: true,
  }),
);
converts schema with all non-null types
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    type: [
      'array',
      'boolean',
      'number',
      'object',
      'string',
    ],
  }, '3.1.0'))),
  schema3({}),
);
converts schema with all types
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    type: [
      'array',
      'boolean',
      'integer',
      'null',
      'number',
      'object',
      'string',
    ],
  }, '3.1.0'))),
  schema3({
    nullable: true,
  }),
);
converts schema with patternProperties
/home/kevin/src/node-projects/openapi-transformers/test/openapi31to30.js
assert.deepStrictEqual(
  new OpenApi31To30Transformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    patternProperties: {
      'test.*': { type: 'string' },
    },
  }, '3.1.0'))),
  schema3({
    type: 'object',
    additionalProperties: { type: 'string' },
  }),
);

PathParametersToOperationTransformer

openapi 3 path to operation parameters
/home/kevin/src/node-projects/openapi-transformers/test/path-parameters-to-operations.js
assert.deepStrictEqual(
  new PathParametersToOperationTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/': {
        parameters: [
          {
            in: 'query',
            name: 'myquery',
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        head: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/': {
        get: {
          parameters: [
            {
              in: 'query',
              name: 'myquery',
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        head: {
          parameters: [
            {
              in: 'query',
              name: 'myquery',
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
openapi 3 path prepend to operation parameters
/home/kevin/src/node-projects/openapi-transformers/test/path-parameters-to-operations.js
assert.deepStrictEqual(
  new PathParametersToOperationTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/': {
        parameters: [
          {
            in: 'query',
            name: 'myquery',
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          parameters: [
            {
              in: 'query',
              name: 'myquery2',
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        head: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/': {
        get: {
          parameters: [
            {
              in: 'query',
              name: 'myquery',
              schema: {
                type: 'string',
              },
            },
            {
              in: 'query',
              name: 'myquery2',
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        head: {
          parameters: [
            {
              in: 'query',
              name: 'myquery',
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
swagger 2 path to operation parameters
/home/kevin/src/node-projects/openapi-transformers/test/path-parameters-to-operations.js
assert.deepStrictEqual(
  new PathParametersToOperationTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/': {
        parameters: [
          {
            in: 'query',
            name: 'myquery',
            type: 'string',
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        head: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/': {
        get: {
          parameters: [
            {
              in: 'query',
              name: 'myquery',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        head: {
          parameters: [
            {
              in: 'query',
              name: 'myquery',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

PatternPropertiesToAdditionalPropertiesTransformer

removes empty patternProperties
/home/kevin/src/node-projects/openapi-transformers/test/pattern-properties-to-additional-properties.js
const transformer =
  new PatternPropertiesToAdditionalPropertiesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    patternProperties: {},
  }, '3.1.0'))),
  schema3({
    type: 'object',
  }, '3.1.0'),
);
converts single patternProperties to additionalProperties
/home/kevin/src/node-projects/openapi-transformers/test/pattern-properties-to-additional-properties.js
const transformer =
  new PatternPropertiesToAdditionalPropertiesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    patternProperties: {
      '^value[0-9]+$': {
        type: 'string',
      },
    },
  }, '3.1.0'))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
  }, '3.1.0'),
);
combines multiple patternProperties with anyOf
/home/kevin/src/node-projects/openapi-transformers/test/pattern-properties-to-additional-properties.js
const transformer =
  new PatternPropertiesToAdditionalPropertiesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    patternProperties: {
      '^string[0-9]+$': {
        type: 'string',
      },
      '^number[0-9]+$': {
        type: 'number',
      },
      '^bool[0-9]+$': {
        type: 'boolean',
      },
    },
  }, '3.1.0'))),
  schema3({
    type: 'object',
    additionalProperties: {
      anyOf: [
        { type: 'string' },
        { type: 'number' },
        { type: 'boolean' },
      ],
    },
  }, '3.1.0'),
);
combines anyOf patternProperties with additionalProperties
/home/kevin/src/node-projects/openapi-transformers/test/pattern-properties-to-additional-properties.js
const transformer =
  new PatternPropertiesToAdditionalPropertiesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    patternProperties: {
      '^string[0-9]+$': {
        type: 'string',
      },
      '^number[0-9]+$': {
        type: 'number',
      },
      '^bool[0-9]+$': {
        type: 'boolean',
      },
    },
    additionalProperties: {
      type: 'object',
    },
  }, '3.1.0'))),
  schema3({
    type: 'object',
    additionalProperties: {
      anyOf: [
        { type: 'string' },
        { type: 'number' },
        { type: 'boolean' },
        { type: 'object' },
      ],
    },
  }, '3.1.0'),
);
combines duplicate patternProperties with additionalProperties
/home/kevin/src/node-projects/openapi-transformers/test/pattern-properties-to-additional-properties.js
const transformer =
  new PatternPropertiesToAdditionalPropertiesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    patternProperties: {
      '^shortName[0-9]+$': {
        type: 'string',
      },
      '^longName[0-9]+$': {
        type: 'string',
      },
    },
    additionalProperties: {
      type: 'string',
    },
  }, '3.1.0'))),
  schema3({
    type: 'object',
    additionalProperties: {
      type: 'string',
    },
  }, '3.1.0'),
);

QueriesToXMsPathsTransformer

moves paths with query to x-ms-paths in openapi 3
/home/kevin/src/node-projects/openapi-transformers/test/queries-to-x-ms-paths.js
assert.deepStrictEqual(
  new QueriesToXMsPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/a?foo=bar': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
    'x-ms-paths': {
      '/a?foo=bar': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
does not create x-ms-paths if none have queries
/home/kevin/src/node-projects/openapi-transformers/test/queries-to-x-ms-paths.js
assert.deepStrictEqual(
  new QueriesToXMsPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
leaves empty paths after moving
/home/kevin/src/node-projects/openapi-transformers/test/queries-to-x-ms-paths.js
assert.deepStrictEqual(
  new QueriesToXMsPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?foo=bar': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {},
    'x-ms-paths': {
      '/a?foo=bar': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
moves paths with query to x-ms-paths in swagger 2
/home/kevin/src/node-projects/openapi-transformers/test/queries-to-x-ms-paths.js
assert.deepStrictEqual(
  new QueriesToXMsPathsTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/a?foo=bar': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
    'x-ms-paths': {
      '/a?foo=bar': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

ReadOnlyNotRequiredTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
assert.throws(
  () => new ReadOnlyNotRequiredTransformer(null),
  TypeError,
);
throws TypeError with number options.removeValidation
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
assert.throws(
  () => new ReadOnlyNotRequiredTransformer({ removeValidation: 1 }),
  TypeError,
);
throws TypeError with number options.setNonNullable
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
assert.throws(
  () => new ReadOnlyNotRequiredTransformer({ setNonNullable: 1 }),
  TypeError,
);
make readOnly properties not-required
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
const transformer = new ReadOnlyNotRequiredTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
      },
    },
    required: ['name'],
  }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
      },
    },
  }),
);
doesn't remove validation of readOnly properties by default
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
const transformer = new ReadOnlyNotRequiredTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
        minLength: 1,
      },
    },
    required: ['name'],
  }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
        minLength: 1,
      },
    },
  }),
);
options.removeValidation to remove validation of readOnly props
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
const transformer = new ReadOnlyNotRequiredTransformer({
  removeValidation: true,
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
        minLength: 1,
      },
    },
    required: ['name'],
  }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
      },
    },
  }),
);
options.setNonNullable to add x-nullable: false to readOnly
/home/kevin/src/node-projects/openapi-transformers/test/read-only-not-required.js
const transformer = new ReadOnlyNotRequiredTransformer({
  setNonNullable: true,
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
      },
    },
    required: ['name'],
  }))),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        readOnly: true,
        'x-nullable': false,
      },
    },
  }),
);

RefPathParametersTransformer

openapi 3 path item parameters to components
/home/kevin/src/node-projects/openapi-transformers/test/ref-path-parameters.js
assert.deepStrictEqual(
  new RefPathParametersTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/': {
        parameters: [
          {
            in: 'query',
            name: 'myquery',
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      parameters: {
        myquery: {
          in: 'query',
          name: 'myquery',
          schema: {
            type: 'string',
          },
        },
      },
    },
    paths: {
      '/': {
        parameters: [
          { $ref: '#/components/parameters/myquery' },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
swagger 2 path item parameters to components
/home/kevin/src/node-projects/openapi-transformers/test/ref-path-parameters.js
assert.deepStrictEqual(
  new RefPathParametersTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/': {
        parameters: [
          {
            in: 'query',
            name: 'myquery',
            type: 'string',
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    parameters: {
      myquery: {
        in: 'query',
        name: 'myquery',
        type: 'string',
      },
    },
    paths: {
      '/': {
        parameters: [
          { $ref: '#/parameters/myquery' },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

RemoveDefaultOnlyResponseProducesTransformer

removes non-JSON produces from default response
/home/kevin/src/node-projects/openapi-transformers/test/remove-default-only-response-produces.js
const transformer = new RemoveDefaultOnlyResponseProducesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(get2({
    produces: [
      'text/plain',
    ],
    responses: {
      default: {
        description: 'Example response',
        schema: {
          type: 'file',
        },
      },
    },
  }))),
  get2({
    produces: [],
    responses: {
      default: {
        description: 'Example response',
        schema: {
          type: 'file',
        },
      },
    },
  }),
);
does not remove non-JSON produces from 200 response
/home/kevin/src/node-projects/openapi-transformers/test/remove-default-only-response-produces.js
const transformer = new RemoveDefaultOnlyResponseProducesTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(get2({
    produces: [
      'text/plain',
    ],
    responses: {
      200: {
        description: 'Example response',
        schema: {
          type: 'file',
        },
      },
    },
  }))),
  get2({
    produces: [
      'text/plain',
    ],
    responses: {
      200: {
        description: 'Example response',
        schema: {
          type: 'file',
        },
      },
    },
  }),
);

RemovePathsWithServersTransformer

removes path items with servers
/home/kevin/src/node-projects/openapi-transformers/test/remove-paths-with-servers.js
assert.deepStrictEqual(
  new RemovePathsWithServersTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        servers: [
          { url: 'https://example.com' },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/b': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/b': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes path items with empty servers
/home/kevin/src/node-projects/openapi-transformers/test/remove-paths-with-servers.js
assert.deepStrictEqual(
  new RemovePathsWithServersTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      { url: 'https://example.com' },
    ],
    paths: {
      '/a': {
        servers: [],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/b': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    servers: [
      { url: 'https://example.com' },
    ],
    paths: {
      '/b': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

RemoveQueryFromPathsTransformer

removes empty query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a?': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
changes path parameter in path item to query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?b={b}': {
        parameters: [
          {
            name: 'b',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
changes path parameter in operation to query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?b={b}': {
        get: {
          parameters: [
            {
              name: 'b',
              in: 'path',
              required: true,
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        get: {
          parameters: [
            {
              name: 'b',
              in: 'query',
              required: true,
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
renames path parameter in path item to query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?b={c}': {
        parameters: [
          {
            name: 'c',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
does not duplicate or change existing query param
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?b={c}': {
        parameters: [
          {
            name: 'c',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'number',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'number',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
adds constant parameter for constant query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a?b=c': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              const: 'c',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
adds constant parameter for constant query (3.0)
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?b=c': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              enum: ['c'],
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
adds constant parameter for constant query (2.0)
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/a?b=c': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            type: 'string',
            enum: ['c'],
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
adds constant parameter for empty constant value
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a?b': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              const: '',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
adds constant parameter for empty constant name
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a?=c': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a': {
        parameters: [
          {
            name: '',
            in: 'query',
            required: true,
            schema: {
              const: 'c',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
adds constant parameter for empty constant name and value
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a?=': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a': {
        parameters: [
          {
            name: '',
            in: 'query',
            required: true,
            schema: {
              const: '',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
does not overwrite existing parameters with constant
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a?b=c': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'number',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    openapi: '3.1.0',
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'number',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
renames path parameter in path item to multiple queries
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a?b={c}&d={c}': {
        parameters: [
          {
            name: 'c',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'string',
            },
          },
          {
            name: 'd',
            in: 'query',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
does not rename path parameter not in query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/{a}?b={c}': {
        parameters: [
          {
            name: 'a',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
          {
            name: 'c',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/{a}': {
        parameters: [
          {
            name: 'a',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
duplicates parameter in path and query
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/{a}?b={a}': {
        parameters: [
          {
            name: 'a',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/{a}': {
        parameters: [
          {
            name: 'a',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
          {
            name: 'b',
            in: 'query',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
combines path items without overlap
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        delete: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/a?': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        delete: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
combines path items with source params
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        delete: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/a?b={c}': {
        parameters: [
          {
            name: 'c',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        delete: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        get: {
          parameters: [
            {
              name: 'b',
              in: 'query',
              required: true,
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
combines path items with dest path params
/home/kevin/src/node-projects/openapi-transformers/test/remove-query-from-paths.js
assert.deepStrictEqual(
  new RemoveQueryFromPathsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/a': {
        parameters: [
          {
            name: 'd',
            in: 'cookie',
            schema: {
              type: 'string',
            },
          },
        ],
        delete: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
      '/a?b={c}': {
        parameters: [
          {
            name: 'c',
            in: 'path',
            required: true,
            schema: {
              type: 'string',
            },
          },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/a': {
        delete: {
          parameters: [
            {
              name: 'd',
              in: 'cookie',
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        get: {
          parameters: [
            {
              name: 'b',
              in: 'query',
              required: true,
              schema: {
                type: 'string',
              },
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

RemoveRefSiblingsTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
assert.throws(
  () => new RemoveRefSiblingsTransformer(null),
  TypeError,
);
throws TypeError with number options.remove
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
assert.throws(
  () => new RemoveRefSiblingsTransformer({ remove: 1 }),
  TypeError,
);
throws TypeError with number options.retain
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
assert.throws(
  () => new RemoveRefSiblingsTransformer({ retain: 1 }),
  TypeError,
);
throws Error with options.remove and options.retain
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
assert.throws(
  () => new RemoveRefSiblingsTransformer({
    remove: [],
    retain: [],
  }),
  Error,
);
removes all $ref siblings by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }))),
  schema3({
    $ref: '#/components/schemas/Test',
  }),
);
does not remove non-$ref properties
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'number',
  }))),
  schema3({
    type: 'number',
  }),
);
does not throw for null schema
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer();
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3(null))),
  schema3(null),
);
removes only siblings in options.remove Array
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer({
  remove: ['required'],
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }))),
  schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
  }),
);
removes siblings not in options.retain Array
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer({
  retain: ['required'],
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }))),
  schema3({
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }),
);
removes only siblings where options.remove()
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer({
  remove: (propName) => propName === 'required',
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }))),
  schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
  }),
);
removes siblings not where options.retain()
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer({
  retain: (propName) => propName === 'required',
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    title: 'Test',
    description: 'Test',
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }))),
  schema3({
    $ref: '#/components/schemas/Test',
    required: ['name'],
  }),
);
does not pass "$ref" to options.remove
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer({
  remove: (propName) => {
    assert.notStrictEqual(propName, '$ref');
    return false;
  },
});
transformer.transformOpenApi(deepFreeze(schema3({
  title: 'Test',
  description: 'Test',
  $ref: '#/components/schemas/Test',
  required: ['name'],
})));
does not pass "$ref" to options.retain
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
const transformer = new RemoveRefSiblingsTransformer({
  retain: (propName) => {
    assert.notStrictEqual(propName, '$ref');
    return false;
  },
});
transformer.transformOpenApi(deepFreeze(schema3({
  title: 'Test',
  description: 'Test',
  $ref: '#/components/schemas/Test',
  required: ['name'],
})));
preserves property order
/home/kevin/src/node-projects/openapi-transformers/test/remove-ref-siblings.js
// eslint-disable-next-line unicorn/consistent-function-scoping
function retain(propName) {
  return propName !== 'required';
}
const transformer = new RemoveRefSiblingsTransformer({ retain });
const origSchema = {
  title: 'Test',
  description: 'Test',
  $ref: '#/components/schemas/Test',
  required: ['name'],
};
const openapi =
  transformer.transformOpenApi(deepFreeze(schema3(origSchema)));
const newSchema = openapi.components.schemas.Test;
assert.deepStrictEqual(
  Object.keys(origSchema).filter(retain),
  Object.keys(newSchema),
);

RemoveRequestBodyTransformer

removes requestBody from get in path by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from get in components by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);
removes body parameters from get by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes formData parameters from get by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from head in path by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from head in components by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);
removes body parameters from head by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes formData parameters from head by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from trace in path by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from trace in components by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);
removes body parameters from trace by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes formData parameters from trace by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from GET in path by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from GET in components by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);
removes body parameters from GET by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes formData parameters from GET by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from HEAD in path by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from HEAD in components by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);
removes body parameters from HEAD by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes formData parameters from HEAD by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from TRACE in path by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        [method]: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes requestBody from TRACE in components by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      pathItems: {
        Example: {
          [method]: {
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
          post: {
            requestBody: {
              content: {
                'application/json': {
                  schema: {
                    type: 'object',
                  },
                },
              },
            },
            responses: {
              204: {
                description: 'Example response',
              },
            },
          },
        },
      },
    },
    paths: {},
  },
);
removes body parameters from TRACE by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'body',
              schema: {
                type: 'object',
              },
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
removes formData parameters from TRACE by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    paths: {
      '/test': {
        [method]: {
          parameters: [
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        post: {
          parameters: [
            {
              name: 'test',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'test2',
              in: 'query',
              type: 'string',
            },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
does not remove requestBody from delete by default
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        delete: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        delete: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
throws TypeError for non-Iterable constructor argument
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.throws(
  () => new RemoveRequestBodyTransformer(1),
  TypeError,
);
removes only methods passed to constructor
/home/kevin/src/node-projects/openapi-transformers/test/remove-request-body.js
assert.deepStrictEqual(
  new RemoveRequestBodyTransformer(['delete']).transformOpenApi(deepFreeze({
    ...openapi,
    paths: {
      '/test': {
        delete: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        get: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    paths: {
      '/test': {
        delete: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
        get: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                },
              },
            },
          },
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

RemoveResponseHeadersTransformer

removes headers from components/responses
/home/kevin/src/node-projects/openapi-transformers/test/remove-response-headers.js
assert.deepStrictEqual(
  new RemoveResponseHeadersTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      responses: {
        myresponse: {
          description: 'Example response',
          headers: {
            'X-Foo': {
              type: 'string',
              pattern: '^foo',
            },
          },
        },
      },
    },
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              $ref: '#/components/responses/myresponse',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      responses: {
        myresponse: {
          description: 'Example response',
        },
      },
    },
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              $ref: '#/components/responses/myresponse',
            },
          },
        },
      },
    },
  },
);
does not remove components/headers
/home/kevin/src/node-projects/openapi-transformers/test/remove-response-headers.js
assert.deepStrictEqual(
  new RemoveResponseHeadersTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      headers: {
        myheader: {
          type: 'string',
          pattern: '^foo',
        },
      },
      responses: {
        myresponse: {
          description: 'Example response',
          headers: {
            'X-Foo': {
              $ref: '#/components/headers/myheader',
            },
          },
        },
      },
    },
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              $ref: '#/components/responses/myresponse',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      headers: {
        myheader: {
          type: 'string',
          pattern: '^foo',
        },
      },
      responses: {
        myresponse: {
          description: 'Example response',
        },
      },
    },
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              $ref: '#/components/responses/myresponse',
            },
          },
        },
      },
    },
  },
);
removes headers from openapi 3 paths/responses
/home/kevin/src/node-projects/openapi-transformers/test/remove-response-headers.js
assert.deepStrictEqual(
  new RemoveResponseHeadersTransformer().transformOpenApi(deepFreeze(get3({
    responses: {
      204: {
        description: 'Example response',
        headers: {
          'X-Foo': {
            type: 'string',
            pattern: '^foo',
          },
        },
      },
    },
  }))),
  get3({
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
removes headers from swagger 2 paths/responses
/home/kevin/src/node-projects/openapi-transformers/test/remove-response-headers.js
assert.deepStrictEqual(
  new RemoveResponseHeadersTransformer().transformOpenApi(deepFreeze(get2({
    responses: {
      204: {
        description: 'Example response',
        headers: {
          'X-Foo': {
            type: 'string',
            pattern: '^foo',
          },
        },
      },
    },
  }))),
  get2({
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);

RemoveSecuritySchemeIfTransformer

throws TypeError without constructor argument
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
assert.throws(
  () => new RemoveSecuritySchemeIfTransformer(),
  TypeError,
);
throws TypeError with non-function constructor argument
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
assert.throws(
  () => new RemoveSecuritySchemeIfTransformer(true),
  TypeError,
);

with OpenAPI 3

removes only scheme from securitySchemes
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: { myScheme },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {},
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 1);
removes one scheme from securitySchemes
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
const otherScheme = { type: 'apiKey', name: 'test2', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: {
        myScheme,
        otherScheme,
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      securitySchemes: {
        otherScheme,
      },
    },
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 2);
removes requirement on root for removed scheme
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: {
        myScheme,
      },
    },
    security: [
      { myScheme: [] },
    ],
    paths: {},
  })),
  {
    ...openapi,
    components: {},
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 1);
removes requirement on operation for removed scheme
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: {
        myScheme,
      },
    },
    paths: {
      '/': {
        get: {
          operationId: 'getRoot',
          security: [
            { myScheme: [] },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {},
    paths: {
      '/': {
        get: {
          operationId: 'getRoot',
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
assert.strictEqual(predicateCallCount, 1);
removes requirement on root for removed scheme not other
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
const otherScheme = { type: 'apiKey', name: 'test2', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: {
        myScheme,
        otherScheme,
      },
    },
    security: [
      { myScheme: [] },
      { otherScheme: [] },
    ],
    paths: {},
  })),
  {
    ...openapi,
    components: {
      securitySchemes: {
        otherScheme,
      },
    },
    security: [
      { otherScheme: [] },
    ],
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 2);
removes requirement on root for removed scheme with other
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
const otherScheme = { type: 'apiKey', name: 'test2', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: {
        myScheme,
        otherScheme,
      },
    },
    security: [
      {
        myScheme: [],
        otherScheme: [],
      },
    ],
    paths: {},
  })),
  {
    ...openapi,
    components: {
      securitySchemes: {
        otherScheme,
      },
    },
    security: [
      { otherScheme: [] },
    ],
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 2);
does not remove previously empty requirement
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      securitySchemes: {
        myScheme,
      },
    },
    security: [
      { myScheme: [] },
      {},
    ],
    paths: {},
  })),
  {
    ...openapi,
    components: {},
    security: [
      {},
    ],
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 1);

with OpenAPI 2

removes only scheme from securityDefinitions
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
    },
    paths: {},
  })),
  {
    ...swagger,
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 1);
removes one scheme from securityDefinitions
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
const otherScheme = { type: 'apiKey', name: 'test2', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
      otherScheme,
    },
    paths: {},
  })),
  {
    ...swagger,
    securityDefinitions: {
      otherScheme,
    },
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 2);
removes requirement on root for removed scheme
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
    },
    security: [
      { myScheme: [] },
    ],
    paths: {},
  })),
  {
    ...swagger,
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 1);
removes requirement on operation for removed scheme
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
    },
    paths: {
      '/': {
        get: {
          operationId: 'getRoot',
          security: [
            { myScheme: [] },
          ],
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  get2({
    operationId: 'getRoot',
    responses: {
      204: {
        description: 'Example response',
      },
    },
  }),
);
assert.strictEqual(predicateCallCount, 1);
removes requirement on root for removed scheme not other
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
const otherScheme = { type: 'apiKey', name: 'test2', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
      otherScheme,
    },
    security: [
      { myScheme: [] },
      { otherScheme: [] },
    ],
    paths: {},
  })),
  {
    ...swagger,
    securityDefinitions: {
      otherScheme,
    },
    security: [
      { otherScheme: [] },
    ],
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 2);
removes requirement on root for removed scheme with other
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
const otherScheme = { type: 'apiKey', name: 'test2', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
      otherScheme,
    },
    security: [
      {
        myScheme: [],
        otherScheme: [],
      },
    ],
    paths: {},
  })),
  {
    ...swagger,
    securityDefinitions: {
      otherScheme,
    },
    security: [
      { otherScheme: [] },
    ],
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 2);
does not remove previously empty requirement
/home/kevin/src/node-projects/openapi-transformers/test/remove-security-scheme-if.js
const myScheme = { type: 'apiKey', name: 'test', in: 'query' };
let predicateCallCount = 0;
assert.deepStrictEqual(
  new RemoveSecuritySchemeIfTransformer((securityScheme) => {
    predicateCallCount += 1;
    return securityScheme === myScheme;
  }).transformOpenApi(deepFreeze({
    ...swagger,
    securityDefinitions: {
      myScheme,
    },
    security: [
      { myScheme: [] },
      {},
    ],
    paths: {},
  })),
  {
    ...swagger,
    security: [
      {},
    ],
    paths: {},
  },
);
assert.strictEqual(predicateCallCount, 1);

RemoveTypeIfTransformer

throws TypeError without predicate
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
assert.throws(
  () => new RemoveTypeIfTransformer(),
  TypeError,
);
throws TypeError with non-function predicate
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
assert.throws(
  () => new RemoveTypeIfTransformer({}),
  TypeError,
);
removes type where predicate(type) is true
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
// eslint-disable-next-line no-use-before-define
const transformer = new RemoveTypeIfTransformer(predicate);
const type1 = ['boolean'];
const type2 = 'number';
let callCount = 0;
function predicate(type) {
  callCount += 1;
  assert.strictEqual(this, transformer);
  assert.ok(type === type1 || type === type2);
  return type === type1;
}
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        Example1: {
          type: type1,
        },
        Example2: {
          type: type2,
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      schemas: {
        Example1: {},
        Example2: {
          type: type2,
        },
      },
    },
    paths: {},
  },
);
assert.strictEqual(callCount, 2);
removes type where predicate(type) is truthy
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
// eslint-disable-next-line no-use-before-define
const transformer = new RemoveTypeIfTransformer(predicate);
const type1 = ['boolean'];
const type2 = 'number';
let callCount = 0;
function predicate(type) {
  callCount += 1;
  assert.strictEqual(this, transformer);
  assert.ok(type === type1 || type === type2);
  return type === type1 ? 1 : 0;
}
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        Example1: {
          type: type1,
        },
        Example2: {
          type: type2,
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      schemas: {
        Example1: {},
        Example2: {
          type: type2,
        },
      },
    },
    paths: {},
  },
);
assert.strictEqual(callCount, 2);
does not call predicate with undefined
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
assert.deepStrictEqual(
  new RemoveTypeIfTransformer(assert.fail).transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        Example1: {},
        Example2: {
          type: undefined,
        },
      },
    },
    paths: {},
  })),
  {
    ...openapi,
    components: {
      schemas: {
        Example1: {},
        Example2: {
          type: undefined,
        },
      },
    },
    paths: {},
  },
);

validatesAllNonNullTypes

removes type with all 5 non-null/integer types
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
const transformer = new RemoveTypeIfTransformer(allNonNullTypes);
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: ['array', 'boolean', 'number', 'object', 'string'],
  }, '3.1.0'))),
  schema3({}, '3.1.0'),
);
removes type with all 7 types
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
const transformer = new RemoveTypeIfTransformer(allNonNullTypes);
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: [
      'array',
      'boolean',
      'integer',
      'null',
      'number',
      'object',
      'string',
    ],
  }, '3.1.0'))),
  schema3({}, '3.1.0'),
);
does not remove single type
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
const transformer = new RemoveTypeIfTransformer(allNonNullTypes);
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: 'boolean',
  }, '3.1.0'))),
  schema3({
    type: 'boolean',
  }, '3.1.0'),
);
does not remove type missing array
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
const transformer = new RemoveTypeIfTransformer(allNonNullTypes);
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: [
      'boolean',
      'integer',
      'null',
      'number',
      'object',
      'string',
    ],
  }, '3.1.0'))),
  schema3({
    type: [
      'boolean',
      'integer',
      'null',
      'number',
      'object',
      'string',
    ],
  }, '3.1.0'),
);
removes type with 7 + duplicate types
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
const transformer = new RemoveTypeIfTransformer(allNonNullTypes);
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: [
      'array',
      'boolean',
      'integer',
      'null',
      'number',
      'object',
      'string',
      'array',
      'number',
    ],
  }, '3.1.0'))),
  schema3({}, '3.1.0'),
);
does not remove type with duplicates missing number
/home/kevin/src/node-projects/openapi-transformers/test/remove-type-if.js
const transformer = new RemoveTypeIfTransformer(allNonNullTypes);
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(schema3({
    type: [
      'array',
      'boolean',
      'integer',
      'null',
      'object',
      'string',
      'integer',
    ],
  }, '3.1.0'))),
  schema3({
    type: [
      'array',
      'boolean',
      'integer',
      'null',
      'object',
      'string',
      'integer',
    ],
  }, '3.1.0'),
);

RenameComponentsTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
assert.throws(
  () => new RenameComponentsTransformer(null),
  TypeError,
);
throws TypeError with number options
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
assert.throws(
  () => new RenameComponentsTransformer(1),
  TypeError,
);
throws TypeError with number options.schemas
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
assert.throws(
  () => new RenameComponentsTransformer({ schemas: 1 }),
  TypeError,
);
rename with options.schemas function openapi 3
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'ResponseType' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        ResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/ResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        NewResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/NewResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
preserves properties on JSON Reference
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'ResponseType' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        ResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  prop1: 'foo',
                  $ref: '#/components/schemas/RequestType',
                  prop2: 'bar',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    prop3: 'baz',
                    $ref: '#/components/schemas/ResponseType',
                    prop4: 'quux',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        NewResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  prop1: 'foo',
                  $ref: '#/components/schemas/RequestType',
                  prop2: 'bar',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    prop3: 'baz',
                    $ref: '#/components/schemas/NewResponseType',
                    prop4: 'quux',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
does not throw for unresolvable URI in $ref
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'ResponseType' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        ResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/RequestType2',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/ResponseType2',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        NewResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/RequestType2',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/ResponseType2',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
ignores invalid URI in $ref
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'ResponseType' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze(post3({
    responses: {
      default: {
        description: 'Example response',
        content: {
          'application/json': {
            schema: {
              $ref: '##',
            },
          },
        },
      },
    },
  }))),
  post3({
    responses: {
      default: {
        description: 'Example response',
        content: {
          'application/json': {
            schema: {
              $ref: '##',
            },
          },
        },
      },
    },
  }),
);
does not modify remote URI in $ref openapi 3
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'ResponseType' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        ResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: 'remote.json#/components/schemas/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: 'remote.json#/components/schemas/ResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        NewResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: 'remote.json#/components/schemas/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: 'remote.json#/components/schemas/ResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
rename encoded with options.schemas function openapi 3
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'Response~Type#2' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        'Response~Type#2': {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/Response~0Type%232',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      schemas: {
        RequestType: {
          type: 'object',
        },
        'NewResponse~Type#2': {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/NewResponse~0Type%232',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
rename options.schemas handles child schemas correctly
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => `New${name}2`,
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      schemas: {
        ResponseType: {
          type: 'object',
          properties: {
            request: {
              type: 'object',
            },
          },
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref:
                    '#/components/schemas/ResponseType/properties/request',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/ResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      schemas: {
        NewResponseType2: {
          type: 'object',
          properties: {
            request: {
              type: 'object',
            },
          },
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/components/schemas/NewResponseType2'
                    + '/properties/request',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/schemas/NewResponseType2',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
options.schemas does not rename outside components.schemas
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => `New${name}`,
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    'x-stuff': {
      RequestType: {
        type: 'object',
      },
    },
    components: {
      myschemas: {
        ResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/x-stuff/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/myschemas/ResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    'x-stuff': {
      RequestType: {
        type: 'object',
      },
    },
    components: {
      myschemas: {
        ResponseType: {
          type: 'object',
        },
      },
    },
    paths: {
      '/': {
        post: {
          requestBody: {
            content: {
              'application/json': {
                schema: {
                  $ref: '#/x-stuff/RequestType',
                },
              },
            },
          },
          responses: {
            default: {
              description: 'Example response',
              content: {
                'application/json': {
                  schema: {
                    $ref: '#/components/myschemas/ResponseType',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
rename with options.schemas function swagger 2
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => (name === 'ResponseType' ? `New${name}` : name),
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...swagger,
    definitions: {
      RequestType: {
        type: 'object',
      },
      ResponseType: {
        type: 'object',
      },
    },
    paths: {
      '/': {
        post: {
          parameters: [
            {
              in: 'body',
              name: 'body',
              schema: {
                $ref: '#/definitions/RequestType',
              },
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                $ref: '#/definitions/ResponseType',
              },
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    definitions: {
      RequestType: {
        type: 'object',
      },
      NewResponseType: {
        type: 'object',
      },
    },
    paths: {
      '/': {
        post: {
          parameters: [
            {
              in: 'body',
              name: 'body',
              schema: {
                $ref: '#/definitions/RequestType',
              },
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                $ref: '#/definitions/NewResponseType',
              },
            },
          },
        },
      },
    },
  },
);
rename with options.schemas doesn't affect responses
/home/kevin/src/node-projects/openapi-transformers/test/rename-components.js
const transformer = new RenameComponentsTransformer({
  schemas: (name) => 'renamed',
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    components: {
      responses: {
        myresponse: {
          description: 'Example response',
        },
      },
    },
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              $ref: '#/components/responses/myresponse',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    components: {
      responses: {
        myresponse: {
          description: 'Example response',
        },
      },
    },
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              $ref: '#/components/responses/myresponse',
            },
          },
        },
      },
    },
  },
);

ReplacedByToDescriptionTransformer

x-deprecated.replaced-by to description for openapi 3 schema
/home/kevin/src/node-projects/openapi-transformers/test/replaced-by-to-description.js
assert.deepStrictEqual(
  new ReplacedByToDescriptionTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'object',
      'x-deprecated': {
        'replaced-by': 'Example2',
      },
    }),
  )),
  schema3({
    type: 'object',
    'x-deprecated': {
      description: 'Use Example2 instead.',
      'replaced-by': 'Example2',
    },
  }),
);
does not change existing x-deprecated.description
/home/kevin/src/node-projects/openapi-transformers/test/replaced-by-to-description.js
assert.deepStrictEqual(
  new ReplacedByToDescriptionTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'object',
      'x-deprecated': {
        description: 'Use something else.  Anything.',
        'replaced-by': 'Example2',
      },
    }),
  )),
  schema3({
    type: 'object',
    'x-deprecated': {
      description: 'Use something else.  Anything.',
      'replaced-by': 'Example2',
    },
  }),
);
x-deprecated.replaced-by to description for openapi 3 property
/home/kevin/src/node-projects/openapi-transformers/test/replaced-by-to-description.js
assert.deepStrictEqual(
  new ReplacedByToDescriptionTransformer().transformOpenApi(deepFreeze(
    schema3({
      type: 'object',
      properties: {
        name: {
          type: 'string',
          'x-deprecated': {
            'replaced-by': 'name2',
          },
        },
      },
    }),
  )),
  schema3({
    type: 'object',
    properties: {
      name: {
        type: 'string',
        'x-deprecated': {
          description: 'Use name2 instead.',
          'replaced-by': 'name2',
        },
      },
    },
  }),
);

ServerVarsToPathParamsTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-path-params.js
assert.throws(
  () => new ServerVarsToPathParamsTransformer(null),
  TypeError,
);
throws TypeError with non-Array options.omitDefault
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-path-params.js
assert.throws(
  () => new ServerVarsToPathParamsTransformer({ omitDefault: {} }),
  TypeError,
);
server variables in path part to path parameters
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-path-params.js
assert.deepStrictEqual(
  new ServerVarsToPathParamsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: 'https://example.com/{foo}',
        variables: {
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    ],
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    servers: [
      {
        url: 'https://example.com',
      },
    ],
    components: {
      parameters: {
        foo: {
          in: 'path',
          name: 'foo',
          required: true,
          schema: {
            type: 'string',
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    },
    paths: {
      '/{foo}/': {
        parameters: [
          { $ref: '#/components/parameters/foo' },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
omits default for names in options.omitDefault
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-path-params.js
const transformer =
  new ServerVarsToPathParamsTransformer({ omitDefault: ['foo'] });
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: 'https://example.com/{foo}',
        variables: {
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    ],
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    servers: [
      {
        url: 'https://example.com',
      },
    ],
    components: {
      parameters: {
        foo: {
          in: 'path',
          name: 'foo',
          required: true,
          schema: {
            type: 'string',
            enum: ['bar', 'baz'],
          },
        },
      },
    },
    paths: {
      '/{foo}/': {
        parameters: [
          { $ref: '#/components/parameters/foo' },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);
does not move server variables in host part
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-path-params.js
assert.deepStrictEqual(
  new ServerVarsToPathParamsTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: 'https://example.{domain}/{foo}',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    ],
    paths: {
      '/': {
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  })),
  {
    ...openapi,
    servers: [
      {
        url: 'https://example.{domain}',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
        },
      },
    ],
    components: {
      parameters: {
        foo: {
          in: 'path',
          name: 'foo',
          required: true,
          schema: {
            type: 'string',
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    },
    paths: {
      '/{foo}/': {
        parameters: [
          { $ref: '#/components/parameters/foo' },
        ],
        get: {
          responses: {
            204: {
              description: 'Example response',
            },
          },
        },
      },
    },
  },
);

ServerVarsToParamHostTransformer

throws TypeError with null options
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.throws(
  () => new ServerVarsToParamHostTransformer(null),
  TypeError,
);
throws TypeError with non-Array options.omitDefault
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.throws(
  () => new ServerVarsToParamHostTransformer({ omitDefault: {} }),
  TypeError,
);
throws TypeError with non-object options.parameter
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.throws(
  () => new ServerVarsToParamHostTransformer({ parameter: 1 }),
  TypeError,
);
throws TypeError with non-object options.xMsParameterizedHost
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.throws(
  () => new ServerVarsToParamHostTransformer({ xMsParameterizedHost: 1 }),
  TypeError,
);
server variables in host part to x-ms-parameterized-host
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.deepStrictEqual(
  new ServerVarsToParamHostTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: 'https://example.{domain}/foo',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
        },
      },
    ],
    paths: {},
  })),
  {
    ...openapi,
    servers: [
      {
        url: 'https://example.{domain}/foo',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
        },
      },
    ],
    'x-ms-parameterized-host': {
      hostTemplate: 'example.{domain}',
      useSchemePrefix: true,
      parameters: [
        {
          in: 'path',
          name: 'domain',
          required: true,
          type: 'string',
          enum: ['com', 'org'],
          default: 'org',
        },
      ],
    },
    paths: {},
  },
);
does not create x-ms-parameterized-host if no host vars
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.deepStrictEqual(
  new ServerVarsToParamHostTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: 'https://example.com/{foo}',
        variables: {
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    ],
    paths: {},
  })),
  {
    ...openapi,
    servers: [
      {
        url: 'https://example.com/{foo}',
        variables: {
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
        },
      },
    ],
    paths: {},
  },
);
server variables in scheme part to x-ms-parameterized-host
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.deepStrictEqual(
  new ServerVarsToParamHostTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: '{scheme}://example.{domain}/foo',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
          scheme: {
            enum: ['https', 'http'],
            default: 'https',
          },
        },
      },
    ],
    paths: {},
  })),
  {
    ...openapi,
    servers: [
      {
        url: '{scheme}://example.{domain}/foo',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
          scheme: {
            enum: ['https', 'http'],
            default: 'https',
          },
        },
      },
    ],
    'x-ms-parameterized-host': {
      hostTemplate: '{scheme}://example.{domain}',
      useSchemePrefix: false,
      parameters: [
        {
          in: 'path',
          name: 'scheme',
          required: true,
          type: 'string',
          enum: ['https', 'http'],
          default: 'https',
        },
        {
          in: 'path',
          name: 'domain',
          required: true,
          type: 'string',
          enum: ['com', 'org'],
          default: 'org',
        },
      ],
    },
    paths: {},
  },
);
server variables in path part not in x-ms-parameterized-host
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
assert.deepStrictEqual(
  new ServerVarsToParamHostTransformer().transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: '{scheme}://example.{domain}/{foo}',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
          scheme: {
            enum: ['https', 'http'],
            default: 'https',
          },
        },
      },
    ],
    paths: {},
  })),
  {
    ...openapi,
    servers: [
      {
        url: '{scheme}://example.{domain}/{foo}',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
          foo: {
            enum: ['bar', 'baz'],
            default: 'bar',
          },
          scheme: {
            enum: ['https', 'http'],
            default: 'https',
          },
        },
      },
    ],
    'x-ms-parameterized-host': {
      hostTemplate: '{scheme}://example.{domain}',
      useSchemePrefix: false,
      parameters: [
        {
          in: 'path',
          name: 'scheme',
          required: true,
          type: 'string',
          enum: ['https', 'http'],
          default: 'https',
        },
        {
          in: 'path',
          name: 'domain',
          required: true,
          type: 'string',
          enum: ['com', 'org'],
          default: 'org',
        },
      ],
    },
    paths: {},
  },
);
adds options.parameter to each parameter
/home/kevin/src/node-projects/openapi-transformers/test/server-vars-to-x-ms-parameterized-host.js
const transformer = new ServerVarsToParamHostTransformer({
  parameter: {
    'x-ms-parameter-location': 'client',
  },
});
assert.deepStrictEqual(
  transformer.transformOpenApi(deepFreeze({
    ...openapi,
    servers: [
      {
        url: 'https://example.{domain}/foo',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
        },
      },
    ],
    paths: {},
  })),
  {
    ...openapi,
    servers: [
      {
        url: 'https://example.{domain}/foo',
        variables: {
          domain: {
            enum: ['com', 'org'],
            default: 'org',
          },
        },
      },
    ],
    'x-ms-parameterized-host': {
      hostTemplate: 'example.{domain}',
      useSchemePrefix: true,
      parameters: [
        {
          in: 'path',
          name: 'domain',
          required: true,
          type: 'string',
          enum: ['com', 'org'],
          default: 'org',
          'x-ms-parameter-location': 'client',
        },
      ],
    },
    paths: {},
  },
);

TypeNullToEnumTransformer

type: 'null' to enum: [null]
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-enum.js
assert.deepStrictEqual(
  new TypeNullToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'null',
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }, '3.1.0'),
);
type: ['null'] to enum: [null]
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-enum.js
assert.deepStrictEqual(
  new TypeNullToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['null'],
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }, '3.1.0'),
);
does not change mixed type
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-enum.js
assert.deepStrictEqual(
  new TypeNullToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['null', 'number'],
  }, '3.1.0'))),
  schema3({
    type: ['null', 'number'],
  }, '3.1.0'),
);
removes type: 'null' with existing enum
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-enum.js
assert.deepStrictEqual(
  new TypeNullToEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'null',
    enum: [null],
  }, '3.1.0'))),
  schema3({
    enum: [null],
  }, '3.1.0'),
);

TypeNullToNullableTransformer

adds `nullable: true`, removes "null" from 2-type
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-nullable.js
assert.deepStrictEqual(
  new TypeNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['null', 'number'],
  }, '3.1.0'))),
  schema3({
    type: 'number',
    nullable: true,
  }, '3.1.0'),
);
adds `nullable: true`, removes "null" from 3-type
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-nullable.js
assert.deepStrictEqual(
  new TypeNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['number', 'null', 'string'],
  }, '3.1.0'))),
  schema3({
    type: ['number', 'string'],
    nullable: true,
  }, '3.1.0'),
);
removes "null" on schema with `nullable: true`
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-nullable.js
assert.deepStrictEqual(
  new TypeNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['null', 'number'],
    nullable: true,
  }, '3.1.0'))),
  schema3({
    type: 'number',
    nullable: true,
  }, '3.1.0'),
);
does not change schema without "null" type
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-nullable.js
assert.deepStrictEqual(
  new TypeNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['number', 'string'],
  }, '3.1.0'))),
  schema3({
    type: ['number', 'string'],
  }, '3.1.0'),
);
does not change schema with type: 'null'
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-nullable.js
assert.deepStrictEqual(
  new TypeNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'null',
  }, '3.1.0'))),
  schema3({
    type: 'null',
  }, '3.1.0'),
);
does not change schema with type: ['null']
/home/kevin/src/node-projects/openapi-transformers/test/type-null-to-nullable.js
assert.deepStrictEqual(
  new TypeNullToNullableTransformer().transformOpenApi(deepFreeze(schema3({
    type: ['null'],
  }, '3.1.0'))),
  schema3({
    type: ['null'],
  }, '3.1.0'),
);

UrlencodedToStringTransformer

converts non-string properties of urlencoded to string
/home/kevin/src/node-projects/openapi-transformers/test/urlencoded-to-string.js
assert.deepStrictEqual(
  new UrlencodedToStringTransformer().transformOpenApi(deepFreeze(post3({
    requestBody: {
      content: {
        'application/x-www-form-urlencoded': {
          schema: {
            type: 'object',
            properties: {
              name: {
                type: 'string',
              },
              hp: {
                type: 'integer',
              },
              speed: {
                type: 'number',
              },
              inverted: {
                type: 'boolean',
              },
            },
          },
        },
      },
    },
    responses: {
      default: {
        description: 'Example response',
        content: {
          'application/json': {
            schema: {
              type: 'object',
              properties: {
                newSpeed: {
                  type: 'number',
                },
              },
            },
          },
        },
      },
    },
  }))),
  post3({
    requestBody: {
      content: {
        'application/x-www-form-urlencoded': {
          schema: {
            type: 'object',
            properties: {
              name: {
                type: 'string',
              },
              hp: {
                type: 'string',
              },
              speed: {
                type: 'string',
              },
              inverted: {
                type: 'string',
              },
            },
          },
        },
      },
    },
    responses: {
      default: {
        description: 'Example response',
        content: {
          'application/json': {
            schema: {
              type: 'object',
              properties: {
                newSpeed: {
                  type: 'number',
                },
              },
            },
          },
        },
      },
    },
  }),
);
converts non-string formData parameters of urlencoded to string
/home/kevin/src/node-projects/openapi-transformers/test/urlencoded-to-string.js
assert.deepStrictEqual(
  new UrlencodedToStringTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    produces: ['application/json'],
    paths: {
      '/': {
        post: {
          consumes: ['application/x-www-form-urlencoded'],
          parameters: [
            {
              name: 'name',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'hp',
              in: 'formData',
              type: 'integer',
            },
            {
              name: 'speed',
              in: 'formData',
              type: 'number',
            },
            {
              name: 'inverted',
              in: 'formData',
              type: 'boolean',
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    produces: ['application/json'],
    paths: {
      '/': {
        post: {
          consumes: ['application/x-www-form-urlencoded'],
          parameters: [
            {
              name: 'name',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'hp',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'speed',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'inverted',
              in: 'formData',
              type: 'string',
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
converts parameters when urlencoded is inherited
/home/kevin/src/node-projects/openapi-transformers/test/urlencoded-to-string.js
assert.deepStrictEqual(
  new UrlencodedToStringTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    produces: ['application/json'],
    consumes: ['application/x-www-form-urlencoded'],
    paths: {
      '/': {
        post: {
          parameters: [
            {
              name: 'name',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'hp',
              in: 'formData',
              type: 'integer',
            },
            {
              name: 'speed',
              in: 'formData',
              type: 'number',
            },
            {
              name: 'inverted',
              in: 'formData',
              type: 'boolean',
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    produces: ['application/json'],
    consumes: ['application/x-www-form-urlencoded'],
    paths: {
      '/': {
        post: {
          parameters: [
            {
              name: 'name',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'hp',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'speed',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'inverted',
              in: 'formData',
              type: 'string',
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
converts non-string body properties of urlencoded to string
/home/kevin/src/node-projects/openapi-transformers/test/urlencoded-to-string.js
assert.deepStrictEqual(
  new UrlencodedToStringTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    produces: ['application/json'],
    consumes: ['application/x-www-form-urlencoded'],
    paths: {
      '/': {
        post: {
          parameters: [
            {
              name: 'whatever',
              in: 'body',
              schema: {
                type: 'object',
                properties: {
                  name: {
                    type: 'string',
                  },
                  hp: {
                    type: 'integer',
                  },
                  speed: {
                    type: 'number',
                  },
                  inverted: {
                    type: 'boolean',
                  },
                },
              },
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    produces: ['application/json'],
    consumes: ['application/x-www-form-urlencoded'],
    paths: {
      '/': {
        post: {
          parameters: [
            {
              name: 'whatever',
              in: 'body',
              schema: {
                type: 'object',
                properties: {
                  name: {
                    type: 'string',
                  },
                  hp: {
                    type: 'string',
                  },
                  speed: {
                    type: 'string',
                  },
                  inverted: {
                    type: 'string',
                  },
                },
              },
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);
does not convert properties of urlencoded+form-data
/home/kevin/src/node-projects/openapi-transformers/test/urlencoded-to-string.js
assert.deepStrictEqual(
  new UrlencodedToStringTransformer().transformOpenApi(deepFreeze({
    ...swagger,
    produces: ['application/json'],
    paths: {
      '/': {
        post: {
          consumes: [
            'application/x-www-form-urlencoded',
            'multipart/form-data',
          ],
          parameters: [
            {
              name: 'name',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'hp',
              in: 'formData',
              type: 'integer',
            },
            {
              name: 'speed',
              in: 'formData',
              type: 'number',
            },
            {
              name: 'inverted',
              in: 'formData',
              type: 'boolean',
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  })),
  {
    ...swagger,
    produces: ['application/json'],
    paths: {
      '/': {
        post: {
          consumes: [
            'application/x-www-form-urlencoded',
            'multipart/form-data',
          ],
          parameters: [
            {
              name: 'name',
              in: 'formData',
              type: 'string',
            },
            {
              name: 'hp',
              in: 'formData',
              type: 'integer',
            },
            {
              name: 'speed',
              in: 'formData',
              type: 'number',
            },
            {
              name: 'inverted',
              in: 'formData',
              type: 'boolean',
            },
          ],
          responses: {
            default: {
              description: 'Example response',
              schema: {
                type: 'object',
                properties: {
                  newSpeed: {
                    type: 'number',
                  },
                },
              },
            },
          },
        },
      },
    },
  },
);

XEnumToXMsEnumTransformer

creates x-ms-enum from x-enum-*
/home/kevin/src/node-projects/openapi-transformers/test/x-enum-to-ms.js
assert.deepStrictEqual(
  new XEnumToXMsEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-enum-descriptions': [
      'Description 1',
      'Description 2',
    ],
    'x-enum-varnames': [
      'Var1',
      'Var2',
    ],
  }))),
  schema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-ms-enum': {
      name: 'Test',
      values: [
        {
          value: 'value1',
          description: 'Description 1',
          name: 'Var1',
        },
        {
          value: 'value2',
          description: 'Description 2',
          name: 'Var2',
        },
      ],
    },
  }),
);
does not create x-ms-enum without name (in property)
/home/kevin/src/node-projects/openapi-transformers/test/x-enum-to-ms.js
assert.deepStrictEqual(
  new XEnumToXMsEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
        'x-enum-descriptions': [
          'Description 1',
          'Description 2',
        ],
        'x-enum-varnames': [
          'Var1',
          'Var2',
        ],
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
        'x-enum-descriptions': [
          'Description 1',
          'Description 2',
        ],
        'x-enum-varnames': [
          'Var1',
          'Var2',
        ],
      },
    },
  }),
);
does not create x-ms-enum without name (in response)
/home/kevin/src/node-projects/openapi-transformers/test/x-enum-to-ms.js
assert.deepStrictEqual(
  new XEnumToXMsEnumTransformer().transformOpenApi(deepFreeze(
    responseSchema3({
      type: 'string',
      enum: [
        'value1',
        'value2',
      ],
      'x-enum-descriptions': [
        'Description 1',
        'Description 2',
      ],
      'x-enum-varnames': [
        'Var1',
        'Var2',
      ],
    }),
  )),
  responseSchema3({
    type: 'string',
    enum: [
      'value1',
      'value2',
    ],
    'x-enum-descriptions': [
      'Description 1',
      'Description 2',
    ],
    'x-enum-varnames': [
      'Var1',
      'Var2',
    ],
  }),
);
adds x-ms-enum.values from x-enum-*
/home/kevin/src/node-projects/openapi-transformers/test/x-enum-to-ms.js
assert.deepStrictEqual(
  new XEnumToXMsEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
        'x-enum-descriptions': [
          'Description 1',
          'Description 2',
        ],
        'x-enum-varnames': [
          'Var1',
          'Var2',
        ],
        'x-ms-enum': {
          name: 'Test',
        },
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
        'x-ms-enum': {
          name: 'Test',
          values: [
            {
              value: 'value1',
              description: 'Description 1',
              name: 'Var1',
            },
            {
              value: 'value2',
              description: 'Description 2',
              name: 'Var2',
            },
          ],
        },
      },
    },
  }),
);
does not overwrite x-ms-enum.values
/home/kevin/src/node-projects/openapi-transformers/test/x-enum-to-ms.js
assert.deepStrictEqual(
  new XEnumToXMsEnumTransformer().transformOpenApi(deepFreeze(schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
        'x-enum-descriptions': [
          'Description 1',
          'Description 2',
        ],
        'x-enum-varnames': [
          'Var1',
          'Var2',
        ],
        'x-ms-enum': {
          name: 'Test',
          values: [
            {
              value: 'value1',
              description: 'MS Description 1',
              name: 'MsVar1',
            },
            {
              value: 'value2',
              description: 'MS Description 2',
              name: 'MsVar2',
            },
          ],
        },
      },
    },
  }))),
  schema3({
    type: 'object',
    properties: {
      myprop: {
        type: 'string',
        enum: [
          'value1',
          'value2',
        ],
        'x-enum-descriptions': [
          'Description 1',
          'Description 2',
        ],
        'x-enum-varnames': [
          'Var1',
          'Var2',
        ],
        'x-ms-enum': {
          name: 'Test',
          values: [
            {
              value: 'value1',
              description: 'MS Description 1',
              name: 'MsVar1',
            },
            {
              value: 'value2',
              description: 'MS Description 2',
              name: 'MsVar2',
            },
          ],
        },
      },
    },
  }),
);