Move tests to helpers.config.tests.js

Author: kurkle

src/helpers/helpers.config.js

@@ -151,7 +151,7 @@ function _resolveSubKeys(parentScopes, prop, value) {
 	const keys = [prop];
 	if (defined(fallback)) {
 		const resolved = isFunction(fallback) ? fallback(prop, value) : fallback;
-		keys.unshift(...(isArray(resolved) ? resolved : [resolved]));
+		keys.push(...(isArray(resolved) ? resolved : [resolved]));
 	}
 	return keys.filter(v => v);
 }

test/specs/helpers.config.tests.js

@@ -0,0 +1,240 @@
+describe('Chart.helpers.config', function() {
+	const {getHoverColor, _createResolver, _attachContext} = Chart.helpers;
+
+	describe('_createResolver', function() {
+		it('should resolve to raw values', function() {
+			const defaults = {
+				color: 'red',
+				backgroundColor: 'green',
+				hoverColor: (ctx, options) => getHoverColor(options.color)
+			};
+			const options = {
+				color: 'blue'
+			};
+			const resolver = _createResolver([options, defaults]);
+			expect(resolver.color).toEqual('blue');
+			expect(resolver.backgroundColor).toEqual('green');
+			expect(resolver.hoverColor).toEqual(defaults.hoverColor);
+		});
+
+		it('should resolve to parent scopes', function() {
+			const defaults = {
+				root: true,
+				sub: {
+					child: true
+				}
+			};
+			const options = {
+				child: 'sub default comes before this',
+				opt: 'opt'
+			};
+			const resolver = _createResolver([options, defaults]);
+			const sub = resolver.sub;
+			expect(sub.root).toEqual(true);
+			expect(sub.child).toEqual(true);
+			expect(sub.opt).toEqual('opt');
+		});
+
+		it('should follow _fallback', function() {
+			const defaults = {
+				interaction: {
+					mode: 'test',
+					priority: 'fall'
+				},
+				hover: {
+					_fallback: 'interaction',
+					priority: 'main'
+				}
+			};
+			const options = {
+				interaction: {
+					a: 1
+				},
+				hover: {
+					b: 2
+				}
+			};
+			const resolver = _createResolver([options, defaults]);
+			expect(resolver.hover).toEqualOptions({
+				mode: 'test',
+				priority: 'main',
+				a: 1,
+				b: 2
+			});
+		});
+	});
+
+	describe('_attachContext', function() {
+		it('should resolve to final values', function() {
+			const defaults = {
+				color: 'red',
+				backgroundColor: 'green',
+				hoverColor: (ctx, options) => getHoverColor(options.color)
+			};
+			const options = {
+				color: ['white', 'blue']
+			};
+			const resolver = _createResolver([options, defaults]);
+			const opts = _attachContext(resolver, {index: 1});
+			expect(opts.color).toEqual('blue');
+			expect(opts.backgroundColor).toEqual('green');
+			expect(opts.hoverColor).toEqual(getHoverColor('blue'));
+		});
+
+		it('should thrown on recursion', function() {
+			const options = {
+				foo: (ctx, opts) => opts.bar,
+				bar: (ctx, opts) => opts.xyz,
+				xyz: (ctx, opts) => opts.foo
+			};
+			const resolver = _createResolver([options]);
+			const opts = _attachContext(resolver, {test: true});
+			expect(function() {
+				return opts.foo;
+			}).toThrowError('Recursion detected: foo->bar->xyz->foo');
+		});
+
+		it('should support scriptable options in subscopes', function() {
+			const defaults = {
+				elements: {
+					point: {
+						backgroundColor: 'red'
+					}
+				}
+			};
+			const options = {
+				elements: {
+					point: {
+						borderColor: (ctx, opts) => getHoverColor(opts.backgroundColor)
+					}
+				}
+			};
+			const resolver = _createResolver([options, defaults]);
+			const opts = _attachContext(resolver, {});
+			expect(opts.elements.point.borderColor).toEqual(getHoverColor('red'));
+			expect(opts.elements.point.backgroundColor).toEqual('red');
+		});
+
+		it('same resolver should be usable with multiple contexts', function() {
+			const defaults = {
+				animation: {
+					delay: 10
+				}
+			};
+			const options = {
+				animation: (ctx) => ctx.index === 0 ? {duration: 1000} : {duration: 500}
+			};
+			const resolver = _createResolver([options, defaults]);
+			const opts1 = _attachContext(resolver, {index: 0});
+			const opts2 = _attachContext(resolver, {index: 1});
+
+			expect(opts1.animation.duration).toEqual(1000);
+			expect(opts1.animation.delay).toEqual(10);
+
+			expect(opts2.animation.duration).toEqual(500);
+			expect(opts2.animation.delay).toEqual(10);
+		});
+
+		it('should fall back from object returned from scriptable option', function() {
+			const defaults = {
+				mainScope: {
+					main: true,
+					subScope: {
+						sub: true
+					}
+				}
+			};
+			const options = {
+				mainScope: (ctx) => ({
+					mainTest: ctx.contextValue,
+					subScope: {
+						subTest: 'a'
+					}
+				})
+			};
+			const opts = _attachContext(_createResolver([options, defaults]), {contextValue: 'test'});
+			expect(opts.mainScope).toEqualOptions({
+				main: true,
+				mainTest: 'test',
+				subScope: {
+					sub: true,
+					subText: 'a'
+				}
+			});
+		});
+
+		it('should resolve array of non-indexable objects properly', function() {
+			const defaults = {
+				label: {
+					value: 42,
+					text: (ctx) => ctx.text
+				},
+				labels: {
+					_fallback: 'label',
+					_indexable: false
+				}
+			};
+
+			const options = {
+				labels: [{text: 'a'}, {text: 'b'}, {value: 1}]
+			};
+			const opts = _attachContext(_createResolver([options, defaults]), {text: 'context'});
+			expect(opts.labels).toEqualOptions([
+				{
+					text: 'a',
+					value: 42
+				},
+				{
+					text: 'b',
+					value: 42
+				},
+				{
+					text: 'context',
+					value: 1
+				}
+			]);
+		});
+
+		describe('_indexable and _scriptable', function() {
+			it('should default to true', function() {
+				const options = {
+					array: [1, 2, 3],
+					func: (ctx) => ctx.index * 10
+				};
+				const opts = _attachContext(_createResolver([options]), {index: 1});
+				expect(opts.array).toEqual(2);
+				expect(opts.func).toEqual(10);
+			});
+
+			it('should allow false', function() {
+				const fn = () => 'test';
+				const options = {
+					_indexable: false,
+					_scriptable: false,
+					array: [1, 2, 3],
+					func: fn
+				};
+				const opts = _attachContext(_createResolver([options]), {index: 1});
+				expect(opts.array).toEqual([1, 2, 3]);
+				expect(opts.func).toEqual(fn);
+				expect(opts.func()).toEqual('test');
+			});
+
+			it('should allow function', function() {
+				const fn = () => 'test';
+				const options = {
+					_indexable: (prop) => prop !== 'array',
+					_scriptable: (prop) => prop === 'func',
+					array: [1, 2, 3],
+					array2: ['a', 'b', 'c'],
+					func: fn
+				};
+				const opts = _attachContext(_createResolver([options]), {index: 1});
+				expect(opts.array).toEqual([1, 2, 3]);
+				expect(opts.func).toEqual('test');
+				expect(opts.array2).toEqual('b');
+			});
+		});
+	});
+
+});