node-turbo 1.0.0

package/test/unit/core/turbo-stream.test.js

@@ -0,0 +1,308 @@
+
+import chai, { expect } from 'chai';
+import eventemitter2 from 'chai-eventemitter2';
+import { TurboStream, TurboElement, TurboStreamElement, TurboReadable } from '#core';
+import { Readable } from 'node:stream';
+
+chai.use(eventemitter2());
+
+const attr = {
+	action: 'a',
+	target: 't'
+};
+
+describe('TurboStream', function() {
+
+	before(function() { 
+		this.stream = new TurboStream(attr, 'c');
+	});
+
+
+	describe('new TurboStream()', function() {
+		it('without arguments creates empty TurboStream instance', function() {
+			const ts = new TurboStream();
+
+			expect(ts).to.be.an.instanceof(TurboStream);
+			expect(ts.elements).to.be.empty;
+		});
+
+
+		it('with arguments adds TurboElement', function() {
+			expect(this.stream.elements[0]).to.be.an.instanceof(TurboElement);
+		});
+	});
+
+
+	describe('addElement()', function() {
+		it('addElement(obj, str) adds TurboElement', function() {
+			this.stream.addElement({ action: 'a2', target: 't2' }, 'c2');
+
+			expect(this.stream.elements[1]).to.be.an.instanceof(TurboElement);
+			expect(this.stream).to.have.lengthOf(2);
+		});
+
+
+		it('addElement(obj, str) assigns correct properties', function() {
+			const ts = new TurboStream().addElement({ action: 'a', target: 't' }, 'c');
+
+			expect(ts.elements[0].attributes).to.be.deep.equal({ action: 'a', target: 't' });
+			expect(ts.elements[0].content).to.be.equal('c');
+		});
+
+
+		it('addElement(element) adds element', function() {
+			const tse = new TurboStreamElement({ action: 'a', target: 't' }, 'c');
+			const ts = new TurboStream().addElement(tse);
+
+			expect(ts.elements[0].attributes).to.be.deep.equal({ action: 'a', target: 't' });
+			expect(ts.elements[0].content).to.be.equal('c');
+		});
+
+
+		it('emits event \'element\' with Turbo Stream element', function() {
+			const ts = new TurboStream({ action: 'a', target: 't' }, 'c');
+			expect(ts).to.emit('element', { withArgs: (element) => element instanceof TurboStreamElement });
+		});
+
+
+		it('is chainable', function() {
+			const ts = new TurboStream().addElement(attr, 'c');
+			
+			expect(ts).to.be.an.instanceof(TurboStream);
+		});
+	});
+
+
+	describe('updateConfig()', function() {
+		it('updates config object', function() {
+			const ts = new TurboStream().updateConfig({ foo: 'bar' });
+			expect(ts.config).to.deep.equal({
+				buffer: true,
+				foo: 'bar'
+			});
+		});
+
+
+		it('emits event \'config\' with config object', function() {
+			const ts = new TurboStream().updateConfig({ foo: 'bar' });
+			expect(ts).to.emit('config', { withArgs: ts.config });
+		});
+
+
+		it('is chainable', function() {
+			const ts = new TurboStream().updateConfig({ foo: 'bar' });
+			expect(ts).to.be.an.instanceof(TurboStream);
+		});
+	});
+
+
+	describe('clear()', function() {
+		it('removes all elements', function() {
+			this.stream.clear();
+			
+			expect(this.stream.elements).to.be.empty;
+		});
+
+		it('emits event \'clear\'', function() {
+			const ts = new TurboStream({ action: 'a', target: 't' }, 'c');
+			ts.clear();
+			expect(ts).to.emit('clear');
+		});
+
+		it('is chainable', function() {
+			const ts = new TurboStream(attr, 'c').clear();
+			
+			expect(ts).to.be.an.instanceof(TurboStream);
+		});
+	});
+
+
+	describe('render()', function() {
+		it('creates correct HTML (single element)', function() {
+			const ts = new TurboStream(attr, 'c');
+			
+			expect(ts.render()).to.equal('<turbo-stream action="a" target="t"><template>c</template></turbo-stream>');
+		});
+
+
+		it('creates correct HTML (multiple elements)', function() {
+			const ts = new TurboStream(attr, 'c')
+				.addElement({ action: 'a2', target: 't2' }, 'c2');
+			
+			expect(ts.render()).to.equal('<turbo-stream action="a" target="t"><template>c</template></turbo-stream>\n<turbo-stream action="a2" target="t2"><template>c2</template></turbo-stream>');
+		});
+
+
+		it('creates correct HTML (additional parameters)', function() {
+			const ts = new TurboStream({ action: 'a', target: 't', foo: 'bar' }, 'c');
+			
+			expect(ts.render()).to.equal('<turbo-stream action="a" target="t" foo="bar"><template>c</template></turbo-stream>');
+		});
+
+
+		it('returns null if there are no elements', function() {
+			const ts = new TurboStream();
+			
+			expect(ts.render()).to.be.null;
+		});
+
+		it('emits event \'render\' with HTML string', function() {
+			const ts = new TurboStream({ action: 'a', target: 't' }, 'c');
+			const html = ts.render();
+
+			expect(ts).to.emit('render', { withArgs: html });
+		});
+	});
+
+
+	describe('flush()', function() {
+		it('removes all elements', function() {
+			const ts = new TurboStream().append('t', 'c');
+			expect(ts.elements).to.not.be.empty;
+			ts.flush();
+			expect(ts.elements).to.be.empty;
+		});
+
+
+		it('returns HTML', function() {
+			const 
+				ts = new TurboStream().append('t', 'c'),
+				html = ts.flush();
+			
+			expect(html).to.equal('<turbo-stream action="append" target="t"><template>c</template></turbo-stream>');
+		});
+
+		it('emits events \'render\' and \'clear\'', function() {
+			const 
+				ts = new TurboStream({ action: 'a', target: 't' }, 'c'),
+				html = ts.flush();
+
+			expect(ts)
+				.to.emit('render', { withArgs: html })
+				.to.emit('clear');
+		});
+	});
+
+
+	describe('Custom actions', function() {
+
+		it('custom() adds TurboElement with custom action', function() {
+			const ts = new TurboStream().custom('custom-name', 't', 'c');
+			expect(ts.elements[0]).to.be.an.instanceof(TurboElement);
+			expect(ts.elements[0].attributes.action).to.equal('custom-name');
+		});
+
+
+		it('customAll() adds TurboElement with custom action and targets attribute', function() {
+			const ts = new TurboStream().customAll('custom-name', '.t', 'c');
+			expect(ts.elements[0]).to.be.an.instanceof(TurboElement);
+			expect(ts.elements[0].attributes.action).to.equal('custom-name');
+			expect(ts.elements[0].attributes.targets).to.equal('.t');
+		});
+
+	});
+
+
+	describe('Action convenience functions', function() {
+		it ('[action]() with target string adds correct target attribute', function() {
+			const ts = new TurboStream();
+			ts.append('t', 'c');
+
+			expect(ts.elements[0].attributes.target).to.equal('t');
+		});
+
+
+		it ('[action]() with attribute object adds correct target attribute', function() {
+			const ts = new TurboStream();
+			ts.append({ target: 't' }, 'c');
+
+			expect(ts.elements[0].attributes.target).to.equal('t');
+		});
+
+
+		it ('[action]() with attribute object can handle additional attributes', function() {
+			const ts = new TurboStream();
+			ts.append({ target: 't', foo: 'bar' }, 'c');
+
+			expect(ts.elements[0].attributes.foo).to.equal('bar');
+		});
+
+		it ('[action]() emits event \'element\'', function() {
+			const ts = new TurboStream();
+			ts.append({ target: 't', foo: 'bar' }, 'c');
+
+			expect(ts).to.emit('element');
+		});
+
+
+		it ('[action]() is chainable', function() {
+			const ts = new TurboStream();
+			const res = ts.append('t', 'c');
+
+			expect(res instanceof TurboStream).to.be.true;
+		});
+
+
+		it ('[action]All() is chainable', function() {
+			const ts = new TurboStream();
+			const res = ts.appendAll('t', 'c');
+
+			expect(res instanceof TurboStream).to.be.true;
+		});
+
+
+		TurboStream.ACTIONS.forEach(action => {
+			it (`${action}() adds TurboElement with action \'${action}\'`, function() {
+				const ts = new TurboStream();
+				ts[action].call(ts, { target: 't' }, 'c');
+
+				expect(ts.elements[0] instanceof TurboElement).to.be.true;
+				expect(ts.elements[0].attributes.action).to.equal(action);
+			});
+
+			if (action === 'remove') {
+				it ('remove() correctly omits <template> and content', function() {
+					const ts = new TurboStream({ action: 'remove', target: 't' });
+					
+					expect(ts.render()).to.equal('<turbo-stream action="remove" target="t"></turbo-stream>');
+				});
+			}
+
+			it (`${action}All() adds TurboElement with action \'${action}\' and targets attribute`, function() {
+				const ts = new TurboStream();
+				ts[action + 'All'].call(ts, '.t', 'c');
+
+				expect(ts.elements[0]).to.be.an.instanceof(TurboElement);
+				expect(ts.elements[0].attributes.action).to.equal(action);
+				expect(ts.elements[0].attributes.targets).to.equal('.t');
+			});	
+		});
+
+	});
+
+	
+	describe('createReadableStream(opts)', function() {
+
+		it('returns new TurboReadable() when opts.continuous = true', function() {
+			const ts = new TurboStream();
+			const readable = ts.createReadableStream();
+			expect(readable).to.be.an.instanceof(TurboReadable);
+		});
+
+		it('returns new Readable() when opts.continuous = false', function() {
+			const ts = new TurboStream().append('t', 'c');
+			const readable = ts.createReadableStream({ continuous: false });
+			expect(readable).not.to.be.an.instanceof(TurboReadable);
+			expect(readable).to.be.an.instanceof(Readable);
+		});
+
+		it('returns new Readable() when opts.continuous = false even if empty', function() {
+			const ts = new TurboStream();
+			const readable = ts.createReadableStream({ continuous: false });
+			expect(readable).not.to.be.an.instanceof(TurboReadable);
+			expect(readable).to.be.an.instanceof(Readable);
+		});
+
+	});
+
+});

package/test/unit/express/express-turbo-stream.test.js

@@ -0,0 +1,39 @@
+
+import chai, { expect } from 'chai';
+import spies from 'chai-spies';
+import { ExpressTurboStream } from '#express';
+import { TurboStream } from '#core';
+
+chai.use(spies);
+const sandbox = chai.spy.sandbox();
+
+
+describe('ExpressTurboStream', function() {
+
+	beforeEach(function() {
+		this.response = {};
+		sandbox.on(this.response, ['send', 'type']);
+	});
+
+
+	afterEach(function() {
+		sandbox.restore();
+	});
+
+
+	it('send() sets correct Content-Type', function() {
+		const kts = new ExpressTurboStream(this.response);
+		kts.send();
+
+		expect(this.response.type).to.have.been.called.with(TurboStream.MIME_TYPE);
+	});
+
+
+	it('send() calls res.send()', function() {
+		const kts = new ExpressTurboStream(this.response);
+		
+		kts.send();
+		expect(this.response.send).to.have.been.called();
+	});
+
+});

package/test/unit/express/turbocharge-express.test.js

@@ -0,0 +1,123 @@
+
+import chai, { expect } from 'chai';
+import spies from 'chai-spies';
+import { turbochargeExpress, ExpressTurboStream } from '#express';
+import { TurboStream } from '#core';
+import { SseTurboStream } from '#sse';
+
+chai.use(spies);
+const sandbox = chai.spy.sandbox();
+
+describe('turbochargeExpress()', function() {
+
+	beforeEach(function() {
+		this.mockExpressApp = {
+			request: {},
+			response: {
+				req: {
+					headers: {
+						'turbo-frame': 'id'
+					}
+				},
+				send: function(content) {
+					this.output = content;
+				},
+				output: ''
+			}
+		};
+
+		sandbox.on(this.mockExpressApp.response, ['set', 'flushHeaders', 'on', 'once', 'emit']);
+	});
+
+	afterEach(function() {
+		sandbox.restore();
+	});
+
+
+	it('adds helper functions to Express\'s request prototype', function() {
+		turbochargeExpress(this.mockExpressApp);
+
+		expect(this.mockExpressApp.request.getTurboFrameId).to.be.a('function');
+		expect(this.mockExpressApp.request.isTurboFrameRequest).to.be.a('function');
+		expect(this.mockExpressApp.request.isTurboStreamRequest).to.be.a('function');
+	});
+
+
+	it('adds turboFrame() to Express\' response prototype', function() {
+		turbochargeExpress(this.mockExpressApp);
+
+		expect(this.mockExpressApp.response.turboFrame).to.be.a('function');
+	});
+
+
+	it('adds turboStream() to Express\' response prototype', function() {
+		turbochargeExpress(this.mockExpressApp);
+
+		expect(this.mockExpressApp.response.turboStream).to.be.a('function');
+	});
+
+	it('turboStream() returns TurboStream when autoSend = false', function() {
+		turbochargeExpress(this.mockExpressApp, { autoSend: false });
+		const ts = this.mockExpressApp.response.turboStream();
+
+		expect(ts).to.be.instanceof(ExpressTurboStream);
+	});
+
+	describe('turboFrame()', function() {
+	
+		it('turboFrame(str, str) correctly calls response.send()', function() {
+			turbochargeExpress(this.mockExpressApp);
+			this.mockExpressApp.response.turboFrame('id', 'c');
+
+			expect(this.mockExpressApp.response.output).to.equal('<turbo-frame id="id">c</turbo-frame>');
+		});
+
+		it('turboFrame(str) correctly retrieves turbo-frame id and calls response.send()', function() {
+			turbochargeExpress(this.mockExpressApp);
+			// Update the mock Express app so response.req has all added 
+			// helper functions of request. 
+			Object.assign(this.mockExpressApp.response.req, this.mockExpressApp.request);
+
+			this.mockExpressApp.response.turboFrame('c');
+			expect(this.mockExpressApp.response.output).to.equal('<turbo-frame id="id">c</turbo-frame>');
+		});
+
+		it('correctly returns HTML when autoSend = false', function() {
+			turbochargeExpress(this.mockExpressApp, { autoSend: false });
+			const html = this.mockExpressApp.response.turboFrame('id', 'c');
+
+			expect(html).to.equal('<turbo-frame id="id">c</turbo-frame>');
+		});
+
+	});
+
+	describe('sseTurboStream()', function() {
+		
+		it('returns SseTurboStream', function() {
+			turbochargeExpress(this.mockExpressApp);
+			const ssets = this.mockExpressApp.response.sseTurboStream();
+
+			expect(ssets).to.be.instanceof(SseTurboStream);
+		});
+
+
+		it('configures Express for an SSE connection', function() {
+			turbochargeExpress(this.mockExpressApp);
+			const ssets = this.mockExpressApp.response.sseTurboStream();
+
+			expect(this.mockExpressApp.response.set).to.have.been.called.with({ 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Content-Type': SseTurboStream.MIME_TYPE });
+			expect(this.mockExpressApp.response.flushHeaders).to.have.been.called();
+		});
+
+		it('pipes to response', function() {
+			turbochargeExpress(this.mockExpressApp);
+			const ssets = this.mockExpressApp.response.sseTurboStream();
+
+			// Pipe
+			expect(this.mockExpressApp.response.on).to.have.been.called();
+		});
+
+
+
+	});
+});

package/test/unit/koa/koa-turbo-stream.test.js

@@ -0,0 +1,56 @@
+
+import { expect } from 'chai';
+import { KoaTurboStream } from '#koa';
+import { TurboStream } from '#core';
+
+
+describe('KoaTurboStream', function() {
+
+	beforeEach(function() {
+		this.ctx = {
+			type: null,
+			body: null,
+			status: null
+		};
+	});
+
+
+	// afterEach(function() {
+	// });
+
+
+	it('Turbo Stream adds element in constructor', function() {
+		const kts = new KoaTurboStream(this.ctx, { action: 'a', target: 't' }, 'c');
+		
+		expect(this.ctx.body).to.not.be.null;
+	});
+
+
+	it('Turbo Stream element gets written to ctx.body', function() {
+		const equalTs = new TurboStream().append('t', 'c');
+		const kts = new KoaTurboStream(this.ctx).append('t', 'c');
+
+		expect(this.ctx.body).to.not.be.null;
+		expect(this.ctx.body.trim()).to.equal(equalTs.render().trim());
+	});
+
+
+	it('Turbo Stream elements don\'t get buffered', function() {
+		const kts = new KoaTurboStream(this.ctx).append('t', 'c');
+		
+		expect(kts.elements).to.be.empty;
+	});
+
+	it('sets status', function() {
+		const kts = new KoaTurboStream(this.ctx);
+		
+		expect(this.ctx.status).to.equal(200);
+	});
+
+	it('sets ctx.body to empty string when not set', function() {
+		const kts = new KoaTurboStream(this.ctx);
+		
+		expect(this.ctx.body).to.equal('');
+	});
+
+});

package/test/unit/koa/turbocharge-koa.test.js

@@ -0,0 +1,141 @@
+
+import chai, { expect } from 'chai';
+import spies from 'chai-spies';
+import { turbochargeKoa } from '#koa';
+import { TurboStream, TurboReadable } from '#core';
+import { SseTurboStream } from '#sse';
+import { Transform } from 'node:stream';
+
+chai.use(spies);
+const sandbox = chai.spy.sandbox();
+
+describe('turbochargeKoa()', function() {
+
+	beforeEach(function() {
+		this.mockKoaApp = {
+			context: {
+				compress: null,
+				body: null,
+				req: {
+					headers: {
+						'turbo-frame': 'id'
+					}
+				}
+			}
+		};
+
+		// sandbox.on(this.mockKoaApp.context.req.socket, ['setTimeout', 'setNoDelay', 'setKeepAlive']);
+		chai.spy.on(this.mockKoaApp.context, 'set');
+	});
+
+
+	afterEach(function() {
+		// sandbox.restore();
+		chai.spy.restore(this.mockKoaApp.context, 'set');
+	});
+
+
+	it('adds helper functions to Koa\'s context prototype', function() {
+		turbochargeKoa(this.mockKoaApp);
+
+		expect(this.mockKoaApp.context.getTurboFrameId).to.be.a('function');
+		expect(this.mockKoaApp.context.isTurboFrameRequest).to.be.a('function');
+		expect(this.mockKoaApp.context.isTurboStreamRequest).to.be.a('function');
+	});
+
+
+	it('adds turboFrame() to Koa\'s context prototype', function() {
+		turbochargeKoa(this.mockKoaApp);
+
+		expect(this.mockKoaApp.context.turboFrame).to.be.a('function');
+	});
+
+
+	it('adds turboStream() to Koa\'s context prototype', function() {
+		turbochargeKoa(this.mockKoaApp);
+
+		expect(this.mockKoaApp.context.turboStream).to.be.a('function');
+	});
+
+
+	it('adds sseTurboStream() to Koa\'s context prototype', function() {
+		turbochargeKoa(this.mockKoaApp);
+
+		expect(this.mockKoaApp.context.sseTurboStream).to.be.a('function');
+	});
+
+
+	it('turboFrame(str, str) correctly writes to context.body', function() {
+		turbochargeKoa(this.mockKoaApp);
+		this.mockKoaApp.context.turboFrame('id', 'c');
+
+		expect(this.mockKoaApp.context.body).to.equal('<turbo-frame id="id">c</turbo-frame>');
+	});
+
+
+	it('turboFrame(str) correctly retrieves turbo-frame id and writes to context.body', function() {
+		turbochargeKoa(this.mockKoaApp);
+		this.mockKoaApp.context.turboFrame('c');
+
+		expect(this.mockKoaApp.context.body).to.equal('<turbo-frame id="id">c</turbo-frame>');
+	});
+
+
+	it('turboFrame() correctly returns HTML when autoRender = false', function() {
+		turbochargeKoa(this.mockKoaApp, { autoRender: false });
+		const html = this.mockKoaApp.context.turboFrame('id', 'c');
+
+		expect(html).to.equal('<turbo-frame id="id">c</turbo-frame>');
+	});
+
+
+	it('turboStream() correctly writes to context.body', function() {
+		turbochargeKoa(this.mockKoaApp);
+		this.mockKoaApp.context.turboStream().append('t', 'c');
+
+		expect(this.mockKoaApp.context.body.trim()).to.equal('<turbo-stream action="append" target="t"><template>c</template></turbo-stream>');
+	});
+
+
+	it('turboStream() returns TurboStream when autoRender = false', function() {
+		turbochargeKoa(this.mockKoaApp, { autoRender: false });
+		const ts = this.mockKoaApp.context.turboStream();
+
+		expect(ts).to.be.instanceof(TurboStream);
+	});
+
+
+	describe('sseTurboStream()', function() {
+		
+		it('returns SseTurboStream', function() {
+			turbochargeKoa(this.mockKoaApp);
+			const ssets = this.mockKoaApp.context.sseTurboStream();//boundSseTurboStream();
+
+			expect(ssets).to.be.instanceof(SseTurboStream);
+		});
+
+
+		it('configures Koa for an SSE connection', function() {
+			turbochargeKoa(this.mockKoaApp);
+			const ssets = this.mockKoaApp.context.sseTurboStream();//boundSseTurboStream();
+
+			expect(this.mockKoaApp.context.compress).to.be.false;
+			// expect(this.mockKoaApp.context.req.socket.setTimeout).to.have.been.called.with(0);
+			// expect(this.mockKoaApp.context.req.socket.setNoDelay).to.have.been.called.with(true);
+			// expect(this.mockKoaApp.context.req.socket.setKeepAlive).to.have.been.called.with(true);
+			expect(this.mockKoaApp.context.set).to.have.been.called.with({ 'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'Content-Type': SseTurboStream.MIME_TYPE });
+			expect(this.mockKoaApp.context.status).to.equal(200);
+			// expect(this.mockKoaApp.context.type).to.equal(SseTurboStream.MIME_TYPE);
+		});
+
+
+		it('sets ctx.body to Transform stream', function() {
+			turbochargeKoa(this.mockKoaApp);
+			const ssets = this.mockKoaApp.context.sseTurboStream();//boundSseTurboStream();
+
+			expect(this.mockKoaApp.context.body).to.be.an.instanceof(Transform);
+		});
+
+	});
+
+});