const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const callback = deepFreeze({
'http://example.com': {},
'$request.body#/url': {},
});
assert.deepStrictEqual(t.transformCallback(callback), callback);
const values = Object.values(callback);
sinon.assert.calledWith(t.transformPathItem, values[0]);
sinon.assert.calledWith(t.transformPathItem, values[1]);
sinon.assert.calledTwice(t.transformPathItem);
sinon.assert.alwaysCalledOn(t.transformPathItem, t);
sinon.assert.calledOnce(t.transformCallback);
assertOnlyCalledMethods(t, [t.transformCallback, t.transformPathItem]);
const t = sinon.spy(new OpenApiTransformerBase());
const callback = deepFreeze({ 'x-test': {} });
assert.deepStrictEqual(t.transformCallback(callback), callback);
sinon.assert.calledOnce(t.transformCallback);
assertOnlyCalledMethods(t, [t.transformCallback]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ schemas: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.schemas,
t.transformSchema,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ responses: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.responses,
t.transformResponse,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ parameters: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.parameters,
t.transformParameter,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.examples,
t.transformExample3,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ requestBodies: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.requestBodies,
t.transformRequestBody,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ headers: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.headers,
t.transformHeader,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ securitySchemes: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.securitySchemes,
t.transformSecurityScheme,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ links: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.links,
t.transformLink,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ callbacks: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.callbacks,
t.transformCallback,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ pathItems: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
t.transformMap,
components.pathItems,
t.transformPathItem,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const encoding = deepFreeze({ headers: {} });
assert.deepStrictEqual(t.transformEncoding(encoding), encoding);
sinon.assert.calledWith(
t.transformMap,
encoding.headers,
t.transformHeader,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformEncoding);
assertOnlyCalledMethods(t, [t.transformEncoding, t.transformMap]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const header = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformHeader(header), header);
sinon.assert.calledWith(t.transformItems, header.items);
sinon.assert.calledOnce(t.transformItems);
sinon.assert.alwaysCalledOn(t.transformItems, t);
sinon.assert.calledOnce(t.transformHeader);
assertOnlyCalledMethods(t, [t.transformHeader, t.transformItems]);
const t = sinon.spy(new OpenApiTransformerBase());
const header = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformHeader(header), header);
sinon.assert.calledWith(t.transformSchema, header.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformHeader);
assertOnlyCalledMethods(t, [t.transformHeader, t.transformSchema]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const info = deepFreeze({ contact: {} });
assert.deepStrictEqual(t.transformInfo(info), info);
sinon.assert.calledWith(t.transformContact, info.contact);
sinon.assert.calledOnce(t.transformContact);
sinon.assert.alwaysCalledOn(t.transformContact, t);
sinon.assert.calledOnce(t.transformInfo);
assertOnlyCalledMethods(t, [t.transformInfo, t.transformContact]);
const t = sinon.spy(new OpenApiTransformerBase());
const info = deepFreeze({ license: {} });
assert.deepStrictEqual(t.transformInfo(info), info);
sinon.assert.calledWith(t.transformLicense, info.license);
sinon.assert.calledOnce(t.transformLicense);
sinon.assert.alwaysCalledOn(t.transformLicense, t);
sinon.assert.calledOnce(t.transformInfo);
assertOnlyCalledMethods(t, [t.transformInfo, t.transformLicense]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const items = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformItems(items), items);
sinon.assert.calledWith(t.transformItems, items.items);
sinon.assert.calledTwice(t.transformItems);
sinon.assert.alwaysCalledOn(t.transformItems, t);
assertOnlyCalledMethods(t, [t.transformItems]);
const t = sinon.spy(new OpenApiTransformerBase());
const items = deepFreeze({ items: undefined });
assert.deepStrictEqual(t.transformItems(items), items);
sinon.assert.calledOnce(t.transformItems);
assertOnlyCalledMethods(t, [t.transformItems]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const link = deepFreeze({ server: {} });
assert.deepStrictEqual(t.transformLink(link), link);
sinon.assert.calledWith(t.transformServer, link.server);
sinon.assert.calledOnce(t.transformServer);
sinon.assert.alwaysCalledOn(t.transformServer, t);
sinon.assert.calledOnce(t.transformLink);
assertOnlyCalledMethods(t, [t.transformLink, t.transformServer]);
const t = sinon.spy(new OpenApiTransformerBase());
const link = deepFreeze({ server: undefined });
assert.deepStrictEqual(t.transformLink(link), link);
sinon.assert.calledOnce(t.transformLink);
assertOnlyCalledMethods(t, [t.transformLink]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const mapper = sinon.stub().returns(true);
const obj = deepFreeze({
a: 1,
b: 2,
});
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), {
a: true,
b: true,
});
sinon.assert.calledWith(mapper, 1);
sinon.assert.calledWith(mapper, 2);
sinon.assert.calledTwice(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);
const mapper = sinon.stub().returns(true);
const obj = deepFreeze({ 'x-test': 1 });
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), { 'x-test': true });
sinon.assert.calledWith(mapper, 1);
sinon.assert.calledOnce(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);
const mapper = sinon.stub().returns(true);
const obj = deepFreeze({
a: 1,
b: undefined,
});
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), {
a: true,
b: undefined,
});
sinon.assert.calledWith(mapper, 1);
sinon.assert.calledOnce(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);
const mapper = sinon.stub().returns(true);
const obj = Object.create({ a: 1 });
obj.b = 2;
deepFreeze(obj);
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), { b: true });
sinon.assert.calledWith(mapper, 2);
sinon.assert.calledOnce(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);
const mapper = sinon.stub().returns(true);
const obj = deepFreeze([1, 2]);
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), obj);
sinon.assert.notCalled(mapper);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [t.transformMap, t.warn]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const mediatype = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformMediaType(mediatype), mediatype);
sinon.assert.calledWith(t.transformSchema, mediatype.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformMediaType);
assertOnlyCalledMethods(t, [t.transformMediaType, t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const mediatype = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformMediaType(mediatype), mediatype);
sinon.assert.calledWith(
t.transformMap,
mediatype.examples,
t.transformExample3,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformMediaType);
assertOnlyCalledMethods(t, [t.transformMediaType, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const mediatype = deepFreeze({ encoding: {} });
assert.deepStrictEqual(t.transformMediaType(mediatype), mediatype);
sinon.assert.calledWith(
t.transformMap,
mediatype.encoding,
t.transformEncoding,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformMediaType);
assertOnlyCalledMethods(t, [t.transformMediaType, t.transformMap]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ implicit: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(t.transformOAuthFlow, oAuthFlows.implicit);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);
const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ password: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(t.transformOAuthFlow, oAuthFlows.password);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);
const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ clientCredentials: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(
t.transformOAuthFlow,
oAuthFlows.clientCredentials,
);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);
const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ authorizationCode: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(
t.transformOAuthFlow,
oAuthFlows.authorizationCode,
);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ info: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformInfo, openApi.info);
sinon.assert.calledOnce(t.transformInfo);
sinon.assert.alwaysCalledOn(t.transformInfo, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformInfo]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformExternalDocs, openApi.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformExternalDocs]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ servers: [] });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformArray,
openApi.servers,
t.transformServer,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ components: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformComponents, openApi.components);
sinon.assert.calledOnce(t.transformComponents);
sinon.assert.alwaysCalledOn(t.transformComponents, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformComponents]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ definitions: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformMap,
openApi.definitions,
t.transformSchema,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ parameters: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformMap,
openApi.parameters,
t.transformParameter,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const parameters = [];
const openApi = deepFreeze({
'x-ms-parameterized-host': {
hostTemplate: 'example.{tld}',
parameters,
},
});
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformArray,
parameters,
t.transformParameter,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ responses: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformMap,
openApi.responses,
t.transformResponse,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ paths: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformPaths, openApi.paths);
sinon.assert.calledOnce(t.transformPaths);
sinon.assert.alwaysCalledOn(t.transformPaths, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformPaths]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ 'x-ms-paths': {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformPaths, openApi['x-ms-paths']);
sinon.assert.calledOnce(t.transformPaths);
sinon.assert.alwaysCalledOn(t.transformPaths, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformPaths]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ webhooks: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformMap,
openApi.webhooks,
t.transformPathItem,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ security: [] });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformArray,
openApi.security,
t.transformSecurityRequirement,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ tags: [] });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
t.transformArray,
openApi.tags,
t.transformTag,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformExternalDocs, operation.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [
t.transformOperation,
t.transformExternalDocs,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const parameters = [];
const operation = deepFreeze({ parameters });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(
t.transformArray,
parameters,
t.transformParameter,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ requestBody: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformRequestBody, operation.requestBody);
sinon.assert.calledOnce(t.transformRequestBody);
sinon.assert.alwaysCalledOn(t.transformRequestBody, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [
t.transformOperation,
t.transformRequestBody,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ responses: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformResponses, operation.responses);
sinon.assert.calledOnce(t.transformResponses);
sinon.assert.alwaysCalledOn(t.transformResponses, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformResponses]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ callbacks: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(
t.transformMap,
operation.callbacks,
t.transformCallback,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const security = [];
const operation = deepFreeze({ security });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(
t.transformArray,
security,
t.transformSecurityRequirement,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const servers = [];
const operation = deepFreeze({ servers });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformArray, servers, t.transformServer);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformArray]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ content: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(
t.transformMap,
parameter.content,
t.transformMediaType,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(t.transformSchema, parameter.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(t.transformItems, parameter.items);
sinon.assert.calledOnce(t.transformItems);
sinon.assert.alwaysCalledOn(t.transformItems, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformItems]);
const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(
t.transformMap,
parameter.examples,
t.transformExample3,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformMap]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const parameters = [];
const pathItem = deepFreeze({ parameters });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(
t.transformArray,
parameters,
t.transformParameter,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const servers = [];
const pathItem = deepFreeze({ servers });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformArray, servers, t.transformServer);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);
const t = sinon.spy(new OpenApiTransformerBase());
const pathItem = deepFreeze({
summary: {},
description: {},
'x-get': {},
});
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const paths = deepFreeze({
'/path1': {},
'/path2': {},
});
assert.deepStrictEqual(t.transformPaths(paths), paths);
const values = Object.values(paths);
sinon.assert.calledWith(t.transformPathItem, values[0]);
sinon.assert.calledWith(t.transformPathItem, values[1]);
sinon.assert.calledTwice(t.transformPathItem);
sinon.assert.alwaysCalledOn(t.transformPathItem, t);
sinon.assert.calledOnce(t.transformPaths);
assertOnlyCalledMethods(t, [t.transformPaths, t.transformPathItem]);
const t = sinon.spy(new OpenApiTransformerBase());
const paths = deepFreeze({
path1: {},
path2: {},
});
assert.deepStrictEqual(t.transformPaths(paths), paths);
const values = Object.values(paths);
sinon.assert.calledWith(t.transformPathItem, values[0]);
sinon.assert.calledWith(t.transformPathItem, values[1]);
sinon.assert.calledTwice(t.transformPathItem);
sinon.assert.alwaysCalledOn(t.transformPathItem, t);
sinon.assert.calledOnce(t.transformPaths);
assertOnlyCalledMethods(t, [t.transformPaths, t.transformPathItem]);
const t = sinon.spy(new OpenApiTransformerBase());
const paths = deepFreeze({ 'x-test': {} });
assert.deepStrictEqual(t.transformPaths(paths), paths);
sinon.assert.calledOnce(t.transformPaths);
assertOnlyCalledMethods(t, [t.transformPaths]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const requestBody = deepFreeze({ content: {} });
assert.deepStrictEqual(t.transformRequestBody(requestBody), requestBody);
sinon.assert.calledWith(
t.transformMap,
requestBody.content,
t.transformMediaType,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformRequestBody);
assertOnlyCalledMethods(t, [t.transformRequestBody, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const requestBody = deepFreeze({ content: undefined });
assert.deepStrictEqual(t.transformRequestBody(requestBody), requestBody);
sinon.assert.calledOnce(t.transformRequestBody);
assertOnlyCalledMethods(t, [t.transformRequestBody]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ headers: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(
t.transformMap,
response.headers,
t.transformHeader,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ content: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(
t.transformMap,
response.content,
t.transformMediaType,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ links: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(
t.transformMap,
response.links,
t.transformLink,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(t.transformSchema, response.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(t.transformExample, response.examples);
sinon.assert.calledOnce(t.transformExample);
sinon.assert.alwaysCalledOn(t.transformExample, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformExample]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ default: {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.calledWith(t.transformResponse, responses.default);
sinon.assert.calledOnce(t.transformResponse);
sinon.assert.alwaysCalledOn(t.transformResponse, t);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses, t.transformResponse]);
const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ 200: {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.calledWith(t.transformResponse, responses[200]);
sinon.assert.calledOnce(t.transformResponse);
sinon.assert.alwaysCalledOn(t.transformResponse, t);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses, t.transformResponse]);
const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ '2XX': {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.calledWith(t.transformResponse, responses['2XX']);
sinon.assert.calledOnce(t.transformResponse);
sinon.assert.alwaysCalledOn(t.transformResponse, t);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses, t.transformResponse]);
const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ 'x-other': {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.notCalled(t.transformResponse);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ discriminator: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformDiscriminator, schema.discriminator);
sinon.assert.calledOnce(t.transformDiscriminator);
sinon.assert.alwaysCalledOn(t.transformDiscriminator, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformDiscriminator]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformExternalDocs, schema.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformExternalDocs]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ xml: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformXml, schema.xml);
sinon.assert.calledOnce(t.transformXml);
sinon.assert.alwaysCalledOn(t.transformXml, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformXml]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ properties: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchemaProperties, schema.properties);
sinon.assert.calledOnce(t.transformSchemaProperties);
sinon.assert.alwaysCalledOn(t.transformSchemaProperties, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [
t.transformSchema,
t.transformSchemaProperties,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema.items);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const items = [];
const schema = deepFreeze({ items });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, items, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({
[schemaMapProp]: {
a: {},
b: {},
},
});
assert.deepStrictEqual(t.transformSchema(schema), schema);
const values = Object.values(schema[schemaMapProp]);
sinon.assert.calledWith(t.transformSchema, values[0]);
sinon.assert.calledWith(t.transformSchema, values[1]);
sinon.assert.callCount(t.transformSchema, 3);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaMapProp]: { 'x-test': {} } });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(
t.transformSchema,
schema[schemaMapProp]['x-test'],
);
sinon.assert.calledTwice(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({
[schemaMapProp]: {
a: {},
b: {},
},
});
assert.deepStrictEqual(t.transformSchema(schema), schema);
const values = Object.values(schema[schemaMapProp]);
sinon.assert.calledWith(t.transformSchema, values[0]);
sinon.assert.calledWith(t.transformSchema, values[1]);
sinon.assert.callCount(t.transformSchema, 3);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaMapProp]: { 'x-test': {} } });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(
t.transformSchema,
schema[schemaMapProp]['x-test'],
);
sinon.assert.calledTwice(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schemas = [];
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const schemas = {};
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [
t.transformSchema,
t.transformArray,
t.warn,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaArrayProp]: undefined });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schemas = [];
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const schemas = {};
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [
t.transformSchema,
t.transformArray,
t.warn,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaArrayProp]: undefined });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schemas = [];
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);
const t = sinon.spy(new OpenApiTransformerBase());
const schemas = {};
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [
t.transformSchema,
t.transformArray,
t.warn,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaArrayProp]: undefined });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);
const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ examples: [{}] });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const properties = deepFreeze({
a: {},
b: {},
});
assert.deepStrictEqual(
t.transformSchemaProperties(properties),
properties,
);
const values = Object.values(properties);
sinon.assert.calledWith(t.transformSchema, values[0]);
sinon.assert.calledWith(t.transformSchema, values[1]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformSchemaProperties);
assertOnlyCalledMethods(t, [
t.transformSchemaProperties,
t.transformSchema,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const properties = deepFreeze({ 'x-test': {} });
assert.deepStrictEqual(
t.transformSchemaProperties(properties),
properties,
);
sinon.assert.calledWith(t.transformSchema, properties['x-test']);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformSchemaProperties);
assertOnlyCalledMethods(t, [
t.transformSchemaProperties,
t.transformSchema,
]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const securityScheme = deepFreeze({ flows: {} });
assert.deepStrictEqual(
t.transformSecurityScheme(securityScheme),
securityScheme,
);
sinon.assert.calledWith(t.transformOAuthFlows, securityScheme.flows);
sinon.assert.calledOnce(t.transformOAuthFlows);
sinon.assert.alwaysCalledOn(t.transformOAuthFlows, t);
sinon.assert.calledOnce(t.transformSecurityScheme);
assertOnlyCalledMethods(t, [
t.transformSecurityScheme,
t.transformOAuthFlows,
]);
const t = sinon.spy(new OpenApiTransformerBase());
const securityScheme = deepFreeze({ flows: undefined });
assert.deepStrictEqual(
t.transformSecurityScheme(securityScheme),
securityScheme,
);
sinon.assert.calledOnce(t.transformSecurityScheme);
assertOnlyCalledMethods(t, [t.transformSecurityScheme]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const server = deepFreeze({ variables: {} });
assert.deepStrictEqual(t.transformServer(server), server);
sinon.assert.calledWith(
t.transformMap,
server.variables,
t.transformServerVariable,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformServer);
assertOnlyCalledMethods(t, [t.transformServer, t.transformMap]);
const t = sinon.spy(new OpenApiTransformerBase());
const server = deepFreeze({ variables: undefined });
assert.deepStrictEqual(t.transformServer(server), server);
sinon.assert.calledOnce(t.transformServer);
assertOnlyCalledMethods(t, [t.transformServer]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
const t = sinon.spy(new OpenApiTransformerBase());
const tag = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformTag(tag), tag);
sinon.assert.calledWith(t.transformExternalDocs, tag.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformTag);
assertOnlyCalledMethods(t, [t.transformTag, t.transformExternalDocs]);
const t = sinon.spy(new OpenApiTransformerBase());
const tag = deepFreeze({ externalDocs: undefined });
assert.deepStrictEqual(t.transformTag(tag), tag);
sinon.assert.calledOnce(t.transformTag);
assertOnlyCalledMethods(t, [t.transformTag]);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);
const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.strictEqual(toJsonPointer(propPath), ptr);
assert.throws(
() => toJsonPointer(),
TypeError,
);
assert.throws(
() => toJsonPointer('foo'),
TypeError,
);
assert.throws(
() => toJsonPointer([1]),
TypeError,
);
assert.throws(
() => toJsonPointer([{}]),
TypeError,
);
const transformer = new OpenApiTransformerBase();
const method = sinon.spy();
const arg = {};
visit(transformer, method, 'propName', arg);
sinon.assert.calledWithExactly(method, arg);
sinon.assert.calledOnce(method);
sinon.assert.alwaysCalledOn(method, transformer);
const transformer = new OpenApiTransformerBase();
const method = sinon.spy();
const arg1 = {};
const arg2 = {};
visit(transformer, method, 'propName', arg1, arg2);
sinon.assert.calledWithExactly(method, arg1, arg2);
sinon.assert.calledOnce(method);
sinon.assert.alwaysCalledOn(method, transformer);
const transformer = new OpenApiTransformerBase();
const retval = {};
const method = () => retval;
assert.strictEqual(visit(transformer, method, 'propName'), retval);
const transformer = new OpenApiTransformerBase();
const { transformPath } = transformer;
assert.deepStrictEqual(transformPath, []);
const propName = 'propName';
let called = false;
function method() {
assert(!called);
called = true;
assert.deepStrictEqual(transformPath, [propName]);
}
visit(transformer, method, propName);
assert(called);
assert.deepStrictEqual(transformPath, []);
const transformer = new OpenApiTransformerBase();
const { transformPath } = transformer;
assert.deepStrictEqual(transformPath, []);
const propName = 'propName';
const errTest = new Error('test');
function method() {
throw errTest;
}
try {
visit(transformer, method, propName);
assert.fail();
} catch (err) {
assert.strictEqual(err, errTest);
assert.deepStrictEqual(transformPath, []);
}
const transformer = new OpenApiTransformerBase();
const { transformPath } = transformer;
assert.deepStrictEqual(transformPath, []);
const propName = 'propName';
const errTest = new Error('test');
function method() {
throw errTest;
}
try {
visit(transformer, method, propName);
assert.fail();
} catch (err) {
assert.strictEqual(err, errTest);
assert.deepStrictEqual(err.transformPath, ['propName']);
assert.deepStrictEqual(transformPath, []);
}
const transformer = new OpenApiTransformerBase();
const { transformPath } = transformer;
assert.deepStrictEqual(transformPath, []);
const propName = 'propName';
const errTest = {};
function method() {
throw errTest;
}
try {
visit(transformer, method, propName);
assert.fail();
} catch (err) {
assert.strictEqual(err, errTest);
assert(!hasOwnProperty.call(err, 'transformPath'));
assert.deepStrictEqual(transformPath, []);
}
const transformer = new OpenApiTransformerBase();
const { transformPath } = transformer;
assert.deepStrictEqual(transformPath, []);
const propName = 'propName';
const errTest = new Error('test');
function method() {
transformPath.push('surprise');
throw errTest;
}
try {
visit(transformer, method, propName);
assert.fail();
} catch (err) {
assert.strictEqual(err, errTest);
}
const transformer = new OpenApiTransformerBase();
const { transformPath } = transformer;
assert.deepStrictEqual(transformPath, []);
const propName = 'propName';
const errTest = new Error('test');
function method() {
transformPath.pop();
throw errTest;
}
try {
visit(transformer, method, propName);
assert.fail();
} catch (err) {
assert.strictEqual(err, errTest);
}