npm - retold-data-service - Versions diffs - 2.1.2 → 2.1.5 - Mend

retold-data-service 2.1.2 → 2.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (80) hide show

package/test/Bundles_smoke_tests.js ADDED Viewed

@@ -0,0 +1,43 @@
+'use strict';
+/**
+ * Bundle smoke tests — verifies `npm run build` produced both browser bundles
+ * and each has the expected window-global identifier.
+ */
+const libFS   = require('fs');
+const libPath = require('path');
+const libChai = require('chai');
+const Expect = libChai.expect;
+suite('Built bundles', function ()
+{
+	test('comprehension-loader bundle is present and non-trivial', function ()
+	{
+		let tmpPath = libPath.resolve(__dirname, '../source/services/comprehension-loader/web/comprehension-loader.js');
+		let tmpStat = libFS.statSync(tmpPath);
+		Expect(tmpStat.size).to.be.greaterThan(10000, 'bundle should be > 10KB');
+	});
+	test('data-cloner bundle is present and non-trivial', function ()
+	{
+		let tmpPath = libPath.resolve(__dirname, '../source/services/data-cloner/web/data-cloner.js');
+		let tmpStat = libFS.statSync(tmpPath);
+		Expect(tmpStat.size).to.be.greaterThan(10000, 'bundle should be > 10KB');
+	});
+	test('comprehension-loader bundle exposes ComprehensionLoaderApplication', function ()
+	{
+		let tmpPath = libPath.resolve(__dirname, '../source/services/comprehension-loader/web/comprehension-loader.js');
+		let tmpSrc = libFS.readFileSync(tmpPath, 'utf8');
+		Expect(tmpSrc).to.include('ComprehensionLoaderApplication');
+	});
+	test('data-cloner bundle exposes DataClonerApplication', function ()
+	{
+		let tmpPath = libPath.resolve(__dirname, '../source/services/data-cloner/web/data-cloner.js');
+		let tmpSrc = libFS.readFileSync(tmpPath, 'utf8');
+		Expect(tmpSrc).to.include('DataClonerApplication');
+	});
+});

package/test/ComprehensionLoader_smoke_tests.js ADDED Viewed

@@ -0,0 +1,95 @@
+'use strict';
+/**
+ * ComprehensionLoader bootstrap smoke tests.
+ *
+ * Verifies: (1) the Application class loads, (2) instantiation registers
+ * all expected views without throwing, (3) the Shell view's render()
+ * actually emits HTML into the application container.
+ *
+ * The async lifecycle (status polling, persistence load, etc.) is NOT
+ * exercised here — that requires real fetch + localStorage backends and
+ * isn't what a "smoke" check should hang on. Constructor + a single
+ * shell-render pass is enough to prove the wiring compiles and runs.
+ */
+const { JSDOM } = require('jsdom');
+const Chai = require('chai');
+const Expect = Chai.expect;
+const libPict = require('pict');
+const libApp = require('../source/services/comprehension-loader/pict-app/Pict-Application-ComprehensionLoader.js');
+suite('Comprehension Loader — bootstrap smoke', function ()
+{
+	setup(function ()
+	{
+		// Each test gets its own fresh DOM. Multiple smoke-test files share
+		// the global namespace; setting up here (not at module load) means
+		// the DOM matches the suite that's currently running.
+		let tmpDOM = new JSDOM(
+			'<!doctype html><html><body>'
+			+ '<div id="ComprehensionLoader-Application-Container"></div>'
+			+ '<style id="PICT-CSS"></style>'
+			+ '</body></html>',
+			{ url: 'http://localhost/' });
+		global.window = tmpDOM.window;
+		global.document = tmpDOM.window.document;
+		global.localStorage = tmpDOM.window.localStorage;
+	});
+	test('Application class loads as a function with a default_configuration', function ()
+	{
+		Expect(libApp).to.be.a('function');
+		Expect(libApp.default_configuration).to.be.an('object');
+	});
+	test('Instantiation registers all theme + shell views without throwing', function ()
+	{
+		let tmpPict = new libPict({ LogStreams: [{ streamtype: 'null', level: 'error' }] });
+		let tmpInstance = new libApp(tmpPict, libApp.default_configuration);
+		Expect(tmpInstance).to.exist;
+		let tmpExpectedViews =
+		[
+			'Pict-Section-Modal',
+			'ComprehensionLoader-Layout',
+			'ComprehensionLoader-Session',
+			'ComprehensionLoader-Schema',
+			'ComprehensionLoader-Source',
+			'ComprehensionLoader-Load',
+			'ComprehensionLoader-StatusHistogram',
+			'ComprehensionLoader-Shell',
+			'ComprehensionLoader-TopBar-Nav',
+			'ComprehensionLoader-TopBar-User',
+			'ComprehensionLoader-StatusBar',
+			'ComprehensionLoader-StatusDetail',
+			'ComprehensionLoader-SettingsPanel'
+		];
+		for (let i = 0; i < tmpExpectedViews.length; i++)
+		{
+			Expect(tmpPict.views[tmpExpectedViews[i]],
+				'expected view ' + tmpExpectedViews[i] + ' to be registered').to.exist;
+		}
+		Expect(tmpPict.providers['Theme-Section'],
+			'Theme-Section provider should be registered').to.exist;
+		Expect(tmpPict.providers.ComprehensionLoader).to.exist;
+	});
+	test('Shell view renders HTML into the application container', function ()
+	{
+		let tmpPict = new libPict({ LogStreams: [{ streamtype: 'null', level: 'error' }] });
+		new libApp(tmpPict, libApp.default_configuration);
+		// Render only the shell — avoids triggering the live-status poll setInterval.
+		tmpPict.views['ComprehensionLoader-Shell'].render();
+		let tmpContainer = global.document.getElementById('ComprehensionLoader-Application-Container');
+		Expect(tmpContainer).to.not.be.null;
+		Expect(tmpContainer.innerHTML.length).to.be.greaterThan(30,
+			'application container should have non-trivial HTML after shell render');
+		Expect(tmpContainer.innerHTML).to.include('ComprehensionLoader-Shell-Mount');
+	});
+});

package/test/DataCloner-RuntimeOverrides_tests.js ADDED Viewed

@@ -0,0 +1,344 @@
+/**
+ * Unit tests for DataCloner-Command-Sync runtime override application.
+ *
+ * Pure-function tests for `applyRuntimeSyncOverrides` and the
+ * `_RuntimeSyncProperties` coercion map. No server boot required.
+ *
+ * @license MIT
+ */
+var Chai = require('chai');
+var Expect = Chai.expect;
+var libSyncCommand = require('../source/services/data-cloner/DataCloner-Command-Sync.js');
+var _RuntimeSyncProperties = libSyncCommand._RuntimeSyncProperties;
+var applyRuntimeSyncOverrides = libSyncCommand.applyRuntimeSyncOverrides;
+// ---- Test helpers ----
+var fMakeMeadowSync = (pEntityNames) =>
+{
+	var tmpEntities = {};
+	for (var i = 0; i < pEntityNames.length; i++)
+	{
+		tmpEntities[pEntityNames[i]] = {};
+	}
+	// Orchestrator-level properties present here are the ones that get mirrored
+	// from the request body (BackSyncTimeLimit, DateTimePrecisionMS, TrueUpPageSize).
+	return {
+		BackSyncTimeLimit: 30000,
+		DateTimePrecisionMS: 1000,
+		TrueUpPageSize: 500,
+		MeadowSyncEntities: tmpEntities
+	};
+};
+var fMakeLog = () =>
+{
+	var tmpEntries = [];
+	return {
+		info: (pMsg) => tmpEntries.push({ level: 'info', msg: pMsg }),
+		warn: (pMsg) => tmpEntries.push({ level: 'warn', msg: pMsg }),
+		Entries: tmpEntries,
+		InfosWithText: (pText) => tmpEntries.filter((p) => p.level === 'info' && p.msg.indexOf(pText) > -1),
+		Warns: () => tmpEntries.filter((p) => p.level === 'warn'),
+		Infos: () => tmpEntries.filter((p) => p.level === 'info')
+	};
+};
+suite
+(
+	'DataCloner Runtime Sync Overrides',
+	function()
+	{
+		suite
+		(
+			'_RuntimeSyncProperties coercion map',
+			function()
+			{
+				test('BackSyncTimeLimit: accepts positive integer', function()
+				{
+					Expect(_RuntimeSyncProperties.BackSyncTimeLimit(60000)).to.equal(60000);
+				});
+				test('BackSyncTimeLimit: coerces numeric string', function()
+				{
+					Expect(_RuntimeSyncProperties.BackSyncTimeLimit('1800000')).to.equal(1800000);
+				});
+				test('BackSyncTimeLimit: rejects zero', function()
+				{
+					Expect(_RuntimeSyncProperties.BackSyncTimeLimit(0)).to.equal(null);
+				});
+				test('BackSyncTimeLimit: rejects negative', function()
+				{
+					Expect(_RuntimeSyncProperties.BackSyncTimeLimit(-100)).to.equal(null);
+				});
+				test('BackSyncTimeLimit: rejects non-numeric string', function()
+				{
+					Expect(_RuntimeSyncProperties.BackSyncTimeLimit('garbage')).to.equal(null);
+				});
+				test('MaxRecordsPerEntity: rejects zero (matches pre-refactor semantics)', function()
+				{
+					Expect(_RuntimeSyncProperties.MaxRecordsPerEntity(0)).to.equal(null);
+				});
+				test('MaxRecordsPerEntity: accepts positive', function()
+				{
+					Expect(_RuntimeSyncProperties.MaxRecordsPerEntity(500)).to.equal(500);
+				});
+				test('DateTimePrecisionMS: allows zero (any integer)', function()
+				{
+					Expect(_RuntimeSyncProperties.DateTimePrecisionMS(0)).to.equal(0);
+				});
+				test('DateTimePrecisionMS: rejects NaN', function()
+				{
+					Expect(_RuntimeSyncProperties.DateTimePrecisionMS('nope')).to.equal(null);
+				});
+				test('TrueUpPageSize: accepts positive integer', function()
+				{
+					Expect(_RuntimeSyncProperties.TrueUpPageSize(250)).to.equal(250);
+				});
+				test('UseAdvancedIDPagination: truthy → true', function()
+				{
+					Expect(_RuntimeSyncProperties.UseAdvancedIDPagination(1)).to.equal(true);
+					Expect(_RuntimeSyncProperties.UseAdvancedIDPagination('yes')).to.equal(true);
+				});
+				test('UseAdvancedIDPagination: falsy → false', function()
+				{
+					Expect(_RuntimeSyncProperties.UseAdvancedIDPagination(0)).to.equal(false);
+					Expect(_RuntimeSyncProperties.UseAdvancedIDPagination('')).to.equal(false);
+					Expect(_RuntimeSyncProperties.UseAdvancedIDPagination(null)).to.equal(false);
+				});
+				test('SyncDeletedRecords: coerces to boolean', function()
+				{
+					Expect(_RuntimeSyncProperties.SyncDeletedRecords(true)).to.equal(true);
+					Expect(_RuntimeSyncProperties.SyncDeletedRecords(false)).to.equal(false);
+				});
+			}
+		);
+		suite
+		(
+			'applyRuntimeSyncOverrides — global (top-level) body keys',
+			function()
+			{
+				test('Empty body leaves everything alone', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.BackSyncTimeLimit).to.equal(30000);
+					Expect(tmpSync.MeadowSyncEntities.Document).to.deep.equal({});
+					Expect(tmpSync.MeadowSyncEntities.Attachment).to.deep.equal({});
+					Expect(tmpClone.SyncDeletedRecords).to.equal(false);
+					Expect(tmpLog.Entries).to.have.lengthOf(0);
+				});
+				test('BackSyncTimeLimit mirrors to orchestrator and every entity', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ BackSyncTimeLimit: 60000 }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.BackSyncTimeLimit).to.equal(60000);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(60000);
+					Expect(tmpSync.MeadowSyncEntities.Attachment.BackSyncTimeLimit).to.equal(60000);
+					// No per-entity overrides → no info log lines
+					Expect(tmpLog.Infos()).to.have.lengthOf(0);
+				});
+				test('Numeric-string BackSyncTimeLimit is coerced to integer', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ BackSyncTimeLimit: '1800000' }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(1800000);
+					Expect(typeof tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal('number');
+				});
+				test('Invalid BackSyncTimeLimit leaves everything unchanged', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ BackSyncTimeLimit: 'oops' }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.BackSyncTimeLimit).to.equal(30000); // original
+					Expect(tmpSync.MeadowSyncEntities.Document).to.deep.equal({});
+				});
+				test('SyncDeletedRecords mirrors to cloneState and entities', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ SyncDeletedRecords: true }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpClone.SyncDeletedRecords).to.equal(true);
+					Expect(tmpSync.MeadowSyncEntities.Document.SyncDeletedRecords).to.equal(true);
+					Expect(tmpSync.MeadowSyncEntities.Attachment.SyncDeletedRecords).to.equal(true);
+				});
+				test('SyncDeletedRecords explicit false is honored', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					tmpSync.MeadowSyncEntities.Document.SyncDeletedRecords = true;
+					var tmpClone = { SyncDeletedRecords: true };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ SyncDeletedRecords: false }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpClone.SyncDeletedRecords).to.equal(false);
+					Expect(tmpSync.MeadowSyncEntities.Document.SyncDeletedRecords).to.equal(false);
+				});
+				test('Orchestrator mirror only fires for keys present on orchestrator', function()
+				{
+					// UseAdvancedIDPagination is NOT a property the orchestrator carries
+					// — it only flows to entities. Verify we don't accidentally add it
+					// to the orchestrator.
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ UseAdvancedIDPagination: true }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.hasOwnProperty('UseAdvancedIDPagination')).to.equal(false);
+					Expect(tmpSync.MeadowSyncEntities.Document.UseAdvancedIDPagination).to.equal(true);
+				});
+			}
+		);
+		suite
+		(
+			'applyRuntimeSyncOverrides — per-entity SyncEntityOptions',
+			function()
+			{
+				test('Per-entity override targets only the named entity', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: { Document: { BackSyncTimeLimit: 600000 } }
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(600000);
+					Expect(tmpSync.MeadowSyncEntities.Attachment.BackSyncTimeLimit).to.equal(undefined);
+				});
+				test('Per-entity override emits one info log per entity with applied keys', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: { Document: { BackSyncTimeLimit: 600000 } }
+					}, tmpSync, tmpClone, tmpLog);
+					var tmpInfo = tmpLog.Infos();
+					Expect(tmpInfo).to.have.lengthOf(1);
+					Expect(tmpInfo[0].msg).to.include('Document');
+					Expect(tmpInfo[0].msg).to.include('BackSyncTimeLimit=600000');
+				});
+				test('Per-entity wins over global', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						BackSyncTimeLimit: 30000,
+						SyncEntityOptions: { Document: { BackSyncTimeLimit: 600000 } }
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(600000);
+					Expect(tmpSync.MeadowSyncEntities.Attachment.BackSyncTimeLimit).to.equal(30000);
+				});
+				test('Multiple per-entity overrides apply independently', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment', 'Note']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						BackSyncTimeLimit: 30000,
+						SyncEntityOptions: {
+							Document: { BackSyncTimeLimit: 600000 },
+							Attachment: { BackSyncTimeLimit: 120000 }
+						}
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(600000);
+					Expect(tmpSync.MeadowSyncEntities.Attachment.BackSyncTimeLimit).to.equal(120000);
+					Expect(tmpSync.MeadowSyncEntities.Note.BackSyncTimeLimit).to.equal(30000);
+					Expect(tmpLog.Infos()).to.have.lengthOf(2);
+				});
+				test('Unknown entity name produces a warn, not a throw', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: { ImaginaryTable: { BackSyncTimeLimit: 60000 } }
+					}, tmpSync, tmpClone, tmpLog);
+					var tmpWarn = tmpLog.Warns();
+					Expect(tmpWarn).to.have.lengthOf(1);
+					Expect(tmpWarn[0].msg).to.include('ImaginaryTable');
+				});
+				test('Unknown property inside SyncEntityOptions[entity] is ignored', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: { Document: { GarbageKey: 'whatever', BackSyncTimeLimit: 60000 } }
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(60000);
+					Expect(tmpSync.MeadowSyncEntities.Document.GarbageKey).to.equal(undefined);
+				});
+				test('Per-entity override with no valid keys produces no log line', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: { Document: { BackSyncTimeLimit: 'garbage' } }
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpLog.Infos()).to.have.lengthOf(0);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(undefined);
+				});
+				test('Non-object SyncEntityOptions is ignored (no throw)', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: 'oops',
+						BackSyncTimeLimit: 60000
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(60000);
+				});
+				test('Null SyncEntityOptions is ignored (no throw)', function()
+				{
+					var tmpSync = fMakeMeadowSync(['Document']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({ SyncEntityOptions: null, BackSyncTimeLimit: 60000 }, tmpSync, tmpClone, tmpLog);
+					Expect(tmpSync.MeadowSyncEntities.Document.BackSyncTimeLimit).to.equal(60000);
+				});
+				test('Per-entity SyncDeletedRecords does NOT mirror to cloneState', function()
+				{
+					// Per-entity overrides target a specific entity; cloneState is a
+					// cross-cutting "is delete-sync enabled at all?" flag and should
+					// only be mirrored from the global value.
+					var tmpSync = fMakeMeadowSync(['Document', 'Attachment']);
+					var tmpClone = { SyncDeletedRecords: false };
+					var tmpLog = fMakeLog();
+					applyRuntimeSyncOverrides({
+						SyncEntityOptions: { Document: { SyncDeletedRecords: true } }
+					}, tmpSync, tmpClone, tmpLog);
+					Expect(tmpClone.SyncDeletedRecords).to.equal(false);
+					Expect(tmpSync.MeadowSyncEntities.Document.SyncDeletedRecords).to.equal(true);
+					Expect(tmpSync.MeadowSyncEntities.Attachment.SyncDeletedRecords).to.equal(undefined);
+				});
+			}
+		);
+	}
+);

package/test/DataCloner_smoke_tests.js ADDED Viewed

@@ -0,0 +1,87 @@
+'use strict';
+/**
+ * DataCloner bootstrap smoke tests — parallel to the ComprehensionLoader
+ * smoke suite. See that file for rationale.
+ */
+const { JSDOM } = require('jsdom');
+const Chai = require('chai');
+const Expect = Chai.expect;
+const libPict = require('pict');
+const libApp = require('../source/services/data-cloner/pict-app/Pict-Application-DataCloner.js');
+suite('Data Cloner — bootstrap smoke', function ()
+{
+	setup(function ()
+	{
+		let tmpDOM = new JSDOM(
+			'<!doctype html><html><body>'
+			+ '<div id="DataCloner-Application-Container"></div>'
+			+ '<style id="PICT-CSS"></style>'
+			+ '</body></html>',
+			{ url: 'http://localhost/' });
+		global.window = tmpDOM.window;
+		global.document = tmpDOM.window.document;
+		global.localStorage = tmpDOM.window.localStorage;
+	});
+	test('Application class loads as a function with a default_configuration', function ()
+	{
+		Expect(libApp).to.be.a('function');
+		Expect(libApp.default_configuration).to.be.an('object');
+	});
+	test('Instantiation registers all theme + shell views without throwing', function ()
+	{
+		let tmpPict = new libPict({ LogStreams: [{ streamtype: 'null', level: 'error' }] });
+		let tmpInstance = new libApp(tmpPict, libApp.default_configuration);
+		Expect(tmpInstance).to.exist;
+		let tmpExpectedViews =
+		[
+			'Pict-Section-Modal',
+			'DataCloner-Layout',
+			'DataCloner-Connection',
+			'DataCloner-Session',
+			'DataCloner-Schema',
+			'DataCloner-Deploy',
+			'DataCloner-Sync',
+			'DataCloner-Export',
+			'DataCloner-ViewData',
+			'DataCloner-StatusHistogram',
+			'PictSection-ConnectionForm',
+			'DataCloner-Shell',
+			'DataCloner-TopBar-Nav',
+			'DataCloner-TopBar-User',
+			'DataCloner-StatusBar',
+			'DataCloner-StatusDetail',
+			'DataCloner-SettingsPanel'
+		];
+		for (let i = 0; i < tmpExpectedViews.length; i++)
+		{
+			Expect(tmpPict.views[tmpExpectedViews[i]],
+				'expected view ' + tmpExpectedViews[i] + ' to be registered').to.exist;
+		}
+		Expect(tmpPict.providers['Theme-Section'],
+			'Theme-Section provider should be registered').to.exist;
+		Expect(tmpPict.providers.DataCloner).to.exist;
+	});
+	test('Shell view renders HTML into the application container', function ()
+	{
+		let tmpPict = new libPict({ LogStreams: [{ streamtype: 'null', level: 'error' }] });
+		new libApp(tmpPict, libApp.default_configuration);
+		tmpPict.views['DataCloner-Shell'].render();
+		let tmpContainer = global.document.getElementById('DataCloner-Application-Container');
+		Expect(tmpContainer).to.not.be.null;
+		Expect(tmpContainer.innerHTML.length).to.be.greaterThan(30,
+			'application container should have non-trivial HTML after shell render');
+		Expect(tmpContainer.innerHTML).to.include('DataCloner-Shell-Mount');
+	});
+});