From b9a2193df78ce57ebdb1aac30712ca9e1ad423ed Mon Sep 17 00:00:00 2001 From: Phil Gold Date: Sun, 22 Oct 2017 22:22:37 -0400 Subject: [PATCH] test: add complete unit tests for utils interface (#5) --- test/utils.test.js | 366 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 360 insertions(+), 6 deletions(-) diff --git a/test/utils.test.js b/test/utils.test.js index 540f8ce..6e0d946 100644 --- a/test/utils.test.js +++ b/test/utils.test.js @@ -4,7 +4,31 @@ const assert = require('assert'); const utils = require('../lib/utils'); describe('utils', function() { + describe('#isFragment', function() { + it('should export a function', function() { + assert.equal(typeof utils.isFragment, 'function'); + }); + + it('should return true for a fragment', function() { + assert.strictEqual(utils.isFragment(['']), true); + assert.strictEqual(utils.isFragment(['', 'hello world']), true); + }); + + it('should return false for non-array types', function() { + assert.strictEqual(utils.isFragment(0), false); + assert.strictEqual(utils.isFragment('no'), false); + assert.strictEqual(utils.isFragment(false), false); + assert.strictEqual(utils.isFragment(null), false); + assert.strictEqual(utils.isFragment(undefined), false); + assert.strictEqual(utils.isFragment({}), false); + }); + }); + describe('#getTagName', function() { + it('should export a function', function() { + assert.equal(typeof utils.getTagName, 'function'); + }); + it('should return the first item as tag name', function() { const node = ['hr']; assert.strictEqual(utils.getTagName(node), 'hr'); @@ -14,37 +38,367 @@ describe('utils', function() { const node = []; assert.strictEqual(utils.getTagName(node), ''); }); + + it('should require a jsonml node', function() { + assert.throws(() => utils.getTagName(), Error); + assert.doesNotThrow(() => utils.getTagName([])); + }); }); describe('#isElement', function() { + it('should export a function', function() { + assert.equal(typeof utils.getTagName, 'function'); + }); + it('should treat a string as element', function() { - assert.ok(utils.isElement('Hello world!')); + assert.strictEqual(utils.isElement('Hello world!'), true); }); it('should treat an array which first item is string as element', function() { - assert.ok(utils.isElement(['hr'])); + assert.strictEqual(utils.isElement(['hr']), true); + }); + + it('should not treat other data types as elements', function() { + [8, true, null, undefined, {}].forEach(val => { + assert.strictEqual(utils.isElement(val), false); + }); }); }); describe('#isAttributes', function() { + it('should export a function', function() { + assert.equal(typeof utils.isAttributes, 'function'); + }); + it('should treat object as attributes', function() { - assert.ok(utils.isAttributes({})); + assert.strictEqual(utils.isAttributes({}), true); }); it('should not treat array as attributes', function() { - assert.ok(!utils.isAttributes([])); + assert.strictEqual(utils.isAttributes([]), false); }); it('should not treat `null` as attributes', function() { - assert.ok(!utils.isAttributes(null)); + assert.strictEqual(utils.isAttributes(null), false); }); it('should not treat `undefined` as attributes', function() { - assert.ok(!utils.isAttributes(undefined)); + assert.strictEqual(utils.isAttributes(undefined), false); }); }); describe('#hasAttributes', function() { + it('should export a function', function() { + assert.equal(typeof utils.hasAttributes, 'function'); + }); + + it('should return true when element has an attributes object', function() { + assert.strictEqual(utils.hasAttributes(['p', {}]), true); + }); + + it('should throw an error when passed an invalid element', function() { + [5, false, undefined, null, {}].forEach(val => { + assert.throws(() => utils.hasAttributes(val), SyntaxError); + }); + assert.doesNotThrow(() => utils.hasAttributes('')); + assert.doesNotThrow(() => utils.hasAttributes([''])); + }); + }); + + describe('#getAttributes', function() { + it('should export a function', function() { + assert.equal(typeof utils.getAttributes, 'function'); + }); + it('should return attributes from an element', function() { + const jml = ['p', { foo: 'bar' }]; + const attrs = utils.getAttributes(jml); + assert.strictEqual(attrs, jml[1]); + }); + + it('should return an empty object when element has no attributes', function() { + const jml = ['p']; + const attrs = utils.getAttributes(jml); + assert.deepEqual(attrs, {}); + assert.strictEqual(jml[1], undefined); + }); + + it('should optionally add an empty attributes object when absent', function() { + const jml = ['p']; + const attrs = utils.getAttributes(jml, true); + assert.deepEqual(attrs, {}); + assert.strictEqual(attrs, jml[1]); + }); + + it('should throw an error when passed an invalid element', function() { + [5, false, undefined, null, {}].forEach(val => { + assert.throws(() => utils.getAttributes(val), SyntaxError); + }); + assert.doesNotThrow(() => utils.getAttributes('')); + assert.doesNotThrow(() => utils.getAttributes([''])); + }); + }); + + describe('#addAttributes', function() { + it('should export a function', function() { + assert.equal(typeof utils.addAttributes, 'function'); + }); + + it('should require valid element and attributes params', function() { + const jml = ['div']; + const attrs = {}; + assert.doesNotThrow(() => utils.addAttributes(jml, attrs)); + assert.throws(() => utils.addAttributes(jml), SyntaxError); + assert.throws(() => utils.addAttributes({}, attrs), SyntaxError); + }); + + it('should add attributes to an element without any', function() { + const jml = ['div', ['p', 'hello world']]; + const attrs = { foo: 'bar' }; + utils.addAttributes(jml, attrs); + assert.strictEqual(jml[1], attrs); + assert.deepEqual(jml, ['div', { foo: 'bar' }, ['p', 'hello world']]); + }); + + it('should merge attributes onto an element with existing attributes', function() { + const jml = ['div', { a: 1, b: 2 }, ['p', 'hello world']]; + const attrs = { a: 'x', c: 3 }; + utils.addAttributes(jml, attrs); + assert.deepEqual(jml, ['div', { a: 'x', b: 2, c: 3 }, ['p', 'hello world']]); + }); + + it('should throw an error if element is a string', function() { + assert.throws(() => utils.setAttribute('hello', {}), Error); + }); + + it('should throw an error when passed an invalid element', function() { + [5, false, undefined, null, {}].forEach(val => { + assert.throws(() => utils.addAttributes(val, {}), SyntaxError); + }); + assert.doesNotThrow(() => utils.addAttributes(['foo'], {})); + }); + }); + + describe('#getAttribute', function() { + it('should export a function', function() { + assert.equal(typeof utils.getAttribute, 'function'); + }); + + it('should return an attribute value by key', function() { + const jml = ['div', { a: 1 }, 'hello world']; + assert.equal(utils.getAttribute(jml, 'a'), 1); + }); + + it('should return undefined if element has no attributes', function() { + const jml = ['div', 'hello world']; + assert.equal(utils.getAttribute(jml, 'a'), undefined); + }); + + it('should throw an error when passed an invalid element', function() { + [5, false, undefined, null, {}].forEach(val => { + assert.throws(() => utils.getAttribute(val), SyntaxError); + }); + assert.doesNotThrow(() => utils.getAttribute('')); + assert.doesNotThrow(() => utils.getAttribute([''])); + }); + }); + + describe('#setAttribute', function() { + it('should export a function', function() { + assert.equal(typeof utils.setAttribute, 'function'); + }); + + it('should set an attriute on an element without any', function() { + const jml = ['p', 'hello world']; + utils.setAttribute(jml, 'a', 1); + assert.deepEqual(jml, ['p', { a: 1 }, 'hello world']); + }); + + it('should set an attribute on an element with existing attributes', function() { + const jml = ['p', { a: 1 }, 'hello world']; + utils.setAttribute(jml, 'b', 2); + assert.deepEqual(jml, ['p', { a: 1, b: 2 }, 'hello world']); + }); + + it('should override an existing attribute value', function() { + const jml = ['p', { a: 1 }, 'hello world']; + utils.setAttribute(jml, 'a', 123); + assert.deepEqual(jml, ['p', { a: 123 }, 'hello world']); + }); + + it('should throw an error if element is a string', function() { + assert.throws(() => utils.setAttribute('hello'), Error); + }); + + it('should throw an error when passed an invalid element', function() { + [5, false, undefined, null, {}].forEach(val => { + assert.throws(() => utils.setAttribute(val), SyntaxError); + }); + assert.doesNotThrow(() => utils.setAttribute([''])); + }); + }); + + describe('#appendChild', function() { + it('should export a function', function() { + assert.equal(typeof utils.appendChild, 'function'); + }); + + it('should throw an error if parent param cannot contain children', function() { + const parent = 'hello'; + const child = 'world'; + assert.throws(() => utils.appendChild(parent, child), SyntaxError); + assert.doesNotThrow(() => utils.appendChild(['p'], child)); + }); + + describe('when appending a fragment', function() { + it('should append all elements', function() { + const jml = ['div']; + const fragment = ['', + ['em', 'hello'], + ['strong', 'world'], + ]; + utils.appendChild(jml, fragment); + assert.deepEqual(jml, ['div', ['em', 'hello'], ['strong', 'world']]); + }); + + // @TODO - is this an intentional mutation? + it('should remove fragment contents', function() { + const jml = ['div']; + const fragment = ['', + ['em', 'hello'], + ['strong', 'world'], + ]; + utils.appendChild(jml, fragment); + assert.deepEqual(fragment, []); + }); + }); + + describe('when appending an element', function() { + it('should throw an error if child is not a valid element', function() { + assert.throws(() => utils.appendChild(['div'], []), SyntaxError); + assert.throws(() => utils.appendChild(['div'], [5]), SyntaxError); + assert.throws(() => utils.appendChild(['div'], [null]), SyntaxError); + assert.throws(() => utils.appendChild(['div'], [true]), SyntaxError); + }); + + it('should append a valid child element', function() { + const jml = ['div']; + const child = ['p']; + utils.appendChild(jml, child); + assert.deepEqual(jml, ['div', child]); + }); + + it('should append element with all descendents', function() { + const jml = ['div', { a: 1}]; + const subtree = ['section', + ['p', 'hello'], + ['p', 'world'], + ]; + utils.appendChild(jml, subtree); + assert.deepEqual(jml, ['div', { a: 1 }, subtree]); + }); + + it('should execute an optional callback before appending (for JBST use)', function(done) { + const jml = ['div']; + const el = ['p']; + utils.appendChild(jml, el, function onAppend(parent, child) { + assert.strictEqual(jml, parent); + assert.strictEqual(el, child); + assert.deepEqual(jml, ['div']); + done(); + }); + }); + }); + + describe('when appending a raw child', function() { + // @TODO - this will currently throw an error due to missing function `isRaw` + xit('should append to the parent', function() { + const jml = ['div']; + const child = new function RawChild() {}; + utils.appendChild(jml, child); + assert.strictEqual(jml, ['div', child]); + }); + }); + + describe('when appending attributes', function() { + // @TODO - this will currently throw an error due to missing function `isRaw` + xit('should add attributes to the parent element', function() { + const jml = ['div']; + const attrs = { a: 1 }; + utils.appendChild(jml, attrs); + assert.deepEqual(jml, ['div', { a: 1 }]); + }); + }); + + describe('when appending a defined, non-null value', function() { + it('should append value to existing text node', function() { + const jml = ['p', { a: 1 }, 'foo']; + utils.appendChild(jml, 'bar'); + assert.deepEqual(jml, ['p', { a: 1 }, 'foobar']); + }); + + it('should coerce value to a string', function() { + const jml = ['p', { a: 1 }, 'foo']; + utils.appendChild(jml, 5); + utils.appendChild(jml, true); + assert.deepEqual(jml, ['p', { a: 1 }, 'foo5true']); + }); + + it('should append text node', function() { + const jml = ['p']; + utils.appendChild(jml, 'hello'); + assert.deepEqual(jml, ['p', 'hello']); + }); + + it('should not append an empty string', function() { + const jml = ['p']; + utils.appendChild(jml, ''); + assert.deepEqual(jml, ['p']); + }); + + // What is the use case for this behavior? + // @TODO investigate and document + it('should append child string to empty parent array', function() { + const jml = []; + utils.appendChild(jml, ''); + assert.deepEqual(jml, ['']); + + utils.appendChild(jml, 'x'); + assert.deepEqual(jml, ['', 'x']); + + utils.appendChild(jml, 'z'); + assert.deepEqual(jml, ['', 'xz']); + }); + }); + }); + + describe('#getChildren', function() { + it('should export a function', function() { + assert.equal(typeof utils.getChildren, 'function'); + }); + + it('should return children when parent has attributes', function() { + const jml = ['div', { a: 1, b: 2 }, + ['p', 'hello world'], + 'more text', + ]; + const children = utils.getChildren(jml); + assert.deepEqual(children, [ + ['p', 'hello world'], + 'more text', + ]); + }); + + it('should return children when parent does not have attributes', function() { + const jml = ['div', + ['p', 'hello world'], + 'more text', + ]; + const children = utils.getChildren(jml); + assert.deepEqual(children, [ + ['p', 'hello world'], + 'more text', + ]); + }); }); });