node-turbo 1.0.0

package/test/integration/ws.test.js

@@ -0,0 +1,155 @@
+
+import { expect } from 'chai';
+import request from 'supertest';
+import { TurboStream } from '#core';
+import { WsTurboStream } from '#ws';
+import { WebSocketServer, WebSocket, createWebSocketStream } from 'ws';
+
+// The port of our test server.
+const port = 8888;
+
+describe('WebSocket integration', function() {
+
+	// Create server.
+	before(function() {
+		this.wss = new WebSocketServer({ port });
+
+		this.wss.on('connection', ws => {
+			ws.on('error', expect.fail);
+		});
+	});
+
+
+	// Close all connections and the server.
+	after(function() {
+		this.wss.clients.forEach(ws => {
+			ws.close();
+
+			// A bit brutal but whatevs.
+			process.nextTick(() => {
+				if ([WebSocket.OPEN, WebSocket.CLOSING].includes(ws.readyState)) {
+					ws.terminate();
+				}
+			});
+		});
+
+		this.wss.close();
+	});
+
+
+	it('Client receives Turbo Stream message (buffer = true)', function() {
+		return new Promise((resolve, reject) => {
+			// Create client.
+			const ws = new WebSocket(`ws://localhost:${port}`, { perMessageDeflate: false });
+
+			ws.on('error', err => {
+				return reject(err);
+			});
+
+			// We're expecting one message with two elements.
+			ws.on('message', data => {
+				expect(data.toString()).to.equal('<turbo-stream action="append" target="t1"><template>c1</template></turbo-stream>\n<turbo-stream action="update" target="t2"><template>c2</template></turbo-stream>');
+				ws.close();
+				resolve();
+			});
+
+			// As soon as the client is ready, the server broadcasts the Turbo Stream message.
+			ws.on('open', () => {
+				this.wss.clients.forEach(ws => {
+					const wsts = new WsTurboStream(ws);
+					wsts
+						.append('t1', 'c1')
+						.update('t2', 'c2')
+						.flush();
+				});
+			});
+		});
+	});
+
+
+	it('Client receives Turbo Stream message (buffer = false)', function() {
+		return new Promise((resolve, reject) => {
+			// Create client.
+			const ws = new WebSocket(`ws://localhost:${port}`, { perMessageDeflate: false });
+			const messages = [];
+
+			ws.on('error', err => {
+				return reject(err);
+			});
+
+			// We're expecting one message with two elements.
+			ws.on('message', data => {
+				messages.push(data.toString());
+				if (messages.length === 2) {
+					expect(messages[0]).to.equal('<turbo-stream action="append" target="t1"><template>c1</template></turbo-stream>');
+					expect(messages[1]).to.equal('<turbo-stream action="update" target="t2"><template>c2</template></turbo-stream>');
+					ws.close();
+					resolve();
+				}
+			});
+
+			// As soon as the client is ready, the server broadcasts the Turbo Stream message.
+			ws.on('open', () => {
+				this.wss.clients.forEach(ws => {
+					 WsTurboStream
+					 	.use(ws)
+						.append('t1', 'c1')
+						.update('t2', 'c2');
+				});
+			});
+		});
+	});
+
+
+	it('Client receives Turbo Stream message through Node.js streams API', function() {
+		return new Promise((resolve, reject) => {
+			// Create client.
+			const ws = new WebSocket(`ws://localhost:${port}`, { perMessageDeflate: false });
+			
+			ws.on('error', err => {
+				return reject(err);
+			});
+
+			const messages = [];
+
+			// We're expecting one message with two elements.
+			ws.on('message', (data, isBinary) => {
+				messages.push(data.toString());
+				if (messages.length === 2) {
+					expect(messages[0]).to.equal('<turbo-stream action="append" target="t1"><template>c1</template></turbo-stream>');
+					expect(messages[1]).to.equal('<turbo-stream action="update" target="t2"><template>c2</template></turbo-stream>');
+					ws.close();
+					resolve();
+				}
+			});
+
+			// As soon as the client is ready, the server broadcasts the Turbo Stream message.
+			ws.once('open', () => {
+				this.wss.clients.forEach(ws => {
+					const ts = new TurboStream();
+					const readable = ts.createReadableStream();
+
+					readable.on('error', err => {
+						return reject(err);
+					});
+
+					const wsStream = createWebSocketStream(ws, { encoding: 'utf8' });
+
+					wsStream.on('error', err => {
+						return reject(err);
+					});
+
+					// Pipe TurboReadable to the WS duplex stream.
+					readable.pipe(wsStream);
+					
+					// Write to TurboReadable.
+					ts.append('t1', 'c1').update('t2', 'c2');
+				});
+			});
+		});
+	});
+
+});
+
+
+

package/test/package.test.js

@@ -0,0 +1,68 @@
+
+import { expect } from 'chai';
+import * as core from 'node-turbo';
+import * as ws from 'node-turbo/ws';
+import * as koa from 'node-turbo/koa';
+import * as express from 'node-turbo/express';
+import * as sse from 'node-turbo/sse';
+import * as errors from 'node-turbo/errors';
+
+const importedModules = { core, ws, koa, express, sse, errors };
+const expectedModules = {
+	core: [
+		'TurboFrame',
+		'TurboStream',
+		'TurboStreamElement',
+		'TurboElement',
+		'TurboReadable',
+		'isTurboFrameRequest',
+		'isTurboStreamRequest',
+		'getTurboFrameId'
+	],
+	ws: [
+		'WsTurboStream'
+	],
+	koa: [
+		'turbochargeKoa',
+		'KoaTurboStream'
+	],
+	express: [
+		'turbochargeExpress',
+		'ExpressTurboStream'
+	],
+	sse: [
+		'SseTurboStream'
+	],
+	errors: [
+		'ValidationError',
+		'AttributeMalformedError',
+		'AttributeMissingError',
+		'AttributeInvalidError'
+	]
+};
+
+function sameMembers(arr1, arr2) {
+	const set1 = new Set(arr1);
+	const set2 = new Set(arr2);
+	return arr1.every(item => set2.has(item)) &&
+		arr2.every(item => set1.has(item))
+}
+
+describe('Package', function() {
+
+	Object.keys(expectedModules).forEach(modName => {
+		describe(modName, function() {
+			expectedModules[modName].forEach(name => {
+				it(`${name} should be exposed`, function() {
+					expect(importedModules[modName][name]).to.be.a('function');
+				});
+			});
+
+			it(`Nothing else should be exposed`, function() {
+				expect(sameMembers(Object.keys(importedModules[modName]), expectedModules[modName])).to.be.true;
+			});
+
+		});
+	});
+
+});

package/test/unit/core/request-helpers.test.js

@@ -0,0 +1,97 @@
+
+import { expect } from 'chai';
+import * as hlp from '../../../lib/request-helpers.js';
+import httpMocks from 'node-mocks-http';
+
+describe('Request helpers', function() {
+
+	describe('isTurboStreamRequest()', function() {
+		
+		it('returns true on recognised MIME type', function() {
+			const req = httpMocks.createRequest({
+				method: 'POST',
+				url: '/',
+				headers: {
+					'Accept': 'text/html',
+					'Accept': 'text/vnd.turbo-stream.html'
+				}
+			});
+
+			expect(hlp.isTurboStreamRequest(req)).to.be.true;
+		});
+
+
+		it('returns false on missing MIME type', function() {
+			const req = httpMocks.createRequest({
+				method: 'POST',
+				url: '/',
+				headers: {
+					'Accept': 'text/html'
+				}
+			});
+
+			expect(hlp.isTurboStreamRequest(req)).to.be.false;
+		});
+
+
+		it('returns false when missing headers fields', function() {
+			expect(hlp.isTurboStreamRequest({})).to.be.false;
+		});
+
+	});
+
+	describe('isTurboFrameRequest()', function() {
+
+		it('returns true on recognised turbo-frame', function() {
+			const req = httpMocks.createRequest({
+				method: 'POST',
+				url: '/',
+				headers: {
+					'turbo-frame': 'name',
+				}
+			});
+
+			expect(hlp.isTurboFrameRequest(req)).to.be.true;
+		});
+
+
+		it('returns false on missing turbo-frame', function() {
+			const req = httpMocks.createRequest({
+				method: 'POST',
+				url: '/',
+				headers: {
+				}
+			});
+
+			expect(hlp.isTurboFrameRequest(req)).to.be.false;
+		});
+
+		it('returns false when missing headers fields', function() {
+			expect(hlp.isTurboFrameRequest({})).to.be.false;
+		});
+
+	});
+
+
+	describe('getTurboFrameId()', function() {
+		
+		it('returns ID of turbo-frame if available', function() {
+			const req = httpMocks.createRequest({
+				method: 'POST',
+				url: '/',
+				headers: {
+					'turbo-frame': 'name',
+				}
+			});
+
+			expect(hlp.getTurboFrameId(req)).to.equal('name');
+		});
+
+		it('returns null in any other case', function() {
+			expect(hlp.getTurboFrameId({})).to.be.null;
+		});
+
+	});
+
+
+});

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

@@ -0,0 +1,15 @@
+
+import { expect } from 'chai';
+import { TurboElement } from '#core';
+
+describe('TurboElement', function() {
+	
+	it('Constructor correctly assigns properties (and throws Error)', function() {
+		expect(function() {
+			const el = new TurboElement({ foo: 'bar' }, 'c');
+			expect(el.content).to.equal('c');
+			expect(el.attributes).to.deep.equal({ foo: 'bar' });
+		}).to.throw();
+	});
+	
+});

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

@@ -0,0 +1,63 @@
+
+import { expect } from 'chai';
+import { TurboFrame } from '#core';
+import { AttributeMissingError, AttributeMalformedError } from '#errors';
+
+describe('TurboFrame', function() {
+
+	it('Constructor with id string correctly assigns attributes', function() {
+		const tf = new TurboFrame('id', 'c');
+		expect(tf.attributes).to.deep.equal({ id: 'id' });
+		expect(tf.content).to.equal('c');
+	});
+
+
+	it('Constructor with attribute object correctly assigns attributes', function() {
+		const tf = new TurboFrame({ id: 'id', foo: 'bar' }, 'c');
+		expect(tf.attributes).to.deep.equal({ id: 'id', foo: 'bar' });
+		expect(tf.content).to.equal('c');
+	});
+
+
+	it('Error is thrown when missing attribute "id"', function() {		
+		expect(function() {
+			const tf = new TurboFrame();	
+		}).to.throw();
+
+		expect(function() {
+			const tf = new TurboFrame({});	
+		}).to.throw();
+
+		expect(function() {
+			const tf = new TurboFrame({ id: null });	
+		}).to.throw();
+	});
+
+
+	it('Error is thrown when attribute "id" is malformed', function() {
+		expect(function() {
+			const tf = new TurboFrame(8);	
+		}).to.throw();
+
+		expect(function() {
+			const tf = new TurboFrame({ id: 12 });	
+		}).to.throw();
+
+		expect(function() {
+			const tf = new TurboFrame('');	
+		}).to.throw();
+	});
+
+
+	it('render() creates correct HTML', function() {
+		const tf = new TurboFrame('id', 'c');
+		expect(tf.render()).to.equal('<turbo-frame id="id">c</turbo-frame>');
+	});
+
+
+	it('render() creates correct HTML (additional attributes)', function() {
+		const tf = new TurboFrame({ id: 'id', foo: 'bar' }, 'c', );
+		expect(tf.render()).to.equal('<turbo-frame id="id" foo="bar">c</turbo-frame>');
+	});
+
+});

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

@@ -0,0 +1,93 @@
+
+import chai, { expect } from 'chai';
+import spies from 'chai-spies';
+import eventemitter2 from 'chai-eventemitter2';
+import { TurboStream, TurboElement, TurboStreamElement, TurboReadable } from '#core';
+import { Readable } from 'node:stream';
+
+chai.use(eventemitter2());
+chai.use(spies);
+// const sandbox = chai.spy.sandbox();
+
+const attr = {
+	action: 'a',
+	target: 't'
+};
+
+describe('TurboReadable', function() {
+
+	before(function() { 
+		this.ts = new TurboStream()
+		this.readable = new TurboReadable(this.ts);
+	});
+
+
+	beforeEach(function() {
+		chai.spy.on(this.readable, 'push');
+	});
+
+
+	afterEach(function() {
+		chai.spy.restore(this.readable, 'push');
+	});
+
+
+	it('new TurboReadable() pushes existing elements', function() {
+		const ts = new TurboStream()
+			.append('t', 'c')
+			.append('t2', 'c2');
+		const readable = new TurboReadable(ts);
+		const data = [];
+
+		return new Promise((resolve, reject) => {
+			readable.on('data', chunk => {
+				data.push(chunk);
+
+				if (data.length == 2) {
+					expect(data.length).to.equal(2);
+					readable.done();
+					resolve();
+				}
+			});
+
+			readable.on('error', err => reject(err));
+		});
+		
+	});
+
+
+	it('new TurboReadable() throws error if argument not TurboStream', function() {
+		expect(function() {
+			const readable = new TurboReadable({ foo: 'bar' });
+		}).to.throw();
+	});
+
+
+	it('_pushElement() calls push()', function() {
+		this.readable._pushElement(new TurboStreamElement({ action: 'a', target: 't' }));
+		expect(this.readable.push).to.have.been.called();
+	});
+
+
+	it('_boundPush() is bound to _pushElement', function() {
+		expect(this.readable._boundPush.name).to.be.equal('bound _pushElement');
+	});
+
+
+	it('_destroy() gets called when steam is destroyed', function() {
+		const readable = this.ts.createReadableStream();
+		chai.spy.on(readable, '_destroy');
+		readable.destroy();
+
+		expect(readable._destroy).to.have.been.called();
+		chai.spy.restore(readable, '_destroy');
+	});
+
+
+	it('done() calls push(null)', function() {
+		this.readable.done();
+		
+		expect(this.readable.push).to.have.been.called.with(null);
+	});
+
+});

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

@@ -0,0 +1,76 @@
+
+import { expect } from 'chai';
+import { TurboStreamElement } from '#core';
+
+describe('TurboStreamElement', function() {
+	
+	it('Error is thrown when missing attributes object', function() {
+		expect(function() {
+			const tse = new TurboStreamElement();
+		}).to.throw();
+	});
+
+
+	it(`Error is thrown when missing attribute "action"`, function() {		
+		expect(function() {
+			const tse = new TurboStreamElement({ target: 't' });	
+		}).to.throw();
+
+		expect(function() {
+			const tse = new TurboStreamElement({ target: 't', action: null });	
+		}).to.throw();
+	});
+
+
+	it(`Error is thrown when attribute "action" is malformed`, function() {
+		expect(function() {
+			const tse = new TurboStreamElement({ target: 't', action: 8 });	
+		}).to.throw();
+
+		expect(function() {
+			const tse = new TurboStreamElement({ target: 't', action: '' });	
+		}).to.throw();
+	});
+
+
+	it(`Error is thrown when missing attribute "target" or "targets"`, function() {		
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a' });	
+		}).to.throw();
+
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a', target: null });	
+		}).to.throw();
+	});
+
+
+	it(`Error is thrown when attribute "target" is malformed`, function() {
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a', target: 8 });	
+		}).to.throw();
+
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a', target: '' });	
+		}).to.throw();
+	});
+
+
+	it(`Error is thrown when attribute "targets" is malformed`, function() {
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a', targets: 8 });	
+		}).to.throw();
+
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a', targets: '' });	
+		}).to.throw();
+	});
+
+
+	it(`Error is thrown when attributes "target" and "targets" are present`, function() {		
+		expect(function() {
+			const tse = new TurboStreamElement({ action: 'a', target: 't', targets: 'ts' });	
+		}).to.throw();
+
+	});
+
+});