mirror of
https://github.com/Kong/insomnia
synced 2024-11-08 23:00:30 +00:00
518 lines
13 KiB
JavaScript
518 lines
13 KiB
JavaScript
import * as renderUtils from '../render';
|
|
import * as models from '../../models';
|
|
import { globalBeforeEach } from '../../__jest__/before-each';
|
|
|
|
jest.mock('electron');
|
|
|
|
describe('render()', () => {
|
|
beforeEach(globalBeforeEach);
|
|
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('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');
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('buildRenderContext()', () => {
|
|
beforeEach(globalBeforeEach);
|
|
it('cascades properly', async () => {
|
|
const ancestors = [
|
|
{
|
|
type: models.requestGroup.type,
|
|
environment: { foo: 'parent', ancestor: true },
|
|
},
|
|
{
|
|
type: models.requestGroup.type,
|
|
environment: { foo: 'grandparent', ancestor: true },
|
|
},
|
|
];
|
|
|
|
const rootEnvironment = {
|
|
type: models.environment.type,
|
|
data: { foo: 'root', root: true },
|
|
};
|
|
|
|
const subEnvironment = {
|
|
type: models.environment.type,
|
|
data: { foo: 'sub', sub: true },
|
|
};
|
|
|
|
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 = [
|
|
{
|
|
// Sub Environment
|
|
type: models.requestGroup.type,
|
|
environment: { recursive: '{{ recursive }}/hello' },
|
|
},
|
|
];
|
|
|
|
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 = {
|
|
type: models.environment.type,
|
|
data: {
|
|
proto: 'http',
|
|
domain: 'base.com',
|
|
url: '{{ proto }}://{{ domain }}',
|
|
},
|
|
};
|
|
|
|
const sub = {
|
|
type: models.environment.type,
|
|
data: {
|
|
proto: 'https',
|
|
domain: 'sub.com',
|
|
port: 8000,
|
|
url: '{{ proto }}://{{ domain }}:{{ port }}',
|
|
},
|
|
};
|
|
|
|
const ancestors = [
|
|
{
|
|
// Folder Environment
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
proto: 'https',
|
|
domain: 'folder.com',
|
|
port: 7000,
|
|
},
|
|
},
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext(ancestors, root, sub);
|
|
|
|
expect(context).toEqual({
|
|
proto: 'https',
|
|
domain: 'folder.com',
|
|
port: 7000,
|
|
url: 'https://folder.com:7000',
|
|
});
|
|
});
|
|
|
|
it('does the thing', async () => {
|
|
const root = {
|
|
type: models.environment.type,
|
|
data: { url: 'insomnia.rest' },
|
|
};
|
|
|
|
const sub = {
|
|
type: models.environment.type,
|
|
data: { url: '{{ url }}/sub' },
|
|
};
|
|
|
|
const ancestors = [
|
|
{
|
|
// Folder Environment
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
url: '{{ url }}/{{ name }}',
|
|
name: 'folder',
|
|
},
|
|
},
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext(ancestors, root, sub);
|
|
|
|
expect(context).toEqual({
|
|
url: 'insomnia.rest/sub/folder',
|
|
name: 'folder',
|
|
});
|
|
});
|
|
|
|
it('render up to 3 recursion levels', async () => {
|
|
const ancestors = [
|
|
{
|
|
// Sub Environment
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
d: '/d',
|
|
c: '/c{{ d }}',
|
|
b: '/b{{ c }}',
|
|
a: '/a{{ b }}',
|
|
test: 'http://insomnia.rest{{ a }}',
|
|
},
|
|
},
|
|
];
|
|
|
|
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 = [
|
|
{
|
|
// Sub Environment
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
sibling: 'sibling',
|
|
test: '{{ sibling }}/hello',
|
|
},
|
|
},
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext(ancestors);
|
|
|
|
expect(context).toEqual({ sibling: 'sibling', test: 'sibling/hello' });
|
|
});
|
|
|
|
it('rendered parent environment variables', async () => {
|
|
const ancestors = [
|
|
{
|
|
name: 'Parent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
test: '{{ grandparent }} parent',
|
|
},
|
|
},
|
|
{
|
|
name: 'Grandparent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
grandparent: 'grandparent',
|
|
},
|
|
},
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext(ancestors);
|
|
|
|
expect(context).toEqual({
|
|
grandparent: 'grandparent',
|
|
test: 'grandparent parent',
|
|
});
|
|
});
|
|
|
|
it('rendered parent same name environment variables', async () => {
|
|
const ancestors = [
|
|
{
|
|
name: 'Parent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
base_url: '{{ base_url }}/resource',
|
|
},
|
|
},
|
|
{
|
|
name: 'Grandparent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
base_url: 'https://insomnia.rest',
|
|
},
|
|
},
|
|
];
|
|
|
|
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 = [
|
|
{
|
|
name: 'Parent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
host: 'parent.com',
|
|
},
|
|
},
|
|
{
|
|
name: 'Grandparent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
host: 'grandparent.com',
|
|
node: {
|
|
admin: 'admin',
|
|
test: 'test',
|
|
port: 8080,
|
|
},
|
|
urls: {
|
|
admin: 'https://{{ host }}/{{ node.admin }}',
|
|
test: 'https://{{ host }}/{{ node.test }}',
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
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 = [
|
|
{
|
|
name: 'Parent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
parent: 'parent',
|
|
},
|
|
},
|
|
{
|
|
name: 'Grandparent',
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
test: '{{ parent }} grandparent',
|
|
},
|
|
},
|
|
];
|
|
|
|
const context = await renderUtils.buildRenderContext(ancestors);
|
|
|
|
expect(context).toEqual({ parent: 'parent', test: 'parent grandparent' });
|
|
});
|
|
|
|
it('cascades properly and renders', async () => {
|
|
const ancestors = [
|
|
{
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
url: '{{ base_url }}/resource',
|
|
ancestor: true,
|
|
winner: 'folder parent',
|
|
},
|
|
},
|
|
{
|
|
type: models.requestGroup.type,
|
|
environment: {
|
|
ancestor: true,
|
|
winner: 'folder grandparent',
|
|
},
|
|
},
|
|
];
|
|
|
|
const subEnvironment = {
|
|
type: models.environment.type,
|
|
data: { winner: 'sub', sub: true, base_url: 'https://insomnia.rest' },
|
|
};
|
|
|
|
const rootEnvironment = {
|
|
type: models.environment.type,
|
|
data: { winner: 'root', root: true, base_url: 'ignore this' },
|
|
};
|
|
|
|
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 being used in tags', async () => {
|
|
const rootEnvironment = {
|
|
type: models.environment.type,
|
|
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',
|
|
},
|
|
};
|
|
|
|
const context = await renderUtils.buildRenderContext([], 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 ancestors = null;
|
|
const rootEnvironment = null;
|
|
const subEnvironment = null;
|
|
|
|
const context = await renderUtils.buildRenderContext(
|
|
ancestors,
|
|
rootEnvironment,
|
|
subEnvironment,
|
|
);
|
|
|
|
expect(context).toEqual({});
|
|
});
|
|
});
|
|
|
|
describe('render()', () => {
|
|
beforeEach(globalBeforeEach);
|
|
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');
|
|
}
|
|
});
|
|
});
|