mirror of
https://github.com/Kong/insomnia
synced 2024-11-08 23:00:30 +00:00
746 lines
22 KiB
TypeScript
746 lines
22 KiB
TypeScript
import { createBuilder } from '@develohpanda/fluent-builder';
|
|
|
|
import { globalBeforeEach } from '../../__jest__/before-each';
|
|
import * as models from '../../models';
|
|
import { environmentModelSchema, requestGroupModelSchema } from '../../models/__schemas__/model-schemas';
|
|
import { Environment } from '../../models/environment';
|
|
import { Workspace } from '../../models/workspace';
|
|
import * as renderUtils from '../render';
|
|
|
|
jest.mock('electron');
|
|
|
|
const envBuilder = createBuilder(environmentModelSchema);
|
|
const reqGroupBuilder = createBuilder(requestGroupModelSchema);
|
|
|
|
describe('render tests', () => {
|
|
beforeEach(async () => {
|
|
await globalBeforeEach();
|
|
await models.space.all();
|
|
envBuilder.reset();
|
|
reqGroupBuilder.reset();
|
|
});
|
|
|
|
describe('render()', () => {
|
|
it('renders hello world', async () => {
|
|
const rendered = await renderUtils.render('Hello {{ msg }}!', {
|
|
msg: 'World',
|
|
});
|
|
expect(rendered).toBe('Hello World!');
|
|
});
|
|
|
|
it('renders custom tag: uuid', async () => {
|
|
const rendered = await renderUtils.render('Hello {% uuid %}!');
|
|
expect(rendered).toMatch(/Hello [a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}!/);
|
|
});
|
|
|
|
it('renders custom tag: timestamp', async () => {
|
|
const rendered = await renderUtils.render('Hello {% timestamp %}!');
|
|
expect(rendered).toMatch(/Hello \d{13}!/);
|
|
});
|
|
|
|
it('renders nested object', async () => {
|
|
const rendered = await renderUtils.render('Hello {{ users[0].name }}!', {
|
|
users: [
|
|
{
|
|
name: 'FooBar',
|
|
},
|
|
],
|
|
});
|
|
expect(rendered).toBe('Hello FooBar!');
|
|
});
|
|
|
|
it('fails on invalid template', async () => {
|
|
try {
|
|
await renderUtils.render('Hello {{ msg }!', {
|
|
msg: 'World',
|
|
});
|
|
fail('Render should have failed');
|
|
} catch (err) {
|
|
expect(err.message).toContain('expected variable end');
|
|
}
|
|
});
|
|
|
|
it('handles variables using tag before tag is defined as expected (incorrect order)', async () => {
|
|
const rootEnvironment = envBuilder
|
|
.data({
|
|
consume: '{{ replaced }}',
|
|
hashed: "{% hash 'md5', 'hex', value %}",
|
|
replaced: "{{ hashed | replace('f67565de946a899a534fd908e7eef872', 'cat') }}",
|
|
value: 'ThisIsATopSecretValue',
|
|
})
|
|
.dataPropertyOrder({
|
|
'&': ['value', 'replaced', 'hashed', 'consume'],
|
|
})
|
|
.build();
|
|
|
|
const context = await renderUtils.buildRenderContext({ ancestors: [], rootEnvironment });
|
|
expect(context).toEqual({
|
|
value: 'ThisIsATopSecretValue',
|
|
hashed: 'f67565de946a899a534fd908e7eef872',
|
|
replaced: 'f67565de946a899a534fd908e7eef872',
|
|
consume: 'f67565de946a899a534fd908e7eef872',
|
|
});
|
|
// In runtime, this context is used to render, which re-evaluates the expression for replaced in the rootEnvironment by using the built context
|
|
// Regression test from issue 1917 - https://github.com/Kong/insomnia/issues/1917
|
|
const renderExpression = await renderUtils.render(rootEnvironment.data.replaced, context);
|
|
expect(renderExpression).toBe('cat');
|
|
});
|
|
});
|
|
|
|
describe('buildRenderContext()', () => {
|
|
it('cascades properly', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder.environment({ foo: 'parent', ancestor: true }).build(),
|
|
reqGroupBuilder.environment({ foo: 'grandparent', ancestor: true }).build(),
|
|
];
|
|
|
|
const rootEnvironment = envBuilder.data({ foo: 'root', root: true }).build();
|
|
const subEnvironment = envBuilder.data({ foo: 'sub', sub: true }).build();
|
|
|
|
const context = await renderUtils.buildRenderContext({ ancestors, rootEnvironment, subEnvironment });
|
|
|
|
expect(context).toEqual({
|
|
foo: 'parent',
|
|
ancestor: true,
|
|
root: true,
|
|
sub: true,
|
|
});
|
|
});
|
|
|
|
it('rendered recursive should not infinite loop', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder.environment({ recursive: '{{ recursive }}/hello' }).build(),
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
// This is longer than 3 because it multiplies every time (1 -> 2 -> 4 -> 8)
|
|
expect(context).toEqual({
|
|
recursive: '{{ recursive }}/hello/hello/hello/hello/hello/hello/hello/hello',
|
|
});
|
|
});
|
|
|
|
it('does not recursive render if itself is not used in var', async () => {
|
|
const root = envBuilder.data({
|
|
proto: 'http',
|
|
domain: 'base.com',
|
|
url: '{{ proto }}://{{ domain }}',
|
|
}).build();
|
|
|
|
const sub = envBuilder.data({
|
|
proto: 'https',
|
|
domain: 'sub.com',
|
|
port: 8000,
|
|
url: '{{ proto }}://{{ domain }}:{{ port }}',
|
|
}).build();
|
|
|
|
const ancestors = [
|
|
reqGroupBuilder.environment({
|
|
proto: 'https',
|
|
domain: 'folder.com',
|
|
port: 7000,
|
|
}).build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors, rootEnvironment: root, subEnvironment: sub });
|
|
expect(context).toEqual({
|
|
proto: 'https',
|
|
domain: 'folder.com',
|
|
port: 7000,
|
|
url: 'https://folder.com:7000',
|
|
});
|
|
});
|
|
|
|
it('does the thing', async () => {
|
|
const root = envBuilder.data({ url: 'insomnia.rest' }).build();
|
|
const sub = envBuilder.data({ url: '{{ url }}/sub' }).build();
|
|
const ancestors = [
|
|
reqGroupBuilder.environment({
|
|
url: '{{ url }}/{{ name }}',
|
|
name: 'folder',
|
|
}).build(),
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext({ ancestors, rootEnvironment: root, subEnvironment: sub });
|
|
expect(context).toEqual({
|
|
url: 'insomnia.rest/sub/folder',
|
|
name: 'folder',
|
|
});
|
|
});
|
|
|
|
it('render up to 3 recursion levels', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder.environment({
|
|
d: '/d',
|
|
c: '/c{{ d }}',
|
|
b: '/b{{ c }}',
|
|
a: '/a{{ b }}',
|
|
test: 'http://insomnia.rest{{ a }}',
|
|
}).build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
d: '/d',
|
|
c: '/c/d',
|
|
b: '/b/c/d',
|
|
a: '/a/b/c/d',
|
|
test: 'http://insomnia.rest/a/b/c/d',
|
|
});
|
|
});
|
|
|
|
it('rendered sibling environment variables', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder.environment({
|
|
sibling: 'sibling',
|
|
test: '{{ sibling }}/hello',
|
|
}).build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
sibling: 'sibling',
|
|
test: 'sibling/hello',
|
|
});
|
|
});
|
|
|
|
it('rendered parent environment variables', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.name('Parent')
|
|
.environment({
|
|
test: '{{ grandparent }} parent',
|
|
})
|
|
.build(),
|
|
reqGroupBuilder
|
|
.name('Grandparent')
|
|
.environment({
|
|
grandparent: 'grandparent',
|
|
})
|
|
.build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
grandparent: 'grandparent',
|
|
test: 'grandparent parent',
|
|
});
|
|
});
|
|
|
|
it('rendered parent same name environment variables', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.name('Parent')
|
|
.environment({
|
|
base_url: '{{ base_url }}/resource',
|
|
})
|
|
.build(),
|
|
reqGroupBuilder
|
|
.name('Grandparent')
|
|
.environment({
|
|
base_url: 'https://insomnia.rest',
|
|
})
|
|
.build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
base_url: 'https://insomnia.rest/resource',
|
|
});
|
|
});
|
|
|
|
it('rendered parent, ignoring sibling environment variables', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.name('Parent')
|
|
.environment({
|
|
host: 'parent.com',
|
|
})
|
|
.build(),
|
|
reqGroupBuilder
|
|
.name('Grandparent')
|
|
.environment({
|
|
host: 'grandparent.com',
|
|
node: {
|
|
admin: 'admin',
|
|
test: 'test',
|
|
port: 8080,
|
|
},
|
|
urls: {
|
|
admin: 'https://{{ host }}/{{ node.admin }}',
|
|
test: 'https://{{ host }}/{{ node.test }}',
|
|
},
|
|
})
|
|
.build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(await renderUtils.render('{{ urls.admin }}/foo', context)).toBe(
|
|
'https://parent.com/admin/foo',
|
|
);
|
|
expect(await renderUtils.render('{{ urls.test }}/foo', context)).toBe(
|
|
'https://parent.com/test/foo',
|
|
);
|
|
});
|
|
|
|
it('renders child environment variables', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.name('Parent')
|
|
.environment({
|
|
parent: 'parent',
|
|
})
|
|
.build(),
|
|
reqGroupBuilder
|
|
.name('Grandparent')
|
|
.environment({
|
|
test: '{{ parent }} grandparent',
|
|
})
|
|
.build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
parent: 'parent',
|
|
test: 'parent grandparent',
|
|
});
|
|
});
|
|
|
|
it('works with object arrays', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.name('Parent')
|
|
.environment({})
|
|
.build(),
|
|
reqGroupBuilder
|
|
.name('Grandparent')
|
|
.environment({
|
|
users: [
|
|
{
|
|
name: 'Foo',
|
|
},
|
|
{
|
|
name: 'Bar',
|
|
},
|
|
],
|
|
})
|
|
.build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
users: [
|
|
{
|
|
name: 'Foo',
|
|
},
|
|
{
|
|
name: 'Bar',
|
|
},
|
|
],
|
|
});
|
|
});
|
|
|
|
it('works with ordered objects', async () => {
|
|
const obj = {
|
|
users: [
|
|
{
|
|
name: 'Foo',
|
|
id: 1,
|
|
},
|
|
{
|
|
name: 'Bar',
|
|
id: 2,
|
|
},
|
|
],
|
|
};
|
|
const order = {
|
|
'&': ['users'],
|
|
'&~|users~|0': ['id', 'name'],
|
|
'&~|users~|1': ['id', 'name'],
|
|
};
|
|
const requestGroup = reqGroupBuilder.name('Parent').environment(obj).environmentPropertyOrder(order).build();
|
|
const rootEnvironment = envBuilder.name('Parent').data(obj).dataPropertyOrder(order).build();
|
|
const subEnvironment = envBuilder.name('Sub').data(obj).dataPropertyOrder(order).build();
|
|
|
|
const groupCtx = await renderUtils.buildRenderContext({ ancestors: [requestGroup] });
|
|
const rootCtx = await renderUtils.buildRenderContext({ ancestors: [], rootEnvironment });
|
|
const subCtx = await renderUtils.buildRenderContext({ ancestors: [], subEnvironment });
|
|
|
|
const expected = {
|
|
users: [
|
|
{
|
|
id: 1,
|
|
name: 'Foo',
|
|
},
|
|
{
|
|
id: 2,
|
|
name: 'Bar',
|
|
},
|
|
],
|
|
};
|
|
expect(groupCtx).toEqual(expected);
|
|
expect(rootCtx).toEqual(expected);
|
|
expect(subCtx).toEqual(expected);
|
|
});
|
|
|
|
it('merges nested properties when rendering', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.name('Parent')
|
|
.environment({
|
|
parent: 'parent',
|
|
nested: {
|
|
common: 'parent',
|
|
parentA: 'pa',
|
|
parentB: 'pb',
|
|
},
|
|
}).build(),
|
|
reqGroupBuilder
|
|
.name('Grandparent')
|
|
.environment({
|
|
test: '{{ parent }} grandparent',
|
|
nested: {
|
|
common: 'grandparent',
|
|
grandParentA: 'gpa',
|
|
grandParentB: 'gpb',
|
|
},
|
|
}).build(),
|
|
];
|
|
const context = await renderUtils.buildRenderContext({ ancestors });
|
|
expect(context).toEqual({
|
|
parent: 'parent',
|
|
test: 'parent grandparent',
|
|
nested: {
|
|
common: 'parent',
|
|
grandParentA: 'gpa',
|
|
grandParentB: 'gpb',
|
|
parentA: 'pa',
|
|
parentB: 'pb',
|
|
},
|
|
});
|
|
});
|
|
|
|
it('cascades properly and renders', async () => {
|
|
const ancestors = [
|
|
reqGroupBuilder
|
|
.environment({
|
|
url: '{{ base_url }}/resource',
|
|
ancestor: true,
|
|
winner: 'folder parent',
|
|
})
|
|
.build(),
|
|
reqGroupBuilder
|
|
.environment({
|
|
ancestor: true,
|
|
winner: 'folder grandparent',
|
|
})
|
|
.build(),
|
|
];
|
|
const subEnvironment = envBuilder.data({
|
|
winner: 'sub',
|
|
sub: true,
|
|
base_url: 'https://insomnia.rest',
|
|
}).build();
|
|
const rootEnvironment = envBuilder.data({
|
|
winner: 'root',
|
|
root: true,
|
|
base_url: 'ignore this',
|
|
}).build();
|
|
const context = await renderUtils.buildRenderContext(
|
|
{ ancestors, rootEnvironment, subEnvironment },
|
|
);
|
|
expect(context).toEqual({
|
|
base_url: 'https://insomnia.rest',
|
|
url: 'https://insomnia.rest/resource',
|
|
ancestor: true,
|
|
winner: 'folder parent',
|
|
root: true,
|
|
sub: true,
|
|
});
|
|
});
|
|
|
|
it('handles variables using tag after tag is defined as expected (correct order)', async () => {
|
|
const rootEnvironment = envBuilder
|
|
.data({
|
|
consume: '{{ replaced }}',
|
|
hashed: "{% hash 'md5', 'hex', value %}",
|
|
replaced: "{{ hashed | replace('f67565de946a899a534fd908e7eef872', 'cat') }}",
|
|
value: 'ThisIsATopSecretValue',
|
|
})
|
|
.dataPropertyOrder({
|
|
'&': ['value', 'hashed', 'replaced', 'consume'],
|
|
})
|
|
.build();
|
|
const context = await renderUtils.buildRenderContext({ ancestors: [], rootEnvironment });
|
|
expect(context).toEqual({
|
|
value: 'ThisIsATopSecretValue',
|
|
hashed: 'f67565de946a899a534fd908e7eef872',
|
|
replaced: 'cat',
|
|
consume: 'cat',
|
|
});
|
|
});
|
|
|
|
it('handles variables being used in tags', async () => {
|
|
const rootEnvironment = envBuilder
|
|
.data({
|
|
hash_input: '{{ orderId }}{{ secret }}',
|
|
hash_input_expected: '123456789012345ThisIsATopSecretValue',
|
|
orderId: 123456789012345,
|
|
password: "{% hash 'sha512', 'hex', hash_input %}",
|
|
password_expected: "{% hash 'sha512', 'hex', hash_input_expected %}",
|
|
secret: 'ThisIsATopSecretValue',
|
|
})
|
|
.build();
|
|
const context = await renderUtils.buildRenderContext({ ancestors: [], rootEnvironment });
|
|
expect(context).toEqual({
|
|
hash_input: '123456789012345ThisIsATopSecretValue',
|
|
hash_input_expected: '123456789012345ThisIsATopSecretValue',
|
|
orderId: 123456789012345,
|
|
password:
|
|
'ea84d15f33d3f9e9098fe01659b1ea0599d345770bba20ba98bf9056676a83ffe6b5528b2451ad04badbf690cf3009a94c510121cc6897045f8bb4ba0826134c',
|
|
password_expected:
|
|
'ea84d15f33d3f9e9098fe01659b1ea0599d345770bba20ba98bf9056676a83ffe6b5528b2451ad04badbf690cf3009a94c510121cc6897045f8bb4ba0826134c',
|
|
secret: 'ThisIsATopSecretValue',
|
|
});
|
|
});
|
|
|
|
it('works with minimal parameters', async () => {
|
|
const context = await renderUtils.buildRenderContext({ });
|
|
expect(context).toEqual({});
|
|
});
|
|
});
|
|
|
|
describe('render()', () => {
|
|
it('correctly renders simple Object', async () => {
|
|
const newObj = await renderUtils.render(
|
|
{
|
|
foo: '{{ foo }}',
|
|
bar: 'bar',
|
|
baz: '{{ bad }}',
|
|
},
|
|
{
|
|
foo: 'bar',
|
|
bad: 'hi',
|
|
},
|
|
);
|
|
expect(newObj).toEqual({
|
|
foo: 'bar',
|
|
bar: 'bar',
|
|
baz: 'hi',
|
|
});
|
|
});
|
|
|
|
it('correctly renders complex Object', async () => {
|
|
const d = new Date();
|
|
const obj = {
|
|
foo: '{{ foo }}',
|
|
null: null,
|
|
bool: true,
|
|
date: d,
|
|
undef: undefined,
|
|
num: 1234,
|
|
nested: {
|
|
foo: '{{ foo }}',
|
|
arr: [1, 2, '{{ foo }}'],
|
|
},
|
|
};
|
|
const newObj = await renderUtils.render(obj, {
|
|
foo: 'bar',
|
|
});
|
|
expect(newObj).toEqual({
|
|
foo: 'bar',
|
|
null: null,
|
|
bool: true,
|
|
date: d,
|
|
undef: undefined,
|
|
num: 1234,
|
|
nested: {
|
|
foo: 'bar',
|
|
arr: [1, 2, 'bar'],
|
|
},
|
|
});
|
|
// Make sure original request isn't changed
|
|
expect(obj.foo).toBe('{{ foo }}');
|
|
expect(obj.nested.foo).toBe('{{ foo }}');
|
|
expect(obj.nested.arr[2]).toBe('{{ foo }}');
|
|
});
|
|
|
|
it('fails on bad template', async () => {
|
|
try {
|
|
await renderUtils.render(
|
|
{
|
|
foo: '{{ foo }',
|
|
bar: 'bar',
|
|
baz: '{{ bad }}',
|
|
},
|
|
{
|
|
foo: 'bar',
|
|
},
|
|
);
|
|
fail('Render should have failed');
|
|
} catch (err) {
|
|
expect(err.message).toContain('expected variable end');
|
|
}
|
|
});
|
|
|
|
it('keep on error setting', async () => {
|
|
const template = '{{ foo }} {% invalid "hi" %}';
|
|
const context = {
|
|
foo: 'bar',
|
|
};
|
|
const resultOnlyVars = await renderUtils.render(
|
|
template,
|
|
context,
|
|
null,
|
|
renderUtils.KEEP_ON_ERROR,
|
|
);
|
|
expect(resultOnlyVars).toBe('{{ foo }} {% invalid "hi" %}');
|
|
|
|
try {
|
|
await renderUtils.render(template, context, null);
|
|
fail('Render should not have succeeded');
|
|
} catch (err) {
|
|
expect(err.message).toBe('unknown block tag: invalid');
|
|
}
|
|
});
|
|
|
|
it('outputs correct error path', async () => {
|
|
const template = {
|
|
foo: [
|
|
{
|
|
bar: '{% foo %}',
|
|
},
|
|
],
|
|
};
|
|
|
|
try {
|
|
await renderUtils.render(template);
|
|
fail('Should have failed to render');
|
|
} catch (err) {
|
|
expect(err.path).toBe('foo[0].bar');
|
|
}
|
|
});
|
|
|
|
it('outputs correct error path when private first node', async () => {
|
|
const template = {
|
|
_foo: {
|
|
_bar: {
|
|
baz: '{% foo %}',
|
|
},
|
|
},
|
|
};
|
|
|
|
try {
|
|
await renderUtils.render(template);
|
|
fail('Should have failed to render');
|
|
} catch (err) {
|
|
expect(err.path).toBe('_bar.baz');
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('getRenderedGrpcRequestMessage()', () => {
|
|
it('renders only the body for a grpc request ', async () => {
|
|
const w1 = await models.workspace.create();
|
|
const env = await models.environment.create({
|
|
parentId: w1._id,
|
|
data: {
|
|
foo: 'bar',
|
|
host: 'testb.in:9000',
|
|
},
|
|
});
|
|
const grpcRequest = await models.grpcRequest.create({
|
|
parentId: w1._id,
|
|
name: 'hi {{ foo }}',
|
|
url: '{{ host }}',
|
|
description: 'hi {{ foo }}',
|
|
body: {
|
|
text: '{ "prop": "{{ foo }}" }',
|
|
},
|
|
});
|
|
const request = await renderUtils.getRenderedGrpcRequestMessage({ request: grpcRequest, environmentId: env._id });
|
|
expect(request).toEqual(
|
|
expect.objectContaining({
|
|
text: '{ "prop": "bar" }',
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('getRenderedGrpcRequest()', () => {
|
|
let w1: Workspace;
|
|
let env: Environment;
|
|
|
|
beforeEach(async () => {
|
|
w1 = await models.workspace.create();
|
|
env = await models.environment.create({
|
|
parentId: w1._id,
|
|
data: {
|
|
foo: 'bar',
|
|
host: 'testb.in:9000',
|
|
},
|
|
});
|
|
});
|
|
|
|
it('renders all grpc request properties', async () => {
|
|
const grpcRequest = await models.grpcRequest.create({
|
|
parentId: w1._id,
|
|
name: 'hi {{ foo }}',
|
|
url: '{{ host }}',
|
|
description: 'hi {{ foo }}',
|
|
body: {
|
|
text: '{ "prop": "{{ foo }}" }',
|
|
},
|
|
});
|
|
const request = await renderUtils.getRenderedGrpcRequest({ request: grpcRequest, environmentId: env._id });
|
|
expect(request).toEqual(
|
|
expect.objectContaining({
|
|
name: 'hi bar',
|
|
url: 'testb.in:9000',
|
|
description: 'hi bar',
|
|
body: {
|
|
text: '{ "prop": "bar" }',
|
|
},
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('renders but ignores the body for a grpc request ', async () => {
|
|
const grpcRequest = await models.grpcRequest.create({
|
|
parentId: w1._id,
|
|
name: 'hi {{ foo }}',
|
|
url: '{{ host }}',
|
|
description: 'hi {{ foo }}',
|
|
body: {
|
|
text: '{ "prop": "{{ foo }}" }',
|
|
},
|
|
});
|
|
const request = await renderUtils.getRenderedGrpcRequest({ request: grpcRequest, environmentId: env._id, skipBody: true });
|
|
expect(request).toEqual(
|
|
expect.objectContaining({
|
|
name: 'hi bar',
|
|
url: 'testb.in:9000',
|
|
description: 'hi bar',
|
|
body: {
|
|
text: '{ "prop": "{{ foo }}" }',
|
|
},
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should still render with bad description', async () => {
|
|
const grpcRequest = await models.grpcRequest.create({
|
|
parentId: w1._id,
|
|
name: 'hi {{ foo }}',
|
|
url: '{{ host }}',
|
|
description: 'hi {{ some error }}',
|
|
body: {
|
|
text: '{ "prop": "{{ foo }}" }',
|
|
},
|
|
});
|
|
const request = await renderUtils.getRenderedGrpcRequest({ request: grpcRequest, environmentId: env._id });
|
|
expect(request).toEqual(
|
|
expect.objectContaining({
|
|
name: 'hi bar',
|
|
url: 'testb.in:9000',
|
|
description: 'hi {{ some error }}',
|
|
body: {
|
|
text: '{ "prop": "bar" }',
|
|
},
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
});
|