, go to parse5 serializer
10 | * and the rest are handled in this class.
11 | *
12 | * Node - Represets DOM Tree
13 | */
14 | module.exports = class CustomSerializer extends Serializer {
15 | constructor(node, { treeAdapter, fullRendering, slotMap, handleTags }) {
16 | super(node, { treeAdapter });
17 | this.fullRendering = fullRendering;
18 | this.slotMap = slotMap;
19 | this.handleTags = handleTags;
20 | this.lastChildInserted = false;
21 | this.defaultSlotsInserted = false;
22 | this.serializedList = [];
23 | this._serializeNode = this._serializeNode.bind(this);
24 | }
25 |
26 | /**
27 | * Push the serialized content in to the serializedList.
28 | *
29 | * this.html - serialized contents exposed by parse5
30 | */
31 | pushBuffer() {
32 | if (this.html !== '') {
33 | this.serializedList.push(Buffer.from(this.html));
34 | this.html = '';
35 | }
36 | }
37 |
38 | /**
39 | * Extract the serialized HTML content and reset the serialized buffer.
40 | *
41 | * @returns {String}
42 | */
43 | getHtmlContent() {
44 | let temp = '';
45 | if (this.html !== '') {
46 | temp = this.html;
47 | this.html = '';
48 | }
49 | return temp;
50 | }
51 |
52 | /**
53 | * Overidden the serialize function of parse5 Serializer
54 | *
55 | * this.startNode - Denotes the root node
56 | * @returns {Array}
57 | */
58 | serialize() {
59 | this._serializeChildNodes(this.startNode);
60 | this.pushBuffer();
61 | return this.serializedList;
62 | }
63 |
64 | /**
65 | * Checks if the node is either slot node / script type=slot
66 | *
67 | * @returns {Boolean}
68 | */
69 | _isSlotNode(node) {
70 | const { attribs = {}, name } = node;
71 | return (
72 | name === 'slot' || (name === 'script' && attribs.type === 'slot')
73 | );
74 | }
75 |
76 | /**
77 | * Checks if the node is one of the nodes passed through handleTags
78 | *
79 | * @returns {Boolean}
80 | */
81 | _isSpecialNode(node) {
82 | const { attribs = {}, name } = node;
83 | return (
84 | this.handleTags.includes(name) ||
85 | (name === 'script' && this.handleTags.includes(attribs.type))
86 | );
87 | }
88 |
89 | /**
90 | * Checks if the node is the lastChild of
91 | *
92 | * @returns {Boolean}
93 | */
94 | _isLastChildOfBody(node) {
95 | const {
96 | parentNode: { name, lastChild }
97 | } = node;
98 | return name === 'body' && Object.is(node, lastChild);
99 | }
100 |
101 | /**
102 | * Serialize the nodes passed via handleTags
103 | *
104 | * @param {object} node
105 | *
106 | * // Input
107 | *
108 | *
109 | * // Output
110 | * {
111 | * name: 'fragment',
112 | * attributes: {
113 | * async: '',
114 | * primary: ''
115 | * },
116 | * }
117 | */
118 | _serializeSpecial(node) {
119 | this.pushBuffer();
120 | let handledObj;
121 | const { name, attribs: attributes } = node;
122 | if (this.handleTags.includes(name)) {
123 | handledObj = Object.assign({}, { name: name, attributes });
124 | this.serializedList.push(handledObj);
125 | this._serializeChildNodes(node);
126 | this.pushBuffer();
127 | } else {
128 | // For handling the script type other than text/javascript
129 | this._serializeChildNodes(node);
130 | handledObj = Object.assign(
131 | {},
132 | {
133 | name: attributes.type,
134 | attributes,
135 | textContent: this.getHtmlContent()
136 | }
137 | );
138 | this.serializedList.push(handledObj);
139 | }
140 | this.serializedList.push({ closingTag: name });
141 | }
142 |
143 | /**
144 | * Serialize the slot nodes from the slot map
145 | *
146 | * @param {object} node
147 | */
148 | _serializeSlot(node) {
149 | const slotName = node.attribs.name;
150 | if (slotName && slotName !== 'default') {
151 | const childNodes = this.treeAdapter.getChildNodes(node);
152 | const slots = this.slotMap.has(slotName)
153 | ? this.slotMap.get(slotName)
154 | : childNodes;
155 | slots && slots.forEach(this._serializeNode);
156 | } else {
157 | // Handling duplicate slots
158 | if (this.defaultSlotsInserted) {
159 | console.warn(
160 | 'Encountered duplicate Unnamed slots in the template - Skipping the node'
161 | );
162 | return;
163 | }
164 | const defaultSlots = this.slotMap.get('default');
165 | this.defaultSlotsInserted = true;
166 | defaultSlots && defaultSlots.forEach(this._serializeNode);
167 | }
168 | }
169 |
170 | /**
171 | * Serialize the nodes in default slot from slot map and insert async placeholder.
172 | *
173 | * should happen before closing the body.
174 | */
175 | _serializeRest() {
176 | this.lastChildInserted = true;
177 | if (!this.defaultSlotsInserted) {
178 | const defaultSlots = this.slotMap.get('default');
179 | defaultSlots && defaultSlots.forEach(this._serializeNode);
180 | }
181 | this.pushBuffer();
182 | this.serializedList.push({ placeholder: 'async' });
183 | }
184 |
185 | /**
186 | * Serialize all the children of a parent node.
187 | *
188 | * @param {object} parentNode
189 | */
190 | _serializeChildNodes(parentNode) {
191 | const childNodes = this.treeAdapter.getChildNodes(parentNode);
192 | childNodes && childNodes.forEach(this._serializeNode);
193 | }
194 |
195 | /**
196 | * Serialize the node based on their type
197 | *
198 | * @param {object} currentNode
199 | */
200 | _serializeNode(currentNode) {
201 | if (this._isSpecialNode(currentNode)) {
202 | this._serializeSpecial(currentNode);
203 | } else if (this._isSlotNode(currentNode)) {
204 | this._serializeSlot(currentNode);
205 | } else if (this.treeAdapter.isElementNode(currentNode)) {
206 | this._serializeElement(currentNode);
207 | } else if (this.treeAdapter.isTextNode(currentNode)) {
208 | this._serializeTextNode(currentNode);
209 | } else if (this.treeAdapter.isCommentNode(currentNode)) {
210 | this._serializeCommentNode(currentNode);
211 | } else if (this.treeAdapter.isDocumentTypeNode(currentNode)) {
212 | this._serializeDocumentTypeNode(currentNode);
213 | }
214 | // Push default slots and async placeholder before body
215 | if (
216 | this.fullRendering &&
217 | !this.lastChildInserted &&
218 | this._isLastChildOfBody(currentNode)
219 | ) {
220 | this._serializeRest();
221 | }
222 | }
223 | };
224 |
--------------------------------------------------------------------------------
/lib/streams/async-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const stream = require('stream');
4 | const BufferConcatStream = require('./buffer-concat-stream');
5 |
6 | module.exports = class AsyncStream extends stream.Transform {
7 | constructor() {
8 | super({ objectMode: true });
9 | this.streams = 0;
10 | }
11 |
12 | _transform(st, encoding, done) {
13 | this.streams += 1;
14 | st.pipe(
15 | new BufferConcatStream(data => {
16 | this.streams -= 1;
17 | this.push(data);
18 | if (this.streams === 0) {
19 | this.emit('alldone');
20 | }
21 | })
22 | );
23 | st.on('error', err => {
24 | this.streams -= 1;
25 | this.emit('error', err);
26 | });
27 | done();
28 | }
29 |
30 | _flush(done) {
31 | if (this.streams === 0) {
32 | done();
33 | } else {
34 | this.on('alldone', done);
35 | }
36 | }
37 | };
38 |
--------------------------------------------------------------------------------
/lib/streams/buffer-concat-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const stream = require('stream');
4 |
5 | module.exports = class BufferConcatStream extends stream.Writable {
6 | constructor(callback) {
7 | super();
8 | this.data = [];
9 | this.on('finish', () => {
10 | callback(Buffer.concat(this.data));
11 | });
12 | }
13 |
14 | _write(chunk, encoding, done) {
15 | this.data.push(chunk);
16 | done(null, chunk);
17 | }
18 | };
19 |
--------------------------------------------------------------------------------
/lib/streams/content-length-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const stream = require('stream');
4 |
5 | module.exports = class ContentLengthStream extends stream.Transform {
6 | constructor(callback) {
7 | super();
8 | this.callback = callback;
9 | this.contentSize = 0;
10 | }
11 |
12 | _transform(chunk, encoding, done) {
13 | this.contentSize += chunk.length;
14 | done(null, chunk);
15 | }
16 |
17 | _flush(done) {
18 | this.callback(this.contentSize);
19 | done();
20 | }
21 | };
22 |
--------------------------------------------------------------------------------
/lib/streams/head-injector-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const stream = require('stream');
4 |
5 | module.exports = class StringifierStream extends stream.Transform {
6 | constructor(primaryFragmentHeaders) {
7 | super({ objectMode: true });
8 |
9 | this.__title =
10 | primaryFragmentHeaders['x-head-title'] !== undefined
11 | ? Buffer.from(
12 | primaryFragmentHeaders['x-head-title'],
13 | 'base64'
14 | ).toString('utf-8')
15 | : '';
16 | this.__meta =
17 | primaryFragmentHeaders['x-head-meta'] !== undefined
18 | ? Buffer.from(
19 | primaryFragmentHeaders['x-head-meta'],
20 | 'base64'
21 | ).toString('utf-8')
22 | : '';
23 |
24 | this.__injected = false;
25 | this.__titleRe = /
.*<\/title>/is;
26 | }
27 |
28 | _transform(chunk, encoding, done) {
29 | if (this.__injected || (this.__title === '' && this.__meta === '')) {
30 | this.push(chunk);
31 | return done();
32 | }
33 |
34 | let schunk = chunk.toString();
35 | let insertPosStart, insertPosEnd;
36 |
37 | const titleMatch = this.__titleRe.exec(schunk);
38 | if (titleMatch !== null) {
39 | insertPosStart = titleMatch.index;
40 | insertPosEnd = insertPosStart + titleMatch[0].length;
41 | } else {
42 | const pos = schunk.indexOf('</head>');
43 | if (pos !== -1) {
44 | insertPosStart = pos;
45 | insertPosEnd = insertPosStart;
46 | }
47 | }
48 |
49 | if (insertPosStart !== undefined) {
50 | schunk =
51 | schunk.substring(0, insertPosStart) +
52 | this.__title +
53 | this.__meta +
54 | schunk.substring(insertPosEnd);
55 | this.__injected = true;
56 | }
57 |
58 | this.push(schunk);
59 | done();
60 | }
61 | };
62 |
--------------------------------------------------------------------------------
/lib/streams/seobots-guard-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const stream = require('stream');
4 | const BotDetector = require('device-detector-js/dist/parsers/bot');
5 | const botDetector = new BotDetector();
6 |
7 | /**
8 | * The goals of this stream is to change behaviour of the Tailor when dealing with SEO/SM bots.
9 | * While it's ok to not to throw an error if non-primary fragment fails when dealing with browser -
10 | * it's not acceptable to bots. This is because browser can attempt to render missing page
11 | * parts at he client while bots can't do so due to the limited JS support.
12 | *
13 | * @type {module.StringifierStream}
14 | */
15 | module.exports = class StringifierStream extends stream.Transform {
16 | #response;
17 | #isBot = false;
18 | #fragmentsCounter = 0;
19 | #fragmentFound = false;
20 | #batch = [];
21 | #erroredState = false;
22 | #writeHeadArgs = null;
23 |
24 | set statusCode(v) {
25 | this.statusCodeVal = v;
26 | if (this.#isBot) {
27 | return;
28 | }
29 |
30 | this.#response.statusCode = v;
31 | }
32 | get statusCode() {
33 | return this.statusCodeVal;
34 | }
35 |
36 | /**
37 | * @param {boolean} enabled
38 | * @param {http.IncomingHttpHeaders} reqHeaders
39 | * @param {http.ServerResponse} res
40 | */
41 | constructor(enabled, reqHeaders, res) {
42 | super({ objectMode: true, autoDestroy: true });
43 | this.#isBot = enabled
44 | ? botDetector.parse(reqHeaders['user-agent']) !== null
45 | : false;
46 | this.#response = res;
47 | }
48 |
49 | _transform(chunk, encoding, done) {
50 | if (!this.#isBot) {
51 | this.push(chunk, encoding);
52 | return done();
53 | }
54 |
55 | // Stop accepting new data in errored state.
56 | // Default error handler should generate response
57 | if (this.#erroredState) {
58 | return done();
59 | }
60 |
61 | this.#batch.push(chunk);
62 |
63 | if (this.#fragmentsCounter === 0 && this.#fragmentFound) {
64 | this.#flushBuffer();
65 | }
66 |
67 | done();
68 | }
69 |
70 | _flush(done) {
71 | //Not allowing to send broken response to Bot
72 | if (this.#erroredState) {
73 | this.#batch = [];
74 | this.end();
75 | return;
76 | }
77 |
78 | this.#flushBuffer();
79 | done();
80 | }
81 |
82 | addFragment(fragment) {
83 | if (!this.#isBot) {
84 | return;
85 | }
86 |
87 | this.#fragmentsCounter++;
88 | this.#fragmentFound = true;
89 |
90 | fragment.once('response', () => this.#fragmentsCounter--);
91 | fragment.prependOnceListener('error', this.#handleFragmentError);
92 | }
93 |
94 | /**
95 | * Not allowing to write headers before all fragments will respond if dealing with Bot
96 | * Handling case when we received them from primary fragment & non-primary one fails afterwards.
97 | * @param args
98 | * @returns {*}
99 | */
100 | writeHead(...args) {
101 | if (!this.#isBot) {
102 | return this.#response.writeHead(...args);
103 | }
104 |
105 | this.#writeHeadArgs = args;
106 |
107 | return this.#response;
108 | }
109 |
110 | #flushBuffer = () => {
111 | this.#flushHead();
112 | this.#batch.forEach(v => this.push(v));
113 | this.#batch = [];
114 | };
115 |
116 | #flushHead = () => {
117 | if (this.statusCode) {
118 | this.#response.statusCode = this.statusCode;
119 | }
120 | if (this.#writeHeadArgs !== null) {
121 | this.#response.writeHead(...this.#writeHeadArgs);
122 | this.#writeHeadArgs = null;
123 | }
124 | };
125 |
126 | #handleFragmentError = () => {
127 | if (!this.#erroredState) {
128 | this.emit(
129 | 'error',
130 | new Error(
131 | 'Fragment error while processing request from SEO/SM bot. See adjacent messages for real cause.'
132 | )
133 | );
134 | }
135 |
136 | this.#erroredState = true;
137 | this.#batch = [];
138 | };
139 | };
140 |
--------------------------------------------------------------------------------
/lib/streams/stringifier-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const stream = require('stream');
3 | const AsyncStream = require('./async-stream');
4 |
5 | module.exports = class StringifierStream extends stream.Transform {
6 | constructor(fn) {
7 | super({ objectMode: true });
8 | this.fn = fn;
9 | this.queue = [];
10 | this.isBusy = false;
11 | this.isFinished = false;
12 | }
13 |
14 | next() {
15 | if (this.isBusy) {
16 | return;
17 | }
18 | if (this.queue.length === 0) {
19 | if (this.isFinished) {
20 | this.emit('alldone');
21 | }
22 | return;
23 | }
24 | let st = this.queue.shift();
25 | if (st instanceof stream) {
26 | if (st instanceof AsyncStream) {
27 | st.emit('plugged');
28 | }
29 | this.isBusy = true;
30 |
31 | /**
32 | * Since streams are consumed in parallel and processed in series,
33 | * We use the endEmitted flag on the stream to know if the stream has ended
34 | * before we even register the 'end' event
35 | */
36 | if (st._readableState && st._readableState.endEmitted) {
37 | this.onEnd(st);
38 | } else {
39 | st.on('end', () => this.onEnd(st));
40 | }
41 | } else {
42 | this.push(st);
43 | this.next();
44 | }
45 | }
46 |
47 | onEnd(st) {
48 | this.push(Buffer.concat(st.buffer));
49 | this.cleanup(st);
50 | this.processNext();
51 | }
52 |
53 | processNext() {
54 | this.isBusy = false;
55 | this.next();
56 | }
57 |
58 | cleanup(st) {
59 | st.buffer = [];
60 | st.removeListener('end', () => this.onEnd(st));
61 | st.removeListener('error', err => this.onError(err, st));
62 | st.setMaxListeners(st.getMaxListeners() - 1);
63 | }
64 |
65 | onError(err, st) {
66 | this.emit('error', err);
67 | this.cleanup(st);
68 | this.processNext();
69 | }
70 |
71 | _transform(chunk, encoding, done) {
72 | if (chunk instanceof Buffer) {
73 | this.queue.push(chunk);
74 | } else if (typeof this.fn !== 'function') {
75 | if (chunk.name) {
76 | this.emit(
77 | 'error',
78 | new Error('Please provide transform function')
79 | );
80 | }
81 | } else {
82 | const st = this.fn(chunk);
83 | // Consume streams in parallel
84 | if (st instanceof stream) {
85 | st.buffer = [];
86 | const onData = data => {
87 | data = data instanceof Buffer ? data : Buffer.from(data);
88 | st.buffer.push(data);
89 | };
90 |
91 | st.setMaxListeners(st.getMaxListeners() + 1);
92 | st.on('data', onData);
93 | st.on('error', err => this.onError(err, st));
94 | }
95 | // Process streams in series
96 | this.queue.push(st);
97 | }
98 | this.next();
99 | done();
100 | }
101 |
102 | _flush(done) {
103 | this.isFinished = true;
104 | if (this.queue.length === 0 && !this.isBusy) {
105 | done();
106 | } else {
107 | this.on('alldone', done);
108 | }
109 | }
110 | };
111 |
--------------------------------------------------------------------------------
/lib/template-cutter.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const MARKED_PARTS_TO_IGNORE = /<!-- TailorX: Ignore during parsing START -->.*?<!-- TailorX: Ignore during parsing END -->/gims;
4 | const IGNORED_PART_WITH_INDEX = /<!-- TailorX: Ignored content during parsing #(\d+) -->/gm;
5 |
6 | function replaceIgnorePart(ignoredPartIndex) {
7 | return `<!-- TailorX: Ignored content during parsing #${ignoredPartIndex} -->`;
8 | }
9 |
10 | class TemplateCutter {
11 | constructor() {
12 | this.ignoredParts = [];
13 | }
14 |
15 | /**
16 | * Cut base templates special parts which marked with the help of special HTML comments:
17 | * <!-- TailorX: Ignore during parsing START --> and <!-- TailorX: Ignore during parsing END -->
18 | * before and after a content which you want to ignore during parsing to speed up transforming of a base template
19 | *
20 | * @example <!-- TailorX: Ignore during parsing START --><div class='example-class>Example</div><!-- TailorX: Ignore during parsing END -->
21 | *
22 | * @param {String} baseTemplate - Base template that contains all the necessary tags and fragments for the given page (Used by multiple pages)
23 | * @returns {String} Base template without ignored parts
24 | */
25 | cut(baseTemplate) {
26 | return baseTemplate.replace(MARKED_PARTS_TO_IGNORE, match => {
27 | const ignorePartsLength = this.ignoredParts.push(match);
28 | return replaceIgnorePart(ignorePartsLength - 1);
29 | });
30 | }
31 |
32 | /**
33 | * Restore base template's special parts after ignoring them by @method _cut
34 | *
35 | * @param {Array} ignoredParts - Base template's ignored parts
36 | * @param {Array} chunks - Array consiting of Buffers and Objects
37 | * @returns {Array} Array consiting of Buffers and Objects
38 | */
39 | restore(chunks) {
40 | const restoredChunks = chunks.map(chunk => {
41 | const isBuffer = chunk instanceof Buffer;
42 | const part = isBuffer ? chunk.toString('utf-8') : chunk;
43 |
44 | if (typeof part !== 'string') {
45 | return chunk;
46 | }
47 |
48 | const restoredPart = part.replace(
49 | IGNORED_PART_WITH_INDEX,
50 | (match, ignoredPartIndex) => {
51 | const ignoredPart = this.ignoredParts[ignoredPartIndex];
52 |
53 | if (typeof ignoredPart !== 'string') {
54 | throw new Error(
55 | `TailorX can not find an ignored part ${ignoredPartIndex} of the current template during restoring!`
56 | );
57 | }
58 |
59 | return ignoredPart;
60 | }
61 | );
62 |
63 | return isBuffer ? Buffer.from(restoredPart, 'utf-8') : restoredPart;
64 | });
65 |
66 | this.ignoredParts = [];
67 |
68 | return restoredChunks;
69 | }
70 | }
71 |
72 | module.exports = TemplateCutter;
73 |
--------------------------------------------------------------------------------
/lib/tracing.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const opentracing = require('opentracing');
4 |
5 | /**
6 | * Sets the given tracer and the Opentracing global tracer
7 | *
8 | * @param {Object} implementation - An Opentracing compliant Tracer implementation
9 | * @see {@link https://doc.esdoc.org/github.com/opentracing/opentracing-javascript/class/src/tracer.js~Tracer.html}
10 | */
11 | module.exports = {
12 | initTracer: function(implementation) {
13 | opentracing.initGlobalTracer(
14 | implementation || new opentracing.Tracer()
15 | );
16 | }
17 | };
18 |
--------------------------------------------------------------------------------
/lib/transform.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const parse5 = require('parse5');
4 | const memoize = require('memoizee');
5 | const treeAdapter = parse5.treeAdapters.htmlparser2;
6 | const CustomSerializer = require('./serializer');
7 |
8 | /**
9 | * Handles the parsing and serialization of templates. Also takes care of
10 | * merging the base and page templates
11 | */
12 |
13 | module.exports = class Transform {
14 | constructor(handleTags, baseTemplatesCacheSize) {
15 | this.handleTags = handleTags;
16 |
17 | if (baseTemplatesCacheSize) {
18 | this._bindAndMemoizeInternalMethods(baseTemplatesCacheSize);
19 | } else {
20 | this._bindInternalMethods();
21 | }
22 | }
23 |
24 | _bindAndMemoizeInternalMethods(baseTemplatesCacheSize) {
25 | const commonMemoizeOptions = {
26 | length: 1,
27 | max: baseTemplatesCacheSize
28 | };
29 |
30 | this._parse = memoize(parse5.parse.bind(null), commonMemoizeOptions);
31 | this._parseFragment = memoize(
32 | parse5.parseFragment.bind(null),
33 | commonMemoizeOptions
34 | );
35 | }
36 |
37 | _bindInternalMethods() {
38 | this._parse = parse5.parse.bind(null);
39 | this._parseFragment = parse5.parseFragment.bind(null);
40 | }
41 |
42 | /**
43 | * Parse and serialize the html.
44 | *
45 | * @param {string} baseTemplate - Base template that contains all the necessary tags and fragments for the given page (Used by multiple pages)
46 | * @param {string=} childTemplate - The current page template that gets merged in to the base template
47 | * @returns {Array} Array consiting of Buffers and Objects
48 | */
49 | applyTransforms(baseTemplate, childTemplate, fullRendering) {
50 | const options = { treeAdapter };
51 |
52 | const rootNodes = fullRendering
53 | ? this._parse(baseTemplate, options)
54 | : this._parseFragment(baseTemplate, options);
55 |
56 | const slotMap =
57 | childTemplate && typeof childTemplate === 'string'
58 | ? this._groupSlots(parse5.parseFragment(childTemplate, options))
59 | : new Map();
60 |
61 | const serializerOptions = {
62 | treeAdapter,
63 | slotMap,
64 | handleTags: this.handleTags,
65 | fullRendering
66 | };
67 |
68 | const serializer = new CustomSerializer(rootNodes, serializerOptions);
69 |
70 | return serializer.serialize();
71 | }
72 |
73 | /**
74 | * Group all the nodes after parsing the child template. Nodes with unnamed slots are
75 | * added to default slots
76 | *
77 | * @param {Object} root - The root node of the child template
78 | * @returns {Map} Map with keys as slot attribute name and corresponding values consisting of array of matching nodes
79 | */
80 | _groupSlots(root) {
81 | const slotMap = new Map([['default', []]]);
82 | const nodes = treeAdapter.getChildNodes(root);
83 | nodes.forEach(node => {
84 | if (!treeAdapter.isTextNode(node)) {
85 | const { slot = 'default' } = node.attribs || {};
86 | const slotNodes = slotMap.get(slot) || [];
87 | const updatedSlotNodes = [...slotNodes, node];
88 | slotMap.set(slot, updatedSlotNodes);
89 | this._pushText(node.next, updatedSlotNodes);
90 | node.attribs && delete node.attribs.slot;
91 | }
92 | });
93 | return slotMap;
94 | }
95 |
96 | /**
97 | * Add the text node to the Slot Map
98 | *
99 | * @param {Object} nextNode
100 | * @param {Array} slot - Array of matching nodes
101 | */
102 | _pushText(nextNode, slot) {
103 | if (nextNode && treeAdapter.isTextNode(nextNode)) {
104 | slot.push(nextNode);
105 | }
106 | }
107 | };
108 |
--------------------------------------------------------------------------------
/lib/utils.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const _ = require('lodash');
4 |
5 | const getCrossOrigin = (url = '', host = '') => {
6 | // Check for the same origin & relative links
7 | if (url.includes(`://${host}`) || !url.includes('://')) {
8 | return '';
9 | }
10 | return 'crossorigin';
11 | };
12 |
13 | const getPreloadAttributes = ({
14 | assetUrl,
15 | host,
16 | asAttribute,
17 | corsCheck = false,
18 | noPush = true // Disable HTTP/2 Push behaviour until digest spec is implemented by most browsers
19 | }) => {
20 | return (
21 | assetUrl &&
22 | `<${assetUrl}>; rel="preload"; as="${asAttribute}"; ${
23 | noPush ? 'nopush;' : ''
24 | } ${corsCheck ? getCrossOrigin(assetUrl, host) : ''}`.trim()
25 | );
26 | };
27 |
28 | // Early preloading of primary fragments assets to improve Performance
29 | const getFragmentAssetsToPreload = (styleRefs, scriptRefs, { host } = {}) => {
30 | let assetsToPreload = [];
31 |
32 | // Handle Server rendered fragments without depending on assets
33 | if (scriptRefs.length === 0 && styleRefs.length === 0) {
34 | return assetsToPreload;
35 | }
36 |
37 | for (const uri of styleRefs) {
38 | assetsToPreload.push(
39 | getPreloadAttributes({
40 | assetUrl: uri,
41 | asAttribute: 'style'
42 | })
43 | );
44 | }
45 |
46 | for (const uri of scriptRefs) {
47 | assetsToPreload.push(
48 | getPreloadAttributes({
49 | assetUrl: uri,
50 | asAttribute: 'script',
51 | corsCheck: true,
52 | host
53 | })
54 | );
55 | }
56 |
57 | return assetsToPreload;
58 | };
59 |
60 | const nextIndexGenerator = (initialIndex, step) => {
61 | let index = initialIndex;
62 |
63 | return () => {
64 | let pastIndex = index;
65 | index += step;
66 | return pastIndex;
67 | };
68 | };
69 |
70 | const assignHeaders = (to, from) => {
71 | from = Object.assign({}, from);
72 | if (to['set-cookie'] !== undefined && from['set-cookie'] !== undefined) {
73 | from['set-cookie'] = _.uniqBy(
74 | from['set-cookie'].concat(to['set-cookie']),
75 | v => {
76 | const m = v.match(/^(.+?)=/);
77 | if (m && m[1]) {
78 | return m[1].trim();
79 | }
80 |
81 | return v;
82 | }
83 | );
84 | }
85 |
86 | return Object.assign(to, from);
87 | };
88 |
89 | module.exports = {
90 | getCrossOrigin,
91 | getFragmentAssetsToPreload,
92 | nextIndexGenerator,
93 | assignHeaders
94 | };
95 |
--------------------------------------------------------------------------------
/lib/wait-fragment-responses.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | class WaitForFragmentResponses {
4 | #promises = [];
5 |
6 | waitFor(fragment) {
7 | const p = new Promise(function(resolve) {
8 | fragment.on('response', function(statusCode, headers) {
9 | resolve([fragment.attributes, headers]);
10 | });
11 | fragment.on('error', function() {
12 | resolve(null);
13 | });
14 | });
15 |
16 | this.#promises.push(p);
17 | }
18 |
19 | all() {
20 | return Promise.all(this.#promises).then(values =>
21 | values.filter(v => v !== null)
22 | );
23 | }
24 | }
25 |
26 | module.exports = WaitForFragmentResponses;
27 |
--------------------------------------------------------------------------------
/logo/README.md:
--------------------------------------------------------------------------------
1 | # TailorX logo
2 |
3 | 
4 |
5 | ## Credits
6 |
7 | The [original Tailor logo](./tailor-logo.svg) was designed by [Nadya Kuzmina](http://nadyakuzmina.com/).
8 |
--------------------------------------------------------------------------------
/logo/tailor-logo.svg:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
3 | <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
4 | width="500px" height="200px" viewBox="0 0 500 200">
5 | <path fill="#030405" d="M61.915,200c-1.548,0-2.689-0.795-3.131-2.183c-0.747-2.344-3.018-9.475,47.497-79.405
6 | c7.598-10.518,15.338-20.991,22.462-30.489c5.277-9.31,9.899-17.421,13.649-23.82c2.513-4.288,4.439-7.472,5.871-9.705
7 | c-11.398,3.841-39.671,12.17-67.273,19.289C34.762,85.609,8.257,89.861,2.209,86.323c-1.172-0.686-1.817-1.728-1.817-2.934
8 | c0-2.244,2.295-4.986,18.95-9.81C42.529,66.863,88,58.091,132.491,51.751c21.577-3.075,40.346-5.208,54.279-6.171
9 | c24.227-1.673,25.774,0.772,26.518,1.948c0.283,0.448,0.3,1.014,0.045,1.478c-0.256,0.464-0.744,0.752-1.273,0.752
10 | c-20.324,0-36.387,15.765-44.152,25.163c-11.772,14.245-18.124,29.736-18.124,37.079c0,1.444,0.243,2.569,0.703,3.252
11 | c0.387,0.576,0.923,0.833,1.738,0.833c13.065,0,36.324-31.312,50.22-50.02c11.573-15.58,13.809-18.255,15.99-17.045
12 | c0.436,0.242,0.738,0.652,0.851,1.152c0.421,1.867-2.106,5.674-12.246,19.871c-10.264,14.372-29.369,41.124-26.402,46.89
13 | c0.126,0.245,0.461,0.896,2.207,0.896c4.347,0,19.252-12.451,37.476-31.238c1.581-2.841,3.071-5.369,4.218-7.268
14 | c7.818-12.946,18.828-28.443,25.804-33.877c0.972-0.757,3.931-3.063,6.166-1.605c0.478,0.312,1.206,1.084,0.708,2.76
15 | c-1.646,5.535-18.535,25.129-33.591,40.756c-0.305,0.317-0.624,0.646-0.955,0.988c-8.136,14.673-10.054,22.229-9.154,24.26
16 | c0.083,0.187,0.168,0.38,0.724,0.38c3.306,0,17.946-10.418,42.814-33.081c1.5-2.322,3.003-4.623,4.508-6.896
17 | C272.892,55.88,311.08,0,326.789,0c1.009,0,1.82,0.266,2.412,0.792c0.437,0.387,0.956,1.104,0.956,2.321
18 | c0,10.318-44.168,53.412-53.022,61.945c-5.117,4.933-11.31,10.76-17.806,16.675c-24.256,37.522-42.014,71.876-42.014,81.645
19 | c0,1.01,0.206,1.418,0.294,1.548c0.056,0.079,0.131,0.189,0.507,0.189c4.128,0,16.444-16.54,27.31-31.132
20 | c10.423-13.997,22.236-29.861,33.328-41.243c13.236-13.583,23.214-18.316,30.496-14.47c0.591,0.312,0.893,0.986,0.732,1.635
21 | c-0.161,0.648-0.742,1.104-1.411,1.104c-8.982,0-20.562,8.721-30.977,23.329c-9.518,13.35-15.912,28.645-15.912,38.061
22 | c0,2.804,0.562,4.947,1.671,6.37c1.136,1.458,2.851,2.167,5.242,2.167c7.311,0,18.181-9.478,29.077-25.353
23 | c8.067-11.754,14.292-24.512,16.147-32.68c-2.537,0.188-4.861-0.211-6.776-1.475c-1.771-1.17-2.522-3.063-1.958-4.942
24 | c0.764-2.54,3.651-4.314,7.021-4.314c2.188,0,3.396,1.046,4.023,1.924c0.773,1.082,1.167,2.592,1.167,4.489
25 | c0,0.247-0.007,0.501-0.021,0.764c6.134-1.696,13.315-6.043,17.938-8.841c5.232-3.167,6.81-4.125,8.081-3.015
26 | c1.844,1.613,0.156,5.101-13.897,28.713c-5.189,8.72-11.072,18.604-15.305,26.534c-5.535,10.371-6.224,13.653-6.192,14.666
27 | c0.619-0.286,2.301-1.61,5.795-7.681c2.959-5.142,6.409-12.208,10.063-19.689c10.162-20.81,20.67-42.328,29.715-43.839
28 | c2.044-0.34,3.977,0.331,5.59,1.945c8.473,8.473,24.308,10.658,48.409,6.68c22.575-3.726,52.062-12.863,90.145-27.933
29 | c0.747-0.294,1.592,0.07,1.887,0.817s-0.07,1.591-0.816,1.887c-50.74,20.079-87.452,29.993-111.853,29.995
30 | c-13.746,0-23.581-3.144-29.826-9.39c-0.961-0.961-1.933-1.321-3.056-1.133c-7.568,1.264-19.136,24.952-27.583,42.247
31 | c-9.331,19.108-14.401,29.08-18.722,29.08c-0.971,0-1.785-0.452-2.233-1.242c-2.086-3.668,4.626-16.102,21.484-44.429
32 | c5.519-9.27,11.651-19.576,13.535-23.922c-1.07,0.597-2.44,1.426-3.715,2.197c-5.354,3.24-13.04,7.892-19.841,9.435
33 | c-1.654,8.615-8.105,22.117-16.811,34.799c-5.493,8.003-19.556,26.616-31.475,26.616c-3.301,0-5.836-1.105-7.535-3.286
34 | c-1.516-1.947-2.285-4.69-2.285-8.157c0-9.972,6.611-25.945,16.452-39.748c4.265-5.981,8.679-10.984,13.071-14.88
35 | c-13.016,10.983-28.215,31.396-40.541,47.949c-15.362,20.631-24.313,32.305-29.642,32.305c-1.574,0-2.447-0.79-2.902-1.452
36 | c-0.542-0.788-0.806-1.832-0.806-3.193c0-10.692,17.268-43.137,36.89-74.432c-16.014,14.168-31.989,26.945-37.058,26.945
37 | c-1.7,0-2.982-0.896-3.519-2.458c-1.2-3.493,1.507-10.813,5.021-18.082c-11.14,11.035-26.8,25.386-32.898,25.386
38 | c-2.909,0-4.211-1.344-4.792-2.473c-3.501-6.803,9.396-25.792,26.621-49.91c1.904-2.667,3.897-5.458,5.691-8.026
39 | c-1.77,2.331-3.689,4.915-5.588,7.47c-15.142,20.386-38.026,51.194-52.553,51.194c-1.783,0-3.218-0.733-4.15-2.118
40 | c-0.795-1.181-1.197-2.822-1.197-4.875c0-8.047,6.454-24.003,18.79-38.93c6.854-8.294,19.946-21.347,36.865-25.147
41 | c-7.407-0.114-20.366,0.591-41.458,3.04c-0.09,0.173-0.216,0.331-0.377,0.46c-1.208,1.168-13.649,16.966-29.529,38.121
42 | c-1.834,3.236-3.712,6.556-5.606,9.903c-12.333,21.795-26.311,46.499-38.133,66.09C68.233,197.337,64.194,200,61.915,200z
43 | M61.606,197.051c0.002,0,0.071,0.037,0.262,0.042c1.164-0.324,5.774-4.335,23.575-33.898
44 | c9.826-16.316,21.103-36.078,31.651-54.695c-3.435,4.681-6.921,9.474-10.393,14.3c-14.572,20.254-25.862,36.877-33.558,49.407
45 | C59.785,193.958,61.379,196.798,61.606,197.051L61.606,197.051z M312.107,85.078c-2.339,0-3.902,1.128-4.236,2.243
46 | c-0.194,0.647,0.066,1.212,0.774,1.679c1.499,0.99,3.461,1.225,5.673,0.955c0.048-0.484,0.072-0.942,0.072-1.371
47 | c0-1.26-0.216-2.227-0.623-2.797C313.53,85.456,313.129,85.078,312.107,85.078z M3.3,83.425c0.008,0.075,0.058,0.202,0.377,0.388
48 | c2.43,1.421,14.755,3.005,76.586-12.94c25.572-6.595,49.076-13.485,61.801-17.515c-36.113,4.872-76.622,12.034-103.878,18.384
49 | C5.994,79.24,3.493,82.927,3.3,83.425z M254.207,46.441c-0.968,0.395-3.037,1.696-6.869,5.926
50 | c-5.255,5.8-11.877,14.929-17.998,24.694C242.953,62.32,252.504,50.27,254.207,46.441z M326.789,2.907
51 | c-9.127,0-32.892,26.9-60.876,68.806c0.093-0.087,0.188-0.176,0.28-0.262c22.13-20.754,48.605-47.903,57.865-61.769
52 | c3.266-4.889,3.228-6.443,3.181-6.723C327.173,2.938,327.037,2.907,326.789,2.907z M153.042,52.627
53 | c-1.271,1.316-5.306,8.012-10.744,17.417c6.619-8.629,11.826-15.253,14.571-18.584c-0.978,0.119-1.972,0.24-2.982,0.366
54 | c-0.125,0.285-0.339,0.528-0.621,0.687C153.204,52.547,153.129,52.585,153.042,52.627z"/>
55 | <path fill="#030405" d="M260.346,38.726c-0.989,0-1.862-0.323-2.521-0.934c-1.215-1.125-1.441-2.969-0.623-5.06
56 | c1.076-2.745,3.804-5.584,6.508-5.584c0.98,0,1.882,0.371,2.606,1.072c1.481,1.435,1.872,3.395,1.069,5.376
57 | C266.28,36.33,262.99,38.726,260.346,38.726z M263.709,30.056c-1.179,0-3.062,1.851-3.802,3.737
58 | c-0.337,0.863-0.381,1.613-0.108,1.866c0.043,0.04,0.173,0.159,0.547,0.159c1.352,0,3.623-1.528,4.345-3.312
59 | c0.473-1.167-0.001-1.812-0.397-2.197C264.11,30.131,263.936,30.056,263.709,30.056z"/>
60 | </svg>
61 |
--------------------------------------------------------------------------------
/logo/tailorx-logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/StyleT/tailorx/44d13e0288d675061aece19e201503260d1339dc/logo/tailorx-logo.png
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "tailorx",
3 | "version": "7.0.1",
4 | "description": "Tailor assembles a web page from multiple fragments",
5 | "keywords": [
6 | "tailor",
7 | "layout service",
8 | "streaming templates",
9 | "node-tailor"
10 | ],
11 | "scripts": {
12 | "test": "mocha --harmony tests/**",
13 | "coverage": "nyc --reporter=lcov --reporter=text mocha --harmony tests/**",
14 | "codecov": "cat coverage/lcov.info | codecov",
15 | "lint": "eslint .",
16 | "fix": "eslint . --fix",
17 | "benchmark": "node perf/benchmark"
18 | },
19 | "pre-commit": [
20 | "lint",
21 | "test"
22 | ],
23 | "engines": {
24 | "node": ">12.0.0"
25 | },
26 | "repository": {
27 | "type": "git",
28 | "url": "ssh://git@github.com:StyleT/tailorx.git"
29 | },
30 | "license": "Apache-2.0",
31 | "dependencies": {
32 | "@namecheap/error-extender": "^1.1.1",
33 | "agentkeepalive": "^4.1.0",
34 | "device-detector-js": "^2.2.1",
35 | "lodash": "^4.17.15",
36 | "memoizee": "^0.4.14",
37 | "opentracing": "^0.14.3",
38 | "parse5": "^3.0.3",
39 | "util.promisify": "^1.0.0"
40 | },
41 | "devDependencies": {
42 | "babel-eslint": "^10.0.3",
43 | "codecov": "^3.6.2",
44 | "eslint": "^6.8.0",
45 | "eslint-plugin-prettier": "^3.1.2",
46 | "iamdee": "^0.4.0",
47 | "lazypipe": "^1.0.1",
48 | "loadtest": "^2.3.0",
49 | "metrics": "^0.1.11",
50 | "mocha": "^7.0.1",
51 | "nock": "^11.7.2",
52 | "nyc": "^15.0.0",
53 | "pre-commit": "^1.2.2",
54 | "prettier": "^1.19.1",
55 | "proxyquire": "^1.8.0",
56 | "puppeteer": "^1.0.0",
57 | "sinon": "^8.1.1",
58 | "wd": "^1.2.0"
59 | },
60 | "files": [
61 | "lib",
62 | "LICENSE",
63 | "MAINTAINERS",
64 | "index.js",
65 | "index.d.ts",
66 | "README.md",
67 | "src/pipe.min.js",
68 | "yarn.lock"
69 | ],
70 | "types": "index.d.ts",
71 | "nyc": {
72 | "check-coverage": true,
73 | "per-file": true,
74 | "lines": 90,
75 | "statements": 80,
76 | "functions": 80,
77 | "branches": 70
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/perf/benchmark.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const http = require('http');
4 | const metrics = require('metrics');
5 | const { spawn } = require('child_process');
6 | const histogram = new metrics.Histogram.createUniformHistogram();
7 | const html = `
8 | <html>
9 | <head>
10 | <meta charset="utf-8">
11 | <title>Test Page
12 |
13 |
14 |
Fragment 1:
15 |
16 |
17 |
Fragment 2:
18 |
19 |
20 |
21 | `;
22 | const parseTemplate = require('../lib/parse-template')(['fragment'], []);
23 | const requests = new WeakMap();
24 | const fragments = new WeakMap();
25 | const Tailor = require('../');
26 | const processTemplate = require('../lib/process-template');
27 |
28 | const handleTag = (request, tag, options, context) => {
29 | if (tag && tag.name === 'switcher') {
30 | const stream = processTemplate(request, options, context);
31 | process.nextTick(() => {
32 | stream.end({
33 | name: 'fragment',
34 | attributes: { src: 'http://localhost:8081' }
35 | });
36 | });
37 | return stream;
38 | }
39 |
40 | return '';
41 | };
42 |
43 | const tailor = new Tailor({
44 | fetchTemplate: () => Promise.resolve(html).then(parseTemplate),
45 | handleTag,
46 | handledTags: ['switcher']
47 | });
48 |
49 | const getMillisecs = hrTime => {
50 | // [seconds, nanoseconds]
51 | return hrTime && hrTime[0] * 1e3 + hrTime[1] / 1e6;
52 | };
53 |
54 | const updateTailorOverhead = (headersTime, primaryOverhead) => {
55 | let duration = headersTime - primaryOverhead;
56 | histogram.update(duration);
57 | };
58 |
59 | let primaryOverhead = 0;
60 | // Tailor Events to collect Metrics
61 | tailor.on('start', request => {
62 | requests.set(request, process.hrtime());
63 | });
64 |
65 | tailor.on('response', request => {
66 | if (primaryOverhead > 0 && requests.has(request)) {
67 | const startTime = requests.get(request);
68 | const timeToHeaders = getMillisecs(process.hrtime(startTime));
69 | updateTailorOverhead(timeToHeaders, primaryOverhead);
70 | }
71 | });
72 |
73 | tailor.on('end', () => {
74 | // reset
75 | primaryOverhead = 0;
76 | });
77 |
78 | tailor.on('fragment:start', (request, fragment) => {
79 | fragments.set(fragment, process.hrtime());
80 | });
81 |
82 | tailor.on('fragment:response', (request, fragment) => {
83 | const startTime = fragments.get(fragment);
84 | if (fragment.primary) {
85 | primaryOverhead = getMillisecs(process.hrtime(startTime));
86 | }
87 | });
88 |
89 | tailor.on('error', (request, error) => {
90 | console.log('Tailor Error ', error);
91 | });
92 |
93 | // Tailor server
94 | const server = http.createServer(tailor.requestHandler);
95 | server.listen(8080);
96 |
97 | //Mock fragment server
98 | const fragment = spawn('node', ['perf/fragment-server.js']);
99 | // Load testing
100 | const worker = spawn('node', ['perf/loadtest.js']);
101 | worker.stdout.pipe(process.stdout);
102 |
103 | worker.on('close', () => {
104 | console.log(
105 | 'Tailor Overhead Metrics',
106 | JSON.stringify(histogram.printObj(), null, 2)
107 | );
108 | fragment.kill();
109 | worker.kill();
110 | process.exit(0);
111 | });
112 |
--------------------------------------------------------------------------------
/perf/fragment-server.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const http = require('http');
4 | const SIZE = 1024;
5 | const CHARS = '0123456789abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY';
6 | const buffer = Buffer.alloc(SIZE);
7 | for (let i = 0; i < SIZE; i++) {
8 | buffer.write(
9 | CHARS.charAt(Math.round(Math.random() * (CHARS.length - 1))),
10 | i
11 | );
12 | }
13 |
14 | http.createServer((request, response) => {
15 | response.writeHead(200, { 'Content-Type': 'text/html' });
16 | response.write(buffer);
17 | response.end();
18 | }).listen(8081);
19 |
--------------------------------------------------------------------------------
/perf/loadtest.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const loadtest = require('loadtest');
4 | const options = {
5 | url: 'http://localhost:8080',
6 | maxRequests: 5000,
7 | concurrency: 100
8 | };
9 |
10 | loadtest.loadTest(options, (error, result) => {
11 | console.log('LoadTest Metrics', JSON.stringify(result, null, 2));
12 | });
13 |
--------------------------------------------------------------------------------
/tests/fetch-template.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const fetchTemplate = require('../lib/fetch-template');
3 | const assert = require('assert');
4 | const sinon = require('sinon');
5 | const path = require('path');
6 | const fs = require('fs');
7 |
8 | describe('fetch-template', () => {
9 | let mockParseTemplate;
10 | const mockRequest = { url: 'http://localhost:8080/test' };
11 | const templatePath = path.join(__dirname);
12 | const baseTemplatePath = path.join(templatePath, 'base-template.html');
13 | const testTemplatePath = path.join(templatePath, 'test.html');
14 |
15 | before(() => {
16 | fs.writeFileSync(baseTemplatePath, '
base-template
');
17 | fs.writeFileSync(testTemplatePath, '
test
');
18 | });
19 |
20 | beforeEach(() => (mockParseTemplate = sinon.spy()));
21 |
22 | after(() => {
23 | if (fs.existsSync(baseTemplatePath)) {
24 | fs.unlinkSync(baseTemplatePath);
25 | }
26 | if (fs.existsSync(testTemplatePath)) {
27 | fs.unlinkSync(testTemplatePath);
28 | }
29 | });
30 |
31 | afterEach(() => mockParseTemplate.resetHistory());
32 |
33 | describe('templatePath - File', () => {
34 | it('should fetch template from file path', () => {
35 | return fetchTemplate(testTemplatePath)(
36 | mockRequest,
37 | mockParseTemplate
38 | ).then(() => {
39 | assert(mockParseTemplate.calledOnce);
40 | assert(mockParseTemplate.calledWith('
test
'));
41 | });
42 | });
43 |
44 | it('should throw TEMPLATE_NOT_FOUND error on wrong file path', () => {
45 | const wrongTemplatePath = path.join(
46 | templatePath,
47 | 'wrong-template.html'
48 | );
49 | return fetchTemplate(wrongTemplatePath)(
50 | mockRequest,
51 | mockParseTemplate
52 | ).catch(err => {
53 | assert(err.code, 1);
54 | assert(err.presentable, 'template not found');
55 | });
56 | });
57 | });
58 |
59 | describe('templatePath - Dir', () => {
60 | it('should fetch the template with absolute path when baseTemplateFn is falsy', () => {
61 | const baseTemplateFn = () => null;
62 | return fetchTemplate(templatePath, baseTemplateFn)(
63 | mockRequest,
64 | mockParseTemplate
65 | ).then(() => {
66 | assert(mockParseTemplate.calledOnce);
67 | assert(mockParseTemplate.calledWith('
test
'));
68 | });
69 | });
70 |
71 | it('should fetch template with relative path and baseTemplateFn', () => {
72 | const baseTemplateFn = () => 'base-template';
73 |
74 | return fetchTemplate(templatePath, baseTemplateFn)(
75 | mockRequest,
76 | mockParseTemplate
77 | ).then(() => {
78 | assert(mockParseTemplate.calledOnce);
79 | assert(
80 | mockParseTemplate.calledWith(
81 | '
base-template
',
82 | '
test
'
83 | )
84 | );
85 | });
86 | });
87 |
88 | it('should throw TEMPLATE_NOT_FOUND error for wrong template path', () => {
89 | const request = { url: 'http://localhost:8080/unknown' };
90 | return fetchTemplate(templatePath)(
91 | request,
92 | mockParseTemplate
93 | ).catch(err => {
94 | assert(err.code, 1);
95 | assert(err.presentable, 'template not found');
96 | });
97 | });
98 | });
99 | });
100 |
--------------------------------------------------------------------------------
/tests/filter-headers.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const filterHeaders = require('../lib/filter-headers');
3 | const assert = require('assert');
4 |
5 | describe('filter-headers', () => {
6 | const headers = {
7 | 'please-kill-me': '0',
8 | 'accept-language': '1',
9 | referer: '2',
10 | 'user-agent': '3',
11 | 'x-request-uri': '/example',
12 | 'x-request-host': 'localhost'
13 | };
14 |
15 | it('keeps only certain headers', () => {
16 | const after = {
17 | 'accept-language': '1',
18 | referer: '2',
19 | 'user-agent': '3',
20 | 'x-request-uri': '/example',
21 | 'x-request-host': 'localhost'
22 | };
23 | assert.deepEqual(filterHeaders({}, { headers }), after);
24 | });
25 |
26 | it('removes headers if fragment is public', () => {
27 | assert.deepEqual(filterHeaders({ public: true }, { headers }), {});
28 | });
29 | });
30 |
--------------------------------------------------------------------------------
/tests/fragment.events.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const assert = require('assert');
3 | const nock = require('nock');
4 | const sinon = require('sinon');
5 | const Fragment = require('../lib/fragment');
6 | const requestFragment = require('../lib/request-fragment');
7 |
8 | const TAG = { attributes: { src: 'https://fragment' } };
9 | const REQUEST = { headers: {} };
10 | const RESPONSE_HEADERS = { connection: 'close' };
11 | const filterHeaderFn = () => ({});
12 | const processFragmentResponseFn = require('../lib/process-fragment-response');
13 | const getOptions = tag => {
14 | return {
15 | tag,
16 | context: {},
17 | index: false,
18 | requestFragment: requestFragment(
19 | filterHeaderFn,
20 | processFragmentResponseFn
21 | )
22 | };
23 | };
24 |
25 | describe('Fragment events', () => {
26 | it('triggers `start` event', done => {
27 | nock('https://fragment')
28 | .get('/')
29 | .reply(200, 'OK');
30 | const fragment = new Fragment(getOptions(TAG));
31 | fragment.on('start', done);
32 | fragment.fetch(REQUEST);
33 | });
34 |
35 | it('triggers `response(statusCode, headers)` when received headers', done => {
36 | nock('https://fragment')
37 | .get('/')
38 | .reply(200, 'OK', RESPONSE_HEADERS);
39 | const fragment = new Fragment(getOptions(TAG));
40 | fragment.on('response', (statusCode, headers) => {
41 | assert.equal(statusCode, 200);
42 | assert.deepEqual(headers, RESPONSE_HEADERS);
43 | done();
44 | });
45 | fragment.fetch(REQUEST);
46 | });
47 |
48 | it('triggers `end(contentSize)` when the content is succesfully retreived', done => {
49 | nock('https://fragment')
50 | .get('/')
51 | .reply(200, '12345');
52 | const fragment = new Fragment(getOptions(TAG));
53 | fragment.on('end', contentSize => {
54 | assert.equal(contentSize, 5);
55 | done();
56 | });
57 | fragment.fetch(REQUEST);
58 | fragment.stream.resume();
59 | });
60 |
61 | it('triggers `error(error)` when fragment responds with 50x', done => {
62 | nock('https://fragment')
63 | .get('/')
64 | .reply(500);
65 | const fragment = new Fragment(getOptions(TAG));
66 | fragment.on('error', error => {
67 | assert.ok(error);
68 | done();
69 | });
70 | fragment.fetch(REQUEST);
71 | });
72 |
73 | it('should not trigger `response` and `end` if there was an `error`', done => {
74 | const onResponse = sinon.spy();
75 | const onEnd = sinon.spy();
76 | const onError = sinon.spy();
77 | nock('https://fragment')
78 | .get('/')
79 | .reply(500);
80 | const fragment = new Fragment(getOptions(TAG));
81 | fragment.on('response', onResponse);
82 | fragment.on('end', onEnd);
83 | fragment.on('error', onError);
84 | fragment.fetch(REQUEST);
85 | fragment.stream.on('end', () => {
86 | assert.equal(onResponse.callCount, 0);
87 | assert.equal(onEnd.callCount, 0);
88 | assert.equal(onError.callCount, 1);
89 | done();
90 | });
91 | fragment.stream.resume();
92 | });
93 |
94 | it('triggers `error(error)` when there is socket error', done => {
95 | const ERROR = {
96 | message: 'something awful happened',
97 | code: 'AWFUL_ERROR'
98 | };
99 | nock('https://fragment')
100 | .get('/')
101 | .replyWithError(ERROR);
102 | const fragment = new Fragment(getOptions(TAG));
103 | fragment.on('error', error => {
104 | assert.equal(error.message, ERROR.message);
105 | done();
106 | });
107 | fragment.fetch(REQUEST);
108 | });
109 |
110 | it('triggers `error(error)` when fragment times out', done => {
111 | nock('https://fragment')
112 | .get('/')
113 | .socketDelay(101)
114 | .reply(200);
115 | const tag = { attributes: { src: 'https://fragment', timeout: '100' } };
116 | const fragment = new Fragment(getOptions(tag));
117 | fragment.on('error', err => {
118 | assert.equal(err.message, 'socket hang up');
119 | done();
120 | });
121 | fragment.fetch(REQUEST);
122 | });
123 | });
124 |
--------------------------------------------------------------------------------
/tests/fragment.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const Fragment = require('../lib/fragment');
4 | const assert = require('assert');
5 | const getOptions = tag => {
6 | return {
7 | tag,
8 | context: {},
9 | index: false,
10 | requestFragment: () => {}
11 | };
12 | };
13 |
14 | describe('Fragment', () => {
15 | it('computed attributes are correctly initiliazed', () => {
16 | const attributes = {
17 | id: 'foo',
18 | src: 'https://fragment',
19 | async: true,
20 | timeout: '4000',
21 | custom: 'bar',
22 | 'ignore-invalid-ssl': true
23 | };
24 |
25 | const expected = {
26 | id: attributes.id,
27 | url: attributes.src,
28 | async: attributes.async,
29 | forwardQuerystring: false,
30 | returnHeaders: false,
31 | timeout: 4000,
32 | primary: false,
33 | public: false,
34 | ignoreInvalidSsl: attributes['ignore-invalid-ssl'],
35 | custom: attributes.custom
36 | };
37 |
38 | const tag = { attributes };
39 | const fragment = new Fragment(getOptions(tag));
40 | const fattributes = fragment.attributes;
41 |
42 | assert.deepEqual(fattributes, expected);
43 | });
44 | });
45 |
--------------------------------------------------------------------------------
/tests/handle-tag.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | const http = require('http');
5 | const sinon = require('sinon');
6 | const Tailor = require('../index');
7 | const PassThrough = require('stream').PassThrough;
8 |
9 | describe('Handle tag', () => {
10 | let server;
11 | let tailor;
12 | const mockTemplate = sinon.stub();
13 | const mockHandleTag = sinon.stub();
14 |
15 | beforeEach(done => {
16 | tailor = new Tailor({
17 | fetchTemplate: (request, parseTemplate) => {
18 | const template = mockTemplate(request);
19 | if (template) {
20 | return parseTemplate(template);
21 | } else {
22 | return Promise.reject('Error fetching template');
23 | }
24 | },
25 | pipeDefinition: () => Buffer.from(''),
26 | handledTags: ['x-tag'],
27 | handleTag: mockHandleTag
28 | });
29 | server = http.createServer(tailor.requestHandler);
30 | server.listen(8080, 'localhost', done);
31 | });
32 |
33 | afterEach(done => {
34 | mockTemplate.reset();
35 | mockHandleTag.reset();
36 | server.close(done);
37 | });
38 |
39 | it('calls handleTag for a tag in handledTags', done => {
40 | mockTemplate.returns('
test');
41 | mockHandleTag.returns('');
42 | http.get('http://localhost:8080/template', response => {
43 | const request = mockHandleTag.args[0][0];
44 | const tag = mockHandleTag.args[0][1];
45 | assert.equal(request.url, '/template');
46 | assert.deepEqual(tag, {
47 | name: 'x-tag',
48 | attributes: {
49 | foo: 'bar'
50 | }
51 | });
52 | response.resume();
53 | response.on('end', done);
54 | });
55 | });
56 |
57 | it('replaces the original tag with stream or string content', done => {
58 | const st = new PassThrough();
59 | mockTemplate.returns('
');
60 | mockHandleTag.onCall(0).returns(st);
61 | mockHandleTag.onCall(1).returns('');
62 | http.get('http://localhost:8080/template', response => {
63 | let data = '';
64 | response.on('data', chunk => (data += chunk));
65 | response.on('end', () => {
66 | assert.equal(
67 | data,
68 | '
'
69 | );
70 | done();
71 | });
72 | });
73 | st.write('
');
74 | st.end('');
75 | });
76 |
77 | it('should let us inject arbitrary html inside the tags', done => {
78 | mockTemplate.returns('
test
');
79 | mockHandleTag.onCall(0).returns('
');
80 | mockHandleTag.onCall(1).returns('');
81 | http.get('http://localhost:8080/template', response => {
82 | let data = '';
83 | response.on('data', chunk => (data += chunk));
84 | response.on('end', () => {
85 | assert.equal(
86 | data,
87 | '
test
'
88 | );
89 | done();
90 | });
91 | });
92 | });
93 | });
94 |
--------------------------------------------------------------------------------
/tests/parse-link-header.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const parseLinkHeader = require('../lib/parse-link-header');
4 | const assert = require('assert');
5 |
6 | describe('Parse Link Header', () => {
7 | it('returns uri and rel of the passed header', () => {
8 | const linkHeader =
9 | '
; rel="script",; rel="stylesheet"';
10 |
11 | assert.deepStrictEqual(parseLinkHeader(linkHeader), [
12 | { uri: 'http://a.com/app.js', rel: 'script', params: {} },
13 | { uri: 'http://a.com/app.css', rel: 'stylesheet', params: {} }
14 | ]);
15 | });
16 |
17 | it('parse attributes other than rel and uri', () => {
18 | const linkHeader =
19 | '; rel="script"; param1 = value1; param2 = "value2"; param3=value3';
20 |
21 | assert.deepStrictEqual(parseLinkHeader(linkHeader), [
22 | {
23 | uri: 'http://a.com/app.js',
24 | rel: 'script',
25 | params: { param1: 'value1', param2: 'value2', param3: 'value3' }
26 | }
27 | ]);
28 | });
29 |
30 | it('correctly handles invalid header links, for backward compatibility reasons', () => {
31 | const linkHeader = 'http://a.com/app.js; rel=script';
32 |
33 | assert.deepStrictEqual(parseLinkHeader(linkHeader), [
34 | { uri: 'http://a.com/app.js', rel: 'script', params: {} }
35 | ]);
36 | });
37 |
38 | it('filters invalid rel attributes', () => {
39 | const linkHeader =
40 | '; aaa="bbb" ; rel="script";, ; rel="stylesheet", ;, , ; rel=""';
41 |
42 | assert.deepStrictEqual(parseLinkHeader(linkHeader), [
43 | {
44 | uri: 'http://a.com/app.js',
45 | rel: 'script',
46 | params: { aaa: 'bbb' }
47 | },
48 | { uri: 'http://a.com/app1.css', rel: 'stylesheet', params: {} }
49 | ]);
50 | });
51 |
52 | it('do not modify query parms in link urls', () => {
53 | const linkHeader = '; rel="script";';
54 |
55 | assert.deepStrictEqual(parseLinkHeader(linkHeader), [
56 | { uri: 'http://a.com/app.js?nocache=1', rel: 'script', params: {} }
57 | ]);
58 | });
59 |
60 | it('correctly handles empty link header', () => {
61 | const linkHeader = '';
62 |
63 | assert.deepStrictEqual(parseLinkHeader(linkHeader), []);
64 | });
65 | });
66 |
--------------------------------------------------------------------------------
/tests/parse-template.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const parseTemplate = require('../lib/parse-template');
3 | const assert = require('assert');
4 | const parseTempatePartial = parseTemplate([], []);
5 |
6 | describe('parseTemplate', () => {
7 | it('returns a Promise', () => {
8 | assert(parseTempatePartial('template') instanceof Promise);
9 | });
10 |
11 | it('should reject with error for invalid templates', () => {
12 | const template = () => new Error('throw');
13 | parseTempatePartial(template()).catch(err => {
14 | assert(err instanceof Error);
15 | });
16 | });
17 | });
18 |
--------------------------------------------------------------------------------
/tests/process-template.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | // const http = require('http');
5 | const nock = require('nock');
6 | const sinon = require('sinon');
7 |
8 | const stream = require('stream');
9 |
10 | const processTemplate = require('../lib/process-template');
11 | const requestFragment = require('../lib/request-fragment')(
12 | require('../lib/filter-headers'),
13 | require('../lib/process-fragment-response')
14 | );
15 | const AsyncStream = require('../lib/streams/async-stream');
16 | const parseTemplate = require('../lib/parse-template');
17 |
18 | describe('processTemplate', () => {
19 | let resultStream;
20 | let options;
21 | let handleNestedTag;
22 |
23 | beforeEach(() => {
24 | const mockedRequest = {
25 | headers: {},
26 | url: '/'
27 | };
28 |
29 | nock('http://fragment')
30 | .get('/f1')
31 | .reply(200, '', {
32 | Link:
33 | '; rel="fragment-script", ; rel="fragment-script", ; rel="fragment-script",' +
34 | '; rel="fragment-script", ; rel="fragment-script", ; rel="fragment-script"'
35 | })
36 | .get('/f2')
37 | .reply(200, '')
38 | .get('/f3')
39 | .reply(200, '')
40 | .get('/r1')
41 | .reply(200, '')
42 | .get('/r2')
43 | .reply(200, '')
44 | .get('/primary')
45 | .reply(200, '')
46 | .get('/bad')
47 | .reply(500, 'Internal Error');
48 |
49 | handleNestedTag = (request, tag, options, context) => {
50 | if (tag && tag.name === 'nested-fragments') {
51 | // Simulate fetching of some remote resource here
52 | // TODO: who does the parsing???
53 | const stream = processTemplate(request, options, context);
54 | setTimeout(() => {
55 | const remoteEndpointResponse = `
56 |
57 |
58 | `;
59 |
60 | options
61 | .parseTemplate(remoteEndpointResponse, null, false)
62 | .then(template => {
63 | template.forEach(parsedTag => {
64 | stream.write(parsedTag);
65 | });
66 | stream.end();
67 | });
68 | }, 10);
69 | return stream;
70 | }
71 |
72 | return Buffer.from('');
73 | };
74 |
75 | let index = 0;
76 |
77 | options = {
78 | maxAssetLinks: 3,
79 | nextIndex: () => ++index,
80 | fragmentTag: 'fragment',
81 | parseTemplate: parseTemplate(
82 | ['fragment', 'nested-fragments'],
83 | ['script']
84 | ),
85 | asyncStream: new AsyncStream(),
86 | handleTag: handleNestedTag,
87 | requestFragment: requestFragment
88 | };
89 | resultStream = processTemplate(mockedRequest, options, {});
90 | });
91 |
92 | it('returns a stream', () => {
93 | assert(resultStream instanceof stream);
94 | });
95 |
96 | describe('result stream', () => {
97 | it('produces buffers as result', done => {
98 | resultStream.on('data', chunk => {
99 | assert(chunk instanceof Buffer);
100 | });
101 | resultStream.on('end', () => {
102 | done();
103 | });
104 | resultStream.on('fragment:found', ({ attributes: { primary } }) => {
105 | primary && options.asyncStream.end();
106 | });
107 | resultStream.write({ placeholder: 'pipe' });
108 | resultStream.write({
109 | name: 'fragment',
110 | attributes: { id: 'f3', async: true, src: 'http://fragment/f3' }
111 | });
112 | resultStream.write({
113 | name: 'fragment',
114 | attributes: { id: 'f1', src: 'http://fragment/f1' }
115 | });
116 | resultStream.write({
117 | name: 'fragment',
118 | attributes: {
119 | id: 'f2',
120 | primary: true,
121 | src: 'http://fragment/primary'
122 | }
123 | });
124 | resultStream.write({ name: 'nested-fragments' });
125 | resultStream.write({ placeholder: 'async' });
126 | resultStream.end();
127 | });
128 |
129 | it('notifies for every fragment found in the template', done => {
130 | const onFragment = sinon.spy();
131 | resultStream.on('fragment:found', onFragment);
132 | resultStream.on('end', () => {
133 | assert.equal(onFragment.callCount, 3);
134 | done();
135 | });
136 | resultStream.resume();
137 | resultStream.write({
138 | name: 'fragment',
139 | attributes: { id: 'f3', async: true, src: 'http://fragment/f3' }
140 | });
141 | resultStream.write({
142 | name: 'fragment',
143 | attributes: { id: 'f1', src: 'http://fragment/f1' }
144 | });
145 | resultStream.write({
146 | name: 'fragment',
147 | attributes: {
148 | id: 'f2',
149 | primary: true,
150 | src: 'http://fragment/f2'
151 | }
152 | });
153 | resultStream.end();
154 | });
155 | it('write async fragments to a separate stream', done => {
156 | let data = '';
157 | options.asyncStream.on('data', chunk => {
158 | data += chunk.toString();
159 | });
160 |
161 | options.asyncStream.on('end', () => {
162 | assert.equal(
163 | data,
164 | ''
165 | );
166 | done();
167 | });
168 | resultStream.write({
169 | name: 'fragment',
170 | attributes: {
171 | id: 'f3',
172 | async: false,
173 | src: 'http://fragment/f2'
174 | }
175 | });
176 | resultStream.write({
177 | name: 'fragment',
178 | attributes: { id: 'f3', async: true, src: 'http://fragment/f3' }
179 | });
180 | resultStream.end();
181 | options.asyncStream.end();
182 | });
183 | it('handles indexes correctly', done => {
184 | let data = '';
185 |
186 | function assertIndex(index, fragmentText) {
187 | const r = new RegExp(
188 | `.+${fragmentText}.+`,
189 | 'g'
190 | );
191 | const doesMatch = r.test(data);
192 | let message = `No match for the fragmend(index: ${index}, text: ${fragmentText})`;
193 | assert.equal(doesMatch, true, message);
194 | }
195 |
196 | resultStream.on('data', chunk => {
197 | data += chunk.toString();
198 | });
199 | resultStream.on('end', () => {
200 | assertIndex(1, 'NormalFragment\\s3');
201 | assertIndex(2, 'NormalFragment\\s1');
202 | assertIndex(3, 'Primary'); // nested fragments are handled with delay
203 | assertIndex(4, 'RemoteFragment\\s1');
204 | assertIndex(5, 'RemoteFragment\\s2');
205 | done();
206 | });
207 | resultStream.on('fragment:found', ({ attributes: { primary } }) => {
208 | primary && options.asyncStream.end();
209 | });
210 | resultStream.write({ placeholder: 'pipe' });
211 | resultStream.write({
212 | name: 'fragment',
213 | attributes: { id: 'f3', async: true, src: 'http://fragment/f3' }
214 | });
215 | resultStream.write({
216 | name: 'fragment',
217 | attributes: { id: 'f1', src: 'http://fragment/f1' }
218 | });
219 | resultStream.write({ name: 'nested-fragments' });
220 | resultStream.write({
221 | name: 'fragment',
222 | attributes: {
223 | id: 'f2',
224 | primary: true,
225 | src: 'http://fragment/primary'
226 | }
227 | });
228 | resultStream.write({ placeholder: 'async' });
229 | resultStream.end();
230 | });
231 | });
232 | });
233 |
--------------------------------------------------------------------------------
/tests/request-fragment.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const https = require('https');
4 | const sinon = require('sinon');
5 | const assert = require('assert');
6 | const nock = require('nock');
7 | const filterHeaderFn = () => ({});
8 | const processFragmentResponseFn = require('../lib/process-fragment-response');
9 | const requestFragment = require('../lib/request-fragment')(
10 | filterHeaderFn,
11 | processFragmentResponseFn
12 | );
13 |
14 | describe('requestFragment', () => {
15 | let fragmentAttrb;
16 | beforeEach(() => {
17 | fragmentAttrb = {
18 | timeout: 1000
19 | };
20 | });
21 |
22 | it('Should request fragment using http protocol', done => {
23 | nock('http://fragment')
24 | .get('/')
25 | .reply(200, 'HTTP');
26 | requestFragment('http://fragment/', fragmentAttrb, {
27 | headers: {}
28 | }).then(response => {
29 | const chunks = [];
30 | response.on('data', chunk => {
31 | chunks.push(chunk);
32 | });
33 | response.on('end', () => {
34 | const data = Buffer.concat(chunks).toString('utf8');
35 | assert.equal(data, 'HTTP');
36 | done();
37 | });
38 | });
39 | });
40 |
41 | describe('while using HTTPS protocol', () => {
42 | let requestSpy;
43 |
44 | const request = {
45 | headers: {}
46 | };
47 |
48 | beforeEach(() => {
49 | requestSpy = sinon.spy(https, 'request');
50 | nock('https://fragment')
51 | .get('/')
52 | .reply(200, 'HTTPS');
53 | });
54 |
55 | afterEach(() => {
56 | requestSpy.restore();
57 | });
58 |
59 | it('Should request fragment', done => {
60 | const fragmentAttributes = {
61 | ...fragmentAttrb,
62 | ignoreInvalidSsl: false
63 | };
64 |
65 | requestFragment(
66 | 'https://fragment/',
67 | fragmentAttributes,
68 | request
69 | ).then(response => {
70 | let chunks = [];
71 | response.on('data', chunk => {
72 | chunks.push(chunk);
73 | });
74 | response.on('end', () => {
75 | const data = Buffer.concat(chunks).toString('utf8');
76 | assert.equal(data, 'HTTPS');
77 | assert.ok(
78 | requestSpy.neverCalledWithMatch({
79 | rejectUnauthorized: false
80 | })
81 | );
82 | done();
83 | });
84 | });
85 | });
86 |
87 | it('Should ignore invalid SSL certificates while requesting a fragment', done => {
88 | const fragmentAttributes = {
89 | ...fragmentAttrb,
90 | ignoreInvalidSsl: true
91 | };
92 |
93 | requestFragment(
94 | 'https://fragment/',
95 | fragmentAttributes,
96 | request
97 | ).then(response => {
98 | let chunks = [];
99 | response.on('data', chunk => {
100 | chunks.push(chunk);
101 | });
102 | response.on('end', () => {
103 | const data = Buffer.concat(chunks).toString('utf8');
104 | assert.equal(data, 'HTTPS');
105 | assert.ok(
106 | requestSpy.calledWithMatch({
107 | rejectUnauthorized: false
108 | })
109 | );
110 | done();
111 | });
112 | });
113 | });
114 | });
115 |
116 | it('Should reject promise and respond with error for status code >500', done => {
117 | nock('http://fragment')
118 | .get('/')
119 | .reply(500, 'Internal Server Error');
120 | requestFragment('http://fragment/', fragmentAttrb, { headers: {} })
121 | .catch(err => {
122 | assert.equal(
123 | err.message,
124 | 'Request fragment error. statusCode: 500; statusMessage: null; url: http://fragment/;'
125 | );
126 | })
127 | .then(done, done);
128 | });
129 |
130 | it('Should resolve promise for primary fragment with non 2xx response', done => {
131 | nock('http://fragment')
132 | .get('/')
133 | .reply(300, 'Redirect');
134 | requestFragment(
135 | 'http://fragment/',
136 | { ...fragmentAttrb, primary: true },
137 | { headers: {} }
138 | )
139 | .then(response => {
140 | assert.equal(response.statusCode, 300);
141 | })
142 | .then(done, done);
143 | });
144 |
145 | it('Should reject promise for non primary fragment with non 2xx response', done => {
146 | nock('http://fragment')
147 | .get('/')
148 | .reply(300, 'Redirect');
149 | requestFragment(
150 | 'http://fragment/',
151 | { ...fragmentAttrb, primary: false },
152 | { headers: {} }
153 | )
154 | .catch(err => {
155 | assert.equal(
156 | err.message,
157 | 'Request fragment error. statusCode: 300; statusMessage: null; url: http://fragment/;'
158 | );
159 | })
160 | .then(done, done);
161 | });
162 |
163 | it('Should timeout when the fragment is not reachable', done => {
164 | nock('http://fragment')
165 | .get('/')
166 | .socketDelay(1001)
167 | .reply(200, 'hello');
168 | requestFragment('http://fragment/', fragmentAttrb, { headers: {} })
169 | .catch(err => {
170 | assert.equal(err.message, 'socket hang up');
171 | })
172 | .then(done, done);
173 | });
174 | });
175 |
--------------------------------------------------------------------------------
/tests/serializer.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | const parse5 = require('parse5');
5 | const adapter = parse5.treeAdapters.htmlparser2;
6 | const CustomSerializer = require('../lib/serializer');
7 |
8 | describe('Serializer', () => {
9 | const defaultOpts = {
10 | treeAdapter: adapter,
11 | slotMap: new Map(),
12 | handleTags: ['x-tag', 'fragment', 'text/template']
13 | };
14 | const getSerializer = (template, fullRendering = true) => {
15 | const rootNode = parse5.parse(template, { treeAdapter: adapter });
16 | const serializerOpts = Object.assign({}, defaultOpts, {
17 | fullRendering
18 | });
19 | return new CustomSerializer(rootNode, serializerOpts);
20 | };
21 |
22 | it('should output serialized buffer array', () => {
23 | const template = '';
24 | const serializedList = getSerializer(template).serialize();
25 | assert(serializedList instanceof Array);
26 | });
27 |
28 | it('should output placeholder and closing tags for handle tags', () => {
29 | const template = '';
30 | const serializedList = getSerializer(template).serialize();
31 | assert.deepEqual(serializedList[1], { attributes: {}, name: 'x-tag' });
32 | assert.deepEqual(serializedList[2], { closingTag: 'x-tag' });
33 | });
34 |
35 | it('should serialize attributes and child nodes inside handle tags', () => {
36 | const template = 'hello
';
37 | const serializedList = getSerializer(template).serialize();
38 | assert.deepEqual(serializedList[1], {
39 | attributes: { foo: 'bar' },
40 | name: 'x-tag'
41 | });
42 | assert.equal(serializedList[2], 'hello
');
43 | assert.deepEqual(serializedList[3], { closingTag: 'x-tag' });
44 | });
45 |
46 | it('should insert async placeholder before end of body tag', () => {
47 | const template = '';
48 | const serializedList = getSerializer(template).serialize();
49 | assert.equal(
50 | serializedList[0].toString().trim(),
51 | ''
52 | );
53 | assert.deepEqual(serializedList[3], { placeholder: 'async' });
54 | assert.equal(serializedList[4].toString().trim(), '');
55 | });
56 |
57 | it('should not insert palceholders for partial rendering', () => {
58 | const template = '';
59 | const serializedList = getSerializer(template, false).serialize();
60 | assert.equal(
61 | serializedList[0].toString(),
62 | ''
63 | );
64 | assert.deepEqual(serializedList[1], { name: 'x-tag', attributes: {} });
65 | assert.deepEqual(serializedList[2], { closingTag: 'x-tag' });
66 | assert.equal(serializedList[3].toString(), '');
67 | });
68 |
69 | it('should support script based custom tags for inserting in head', () => {
70 | const template =
71 | '';
72 | const serializedList = getSerializer(template).serialize();
73 | assert.equal(serializedList[0].toString().trim(), '');
74 | assert.deepEqual(serializedList[1], {
75 | name: 'fragment',
76 | attributes: {
77 | type: 'fragment',
78 | primary: '',
79 | async: '',
80 | src: 'https://example.com'
81 | },
82 | textContent: ''
83 | });
84 | assert.equal(
85 | serializedList[3].toString().trim(),
86 | ''
87 | );
88 | });
89 |
90 | it('should not serialize script tags that are not text/javascript', () => {
91 | const template =
92 | '';
93 | const serializedList = getSerializer(template).serialize();
94 | assert.equal(serializedList[0].toString().trim(), '');
95 | assert.deepEqual(serializedList[1], {
96 | name: 'text/template',
97 | attributes: { type: 'text/template' },
98 | textContent: 'console.log("yo")'
99 | });
100 | assert.equal(
101 | serializedList[3].toString().trim(),
102 | ''
103 | );
104 | });
105 | });
106 |
--------------------------------------------------------------------------------
/tests/streams/async-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | const stream = require('stream');
5 | const AsyncStream = require('../../lib/streams/async-stream');
6 |
7 | describe('Async Stream', () => {
8 | it('should join streams in the order of data', done => {
9 | const asyncStream = new AsyncStream();
10 | const st1 = new stream.PassThrough();
11 | const st2 = new stream.PassThrough();
12 | let data = '';
13 | asyncStream.write(st1);
14 | asyncStream.end(st2);
15 | st2.end('two');
16 | st1.end('one');
17 | asyncStream.on('data', chunk => {
18 | data += chunk;
19 | });
20 | asyncStream.on('end', () => {
21 | assert.equal(data, 'twoone');
22 | done();
23 | });
24 | });
25 |
26 | it('should end without streams', done => {
27 | const asyncStream = new AsyncStream();
28 | asyncStream.on('data', () => {});
29 | asyncStream.on('end', () => {
30 | done();
31 | });
32 | asyncStream.end();
33 | });
34 |
35 | it('should re-emit errors when fragment stream emit errors', done => {
36 | const asyncStream = new AsyncStream();
37 | const st1 = new stream.PassThrough();
38 | asyncStream.on('error', err => {
39 | assert.equal(err.message, 'Test');
40 | done();
41 | });
42 | asyncStream.end(st1);
43 | st1.emit('error', new Error('Test'));
44 | st1.end('aa');
45 | });
46 | });
47 |
--------------------------------------------------------------------------------
/tests/streams/buffer-concat-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const assert = require('assert');
3 | const BufferConcatStream = require('../../lib/streams/buffer-concat-stream');
4 |
5 | describe('BufferConcatStream', () => {
6 | it('concats the input and calls the callback with the result', done => {
7 | const st = new BufferConcatStream(result => {
8 | assert(result.toString(), 'foobar');
9 | done();
10 | });
11 | st.write(Buffer.from('foo'));
12 | st.end(Buffer.from('bar'));
13 | });
14 | });
15 |
--------------------------------------------------------------------------------
/tests/streams/content-length-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const assert = require('assert');
3 | const ContentLengthStream = require('../../lib/streams/content-length-stream');
4 | const Transform = require('stream').Transform;
5 |
6 | describe('ContentLengthStream', () => {
7 | it('calculates content length and calls callback with the result', done => {
8 | const st = new ContentLengthStream(contentLength => {
9 | assert(contentLength, 'foobar'.length);
10 | done();
11 | });
12 | st.write(Buffer.from('foo'));
13 | st.end(Buffer.from('bar'));
14 | });
15 |
16 | it('is a Transform stream', () => {
17 | const st = new ContentLengthStream(() => {});
18 | assert(st instanceof Transform);
19 | });
20 |
21 | it('passes through data chunks', done => {
22 | const chunk = Buffer.from('foo');
23 | const st = new ContentLengthStream(() => {});
24 | st.on('data', data => {
25 | assert.equal(data, chunk);
26 | done();
27 | });
28 | st.write(chunk);
29 | });
30 | });
31 |
--------------------------------------------------------------------------------
/tests/streams/header-injector-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const assert = require('assert');
3 | const HeadInjectorSream = require('../../lib/streams/head-injector-stream');
4 |
5 | describe('HeadInjectorSream', () => {
6 | it('injects title and meta tags at the end of the "head" tag', done => {
7 | const PAGE1 = '';
8 | const PAGE2 = '';
9 |
10 | const TITLE = 'TEST TITLE';
11 | const META_TAGS =
12 | '';
13 |
14 | const PAGE_RES = `${TITLE}${META_TAGS}`;
15 |
16 | const headers = {
17 | 'x-head-title': Buffer.from(TITLE, 'utf-8').toString('base64'),
18 | 'x-head-meta': Buffer.from(META_TAGS, 'utf-8').toString('base64')
19 | };
20 |
21 | let dataBuf = '';
22 |
23 | const st = new HeadInjectorSream(headers);
24 | st.on('data', data => {
25 | dataBuf += data;
26 | });
27 | st.on('end', () => {
28 | assert.equal(dataBuf, PAGE_RES);
29 | done();
30 | });
31 | st.write(Buffer.from(PAGE1));
32 | st.write(Buffer.from(PAGE2));
33 | st.end();
34 | });
35 |
36 | it('injects title and meta tags at the position of "title" tag', done => {
37 | const PAGE =
38 | '\n\nTPL_TITLE\n\n\n';
39 |
40 | const TITLE = 'TEST TITLE';
41 | const META_TAGS =
42 | '';
43 |
44 | const PAGE_RES = `\n${TITLE}${META_TAGS}\n\n`;
45 |
46 | const headers = {
47 | 'x-head-title': Buffer.from(TITLE, 'utf-8').toString('base64'),
48 | 'x-head-meta': Buffer.from(META_TAGS, 'utf-8').toString('base64')
49 | };
50 |
51 | const st = new HeadInjectorSream(headers);
52 | st.on('data', data => {
53 | assert.equal(data, PAGE_RES);
54 | done();
55 | });
56 | st.write(Buffer.from(PAGE));
57 | });
58 |
59 | it("doesn't break anything", done => {
60 | const PAGE1 = '';
61 | const PAGE2 = '';
62 | const PAGE = PAGE1 + PAGE2;
63 |
64 | const headers = {};
65 |
66 | let dataBuf = '';
67 |
68 | const st = new HeadInjectorSream(headers);
69 | st.on('data', data => {
70 | dataBuf += data;
71 | });
72 | st.on('end', () => {
73 | assert.equal(dataBuf, PAGE);
74 | done();
75 | });
76 | st.write(Buffer.from(PAGE1));
77 | st.write(Buffer.from(PAGE2));
78 | st.end();
79 | });
80 | });
81 |
--------------------------------------------------------------------------------
/tests/streams/seobots-guard-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const assert = require('assert');
3 | const sinon = require('sinon');
4 | const util = require('util');
5 | const setTimeoutPromise = util.promisify(setTimeout);
6 | const EventEmitter = require('events').EventEmitter;
7 |
8 | const BotGuardStream = require('../../lib/streams/seobots-guard-stream');
9 |
10 | const resStub = {
11 | statusCode: 0,
12 | writeHead: () => {}
13 | };
14 | const resStubSpy = sinon.spy(resStub, 'writeHead');
15 |
16 | const headersStub = Object.freeze({
17 | bot: { 'user-agent': 'Googlebot-Image/1.0' },
18 | notBot: {
19 | 'user-agent':
20 | 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.117 Safari/537.36'
21 | }
22 | });
23 |
24 | class Fragment extends EventEmitter {}
25 |
26 | describe('SeoBotsGuardStream', () => {
27 | afterEach(() => {
28 | resStub.statusCode = 0;
29 | resStubSpy.resetHistory();
30 | });
31 |
32 | describe('when processes request from Bot', () => {
33 | it('prevents data flow until all fragments will respond', done => {
34 | const fragment1 = new Fragment();
35 | const fragment2 = new Fragment();
36 | let bothResponded = false;
37 |
38 | const st = new BotGuardStream(true, headersStub.bot, resStub);
39 | st.on('data', data => {
40 | data = Buffer.from(data).toString('utf-8');
41 |
42 | try {
43 | assert.equal(data, 'some test data');
44 | assert.ok(
45 | bothResponded,
46 | 'Data came after response of both fragments'
47 | );
48 | assert.equal(resStub.statusCode, 200);
49 | assert(resStubSpy.calledOnceWith(200, { a: 'b' }));
50 | } catch (e) {
51 | return done(e);
52 | }
53 |
54 | done();
55 | });
56 |
57 | st.write(Buffer.from('some test data'));
58 | st.statusCode = 200;
59 | st.writeHead(200, { a: 'b' });
60 |
61 | st.addFragment(fragment1);
62 | st.addFragment(fragment2);
63 |
64 | setTimeoutPromise(20)
65 | .then(() => fragment1.emit('response'))
66 | .then(() => setTimeoutPromise(20))
67 | .then(() => {
68 | assert.equal(resStub.statusCode, 0);
69 | assert(resStubSpy.notCalled);
70 | fragment2.emit('response');
71 | bothResponded = true;
72 | })
73 | .then(() => setTimeoutPromise(20))
74 | .then(() => st.end())
75 | .catch(e => done(e));
76 | });
77 |
78 | it('emits "error" event while blocking data flow in case of one of the fragments error', done => {
79 | const fragment1 = new Fragment();
80 | const fragment2 = new Fragment();
81 | const fragment3 = new Fragment();
82 |
83 | const st = new BotGuardStream(true, headersStub.bot, resStub);
84 | st.addFragment(fragment1);
85 | st.addFragment(fragment2);
86 | st.addFragment(fragment3);
87 | st.on('data', () => done(new Error('Failed to prevent data flow')));
88 | st.on('error', err => {
89 | try {
90 | assert.equal(resStub.statusCode, 0);
91 | assert(resStubSpy.notCalled);
92 | assert.equal(
93 | err.message,
94 | 'Fragment error while processing request from SEO/SM bot. See adjacent messages for real cause.'
95 | );
96 | } catch (e) {
97 | return done(e);
98 | }
99 |
100 | done();
101 | });
102 |
103 | st.write(Buffer.from('some test data'));
104 | st.statusCode = 200;
105 | st.writeHead(200, { a: 'b' });
106 |
107 | setTimeoutPromise(20)
108 | .then(() => fragment1.emit('response'))
109 | .then(() => setTimeoutPromise(20))
110 | .then(() => {
111 | fragment2.emit('error');
112 | fragment3.emit('error');
113 | st.write(Buffer.from('some test data'));
114 | })
115 | .then(() => setTimeoutPromise(20))
116 | .then(() => st.end())
117 | .catch(e => done(e));
118 | });
119 |
120 | it('does nothing when disabled', done => {
121 | const st = new BotGuardStream(false, headersStub.bot, resStub);
122 | st.on('data', data => {
123 | data = Buffer.from(data).toString('utf-8');
124 |
125 | try {
126 | assert.equal(data, 'some test data');
127 | assert.equal(resStub.statusCode, 200);
128 | assert(resStubSpy.calledOnceWith(200, { a: 'b' }));
129 | } catch (e) {
130 | return done(e);
131 | }
132 |
133 | done();
134 | });
135 |
136 | st.statusCode = 200;
137 | st.writeHead(200, { a: 'b' });
138 | st.write(Buffer.from('some test data'));
139 | });
140 | });
141 | describe('when processes request NOT from Bot', () => {
142 | it('does nothing', done => {
143 | const st = new BotGuardStream(true, headersStub.notBot, resStub);
144 | st.on('data', data => {
145 | data = Buffer.from(data).toString('utf-8');
146 |
147 | try {
148 | assert.equal(data, 'some test data');
149 | assert.equal(resStub.statusCode, 200);
150 | assert(resStubSpy.calledOnceWith(200, { a: 'b' }));
151 | } catch (e) {
152 | return done(e);
153 | }
154 |
155 | done();
156 | });
157 |
158 | st.statusCode = 200;
159 | st.writeHead(200, { a: 'b' });
160 | st.write(Buffer.from('some test data'));
161 | });
162 | });
163 | });
164 |
--------------------------------------------------------------------------------
/tests/streams/stringifier-stream.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | const PassThrough = require('stream').PassThrough;
3 | const assert = require('assert');
4 | const parseTemplate = require('../../lib/parse-template');
5 | const StringifierStream = require('../../lib/streams/stringifier-stream');
6 |
7 | function getTemplate(template, specialTags, pipeBeforeTags) {
8 | specialTags = specialTags || ['fragment'];
9 | pipeBeforeTags = pipeBeforeTags || [];
10 | return parseTemplate(specialTags, pipeBeforeTags)(template);
11 | }
12 |
13 | describe('Stringifier Stream', () => {
14 | function getRandomDelay() {
15 | const max = 30;
16 | const min = 0;
17 | return Math.floor(Math.random() * (max - min + 1)) + min;
18 | }
19 |
20 | function writeDelayedDataToStream(data, stream) {
21 | const chunks = data.split(' ');
22 | setTimeout(() => scheduleChunk(chunks, stream, 0), getRandomDelay());
23 | }
24 |
25 | function scheduleChunk(chunks, stream, index) {
26 | if (index === chunks.length - 1) {
27 | stream.end(chunks[index]);
28 | return;
29 | } else {
30 | stream.write(chunks[index]);
31 | }
32 |
33 | setTimeout(
34 | () => scheduleChunk(chunks, stream, index + 1),
35 | getRandomDelay()
36 | );
37 | }
38 |
39 | it('should stream the content from a fragment tag', done => {
40 | let st = new PassThrough();
41 | const templatePromise = getTemplate(
42 | ''
43 | );
44 | templatePromise.then(nodes => {
45 | let data = '';
46 | const stream = new StringifierStream(tag => {
47 | if (tag && tag.name) {
48 | assert.deepEqual(tag.attributes, { title: 'mock' });
49 | return st;
50 | }
51 | return '';
52 | });
53 | stream.on('data', chunk => {
54 | data += chunk;
55 | });
56 | stream.on('end', () => {
57 | assert.equal(
58 | data,
59 | 'mock'
60 | );
61 | done();
62 | });
63 | nodes.forEach(node => stream.write(node));
64 | stream.end();
65 | st.end('mock');
66 | });
67 | });
68 |
69 | it('should consume stream asynchronously', done => {
70 | const templatePromise = getTemplate(
71 | ''
72 | );
73 | templatePromise.then(nodes => {
74 | let data = '';
75 | let streams = [
76 | new PassThrough(),
77 | new PassThrough(),
78 | new PassThrough()
79 | ];
80 | const stream = new StringifierStream(tag => {
81 | if (tag && tag.name) {
82 | return streams[tag.attributes.id - 1];
83 | }
84 | return '';
85 | });
86 | stream.on('data', chunk => {
87 | data += chunk;
88 | });
89 | stream.on('end', () => {
90 | assert.equal(
91 | data,
92 | '123'
93 | );
94 | done();
95 | });
96 | nodes.forEach(node => stream.write(node));
97 | stream.end();
98 | setTimeout(() => {
99 | streams[0].end('1');
100 | }, 10);
101 |
102 | setTimeout(() => {
103 | streams[1].end('2');
104 | }, 5);
105 |
106 | streams[2].end('3');
107 | });
108 | });
109 |
110 | it('should flush the streams to the client in declared order', done => {
111 | const templatePromise = getTemplate(
112 | ''
113 | );
114 |
115 | templatePromise.then(nodes => {
116 | let data = '';
117 | let streams = [
118 | new PassThrough(),
119 | new PassThrough(),
120 | new PassThrough({ objectMode: true })
121 | ];
122 | const stream = new StringifierStream(tag => {
123 | if (tag && tag.name) {
124 | return streams[tag.attributes.id - 1];
125 | }
126 | return '';
127 | });
128 | stream.on('data', chunk => {
129 | data += chunk;
130 | });
131 | stream.on('end', () => {
132 | assert.equal(
133 | data,
134 | 'DatafromS1DatafromS2DatafromS3'
135 | );
136 | done();
137 | });
138 | nodes.forEach(node => stream.write(node));
139 | stream.end();
140 |
141 | writeDelayedDataToStream('Data from S1', streams[0]);
142 | writeDelayedDataToStream('Data from S2', streams[1]);
143 | writeDelayedDataToStream('Data from S3', streams[2]);
144 | });
145 | });
146 |
147 | it('should emit an error if a fragment is not handled', done => {
148 | getTemplate('').then(nodes => {
149 | let stream = new StringifierStream();
150 | stream.on('error', error => {
151 | assert(error instanceof Error);
152 | done();
153 | });
154 | nodes.forEach(node => stream.write(node));
155 | stream.end();
156 | });
157 | });
158 |
159 | it('should re-emit errors from fragment streams', done => {
160 | getTemplate('').then(nodes => {
161 | let st = new PassThrough();
162 | let stream = new StringifierStream(tag => {
163 | if (tag.name === 'fragment') {
164 | return st;
165 | }
166 | });
167 | stream.on('error', error => {
168 | assert.equal(error.message, 'sorry!');
169 | done();
170 | });
171 | nodes.forEach(node => stream.write(node));
172 | stream.end();
173 | st.emit('error', new Error('sorry!'));
174 | });
175 | });
176 | });
177 |
--------------------------------------------------------------------------------
/tests/tailor.events.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | const http = require('http');
5 | const nock = require('nock');
6 | const sinon = require('sinon');
7 | const Tailor = require('../index');
8 |
9 | describe('Tailor events', () => {
10 | let server;
11 | let tailor;
12 | const mockTemplate = sinon.stub();
13 | const mockContext = sinon.stub();
14 |
15 | beforeEach(done => {
16 | tailor = new Tailor({
17 | fetchContext: mockContext,
18 | pipeDefinition: () => Buffer.from(''),
19 | fetchTemplate: (request, parseTemplate) => {
20 | const template = mockTemplate(request);
21 | if (template) {
22 | return parseTemplate(template);
23 | } else {
24 | return Promise.reject('Error fetching template');
25 | }
26 | }
27 | });
28 | mockContext.returns(Promise.resolve({}));
29 | server = http.createServer(tailor.requestHandler);
30 | server.listen(8080, 'localhost', done);
31 | });
32 |
33 | afterEach(done => {
34 | mockContext.reset();
35 | mockTemplate.reset();
36 | server.close(done);
37 | });
38 |
39 | it('forwards `fragment:start(request, fragment)` event from a fragment', done => {
40 | const onFragmentStart = sinon.spy();
41 | nock('https://fragment')
42 | .get('/')
43 | .reply(200, 'hello');
44 | mockTemplate.returns('');
45 | tailor.on('fragment:start', onFragmentStart);
46 | http.get('http://localhost:8080/template', response => {
47 | const request = onFragmentStart.args[0][0];
48 | const fragment = onFragmentStart.args[0][1];
49 | assert.equal(request.url, '/template');
50 | assert.equal(fragment.url, 'https://fragment');
51 | response.resume();
52 | response.on('end', done);
53 | });
54 | });
55 |
56 | it('emits `start(request)` event', done => {
57 | const onStart = sinon.spy();
58 | nock('https://fragment')
59 | .get('/')
60 | .reply(200, 'hello');
61 | mockTemplate.returns('');
62 | tailor.on('start', onStart);
63 | http.get('http://localhost:8080/template', response => {
64 | response.resume();
65 | response.on('end', () => {
66 | const request = onStart.args[0][0];
67 | assert.equal(request.url, '/template');
68 | assert.equal(onStart.callCount, 1);
69 | done();
70 | });
71 | });
72 | });
73 |
74 | it('emits `response(request, statusCode, headers)` event', done => {
75 | const onResponse = sinon.spy();
76 | mockTemplate.returns('');
77 | tailor.on('response', onResponse);
78 | http.get('http://localhost:8080/template', response => {
79 | response.resume();
80 | response.on('end', () => {
81 | const request = onResponse.args[0][0];
82 | const statusCode = onResponse.args[0][1];
83 | const headers = onResponse.args[0][2];
84 | assert.equal(request.url, '/template');
85 | assert.equal(statusCode, 200);
86 | assert.deepEqual(headers, {
87 | 'Cache-Control': 'no-cache, no-store, must-revalidate',
88 | 'Content-Type': 'text/html',
89 | Pragma: 'no-cache'
90 | });
91 | assert.equal(onResponse.callCount, 1);
92 | done();
93 | });
94 | });
95 | });
96 |
97 | it('emits `end(request, contentSize)` event', done => {
98 | const onEnd = sinon.spy();
99 | mockTemplate.returns(
100 | ''
101 | );
102 | tailor.on('end', onEnd);
103 | http.get('http://localhost:8080/template', response => {
104 | response.resume();
105 | response.on('end', () => {
106 | const request = onEnd.args[0][0];
107 | const contentSize = onEnd.args[0][1];
108 | assert.equal(request.url, '/template');
109 | assert.equal(contentSize, 48);
110 | assert.equal(onEnd.callCount, 1);
111 | done();
112 | });
113 | });
114 | });
115 |
116 | it('emits `error(request, error, response)` event on primary error/timeout', done => {
117 | const onPrimaryError = sinon.stub().callsFake((req, err, res) => {
118 | res.statusCode = 500;
119 | res.end('error response');
120 | });
121 | nock('https://fragment')
122 | .get('/')
123 | .reply(500);
124 | mockTemplate.returns(
125 | ''
126 | );
127 | tailor.on('error', onPrimaryError);
128 | http.get('http://localhost:8080/template', response => {
129 | const request = onPrimaryError.args[0][0];
130 | const error = onPrimaryError.args[0][1];
131 |
132 | assert.equal(request.url, '/template');
133 | assert.equal(error.message, 'Fragment error for "tst_fragment"');
134 |
135 | let rawData = '';
136 | response.on('data', chunk => (rawData += chunk));
137 | response.on('end', () => {
138 | assert.equal(rawData, 'error response');
139 | done();
140 | });
141 | });
142 | });
143 |
144 | it('emits `error(request, error, response)` event on template error', done => {
145 | const onTemplateError = sinon.stub().callsFake((req, err, res) => {
146 | res.statusCode = 500;
147 | res.end('error response');
148 | });
149 | mockTemplate.returns(false);
150 | tailor.on('error', onTemplateError);
151 | http.get('http://localhost:8080/template', response => {
152 | const request = onTemplateError.args[0][0];
153 | const error = onTemplateError.args[0][1];
154 |
155 | assert.equal(request.url, '/template');
156 | assert.equal(error, 'Error fetching template');
157 |
158 | let rawData = '';
159 | response.on('data', chunk => (rawData += chunk));
160 | response.on('end', () => {
161 | assert.equal(rawData, 'error response');
162 | done();
163 | });
164 | });
165 | });
166 |
167 | it('emits `error(request, error, response)` event on error in context function', done => {
168 | const errMsg = 'Error fetching context';
169 | const onContextError = sinon.spy((req, err, res) => {
170 | res.statusCode = 500;
171 | res.end();
172 | });
173 | tailor.on('error', onContextError);
174 |
175 | const rejectPrm = Promise.reject(errMsg);
176 | rejectPrm.catch(() => {});
177 | mockContext.returns(rejectPrm);
178 |
179 | mockTemplate.returns('');
180 |
181 | http.get('http://localhost:8080/template', response => {
182 | const request = onContextError.args[0][0];
183 | const error = onContextError.args[0][1];
184 | assert.equal(request.url, '/template');
185 | assert.equal(error, errMsg);
186 | response.resume();
187 | response.on('end', done);
188 | });
189 | });
190 | });
191 |
--------------------------------------------------------------------------------
/tests/template-cutter.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | const TemplateCutter = require('../lib/template-cutter');
5 |
6 | describe('TemplateCutter', () => {
7 | let templateCutter;
8 |
9 | beforeEach(() => {
10 | templateCutter = new TemplateCutter();
11 | });
12 |
13 | it('should cut and restore a base template and ignore comment tags without a pair', () => {
14 | const baseTemplate =
15 | '' +
16 | '' +
17 | '' +
18 | '' +
19 | '' +
20 | '' +
21 | '' +
22 | '' +
23 | '' +
24 | '' +
25 | '
' +
26 | '' +
27 | '' +
28 | '' +
29 | '' +
30 | '
' +
31 | '' +
32 | '' +
33 | '
' +
34 | '' +
35 | '' +
36 | '' +
37 | '
' +
38 | '' +
39 | '' +
40 | '' +
41 | '
' +
42 | '' +
43 | '' +
46 | '' +
47 | '';
48 |
49 | const correctCuttedBaseTemplate =
50 | '' +
51 | '' +
52 | '' +
53 | '' +
54 | '' +
55 | '' +
56 | '' +
57 | '' +
58 | '' +
59 | '' +
60 | '' +
61 | '
' +
62 | '' +
63 | '' +
64 | '
' +
65 | '' +
66 | '' +
67 | '' +
68 | '
' +
69 | '' +
70 | '' +
73 | '' +
74 | '';
75 |
76 | const chunks = [
77 | '',
78 | '',
79 | Buffer.from(
80 | '' +
81 | '' +
82 | '' +
83 | '',
84 | 'utf-8'
85 | ),
86 | Buffer.from('', 'utf-8'),
87 | '' +
88 | '' +
89 | '' +
90 | '' +
91 | '
',
92 | Buffer.from(`{}`, 'utf-8'),
93 | Buffer.from(
94 | '' +
95 | '' +
96 | '
' +
97 | '' +
98 | '' +
99 | '' +
100 | '
',
101 | 'utf-8'
102 | ),
103 | '' +
104 | '' +
107 | '' +
108 | ''
109 | ];
110 |
111 | const correctRestoredFirstSlot =
112 | '' +
113 | '' +
114 | '' +
115 | '
' +
116 | '' +
117 | '' +
118 | '' +
119 | '' +
120 | '
';
121 | const correctRestoredSecondSlot =
122 | '' +
123 | '' +
124 | '
' +
125 | '' +
126 | '' +
127 | '' +
128 | '
' +
129 | '' +
130 | '' +
131 | '' +
132 | '
';
133 |
134 | const cuttedBaseTemplate = templateCutter.cut(baseTemplate);
135 | const restoredChunks = templateCutter.restore(chunks);
136 |
137 | assert.equal(cuttedBaseTemplate, correctCuttedBaseTemplate);
138 | assert.equal(restoredChunks[4], correctRestoredFirstSlot);
139 | assert.equal(
140 | restoredChunks[6].toString('utf-8'),
141 | correctRestoredSecondSlot
142 | );
143 | assert.equal(restoredChunks.length, chunks.length);
144 | assert.equal(templateCutter.ignoredParts.length, 0);
145 | });
146 |
147 | it('should throw an error when a cutter can not find an ignored part while restoring a base template', () => {
148 | const baseTemplate =
149 | '' +
150 | '' +
151 | '' +
152 | '' +
153 | '' +
154 | '' +
155 | '' +
156 | '' +
157 | '' +
158 | '' +
159 | '
' +
160 | '' +
161 | '' +
162 | '';
163 |
164 | const chunks = [
165 | '',
166 | '',
167 | Buffer.from(
168 | '' +
169 | '' +
170 | '' +
171 | '',
172 | 'utf-8'
173 | ),
174 | Buffer.from('', 'utf-8'),
175 | '' +
176 | '' +
177 | '' +
178 | ''
179 | ];
180 |
181 | let catchedError;
182 |
183 | templateCutter.cut(baseTemplate);
184 |
185 | try {
186 | templateCutter.restore(chunks);
187 | } catch (error) {
188 | catchedError = error;
189 | }
190 |
191 | assert.equal(
192 | catchedError.message,
193 | 'TailorX can not find an ignored part 100 of the current template during restoring!'
194 | );
195 | });
196 | });
197 |
--------------------------------------------------------------------------------
/tests/transform.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | const assert = require('assert');
4 | const sinon = require('sinon');
5 | const proxyquire = require('proxyquire').noPreserveCache();
6 |
7 | describe('Transform', () => {
8 | let Transform;
9 | let transformInstance;
10 |
11 | class MockSerializer {
12 | constructor(node, options) {
13 | this.node = node;
14 | this.options = options;
15 | }
16 | serialize() {}
17 | }
18 |
19 | const mockSerializer = sinon.spy(function() {
20 | return sinon.createStubInstance(MockSerializer);
21 | });
22 | const handleTags = ['x-tag'];
23 | const baseTemplatesCacheSize = 1;
24 |
25 | beforeEach(() => {
26 | Transform = proxyquire('../lib/transform', {
27 | './serializer': mockSerializer
28 | });
29 | transformInstance = new Transform(handleTags, baseTemplatesCacheSize);
30 | });
31 |
32 | afterEach(() => mockSerializer.resetHistory());
33 |
34 | it('should make child Templates optional', () => {
35 | const childTemplate = '';
36 | transformInstance.applyTransforms('', childTemplate);
37 | assert.equal(mockSerializer.callCount, 1); // No errros are thrown
38 | });
39 |
40 | it('should put tags in default slot if type is not defined', () => {
41 | const childTemplate = '';
42 | transformInstance.applyTransforms('', childTemplate);
43 | const slotMap = mockSerializer.args[0][1].slotMap;
44 | assert(slotMap.has('default'));
45 | });
46 |
47 | it('should put comment tags in default slot', () => {
48 | const childTemplate = '';
49 | transformInstance.applyTransforms('', childTemplate);
50 | const slotMap = mockSerializer.args[0][1].slotMap;
51 | assert(slotMap.has('default'));
52 | });
53 |
54 | it('should group slots based on slot types for child Templates', () => {
55 | const childTemplate = `
56 |
57 |
58 |
59 | `;
60 | transformInstance.applyTransforms('', childTemplate);
61 | const slotMap = mockSerializer.args[0][1].slotMap;
62 | assert.equal(slotMap.size, 3);
63 | assert.ok(slotMap.get('default'));
64 | assert.ok(slotMap.has('head'));
65 | assert.ok(slotMap.has('body'));
66 | });
67 |
68 | it('should group text nodes along with the childTemplate nodes', () => {
69 | const childTemplate = `
70 |
71 |
72 | `;
73 | transformInstance.applyTransforms('', childTemplate);
74 | const slotMap = mockSerializer.args[0][1].slotMap;
75 | assert.equal(slotMap.size, 2);
76 | // Text node that symbolizes next line of HTML
77 | assert.equal(slotMap.get('default')[1].type, 'text');
78 | assert.equal(slotMap.get('head')[1].type, 'text');
79 | });
80 |
81 | it('should call serializer with proper options', () => {
82 | transformInstance.applyTransforms('', '');
83 | const options = mockSerializer.args[0][1];
84 | assert(options.slotMap instanceof Map);
85 | assert(options.treeAdapter instanceof Object);
86 | assert.equal(options.handleTags, handleTags);
87 | });
88 | });
89 |
--------------------------------------------------------------------------------