├── .editorconfig
├── .gitignore
├── .npmignore
├── LICENSE.txt
├── README.md
├── package.json
├── scripts
    ├── build-core.js
    └── node-tests.js
├── src
    ├── copyright-header.txt
    └── index.js
└── tests
    ├── index.html
    ├── qunit.config.js
    └── tests.js


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | end_of_line = lf
 6 | insert_final_newline = true
 7 | indent_style = tab
 8 | indent_size = 4
 9 | 
10 | [*.md]
11 | indent_style = space
12 | indent_size = 4
13 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | coverage/
3 | dist/
4 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .npmignore
2 | .gitignore
3 | node_modules/
4 | coverage/
5 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2017 Kyle Simpson <getify@gmail.com>
 2 | 
 3 | Permission is hereby granted, free of charge, to any person
 4 | obtaining a copy of this software and associated documentation
 5 | files (the "Software"), to deal in the Software without
 6 | restriction, including without limitation the rights to use,
 7 | copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the
 9 | Software is furnished to do so, subject to the following
10 | conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Mock DOM Resources
  2 | 
  3 | [![npm Module](https://badge.fury.io/js/mock-dom-resources.svg)](https://www.npmjs.org/package/mock-dom-resources)
  4 | [![Dependencies](https://david-dm.org/getify/mock-dom-resources.svg)](https://david-dm.org/getify/mock-dom-resources)
  5 | [![devDependencies](https://david-dm.org/getify/mock-dom-resources/dev-status.svg)](https://david-dm.org/getify/mock-dom-resources)
  6 | 
  7 | A simple utility for mocking the DOM APIs to simulate browser resource preloading and loading.
  8 | 
  9 | Resources are not actually loaded. This is a simulation. The request for a resource (i.e. adding a `<script>` element to the mock DOM) is matched up to a delayed firing of a load or error event as if the resource had actually loaded.
 10 | 
 11 | For fine grained testing purposes, you can configure all aspects of the simulation, including timings, success/error, and even browser capabilities (preloading, script ordered-async, etc).
 12 | 
 13 | **Note:** This is not a spec compliant implementation of a DOM, nor a virtual DOM, nor do we even mock the whole DOM API. The only parts that are mocked are what's minimally necessary for common resource loading simulations.
 14 | 
 15 | ## API
 16 | 
 17 | The API is a single function (by default called `$DOM`) that creates an instance of a mocked DOM (aka `window`) each time its called. This function is passed an options object to control its behavior.
 18 | 
 19 | Example:
 20 | 
 21 | ```js
 22 | var win = $DOM( {
 23 |     log(msg) {
 24 |         console.log( "msg:", msg );
 25 |     },
 26 |     resources: [
 27 |         { url: "http://some.tld/a.js", loadDelay: 300, load: true },
 28 |         { url: "http://some.tld/b.css", loadDelay: 400, load: false },
 29 |     ],
 30 | } );
 31 | 
 32 | var elem = win.document.createElement( "script" );
 33 | elem.setAttribute( "src", "http://some.tld/a.js" );
 34 | elem.addEventListener( "load", function(){
 35 |     console.log( "Loaded:", this.src );
 36 | } );
 37 | win.document.head.appendChild( elem );
 38 | 
 39 | elem = win.document.createElement( "link" );
 40 | elem.setAttribute( "href", "http://some.tld/b.css" );
 41 | elem.addEventListener( "error", function(){
 42 |     console.log( "Failed:", this.href );
 43 | } );
 44 | win.document.head.appendChild( elem );
 45 | ```
 46 | 
 47 | The console output from the above program will be:
 48 | 
 49 | ```
 50 | msg: { window: 503186 }
 51 | msg: { document: 111648 }
 52 | msg: { head: 645112 }
 53 | msg: { body: 298071 }
 54 | msg: { createElement: 'script', internal_id: 982599 }
 55 | msg: { setAttribute: 'src | http://some.tld/a.js', internal_id: 982599 }
 56 | msg: { addEventListener: 'load', internal_id: 982599 }
 57 | msg: { appendChild: 982599, internal_id: 645112 }
 58 | msg: { createElement: 'link', internal_id: 771705 }
 59 | msg: { setAttribute: 'href | http://some.tld/b.css', internal_id: 771705 }
 60 | msg: { addEventListener: 'error', internal_id: 771705 }
 61 | msg: { appendChild: 771705, internal_id: 645112 }
 62 | msg: { dispatchEvent: 'load', internal_id: 982599 }
 63 | Loaded: http://some.tld/a.js
 64 | msg: { dispatchEvent: 'error', internal_id: 771705 }
 65 | Failed: http://some.tld/b.css
 66 | ```
 67 | 
 68 | **Note:** The numbers shown in the output are randomly generated internal IDs for each DOM element, and as such will vary with each use. To constrain the IDs to predictable incrementing numbers (starting at 1), pass the `sequentialIds: true` option.
 69 | 
 70 | `window.performance` has only the `getEntriesByName(..)` method, which takes a URL and returns an array (of only that URL) if that resource URL has been loaded already, false if not.
 71 | 
 72 | ### DOM Features Provided
 73 | 
 74 | The following subset of DOM features are mocked:
 75 | 
 76 | * `window`
 77 | * `window.onload`
 78 | * `window.Event`
 79 | * `window.document` (and `document`)
 80 | * `window` event: `load`
 81 | * `document.location` (and `window.location` and `location`)
 82 | * `document.baseURI`
 83 | * `document.head`
 84 | * `document.body`
 85 | * `document.createElement(..)`
 86 | * `document.readyState`
 87 | * `document` event: `DOMContentLoaded`
 88 | * DOM `Element`s:
 89 |     - `appendChild(..)`
 90 |     - `removeChild(..)`
 91 |     - `setAttribute(..)`
 92 |     - `getAttribute(..)`
 93 |     - `addEventListener(..)`
 94 |     - `removeEventListener(..)`
 95 |     - `dispatchEvent(..)`
 96 |     - `getElementsByTagName(..)`
 97 |     - event: `load`
 98 |     - event: `error`
 99 | * `window.performance.getEntriesByName(..)`
100 | 
101 | ### Options
102 | 
103 | The options that can be passed to `$DOM(..)`:
104 | 
105 | * `replaceGlobals` (`true` / `false`): In the browser, override various globals that are typically used in resource loading, like `document.createElement(..)` and `document.head.appendChild(..)`. In node, define/replace `global.window`, `global.document`, `global.performance`, `global.Event`, and `global.location`. Call `$DOM.restoreGlobals()` to reset them. Defaults to `false`.
106 | 
107 | * `sequentialIds` (`true` / `false`): Use strictly incrementing numeric IDs (starting with `1`) for created DOM elements. Defaults to `false` (generates random IDs).
108 | 
109 | * `docReadyState` (`"loading"` / `"interactive"` / `"complete"`): Manually sets the initial state of `document.readyState`. If `"loading"`, the state will emulate transition to `"interactive"` and then `"complete"`. If `"interactive"`, the state will emulate transition to `"complete"`. When the `readyState` transitions to `"interactive"`, the `DOMContentLoaded` event (commonly known as "DOM ready") will be dispatched on `document`. When the `readyState` transitions to `"complete"`, the `load` event (commonly known as `window.onload`) will be dispatched on the DOM instance (aka `window`). Defaults to `"loading"`.
110 | 
111 | * `docReadyDelay` (`number`): The delay in milliseconds to use between transitions of `document.readyState`. Defaults to `5`.
112 | 
113 | * `relList` (`true` / `false`): Mock the [`relList` mechanism](http://caniuse.com/#search=relList) on DOM elements, including [`relList.supports(..)`](https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList/supports). Defaults to `true`.
114 | 
115 | * `scriptAsync` (`true` / `false`): Make `<script>` elements behave with the ["ordered async" capability](https://www.w3.org/Bugs/Public/show_bug.cgi?id=11295) where the `async` property defaults to `true` but if set to `false`, multiple requested scripts of this same sort will always execute in order of being appended to the DOM. Defaults to `true`.
116 | 
117 | * `linkPreload` (`true` / `false`): Make `<link>` elements behave with the [`rel=preload` preloading capability](https://w3c.github.io/preload/). Defaults to `true`.
118 | 
119 | * `location` (`string`): Set the default `document.location`. Defaults to `"https://some.thing/else"`.
120 | 
121 | * `baseURI` (`string`): Set the default `document.baseURI` property. Defaults to the value of `opts.location`.
122 | 
123 | * `log` (`function`): Specify a function to receive the log messages while performing mock DOM operations. This is useful for test cases where you want to verify that all operations were performed as expected. Set to an empty function to ignore/discard log messages. Defaults to printing to the console as with `console.log(..)`.
124 | 
125 | * `error` (`function`): Specify a function to receive any error messages while performing mock DOM operations. Set to an empty function to ignore/discard errors. Defaults to `throw`ing the error as an exception.
126 | 
127 | * `resources` (`array`): Specify the resources that should be available for the mock DOM to pretend to load. Each entry in this array is an object including the following specifiers:
128 | 
129 |     - `url` (required): the exact URL that the resource loading request should match. **Note:** no normalization is done on either these URLs or those requested by mock DOM elements.
130 |     - `cached` (optional): boolean that controls if the resource is treated as if it was already fully loaded into the "cache" before any of the DOM processing occurs. Also adds an entry to be exposed by `window.performance.getEntriesByName(..)`. Overrides `preloadDelay`, `preload`, `loadDelay`, and `load` specifiers for that resource entry.
131 |     - `preloadDelay` (optional): integer of milliseconds to emulate as delay for preloading the element (with `<link rel=preload>` functionality). If provided, must be greater than `0`; otherwise, defaults to `10`.
132 |     - `preload` (optional): boolean that indicates if the preload should be complete successfully (`true`) or as a loading error (`false`).
133 |     - `loadDelay` (optional): integer of milliseconds to emulate as delay for loading the element (with a `<link>`, `<script>`, or `<img>` element). If provided, must be greater than `0`; otherwise, defaults to `10`.
134 |     - `load` (optional): boolean that indicates if the load should complete successfully (`true`) or as a loading error (`false`).
135 | 
136 | * `initialDOM` (`object`): Specify `head` and `body` arrays of objects that represent the initial DOM elements as if they had been parsed from the markup.
137 | 
138 | ## Using with Node.js
139 | 
140 | You'll most likely use this utility to mock out a DOM for tests in Node.js. To do so, install with `npm` then require it in your script:
141 | 
142 | ```js
143 | var $DOM = require( "mock-dom-resources" );
144 | 
145 | // ..
146 | ```
147 | 
148 | ## Builds
149 | 
150 | [![npm Module](https://badge.fury.io/js/mock-dom-resources.svg)](https://www.npmjs.org/package/mock-dom-resources)
151 | 
152 | The distribution library file (`dist/mock-dom.js`) comes pre-built with the npm package distribution, so you shouldn't need to rebuild it under normal circumstances.
153 | 
154 | However, if you download this repository via Git:
155 | 
156 | 1. The included build utility (`scripts/build-core.js`) builds (and ~~minifies~~) `dist/mock-dom.js` from source. **Note:** Minification is currently disabled. **The build utility expects Node.js version 6+.**
157 | 
158 | 2. To install the build and test dependencies, run `npm install` from the project root directory.
159 | 
160 | 3. Because of how npm lifecyle events (currently: npm v4) work, `npm install` will have the side effect of automatically running the build and test utilities for you. So, no further action should be needed on your part. Starting with npm v5, the build utility will still be run automatically on `npm install`, but the test utility will not.
161 | 
162 | To run the build utility with npm:
163 | 
164 | ```
165 | npm run build
166 | ```
167 | 
168 | To run the build utility directly without npm:
169 | 
170 | ```
171 | node scripts/build-core.js
172 | ```
173 | 
174 | ## Tests
175 | 
176 | A comprehensive test suite is included in this repository, as well as the npm package distribution.
177 | 
178 | 1. You can run the tests in a browser by opening up `tests/index.html` (**requires ES6+ browser environment**).
179 | 
180 | 2. The included Node.js test utility (`scripts/node-tests.js`) runs the test suite. **This test utility expects Node.js version 6+.**
181 | 
182 | 3. Ensure the Node.js test utility dependencies are installed by running `npm install` from the project root directory.
183 | 
184 | 4. Because of how npm lifecycle events (currently: npm v4) work, `npm install` will have the side effect of automatically running the build and test utilities for you. So, no further action should be needed on your part. Starting with npm v5, the build utility will still be run automatically on `npm install`, but the test utility will not.
185 | 
186 | To run the test utility with npm:
187 | 
188 | ```
189 | npm test
190 | ```
191 | 
192 | To run the test utility directly without npm:
193 | 
194 | ```
195 | node scripts/node-tests.js
196 | ```
197 | 
198 | ### Test Coverage
199 | 
200 | If you have [Istanbul](https://github.com/gotwarlost/istanbul) already installed on your system (requires v1.0+), you can use it to check the test coverage:
201 | 
202 | ```
203 | npm run coverage
204 | ```
205 | 
206 | Then open up `coverage/lcov-report/index.html` in a browser to view the report.
207 | 
208 | To run Istanbul directly without npm:
209 | 
210 | ```
211 | istanbul cover scripts/node-tests.js
212 | ```
213 | 
214 | ## License
215 | 
216 | All code and documentation are (c) 2017 Kyle Simpson and released under the [MIT License](http://getify.mit-license.org/). A copy of the MIT License [is also included](LICENSE.txt).
217 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "mock-dom-resources",
 3 | 	"version": "10.0.0-pre1",
 4 | 	"description": "Utility for mocking the DOM APIs to simulate browser resource loading",
 5 | 	"main": "./src/index.js",
 6 | 	"scripts": {
 7 | 		"test": "node scripts/node-tests.js",
 8 | 		"coverage": "istanbul cover scripts/node-tests.js",
 9 | 		"build-core": "node scripts/build-core.js",
10 | 		"build": "npm run build-core",
11 | 		"prepare": "npm run build",
12 | 		"prepublish": "npm run build && npm test"
13 | 	},
14 | 	"devDependencies": {
15 | 		"qunitjs": "~2.4.1",
16 | 		"stable-timers": "~1.0.0"
17 | 	},
18 | 	"repository": "getify/Mock-DOM-Resources",
19 | 	"keywords": [
20 | 		"test",
21 | 		"testing",
22 | 		"mock",
23 | 		"DOM",
24 | 		"resource loading"
25 | 	],
26 | 	"bugs": {
27 | 		"url": "https://github.com/getify/Mock-DOM-Resources/issues",
28 | 		"email": "getify@gmail.com"
29 | 	},
30 | 	"homepage": "https://github.com/getify/Mock-DOM-Resources",
31 | 	"author": "Kyle Simpson <getify@gmail.com>",
32 | 	"license": "MIT"
33 | }
34 | 


--------------------------------------------------------------------------------
/scripts/build-core.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | var fs = require("fs"),
 4 | 	path = require("path"),
 5 | 	// ugly = require("uglify-js"),
 6 | 	packageJSON,
 7 | 	copyrightHeader,
 8 | 	version,
 9 | 	year = (new Date()).getFullYear(),
10 | 
11 | 	ROOT_DIR = path.join(__dirname,".."),
12 | 	SRC_DIR = path.join(ROOT_DIR,"src"),
13 | 	DIST_DIR = path.join(ROOT_DIR,"dist"),
14 | 
15 | 	LIB_SRC = path.join(SRC_DIR,"index.js"),
16 | 	LIB_DIST = path.join(DIST_DIR,"mock-dom.js"),
17 | 
18 | 	result
19 | ;
20 | 
21 | console.log("*** Building Core ***");
22 | console.log(`Building: ${LIB_DIST}`);
23 | 
24 | try {
25 | 	// try to make the dist directory, if needed
26 | 	try {
27 | 		fs.mkdirSync(DIST_DIR,0o755);
28 | 	}
29 | 	catch (err) { }
30 | 
31 | 	// NOTE: since uglify doesn't yet support ES6, no minifying happening :(
32 | 	result = fs.readFileSync(LIB_SRC,{ encoding: "utf8" });
33 | 
34 | 	// result = ugly.minify(path.join(SRC_DIR,"index.js"),{
35 | 	// 	mangle: {
36 | 	// 		keep_fnames: true
37 | 	// 	},
38 | 	// 	compress: {
39 | 	// 		keep_fnames: true
40 | 	// 	},
41 | 	// 	output: {
42 | 	// 		comments: /^!/
43 | 	// 	}
44 | 	// });
45 | 
46 | 	// read version number from package.json
47 | 	packageJSON = JSON.parse(
48 | 		fs.readFileSync(
49 | 			path.join(ROOT_DIR,"package.json"),
50 | 			{ encoding: "utf8" }
51 | 		)
52 | 	);
53 | 	version = packageJSON.version;
54 | 
55 | 	// read copyright-header text, render with version and year
56 | 	copyrightHeader = fs.readFileSync(
57 | 		path.join(SRC_DIR,"copyright-header.txt"),
58 | 		{ encoding: "utf8" }
59 | 	).replace(/`/g,"");
60 | 	copyrightHeader = Function("version","year",`return \`${copyrightHeader}\`;`)( version, year );
61 | 
62 | 	// append copyright-header text
63 | 	result = copyrightHeader + result;
64 | 
65 | 	// write dist
66 | 	fs.writeFileSync( LIB_DIST, result /* result.code + "\n" */, { encoding: "utf8" } );
67 | 
68 | 	console.log("Complete.");
69 | }
70 | catch (err) {
71 | 	console.error(err);
72 | 	process.exit(1);
73 | }
74 | 


--------------------------------------------------------------------------------
/scripts/node-tests.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | "use strict";
 4 | 
 5 | var path = require("path");
 6 | 
 7 | // make timers behave more stably
 8 | require("stable-timers").replaceGlobals();
 9 | 
10 | global.$DOM = require(path.join("..","src","index.js"));
11 | 
12 | global.QUnit = require("qunitjs");
13 | 
14 | require("../tests/qunit.config.js");
15 | require("../tests/tests.js");
16 | 
17 | QUnit.start();
18 | 


--------------------------------------------------------------------------------
/src/copyright-header.txt:
--------------------------------------------------------------------------------
1 | /*! Mock DOM Resources
2 | 	v${version} (c) ${year} Kyle Simpson
3 | 	MIT License: http://getify.mit-license.org
4 | */
5 | 
6 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
  1 | (function UMD(name,context,definition){
  2 | 	/* istanbul ignore next */if (typeof define === "function" && define.amd) { define(definition); }
  3 | 	/* istanbul ignore next */else if (typeof module !== "undefined" && module.exports) { module.exports = definition(); }
  4 | 	/* istanbul ignore next */else { context[name] = definition(name,context); }
  5 | })("$DOM",this,function DEF(name,context){
  6 | 	"use strict";
  7 | 
  8 | 	var global = Function( "return this" )();
  9 | 
 10 | 	// probably running in the browser?
 11 | 	/* istanbul ignore next */if (typeof window != "undefined" && global === window && window.document) {
 12 | 		/* istanbul ignore next */var originalGlobals = [
 13 | 			window.document.createElement,
 14 | 			window.document.createEvent,
 15 | 			window.document.appendChild,
 16 | 			window.document.removeChild,
 17 | 			window.document.getElementsByTagName,
 18 | 			window.document.head.appendChild,
 19 | 			window.document.head.removeChild,
 20 | 			window.document.head.getElementsByTagName,
 21 | 			window.document.body.appendChild,
 22 | 			window.document.body.removeChild,
 23 | 			window.document.body.getElementsByTagName,
 24 | 			global.performance.getEntriesByName,
 25 | 			global.Event,
 26 | 		];
 27 | 	}
 28 | 	// otherwise, assume an environment like Node
 29 | 	else {
 30 | 		var originalGlobals = [
 31 | 			global.window,
 32 | 			global.document,
 33 | 			global.location,
 34 | 			global.performance,
 35 | 			global.Event,
 36 | 		];
 37 | 	}
 38 | 
 39 | 	createMockDOM.restoreGlobals = restoreGlobals;
 40 | 
 41 | 	return createMockDOM;
 42 | 
 43 | 
 44 | 	// **************************************
 45 | 
 46 | 	function createMockDOM(opts) {
 47 | 		/* istanbul ignore next */opts = opts ? Object.assign( {}, opts ) : {};
 48 | 		if (!("replaceGlobals" in opts)) opts.replaceGlobals = false;
 49 | 		if (!("relList" in opts)) opts.relList = true;
 50 | 		if (!("scriptAsync" in opts)) opts.scriptAsync = true;
 51 | 		if (!("linkPreload" in opts)) opts.linkPreload = true;
 52 | 		if (!("docReadyState" in opts)) opts.docReadyState = "loading";
 53 | 		if (!("docReadyDelay" in opts)) opts.docReadyDelay = 1;
 54 | 		if (!("location" in opts)) opts.location = "https://some.thing/else";
 55 | 		/* istanbul ignore next */if (!("log" in opts)) opts.log = function log(status) { console.log( JSON.stringify( status ) ); };
 56 | 		/* istanbul ignore next */if (!("error" in opts)) opts.error = function error(err) { throw err; };
 57 | 		if (!("resources" in opts)) opts.resources = [];
 58 | 		if (!("sequentialIds" in opts)) opts.sequentialIds = false;
 59 | 
 60 | 		if (!/^(?:loading|interactive|complete)$/.test( String( opts.docReadyState ) )) {
 61 | 			opts.docReadyState = "loading";
 62 | 		}
 63 | 
 64 | 		var docReadyState = opts.docReadyState;
 65 | 		var docReadyDelay = opts.docReadyDelay = Math.max( 0, Number( opts.docReadyDelay ) || 5 );
 66 | 
 67 | 		// copy resources list and normalize its entries
 68 | 		opts.resources = opts.resources.map(function fix(resource){
 69 | 			var newEntry = { url: resource.url };
 70 | 			if (resource.cached === true) {
 71 | 				newEntry.loaded = true;
 72 | 				newEntry.preload = true;
 73 | 				newEntry.preloadDelay = 1;
 74 | 				newEntry.load = true;
 75 | 				newEntry.loadDelay = 1;
 76 | 			}
 77 | 			else {
 78 | 				if ("preload" in resource) newEntry.preload = resource.preload;
 79 | 				if ("preloadDelay" in resource) newEntry.preloadDelay = Math.max( Number( resource.preloadDelay ) || 10, 1 );
 80 | 				else newEntry.preloadDelay = 10;
 81 | 				if ("load" in resource) newEntry.load = resource.load;
 82 | 				if ("loadDelay" in resource) newEntry.loadDelay = Math.max( Number( resource.loadDelay ) || 10, 1 );
 83 | 				else newEntry.loadDelay = 10;
 84 | 			}
 85 | 			return newEntry;
 86 | 		} );
 87 | 
 88 | 		// populate `opts.performanceEntries`
 89 | 		var performanceEntries = opts.resources.reduce( function findLoaded(entries,resource){
 90 | 			if (resource.loaded === true) entries.push( resource.url );
 91 | 			return entries;
 92 | 		}, [] );
 93 | 
 94 | 		// setup Element prototype
 95 | 		Element.prototype.getElementsByTagName = getElementsByTagName;
 96 | 		Element.prototype.appendChild = appendChild;
 97 | 		Element.prototype.removeChild = removeChild;
 98 | 		Element.prototype.setAttribute = setAttribute;
 99 | 		Element.prototype.getAttribute = getAttribute;
100 | 		Element.prototype.addEventListener = addEventListener;
101 | 		Element.prototype.removeEventListener = removeEventListener;
102 | 		Element.prototype.dispatchEvent = dispatchEvent;
103 | 
104 | 		var sequentialId = 0;
105 | 		var deferQueue = [];
106 | 		var execQueue = [];
107 | 		var silent = true;
108 | 		var locObj = setupLocation( opts.location );
109 | 
110 | 		// create the initial DOM elements
111 | 		var mockDOM = createElement( "window" );
112 | 		var documentElement = createElement( "document" );
113 | 		documentElement.head = createElement( "head" );
114 | 		documentElement.body = createElement( "body" );
115 | 
116 | 		documentElement.appendChild( documentElement.head );
117 | 		documentElement.appendChild( documentElement.body );
118 | 		documentElement.baseURI = opts.location;
119 | 		Object.defineProperty( documentElement, "readyState", {
120 | 			get() { return docReadyState; },
121 | 			set(val) { return val; },
122 | 			configurable: false,
123 | 		} );
124 | 		documentElement.createElement = createElement;
125 | 		documentElement.createEvent = createEvent;
126 | 		Object.defineProperty( documentElement, "location", {
127 | 			get() { return locObj; },
128 | 			set(val) { locObj.href = val; return val; },
129 | 			configurable: true,
130 | 		} );
131 | 
132 | 		var performanceAPI = {
133 | 			getEntriesByName: getEntriesByName,
134 | 		};
135 | 
136 | 		mockDOM.document = documentElement;
137 | 		mockDOM.performance = performanceAPI;
138 | 		mockDOM.Event = Event;
139 | 		Object.defineProperty( mockDOM, "location", {
140 | 			get() { return locObj; },
141 | 			set(val) { locObj.href = val; return val; },
142 | 			configurable: true,
143 | 		} );
144 | 
145 | 		if ("initialDOM" in opts) {
146 | 			processInitialDOM( opts.initialDOM );
147 | 		}
148 | 
149 | 		// emulate document.readyState (DOMContentLoaded and window.load)
150 | 		if (docReadyState != "complete") {
151 | 			setTimeout( advanceReadyState, docReadyDelay );
152 | 		}
153 | 
154 | 		silent = false;
155 | 
156 | 		// hard-bind "global" DOM element methods
157 | 		documentElement.appendChild = documentElement.appendChild.bind( documentElement );
158 | 		documentElement.removeChild = documentElement.removeChild.bind( documentElement );
159 | 		documentElement.getElementsByTagName = documentElement.getElementsByTagName.bind( documentElement );
160 | 		documentElement.head.appendChild = documentElement.head.appendChild.bind( documentElement.head );
161 | 		documentElement.head.removeChild = documentElement.head.removeChild.bind( documentElement.head );
162 | 		documentElement.head.getElementsByTagName = documentElement.head.getElementsByTagName.bind( documentElement.head );
163 | 		documentElement.body.appendChild = documentElement.body.appendChild.bind( documentElement.body );
164 | 		documentElement.body.removeChild = documentElement.body.removeChild.bind( documentElement.body );
165 | 		documentElement.body.getElementsByTagName = documentElement.body.getElementsByTagName.bind( documentElement.body );
166 | 
167 | 		// notify: internal IDs for built-ins
168 | 		opts.log( {window: mockDOM._internal_id} );
169 | 		opts.log( {document: documentElement._internal_id} );
170 | 		opts.log( {head: documentElement.head._internal_id} );
171 | 		opts.log( {body: documentElement.body._internal_id} );
172 | 
173 | 		if (opts.replaceGlobals) {
174 | 			// probably running in the browser?
175 | 			/* istanbul ignore next */if (typeof window != "undefined" && global === window && window.document) {
176 | 				/* istanbul ignore next */try { window.document.createElement = createElement; } catch (err) {}
177 | 				/* istanbul ignore next */try { window.document.createEvent = createEvent; } catch (err) {}
178 | 				/* istanbul ignore next */try { window.document.appendChild = documentElement.appendChild; } catch (err) {}
179 | 				/* istanbul ignore next */try { window.document.removeChild = documentElement.removeChild; } catch (err) {}
180 | 				/* istanbul ignore next */try { window.document.getElementsByTagName = documentElement.getElementsByTagName; } catch (err) {}
181 | 				/* istanbul ignore next */try { window.document.head.appendChild = documentElement.head.appendChild; } catch (err) {}
182 | 				/* istanbul ignore next */try { window.document.head.removeChild = documentElement.head.removeChild; } catch (err) {}
183 | 				/* istanbul ignore next */try { window.document.head.getElementsByTagName = documentElement.head.getElementsByTagName; } catch (err) {}
184 | 				/* istanbul ignore next */try { window.document.body.appendChild = documentElement.body.appendChild; } catch (err) {}
185 | 				/* istanbul ignore next */try { window.document.body.removeChild = documentElement.body.removeChild; } catch (err) {}
186 | 				/* istanbul ignore next */try { window.document.body.getElementsByTagName = documentElement.body.getElementsByTagName; } catch (err) {}
187 | 				/* istanbul ignore next */try { global.performance.getEntriesByName = mockDOM.performance.getEntriesByName; } catch (err) {}
188 | 				/* istanbul ignore next */try { global.Event = Event; } catch (err) {}
189 | 			}
190 | 			// otherwise, assume an environment like Node
191 | 			else {
192 | 				global.window = mockDOM;
193 | 				global.document = mockDOM.document;
194 | 				Object.defineProperty( global, "location", {
195 | 					get() { return locObj; },
196 | 					set(val) { locObj.href = val; return val; },
197 | 					configurable: true,
198 | 				} );
199 | 				global.performance = mockDOM.performance;
200 | 				global.Event = Event;
201 | 			}
202 | 			createMockDOM.replaceGlobals = false;
203 | 		}
204 | 
205 | 		return mockDOM;
206 | 
207 | 
208 | 		// **************************************
209 | 
210 | 		// document.createElement(..)
211 | 		function createElement(tagName) {
212 | 			tagName = tagName.toLowerCase();
213 | 
214 | 			var element = new Element();
215 | 			element.tagName = tagName.toUpperCase();
216 | 
217 | 			!silent && opts.log( {createElement: tagName, internal_id: element._internal_id} );
218 | 
219 | 			if (tagName == "script") {
220 | 				element.async = !!opts.scriptAsync;
221 | 			}
222 | 			if (tagName == "link") {
223 | 				element.href = "";
224 | 			}
225 | 			if (/^(?:script|img)$/.test( tagName )) {
226 | 				element.src = "";
227 | 			}
228 | 
229 | 			return element;
230 | 		}
231 | 
232 | 		function Element() {
233 | 			this.tagName = null;
234 | 			this.parentNode = null;
235 | 			this.childNodes = [];
236 | 			if (opts.relList) {
237 | 				this.relList = {
238 | 					supports: supports,
239 | 					_parent: this,
240 | 				};
241 | 			}
242 | 
243 | 			// ************
244 | 			if (opts.sequentialIds) {
245 | 				this._internal_id = ++sequentialId;
246 | 			}
247 | 			else {
248 | 				this._internal_id = Math.floor( Math.random() * 1E6 );
249 | 			}
250 | 			this._tagNameNodeLists = {};
251 | 			this._eventHandlers = {};
252 | 		}
253 | 
254 | 		// Element#getElementsByTagName(..)
255 | 		function getElementsByTagName(tagName) {
256 | 			this._tagNameNodeLists[tagName] = this._tagNameNodeLists[tagName] || [];
257 | 			return this._tagNameNodeLists[tagName];
258 | 		}
259 | 
260 | 		// Element#appendChild(..)
261 | 		function appendChild(childElement) {
262 | 			!silent && opts.log( {appendChild: childElement._internal_id, internal_id: this._internal_id} );
263 | 
264 | 			this.childNodes.push( childElement );
265 | 			childElement.parentNode = this;
266 | 			updateTagNameNodeLists( childElement );
267 | 
268 | 			if (childElement.tagName.toLowerCase() == "link" && childElement.rel == "preload") {
269 | 				let resource = findMatchingOptResource( childElement.href );
270 | 
271 | 				if (resource) {
272 | 					fakePreload( resource, childElement );
273 | 				}
274 | 				else {
275 | 					opts.error( new Error( "appendChild: Preload resource not found (" + childElement.href + "; " + childElement._internal_id + ")" ) );
276 | 				}
277 | 			}
278 | 			else if (/^(?:script|link|img)$/i.test( childElement.tagName )) {
279 | 				let url = (/^(?:script|img)$/i.test( childElement.tagName )) ?
280 | 					childElement.src :
281 | 					childElement.href;
282 | 				let resource = findMatchingOptResource( url );
283 | 
284 | 				if (resource) {
285 | 					// track execution-order queue (for ordered-async on scripts)?
286 | 					let enforceExecOrder = (opts.scriptAsync && childElement.tagName.toLowerCase() == "script" && childElement.async === false);
287 | 
288 | 					if (enforceExecOrder) {
289 | 						execQueue.push( {url: url, element: childElement} );
290 | 					}
291 | 
292 | 					fakeLoad( resource, childElement, enforceExecOrder );
293 | 				}
294 | 				else {
295 | 					opts.error( new Error( "appendChild: Load resource not found (" + url + "; " + childElement._internal_id + ")" ) );
296 | 				}
297 | 			}
298 | 			else {
299 | 				!silent && opts.error( new Error( "appendChild: Unrecognized tag (" + childElement.tagName + "; " + childElement._internal_id + ")" ) );
300 | 			}
301 | 
302 | 			return childElement;
303 | 		}
304 | 
305 | 		// Element#removeChild(..)
306 | 		function removeChild(childElement) {
307 | 			opts.log( {removeChild: childElement._internal_id, internal_id: this._internal_id} );
308 | 
309 | 			var idx = this.childNodes.indexOf( childElement );
310 | 			if (idx != -1) {
311 | 				this.childNodes.splice( idx, 1 );
312 | 				filterTagNameNodeLists( childElement );
313 | 				childElement.parentNode = null;
314 | 			}
315 | 
316 | 			return childElement;
317 | 		}
318 | 
319 | 		// Element#setAttribute(..)
320 | 		function setAttribute(attrName,attrValue) {
321 | 			opts.log( {setAttribute: attrName + " | " + attrValue, internal_id: this._internal_id} );
322 | 
323 | 			this[attrName] = attrValue;
324 | 		}
325 | 
326 | 		// Element#getAttribute(..)
327 | 		function getAttribute(attrName) {
328 | 			return this[attrName];
329 | 		}
330 | 
331 | 		// Element#addEventListener(..)
332 | 		function addEventListener(evtName,handler) {
333 | 			opts.log( {addEventListener: evtName, internal_id: this._internal_id} );
334 | 
335 | 			this._eventHandlers[evtName] = this._eventHandlers[evtName] || [];
336 | 			this._eventHandlers[evtName].push( handler );
337 | 		}
338 | 
339 | 		// Element#removeEventListener(..)
340 | 		function removeEventListener(evtName,handler) {
341 | 			opts.log( {removeEventListener: evtName, internal_id: this._internal_id} );
342 | 
343 | 			if (this._eventHandlers[evtName]) {
344 | 				let idx = this._eventHandlers[evtName].indexOf( handler );
345 | 				this._eventHandlers[evtName].splice( idx, 1 );
346 | 			}
347 | 		}
348 | 
349 | 		// Element#dispatchEvent(..)
350 | 		function dispatchEvent(evt) {
351 | 			opts.log( {dispatchEvent: evt.type, internal_id: this._internal_id} );
352 | 
353 | 			if (evt.type == null) {
354 | 				opts.error( new Error( "dispatchEvent: Event not initialized (" + this._internal_id + ")" ) );
355 | 				return;
356 | 			}
357 | 
358 | 			evt.target = evt.currentTarget = this;
359 | 
360 | 			if (this._eventHandlers[evt.type]) {
361 | 				let evtHandlers = this._eventHandlers[evt.type].slice();
362 | 
363 | 				for (let i = 0; i < evtHandlers.length; i++) {
364 | 					try { evtHandlers[i].call( this, evt ); } catch (err) {}
365 | 				}
366 | 			}
367 | 
368 | 			// manually fire `window.onload` handler?
369 | 			if (evt.target === mockDOM && evt.type === "load" && typeof mockDOM.onload == "function") {
370 | 				mockDOM.onload.call( this, evt );
371 | 			}
372 | 		}
373 | 
374 | 		// Element#relList.supports(..)
375 | 		function supports(rel) {
376 | 			if (rel == "preload" && opts.linkPreload && this._parent.tagName.toLowerCase() == "link") {
377 | 				return true;
378 | 			}
379 | 			return false;
380 | 		}
381 | 
382 | 		// performance.getEntriesByName(..)
383 | 		function getEntriesByName(url) {
384 | 			if (~performanceEntries.indexOf( url )) {
385 | 				return [url];
386 | 			}
387 | 			return [];
388 | 		}
389 | 
390 | 		function updateTagNameNodeLists(element) {
391 | 			var el = element.parentNode;
392 | 			var tagName = element.tagName.toLowerCase();
393 | 
394 | 			var keys = Object.keys( element._tagNameNodeLists );
395 | 
396 | 			// recursively walk up the element tree
397 | 			while (el != null) {
398 | 				el._tagNameNodeLists[tagName] = el._tagNameNodeLists[tagName] || [];
399 | 				if (!~el._tagNameNodeLists[tagName].indexOf( element )) {
400 | 					el._tagNameNodeLists[tagName].push( element );
401 | 				}
402 | 
403 | 				// merge element's node-lists upward
404 | 				for (let i = 0; i < keys.length; i++) {
405 | 					el._tagNameNodeLists[keys[i]] = el._tagNameNodeLists[keys[i]] || [];
406 | 					for (let j = 0; j < element._tagNameNodeLists[keys[i]].length; j++) {
407 | 						if (!~el._tagNameNodeLists[keys[i]].indexOf( element._tagNameNodeLists[keys[i]][j] )) {
408 | 							el._tagNameNodeLists[keys[i]].push( element._tagNameNodeLists[keys[i]][j] );
409 | 						}
410 | 					}
411 | 				}
412 | 
413 | 				el = el.parentNode;
414 | 			}
415 | 
416 | 		}
417 | 
418 | 		function filterTagNameNodeLists(element) {
419 | 			var el = element.parentNode;
420 | 			var tagName = element.tagName.toLowerCase();
421 | 
422 | 			// recursively walk up the element tree
423 | 			while (el != null) {
424 | 				let idx;
425 | 				if (el._tagNameNodeLists[tagName] && (idx = el._tagNameNodeLists[tagName].indexOf( element )) != -1) {
426 | 					el._tagNameNodeLists[tagName].splice( idx, 1 );
427 | 				}
428 | 				el = el.parentNode;
429 | 			}
430 | 		}
431 | 
432 | 		function findMatchingOptResource(url) {
433 | 			for (let i = 0; i < opts.resources.length; i++) {
434 | 				if (opts.resources[i].url == url) {
435 | 					return opts.resources[i];
436 | 				}
437 | 			}
438 | 		}
439 | 
440 | 		function fakePreload(resource,element) {
441 | 			setTimeout( function preload(){
442 | 				if (resource.preload === true) {
443 | 					var evt = new Event( "load" );
444 | 				}
445 | 				else {
446 | 					var evt = new Event( "error" );
447 | 				}
448 | 
449 | 				addPerformanceEntry( resource.url );
450 | 
451 | 				element.dispatchEvent( evt );
452 | 			}, resource.preloadDelay );
453 | 		}
454 | 
455 | 		function fakeLoad(resource,element,enforceExecOrder) {
456 | 			setTimeout( function load(){
457 | 				resourceLoaded( resource, element, enforceExecOrder );
458 | 			}, resource.loadDelay );
459 | 		}
460 | 
461 | 		function resourceLoaded(resource,element,enforceExecOrder) {
462 | 			if (resource.load === true) {
463 | 				var evt = new Event( "load" );
464 | 			}
465 | 			else {
466 | 				var evt = new Event( "error" );
467 | 			}
468 | 
469 | 			// simulating ordered-async for <script> elements?
470 | 			if (enforceExecOrder) {
471 | 				updateExecQueue( resource.url, element, evt );
472 | 			}
473 | 			else {
474 | 				element.dispatchEvent( evt );
475 | 			}
476 | 
477 | 			addPerformanceEntry( resource.url );
478 | 		}
479 | 
480 | 		function Event(type) {
481 | 			this.type = type;
482 | 			this.name = type;
483 | 			this.target = null;
484 | 			this.currentTarget = null;
485 | 			this.bubbles = false;
486 | 			this.cancelable = false;
487 | 			this.composed = false;
488 | 			this.scoped = false;
489 | 			this.defaultPrevented = false;
490 | 			this.timestamp = Date.now();
491 | 			this.isTrusted = true;
492 | 			this.eventPhase = 2; // Event.AT_TARGET
493 | 			this.preventDefault = function preventDefault(){ this.defaultPrevented = true; };
494 | 			this.stopPropagation = function stopPropagation(){};
495 | 			this.stopImmediatePropagation = function stopImmediatePropagation(){};
496 | 			this.initEvent = function initEvent(type,bubbles,cancelable){
497 | 				this.type = this.name = type;
498 | 				this.bubbles = bubbles;
499 | 				this.cancelable = cancelable;
500 | 			};
501 | 		}
502 | 
503 | 		function createEvent() {
504 | 			return new Event( null );
505 | 		}
506 | 
507 | 		// ensures load event order (queue) for ordered-async
508 | 		function updateExecQueue(url,element,evt) {
509 | 			var dispatchReady = true;
510 | 			var idx = 0;
511 | 
512 | 			while (execQueue.length > 0 && idx < execQueue.length) {
513 | 				// update queue item?
514 | 				if (execQueue[idx].url == url && execQueue[idx].element == element) {
515 | 					opts.log( {updateExecQueue: url, internal_id: element._internal_id} );
516 | 					execQueue[idx].evt = evt;
517 | 				}
518 | 
519 | 				if (dispatchReady) {
520 | 					let entry = execQueue[0];
521 | 
522 | 					if (entry.evt) {
523 | 						entry.element.dispatchEvent( entry.evt );
524 | 						execQueue.shift();
525 | 						// NOTE: since we're shifting off index 0, no need
526 | 						// to increment `idx`
527 | 					}
528 | 					else {
529 | 						dispatchReady = false;
530 | 						idx++;
531 | 					}
532 | 				}
533 | 				else {
534 | 					idx++;
535 | 				}
536 | 			}
537 | 		}
538 | 
539 | 		function addPerformanceEntry(url) {
540 | 			if (!~performanceEntries.indexOf( url )) {
541 | 				performanceEntries.push( url );
542 | 			}
543 | 		}
544 | 
545 | 		function advanceReadyState(){
546 | 			if (docReadyState == "loading") {
547 | 				// defer-scripts waiting?
548 | 				if (deferQueue.length > 0) {
549 | 					for (let i = 0; i < deferQueue.length; i++) {
550 | 						resourceLoaded( deferQueue[i].resource, deferQueue[i].element, /*enforceExecOrder=*/true );
551 | 					}
552 | 					deferQueue.length = 0;
553 | 				}
554 | 
555 | 				docReadyState = "interactive";
556 | 				var evt = new Event( "DOMContentLoaded" );
557 | 				documentElement.dispatchEvent( evt );
558 | 				docReadyDelay = opts.docReadyDelay;
559 | 				setTimeout( advanceReadyState, docReadyDelay );
560 | 			}
561 | 			// otherwise, must already be "interactive"
562 | 			else {
563 | 				docReadyState = "complete";
564 | 				var evt = new Event( "load" );
565 | 				mockDOM.dispatchEvent( evt );
566 | 			}
567 | 		}
568 | 
569 | 		function processInitialDOM(DOM) {
570 | 			if (Array.isArray( DOM.head )) {
571 | 				for (let i = 0; i < DOM.head.length; i++) {
572 | 					processInitialElement( documentElement.head, DOM.head[i] );
573 | 				}
574 | 			}
575 | 			if (Array.isArray( DOM.body )) {
576 | 				for (let i = 0; i < DOM.body.length; i++) {
577 | 					processInitialElement( documentElement.body, DOM.body[i] );
578 | 				}
579 | 			}
580 | 		}
581 | 
582 | 		function processInitialElement(parentElem,entry) {
583 | 			var tagName = (entry.tagName || "div").toLowerCase();
584 | 			var element = createElement( tagName );
585 | 			var entryProps = Object.keys( entry );
586 | 
587 | 			// skip some properties
588 | 			entryProps = entryProps.filter( function skipProperty(prop){
589 | 				if (prop == "tagName") return false;
590 | 				if (tagName == "script" && prop == "async" && !opts.scriptAsync) return false;
591 | 				if (tagName == "link" && prop == "rel" && entry.rel == "preload" && !opts.linkPreload) return false;
592 | 				return true;
593 | 			} );
594 | 
595 | 			// need to undo some default properties from `createElement(..)` API?
596 | 			if (/^(?:script|link|img)$/.test( tagName )) {
597 | 				if (tagName == "script") {
598 | 					delete element.async;
599 | 					delete element.src;
600 | 				}
601 | 				if (tagName == "link") {
602 | 					delete element.href;
603 | 				}
604 | 				if (tagName == "img") {
605 | 					delete element.src;
606 | 				}
607 | 			}
608 | 
609 | 			// copy remaining properties
610 | 			for (let i = 0; i < entryProps.length; i++) {
611 | 				element[entryProps[i]] = entry[entryProps[i]];
612 | 			}
613 | 
614 | 			// correctly default `async` on `<script>`
615 | 			if (tagName == "script" &&
616 | 				!("async" in entry) || ("defer" in entry)
617 | 			) {
618 | 				element.async = false;
619 | 			}
620 | 
621 | 			// "insert" element into DOM
622 | 			parentElem.childNodes.push( element );
623 | 			element.parentNode = parentElem;
624 | 			updateTagNameNodeLists( element );
625 | 
626 | 			// `DOMContentLoaded` still yet to fire, and element makes a resource request?
627 | 			if (
628 | 				docReadyState == "loading" &&
629 | 				(
630 | 					(tagName == "script" && "src" in element) ||
631 | 					(tagName == "img" && "src" in element) ||
632 | 					(tagName == "link" && "href" in element)
633 | 				)
634 | 			) {
635 | 				let url = /script|img/.test( tagName ) ? element.src : element.href;
636 | 				let resource = findMatchingOptResource( url );
637 | 
638 | 				// registered resource?
639 | 				if (resource) {
640 | 					// resource preload element?
641 | 					if (tagName == "link" && element.rel == "preload") {
642 | 						fakePreload( resource, element );
643 | 					}
644 | 					// script-defer element?
645 | 					else if (tagName == "script" && "src" in element && "defer" in element) {
646 | 						execQueue.push( {url, element} );
647 | 						deferQueue.push( {url, element, resource} );
648 | 
649 | 						// need to delay `DOMContentLoaded` for this resource?
650 | 						if (resource.loadDelay > docReadyDelay) {
651 | 							docReadyDelay = Math.max( docReadyDelay, resource.loadDelay );
652 | 						}
653 | 					}
654 | 					// otherwise, normal resource request
655 | 					else {
656 | 						let enforceExecOrder = !(tagName == "script" && element.async);
657 | 
658 | 						// resource request also needs to go into execution-order queue?
659 | 						if (enforceExecOrder)  {
660 | 							execQueue.push( {url, element} );
661 | 						}
662 | 
663 | 						fakeLoad( resource, element, enforceExecOrder );
664 | 					}
665 | 				}
666 | 				else {
667 | 					opts.error( new Error( "initialDOM: Resource not found (" + url + ")" ) );
668 | 				}
669 | 			}
670 | 		}
671 | 	}
672 | 
673 | 	function setupLocation(location) {
674 | 		var loc = {
675 | 			toString() { return location; },
676 | 			get href() { return location; },
677 | 			set href(val) {
678 | 				location = val;
679 | 				parseLocation();
680 | 			},
681 | 			assign: function assign(val){ this.href = val; },
682 | 			reload: function reload(){},
683 | 			replace: function replace(val){ this.href = val; },
684 | 		};
685 | 
686 | 		loc.href = location;
687 | 
688 | 		return loc;
689 | 
690 | 
691 | 		// *************************
692 | 
693 | 		function parseLocation() {
694 | 			var locParts = parseURI( location );
695 | 			loc.protocol = (locParts.protocol || "") + ":";
696 | 			loc.host = locParts.host || "";
697 | 			loc.pathname = locParts.path || "";
698 | 			loc.port = locParts.port || "";
699 | 			loc.host = locParts.host + (loc.port ? ":" + loc.port : "");
700 | 			loc.hostname = locParts.host;
701 | 			loc.hash = locParts.anchor ? "#" + locParts.anchor : "";
702 | 			loc.search = locParts.query ? "?" + locParts.query : "";
703 | 			loc.username = locParts.user ? locParts.user : undefined;
704 | 			loc.password = locParts.password ? locParts.password : undefined;
705 | 			loc.origin = loc.protocol + "//" + loc.host;
706 | 		}
707 | 	}
708 | 
709 | 	// adapted from http://blog.stevenlevithan.com/archives/parseuri
710 | 	function parseURI(str) {
711 | 		var	o = {
712 | 				key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],
713 | 			};
714 | 		var m = /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/.exec(str);
715 | 		var uri = {};
716 | 		var i = 14;
717 | 
718 | 		while (i--) uri[o.key[i]] = m[i] || "";
719 | 
720 | 		return uri;
721 | 	}
722 | 
723 | 	function restoreGlobals() {
724 | 		/* istanbul ignore next */if (typeof window != "undefined" && global === window && window.document) {
725 | 			/* istanbul ignore next */window.document.createElement = originalGlobals[0];
726 | 			/* istanbul ignore next */window.document.createEvent = originalGlobals[1];
727 | 			/* istanbul ignore next */window.document.appendChild = originalGlobals[2];
728 | 			/* istanbul ignore next */window.document.removeChild = originalGlobals[3];
729 | 			/* istanbul ignore next */window.document.getElementsByTagName = originalGlobals[4];
730 | 			/* istanbul ignore next */window.document.head.appendChild = originalGlobals[5];
731 | 			/* istanbul ignore next */window.document.head.removeChild = originalGlobals[6];
732 | 			/* istanbul ignore next */window.document.head.getElementsByTagName = originalGlobals[7];
733 | 			/* istanbul ignore next */window.document.body.appendChild = originalGlobals[8];
734 | 			/* istanbul ignore next */window.document.body.removeChild = originalGlobals[9];
735 | 			/* istanbul ignore next */window.document.body.getElementsByTagName = originalGlobals[10];
736 | 			/* istanbul ignore next */global.performance.getEntriesByName = originalGlobals[11];
737 | 			/* istanbul ignore next */global.Event = originalGlobals[12];
738 | 		}
739 | 		else {
740 | 			global.window = originalGlobals[0];
741 | 			global.document = originalGlobals[1];
742 | 			Object.defineProperty( global, "location", {
743 | 				configurable: true,
744 | 				value: originalGlobals[2],
745 | 			} );
746 | 			global.performance = originalGlobals[3];
747 | 			global.Event = originalGlobals[4];
748 | 		}
749 | 	}
750 | });
751 | 


--------------------------------------------------------------------------------
/tests/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 | <meta charset="utf-8" />
 5 | <title>Mock-DOM-Resources Test Suite</title>
 6 | <link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-2.3.0.css">
 7 | </head>
 8 | <body>
 9 | <div id="qunit"></div>
10 | <div id="qunit-fixture"></div>
11 | 
12 | <script src="../src/index.js"></script>
13 | <script src="https://code.jquery.com/qunit/qunit-2.3.0.js"></script>
14 | <script src="tests.js"></script>
15 | </body>
16 | </html>
17 | 


--------------------------------------------------------------------------------
/tests/qunit.config.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | QUnit.config.requireExpects = true;
  4 | 
  5 | QUnit.begin(begin);
  6 | QUnit.log(testLog);
  7 | QUnit.testDone(testDone);
  8 | QUnit.done(done);
  9 | 
 10 | var testLogEntries = {};
 11 | 
 12 | // ******************************
 13 | 
 14 | function begin(details){
 15 | 	printEnvNotification();
 16 | 
 17 | 	if (details.totalTests > 0) {
 18 | 		console.log(`Mock-DOM-Resources Test Suite (${details.totalTests})`);
 19 | 		console.log("");
 20 | 	}
 21 | 	else {
 22 | 		console.log(`Mock-DOM-Resources Test Suite: empty!`);
 23 | 		process.exit(1);
 24 | 	}
 25 | }
 26 | 
 27 | function testLog(details) {
 28 | 	var testId = details.testId;
 29 | 
 30 | 	testLogEntries[testId] = testLogEntries[testId] || {};
 31 | 	testLogEntries[testId][details.message] = details;
 32 | }
 33 | 
 34 | function testDone(results){
 35 | 	var testId = results.testId;
 36 | 
 37 | 	if (results.failed > 0) {
 38 | 		console.log(`Failed: '${results.name}' (${results.failed}/${results.total})`);
 39 | 		for (let i = 0; i < results.assertions.length; i++) {
 40 | 			if (results.assertions[i].result === false) {
 41 | 				let { message, expected, actual } = testLogEntries[testId][results.assertions[i].message];
 42 | 				console.log(`  ${message}`);
 43 | 				console.log(`    expected: ${prettyPrint(expected)}`);
 44 | 				console.log(`    actual: ${prettyPrint(actual)}`);
 45 | 			}
 46 | 		}
 47 | 	}
 48 | 	else if (results.passed > 0) {
 49 | 		console.log(`Passed: '${results.name}' (${results.passed}/${results.total})`);
 50 | 	}
 51 | 	else {
 52 | 		console.log(`No assertions run: '${results.name}'`);
 53 | 	}
 54 | }
 55 | 
 56 | function done(results){
 57 | 	console.log("");
 58 | 
 59 | 	if (results.failed > 0) {
 60 | 		console.log(`Failed (${results.failed}/${results.total})`);
 61 | 		printEnvNotification();
 62 | 		process.exit(1);
 63 | 	}
 64 | 	else if (results.passed > 0) {
 65 | 		console.log(`Passed (${results.passed}/${results.total})`);
 66 | 		printEnvNotification();
 67 | 		process.exit(0);
 68 | 	}
 69 | 	else {
 70 | 		console.log("No tests run!");
 71 | 		printEnvNotification();
 72 | 		process.exit(1);
 73 | 	}
 74 | }
 75 | 
 76 | function prettyPrint(v) {
 77 | 	if (Array.isArray(v)) {
 78 | 		return `[${ v.map( prettyPrint ).toString() }]`;
 79 | 	}
 80 | 	else if (v && typeof v == "object") {
 81 | 		return JSON.stringify(v,function(k,v){
 82 | 			if (v === undefined) {
 83 | 				return null;
 84 | 			}
 85 | 			return v;
 86 | 		});
 87 | 	}
 88 | 	return String(v);
 89 | }
 90 | 
 91 | function printEnvNotification() {
 92 | 	return;
 93 | 
 94 | 	console.log("");
 95 | 	console.log("**********************************");
 96 | 	if (process.env.TEST_DIST) {
 97 | 		console.log("********** TESTING DIST **********");
 98 | 	}
 99 | 	else if (process.env.TEST_PACKAGE) {
100 | 		console.log("******** TESTING PACKAGE *********");
101 | 	}
102 | 	else {
103 | 		console.log("********** TESTING SRC ***********");
104 | 	}
105 | 	console.log("**********************************");
106 | 	console.log("");
107 | }
108 | 


--------------------------------------------------------------------------------
/tests/tests.js:
--------------------------------------------------------------------------------
   1 | "use strict";
   2 | 
   3 | const WINDOW_ID = 1;
   4 | const DOCUMENT_ID = 2;
   5 | const HEAD_ID = 3;
   6 | const BODY_ID = 4;
   7 | 
   8 | QUnit.test( "build DOM", function test(assert){
   9 | 	var win = $DOM( {
  10 | 		sequentialIds: true,
  11 | 		log: function log(){},
  12 | 		error: function error(){},
  13 | 	} );
  14 | 
  15 | 	var x = win.document.createElement( "p" );
  16 | 	x.innerHTML = "Hello";
  17 | 	var y = win.document.createElement( "p" );
  18 | 	y.innerHTML = "World";
  19 | 	var z = win.document.createElement( "p" );
  20 | 	z.innerHTML = "!";
  21 | 
  22 | 	var w = win.document.createElement( "div" );
  23 | 	w.appendChild( x );
  24 | 	w.appendChild( y );
  25 | 	w.appendChild( z );
  26 | 
  27 | 	var p = win.document.createElement( "p" );
  28 | 	p.innerHTML = ":)";
  29 | 
  30 | 	win.document.body.appendChild( w );
  31 | 	win.document.body.appendChild( p );
  32 | 
  33 | 	var pElems = win.document.body.getElementsByTagName( "p" );
  34 | 	var aElems = win.document.body.getElementsByTagName( "a" );
  35 | 
  36 | 	var rExpected = 4;
  37 | 	var pExpected = 3;
  38 | 	var qExpected = 3;
  39 | 	var tExpected = {
  40 | 		tagName: "DOCUMENT",
  41 | 		childNodes: [
  42 | 			{ tagName: "HEAD", childNodes: [], _internal_id: HEAD_ID, },
  43 | 			{ tagName: "BODY",
  44 | 				childNodes: [
  45 | 					{ tagName: "DIV",
  46 | 						childNodes: [
  47 | 							{ tagName: "P", childNodes: [], innerHTML: "Hello", _internal_id: 5, },
  48 | 							{ tagName: "P", childNodes: [], innerHTML: "!", _internal_id: 7, },
  49 | 						],
  50 | 						_internal_id: 8,
  51 | 					},
  52 | 					{ tagName: "P", childNodes: [], innerHTML: ":)", _internal_id: 9, },
  53 | 				],
  54 | 				_internal_id: BODY_ID,
  55 | 			},
  56 | 		],
  57 | 		_internal_id: DOCUMENT_ID,
  58 | 	};
  59 | 	var sExpected = ":)";
  60 | 	var uExpected = 0;
  61 | 
  62 | 	var rActual = pElems.length;
  63 | 	w.removeChild( y );
  64 | 	var pActual = pElems.length;
  65 | 	w.removeChild( y );
  66 | 	var qActual = pElems.length;
  67 | 	var tActual = JSON.parse( JSON.stringify( win.document, ["tagName","childNodes","innerHTML","_internal_id",] ) );
  68 | 	var sActual = p.getAttribute( "innerHTML" );
  69 | 	var uActual = aElems.length;
  70 | 
  71 | 	assert.expect( 6 );
  72 | 	assert.strictEqual( rActual, rExpected, "p elements" );
  73 | 	assert.strictEqual( pActual, pExpected, "p elements, after removeChild()" );
  74 | 	assert.strictEqual( qActual, qExpected, "extraneous removeChild()" );
  75 | 	assert.deepEqual( tActual, tExpected, "node tree structure" );
  76 | 	assert.strictEqual( sActual, sExpected, "getAttribute()" );
  77 | 	assert.strictEqual( uActual, uExpected, "(no) a elements" );
  78 | } );
  79 | 
  80 | QUnit.test( "check already cached resource", function test(assert){
  81 | 	assert.expect( 2 );
  82 | 
  83 | 	var win = $DOM( {
  84 | 		sequentialIds: true,
  85 | 		log: function log(){},
  86 | 		error: function error(){},
  87 | 		resources: [
  88 | 			{ url: "a.js", cached: true, },
  89 | 		],
  90 | 	} );
  91 | 
  92 | 	var rExpected = ["a.js",];
  93 | 	var pExpected = [];
  94 | 
  95 | 	var rActual = win.performance.getEntriesByName( "a.js" );
  96 | 	var pActual = win.performance.getEntriesByName( "b.js" );
  97 | 
  98 | 	assert.deepEqual( rActual, rExpected, "found resource" );
  99 | 	assert.deepEqual( pActual, pExpected, "resource not found" );
 100 | } );
 101 | 
 102 | QUnit.test( "relList / supports()", function test(assert){
 103 | 	var win1 = $DOM( {
 104 | 		relList: false,
 105 | 		log: function log(){},
 106 | 		error: function error(){},
 107 | 	} );
 108 | 
 109 | 	var win2 = $DOM( {
 110 | 		log: function log(){},
 111 | 		error: function error(){},
 112 | 	} );
 113 | 
 114 | 	var win3 = $DOM( {
 115 | 		linkPreload: false,
 116 | 		log: function log(){},
 117 | 		error: function error(){},
 118 | 	} );
 119 | 
 120 | 	var link1 = win2.document.createElement( "link" );
 121 | 	link1.setAttribute( "rel", "preload" );
 122 | 
 123 | 	var link2 = win3.document.createElement( "link" );
 124 | 	link2.setAttribute( "rel", "preload" );
 125 | 
 126 | 	var script = win2.document.createElement( "script" );
 127 | 
 128 | 	var rExpected = false;
 129 | 	var pExpected = true;
 130 | 	var qExpected = false;
 131 | 	var tExpected = false;
 132 | 	var sExpected = false;
 133 | 
 134 | 	var rActual = !!win1.document.relList;
 135 | 	var pActual = link1.relList.supports( "preload" );
 136 | 	var qActual = link1.relList.supports( "funny" );
 137 | 	var tActual = link2.relList.supports( "preload" );
 138 | 	var sActual = script.relList.supports( "preload" );
 139 | 
 140 | 	assert.expect( 5 );
 141 | 	assert.strictEqual( rActual, rExpected, "no relList" );
 142 | 	assert.strictEqual( pActual, pExpected, "check rel: 'preload'" );
 143 | 	assert.strictEqual( qActual, qExpected, "check rel: 'funny'" );
 144 | 	assert.strictEqual( tActual, tExpected, "no preloading" );
 145 | 	assert.strictEqual( sActual, sExpected, "not <link>" );
 146 | } );
 147 | 
 148 | QUnit.test( "event listeners", function test(assert){
 149 | 	var win = $DOM( {
 150 | 		log: function log(){},
 151 | 		error: function error(){},
 152 | 	} );
 153 | 
 154 | 	var rExpected = 3;
 155 | 	var pExpected = 1;
 156 | 	var qExpected = 2;
 157 | 
 158 | 	var rActual = 0;
 159 | 	var pActual = 0;
 160 | 	var qActual = 0;
 161 | 
 162 | 	var x = win.document.createElement( "script" );
 163 | 	x.addEventListener( "funny", function onfunny(evt){
 164 | 		evt.preventDefault();
 165 | 		evt.stopPropagation();
 166 | 		evt.stopImmediatePropagation();
 167 | 		rActual++;
 168 | 	} );
 169 | 	x.addEventListener( "hello", function onhello(){
 170 | 		x.removeEventListener( "hello", onhello );
 171 | 		x.removeEventListener( "hello2", onhello );
 172 | 		pActual++;
 173 | 	} );
 174 | 	x.addEventListener( "world", function onworld(){
 175 | 		qActual++;
 176 | 	} );
 177 | 
 178 | 	var e1 = win.document.createEvent();
 179 | 	x.dispatchEvent( e1 );
 180 | 	e1.initEvent( "funny" );
 181 | 
 182 | 	var e2 = new win.Event( "hello" );
 183 | 	var e3 = new win.Event( "world" );
 184 | 	var e4 = new win.Event( "!!" );
 185 | 
 186 | 	x.dispatchEvent( e1 );
 187 | 	x.dispatchEvent( e1 );
 188 | 	x.dispatchEvent( e1 );
 189 | 	x.dispatchEvent( e2 );
 190 | 	x.dispatchEvent( e2 );
 191 | 	x.dispatchEvent( e3 );
 192 | 	x.dispatchEvent( e3 );
 193 | 	x.dispatchEvent( e4 );
 194 | 
 195 | 	assert.expect( 3 );
 196 | 	assert.strictEqual( rActual, rExpected, "event prevented" );
 197 | 	assert.strictEqual( pActual, pExpected, "event removed" );
 198 | 	assert.strictEqual( qActual, qExpected, "event" );
 199 | } );
 200 | 
 201 | QUnit.test( "request unknown resources", function test(assert){
 202 | 	var done = assert.async();
 203 | 	assert.expect( 1 );
 204 | 
 205 | 	var rExpected = [
 206 | 		{ window: WINDOW_ID, },
 207 | 		{ document: DOCUMENT_ID, },
 208 | 		{ head: HEAD_ID, },
 209 | 		{ body: BODY_ID, },
 210 | 		{ createElement: "link", internal_id: 5, },
 211 | 		{ setAttribute: "rel | preload", internal_id: 5, },
 212 | 		{ setAttribute: "href | a.js", internal_id: 5, },
 213 | 		{ createElement: "link", internal_id: 6, },
 214 | 		{ setAttribute: "href | b.js", internal_id: 6, },
 215 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 216 | 		{ message: "appendChild: Preload resource not found (a.js; 5)", },
 217 | 		{ appendChild: 6, internal_id: HEAD_ID, },
 218 | 		{ message: "appendChild: Load resource not found (b.js; 6)", },
 219 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 220 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 221 | 	];
 222 | 
 223 | 	var { logs: rActual, log, error, } = collectLogs();
 224 | 
 225 | 	var wrappedErrorFn = function wrapped(msg) {
 226 | 		if (msg instanceof Error) {
 227 | 			msg = JSON.parse( JSON.stringify( msg, ["message",] ) );
 228 | 		}
 229 | 		return error( msg );
 230 | 	};
 231 | 
 232 | 	var win = $DOM( {
 233 | 		sequentialIds: true,
 234 | 		log,
 235 | 		error: wrappedErrorFn,
 236 | 	} );
 237 | 
 238 | 	var link1 = win.document.createElement( "link" );
 239 | 	link1.setAttribute( "rel", "preload" );
 240 | 	link1.setAttribute( "href", "a.js" );
 241 | 
 242 | 	var link2 = win.document.createElement( "link" );
 243 | 	link2.setAttribute( "href", "b.js" );
 244 | 
 245 | 	win.document.head.appendChild( link1 );
 246 | 	win.document.head.appendChild( link2 );
 247 | 
 248 | 	win.onload = function onload(){
 249 | 		assert.deepEqual( rActual, rExpected, "logs" );
 250 | 		done();
 251 | 	};
 252 | } );
 253 | 
 254 | QUnit.test( "load a script", function test(assert){
 255 | 	var done = assert.async( 2 );
 256 | 	assert.expect( 1 );
 257 | 
 258 | 	var rExpected = [
 259 | 		{ window: WINDOW_ID, },
 260 | 		{ document: DOCUMENT_ID, },
 261 | 		{ head: HEAD_ID, },
 262 | 		{ body: BODY_ID, },
 263 | 		{ createElement: "script", internal_id: 5, },
 264 | 		{ setAttribute: "src | a.js", internal_id: 5, },
 265 | 		{ addEventListener: "load", internal_id: 5, },
 266 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 267 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 268 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 269 | 		{ dispatchEvent: "load", internal_id: 5, },
 270 | 	];
 271 | 
 272 | 	var { logs: rActual, log, error, } = collectLogs();
 273 | 
 274 | 	var win = $DOM( {
 275 | 		sequentialIds: true,
 276 | 		log,
 277 | 		error,
 278 | 		resources: [
 279 | 			{ url: "a.js", load: true, loadDelay: "invalid" },
 280 | 		],
 281 | 	} );
 282 | 
 283 | 	win.onload = done;
 284 | 
 285 | 	var script = win.document.createElement( "script" );
 286 | 	script.setAttribute( "src", "a.js" );
 287 | 	script.addEventListener( "load", function onload(){
 288 | 		assert.deepEqual( rActual, rExpected, "logs" );
 289 | 		done();
 290 | 	} );
 291 | 	win.document.head.appendChild( script );
 292 | } );
 293 | 
 294 | QUnit.test( "load multiple scripts (ordered async)", function test(assert){
 295 | 	var done = assert.async( 3 );
 296 | 	assert.expect( 1 );
 297 | 
 298 | 	var rExpected = [
 299 | 		{ window: WINDOW_ID, },
 300 | 		{ document: DOCUMENT_ID, },
 301 | 		{ head: HEAD_ID, },
 302 | 		{ body: BODY_ID, },
 303 | 		{ createElement: "script", internal_id: 5, },
 304 | 		{ setAttribute: "src | a.js", internal_id: 5, },
 305 | 		{ addEventListener: "load", internal_id: 5, },
 306 | 		{ createElement: "script", internal_id: 6, },
 307 | 		{ setAttribute: "src | b.js", internal_id: 6, },
 308 | 		{ addEventListener: "load", internal_id: 6, },
 309 | 		{ createElement: "script", internal_id: 7, },
 310 | 		{ setAttribute: "src | c.js", internal_id: 7, },
 311 | 		{ addEventListener: "load", internal_id: 7, },
 312 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 313 | 		{ appendChild: 6, internal_id: HEAD_ID, },
 314 | 		{ appendChild: 7, internal_id: HEAD_ID, },
 315 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 316 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 317 | 		{ updateExecQueue: "b.js", internal_id: 6, },
 318 | 		{ updateExecQueue: "c.js", internal_id: 7, },
 319 | 		{ updateExecQueue: "a.js", internal_id: 5, },
 320 | 		{ dispatchEvent: "load", internal_id: 5, },
 321 | 		{ dispatchEvent: "load", internal_id: 6, },
 322 | 		{ dispatchEvent: "load", internal_id: 7, },
 323 | 	];
 324 | 
 325 | 	var { logs: rActual, log, error, } = collectLogs();
 326 | 
 327 | 	var win = $DOM( {
 328 | 		sequentialIds: true,
 329 | 		log,
 330 | 		error,
 331 | 		resources: [
 332 | 			{ url: "a.js", loadDelay: 40, load: true, },
 333 | 			{ url: "b.js", loadDelay: 10, load: true, },
 334 | 			{ url: "c.js", loadDelay: 25, load: true, },
 335 | 		],
 336 | 	} );
 337 | 
 338 | 	var script1 = win.document.createElement( "script" );
 339 | 	script1.setAttribute( "src", "a.js" );
 340 | 	script1.async = false;
 341 | 	script1.addEventListener( "load", done );
 342 | 
 343 | 	var script2 = win.document.createElement( "script" );
 344 | 	script2.setAttribute( "src", "b.js" );
 345 | 	script2.async = false;
 346 | 	script2.addEventListener( "load", done );
 347 | 
 348 | 	var script3 = win.document.createElement( "script" );
 349 | 	script3.setAttribute( "src", "c.js" );
 350 | 	script3.async = false;
 351 | 	script3.addEventListener( "load", function onload(){
 352 | 		assert.deepEqual( rActual, rExpected, "logs" );
 353 | 		done();
 354 | 	} );
 355 | 
 356 | 	win.document.head.appendChild( script1 );
 357 | 	win.document.head.appendChild( script2 );
 358 | 	win.document.head.appendChild( script3 );
 359 | } );
 360 | 
 361 | QUnit.test( "load multiple scripts (NO ordered async)", function test(assert){
 362 | 	var done = assert.async( 3 );
 363 | 	assert.expect( 1 );
 364 | 
 365 | 	var rExpected = [
 366 | 		{ window: WINDOW_ID, },
 367 | 		{ document: DOCUMENT_ID, },
 368 | 		{ head: HEAD_ID, },
 369 | 		{ body: BODY_ID, },
 370 | 		{ createElement: "script", internal_id: 5, },
 371 | 		{ setAttribute: "src | a.js", internal_id: 5, },
 372 | 		{ addEventListener: "load", internal_id: 5, },
 373 | 		{ createElement: "script", internal_id: 6, },
 374 | 		{ setAttribute: "src | b.js", internal_id: 6, },
 375 | 		{ addEventListener: "load", internal_id: 6, },
 376 | 		{ createElement: "script", internal_id: 7, },
 377 | 		{ setAttribute: "src | c.js", internal_id: 7, },
 378 | 		{ addEventListener: "load", internal_id: 7, },
 379 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 380 | 		{ appendChild: 6, internal_id: HEAD_ID, },
 381 | 		{ appendChild: 7, internal_id: HEAD_ID, },
 382 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 383 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 384 | 		{ dispatchEvent: "load", internal_id: 6, },
 385 | 		{ dispatchEvent: "load", internal_id: 7, },
 386 | 		{ dispatchEvent: "load", internal_id: 5, },
 387 | 	];
 388 | 
 389 | 	var { logs: rActual, log, error, } = collectLogs();
 390 | 
 391 | 	var win = $DOM( {
 392 | 		sequentialIds: true,
 393 | 		log,
 394 | 		error,
 395 | 		scriptAsync: false,
 396 | 		resources: [
 397 | 			{ url: "a.js", loadDelay: 40, load: true, },
 398 | 			{ url: "b.js", loadDelay: 10, load: true, },
 399 | 			{ url: "c.js", loadDelay: 25, load: true, },
 400 | 		],
 401 | 	} );
 402 | 
 403 | 	var script1 = win.document.createElement( "script" );
 404 | 	script1.setAttribute( "src", "a.js" );
 405 | 	script1.addEventListener( "load", function onload(){
 406 | 		assert.deepEqual( rActual, rExpected, "logs" );
 407 | 		done();
 408 | 	} );
 409 | 
 410 | 	var script2 = win.document.createElement( "script" );
 411 | 	script2.setAttribute( "src", "b.js" );
 412 | 	script2.addEventListener( "load", done );
 413 | 
 414 | 	var script3 = win.document.createElement( "script" );
 415 | 	script3.setAttribute( "src", "c.js" );
 416 | 	script3.addEventListener( "load", done );
 417 | 
 418 | 	win.document.head.appendChild( script1 );
 419 | 	win.document.head.appendChild( script2 );
 420 | 	win.document.head.appendChild( script3 );
 421 | } );
 422 | 
 423 | QUnit.test( "preload a script", function test(assert){
 424 | 	var done = assert.async();
 425 | 	assert.expect( 1 );
 426 | 
 427 | 	var rExpected = [
 428 | 		{ window: WINDOW_ID, },
 429 | 		{ document: DOCUMENT_ID, },
 430 | 		{ head: HEAD_ID, },
 431 | 		{ body: BODY_ID, },
 432 | 		{ createElement: "link", internal_id: 5, },
 433 | 		{ setAttribute: "rel | preload", internal_id: 5, },
 434 | 		{ setAttribute: "as | script", internal_id: 5, },
 435 | 		{ setAttribute: "href | a.js", internal_id: 5, },
 436 | 		{ addEventListener: "load", internal_id: 5, },
 437 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 438 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 439 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 440 | 		{ dispatchEvent: "load", internal_id: 5, },
 441 | 	];
 442 | 
 443 | 	var { logs: rActual, log, error, } = collectLogs();
 444 | 
 445 | 	var win = $DOM( {
 446 | 		sequentialIds: true,
 447 | 		log,
 448 | 		error,
 449 | 		resources: [
 450 | 			{ url: "a.js", preloadDelay: "invalid", preload: true, },
 451 | 		],
 452 | 	} );
 453 | 
 454 | 	var link = win.document.createElement( "link" );
 455 | 	link.setAttribute( "rel", "preload" );
 456 | 	link.setAttribute( "as", "script" );
 457 | 	link.setAttribute( "href", "a.js" );
 458 | 	link.addEventListener( "load", function onload(){
 459 | 		assert.deepEqual( rActual, rExpected, "logs" );
 460 | 		done();
 461 | 	} );
 462 | 	win.document.head.appendChild( link );
 463 | } );
 464 | 
 465 | QUnit.test( "preload multiple scripts", function test(assert){
 466 | 	var done = assert.async( 3 );
 467 | 	assert.expect( 1 );
 468 | 
 469 | 	var rExpected = [
 470 | 		{ window: WINDOW_ID, },
 471 | 		{ document: DOCUMENT_ID, },
 472 | 		{ head: HEAD_ID, },
 473 | 		{ body: BODY_ID, },
 474 | 		{ createElement: "link", internal_id: 5, },
 475 | 		{ setAttribute: "rel | preload", internal_id: 5, },
 476 | 		{ setAttribute: "as | script", internal_id: 5, },
 477 | 		{ setAttribute: "href | a.js", internal_id: 5, },
 478 | 		{ addEventListener: "load", internal_id: 5, },
 479 | 		{ createElement: "link", internal_id: 6, },
 480 | 		{ setAttribute: "rel | preload", internal_id: 6, },
 481 | 		{ setAttribute: "as | script", internal_id: 6, },
 482 | 		{ setAttribute: "href | b.js", internal_id: 6, },
 483 | 		{ addEventListener: "load", internal_id: 6, },
 484 | 		{ createElement: "link", internal_id: 7, },
 485 | 		{ setAttribute: "rel | preload", internal_id: 7, },
 486 | 		{ setAttribute: "as | script", internal_id: 7, },
 487 | 		{ setAttribute: "href | c.js", internal_id: 7, },
 488 | 		{ addEventListener: "load", internal_id: 7, },
 489 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 490 | 		{ appendChild: 6, internal_id: HEAD_ID, },
 491 | 		{ appendChild: 7, internal_id: HEAD_ID, },
 492 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 493 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 494 | 		{ dispatchEvent: "load", internal_id: 6, },
 495 | 		{ dispatchEvent: "load", internal_id: 7, },
 496 | 		{ dispatchEvent: "load", internal_id: 5, },
 497 | 	];
 498 | 
 499 | 	var { logs: rActual, log, error, } = collectLogs();
 500 | 
 501 | 	var win = $DOM( {
 502 | 		sequentialIds: true,
 503 | 		log,
 504 | 		error,
 505 | 		resources: [
 506 | 			{ url: "a.js", preloadDelay: 40, preload: true, },
 507 | 			{ url: "b.js", preload: true, },
 508 | 			{ url: "c.js", preloadDelay: 25, preload: true, },
 509 | 		],
 510 | 	} );
 511 | 
 512 | 	var link1 = win.document.createElement( "link" );
 513 | 	link1.setAttribute( "rel", "preload" );
 514 | 	link1.setAttribute( "as", "script" );
 515 | 	link1.setAttribute( "href", "a.js" );
 516 | 	link1.addEventListener( "load", function onload(){
 517 | 		assert.deepEqual( rActual, rExpected, "logs" );
 518 | 		done();
 519 | 	} );
 520 | 
 521 | 	var link2 = win.document.createElement( "link" );
 522 | 	link2.setAttribute( "rel", "preload" );
 523 | 	link2.setAttribute( "as", "script" );
 524 | 	link2.setAttribute( "href", "b.js" );
 525 | 	link2.addEventListener( "load", done );
 526 | 
 527 | 	var link3 = win.document.createElement( "link" );
 528 | 	link3.setAttribute( "rel", "preload" );
 529 | 	link3.setAttribute( "as", "script" );
 530 | 	link3.setAttribute( "href", "c.js" );
 531 | 	link3.addEventListener( "load", done );
 532 | 
 533 | 	win.document.head.appendChild( link1 );
 534 | 	win.document.head.appendChild( link2 );
 535 | 	win.document.head.appendChild( link3 );
 536 | } );
 537 | 
 538 | QUnit.test( "preload a script, then load it", function test(assert){
 539 | 	var done = assert.async();
 540 | 	assert.expect( 1 );
 541 | 
 542 | 	var rExpected = [
 543 | 		{ window: WINDOW_ID, },
 544 | 		{ document: DOCUMENT_ID, },
 545 | 		{ head: HEAD_ID, },
 546 | 		{ body: BODY_ID, },
 547 | 		{ createElement: "link", internal_id: 5, },
 548 | 		{ setAttribute: "rel | preload", internal_id: 5, },
 549 | 		{ setAttribute: "as | script", internal_id: 5, },
 550 | 		{ setAttribute: "href | a.js", internal_id: 5, },
 551 | 		{ addEventListener: "load", internal_id: 5, },
 552 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 553 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 554 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 555 | 		{ dispatchEvent: "load", internal_id: 5, },
 556 | 		{ createElement: "script", internal_id: 6, },
 557 | 		{ setAttribute: "src | a.js", internal_id: 6, },
 558 | 		{ addEventListener: "load", internal_id: 6, },
 559 | 		{ appendChild: 6, internal_id: HEAD_ID, },
 560 | 		{ dispatchEvent: "load", internal_id: 6, },
 561 | 	];
 562 | 
 563 | 	var { logs: rActual, log, error, } = collectLogs();
 564 | 
 565 | 	var win = $DOM( {
 566 | 		sequentialIds: true,
 567 | 		log,
 568 | 		error,
 569 | 		resources: [
 570 | 			{ url: "a.js", preloadDelay: 25, preload: true, loadDelay: 50, load: true, },
 571 | 		],
 572 | 	} );
 573 | 
 574 | 	var link = win.document.createElement( "link" );
 575 | 	link.setAttribute( "rel", "preload" );
 576 | 	link.setAttribute( "as", "script" );
 577 | 	link.setAttribute( "href", "a.js" );
 578 | 	link.addEventListener( "load", function onload(){
 579 | 		var script = win.document.createElement( "script" );
 580 | 		script.setAttribute( "src", "a.js" );
 581 | 		script.addEventListener( "load", function onload(){
 582 | 			assert.deepEqual( rActual, rExpected, "logs" );
 583 | 			done();
 584 | 		} );
 585 | 		win.document.head.appendChild( script );
 586 | 	} );
 587 | 	win.document.head.appendChild( link );
 588 | } );
 589 | 
 590 | QUnit.test( "preload multiple scripts, then load them (ordered async)", function test(assert){
 591 | 	var done = assert.async( 3 );
 592 | 	assert.expect( 2 );
 593 | 
 594 | 	var rExpected = [
 595 | 		{ window: WINDOW_ID, },
 596 | 		{ document: DOCUMENT_ID, },
 597 | 		{ head: HEAD_ID, },
 598 | 		{ body: BODY_ID, },
 599 | 		{ createElement: "link", internal_id: 5, },
 600 | 		{ setAttribute: "rel | preload", internal_id: 5, },
 601 | 		{ setAttribute: "as | script", internal_id: 5, },
 602 | 		{ setAttribute: "href | a.js", internal_id: 5, },
 603 | 		{ addEventListener: "load", internal_id: 5, },
 604 | 		{ createElement: "link", internal_id: 6, },
 605 | 		{ setAttribute: "rel | preload", internal_id: 6, },
 606 | 		{ setAttribute: "as | script", internal_id: 6, },
 607 | 		{ setAttribute: "href | b.js", internal_id: 6, },
 608 | 		{ addEventListener: "load", internal_id: 6, },
 609 | 		{ createElement: "link", internal_id: 7, },
 610 | 		{ setAttribute: "rel | preload", internal_id: 7, },
 611 | 		{ setAttribute: "as | script", internal_id: 7, },
 612 | 		{ setAttribute: "href | c.js", internal_id: 7, },
 613 | 		{ addEventListener: "load", internal_id: 7, },
 614 | 		{ appendChild: 5, internal_id: HEAD_ID, },
 615 | 		{ appendChild: 6, internal_id: HEAD_ID, },
 616 | 		{ appendChild: 7, internal_id: HEAD_ID, },
 617 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 618 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 619 | 		{ dispatchEvent: "load", internal_id: 6, },
 620 | 		{ dispatchEvent: "load", internal_id: 7, },
 621 | 		{ dispatchEvent: "load", internal_id: 5, },
 622 | 		{ createElement: "script", internal_id: 8, },
 623 | 		{ setAttribute: "src | a.js", internal_id: 8, },
 624 | 		{ addEventListener: "load", internal_id: 8, },
 625 | 		{ createElement: "script", internal_id: 9, },
 626 | 		{ setAttribute: "src | b.js", internal_id: 9, },
 627 | 		{ addEventListener: "load", internal_id: 9, },
 628 | 		{ createElement: "script", internal_id: 10, },
 629 | 		{ setAttribute: "src | c.js", internal_id: 10, },
 630 | 		{ addEventListener: "load", internal_id: 10, },
 631 | 		{ appendChild: 8, internal_id: HEAD_ID, },
 632 | 		{ appendChild: 9, internal_id: HEAD_ID, },
 633 | 		{ appendChild: 10, internal_id: HEAD_ID, },
 634 | 		{ updateExecQueue: "c.js", internal_id: 10, },
 635 | 		{ updateExecQueue: "a.js", internal_id: 8, },
 636 | 		{ dispatchEvent: "load", internal_id: 8, },
 637 | 		{ updateExecQueue: "b.js", internal_id: 9, },
 638 | 		{ dispatchEvent: "load", internal_id: 9, },
 639 | 		{ dispatchEvent: "load", internal_id: 10, },
 640 | 	];
 641 | 	var pExpected = ["a.js","b.js","c.js",];
 642 | 
 643 | 	var { logs: rActual, log, error, } = collectLogs();
 644 | 
 645 | 	var win = $DOM( {
 646 | 		sequentialIds: true,
 647 | 		log,
 648 | 		error,
 649 | 		resources: [
 650 | 			{ url: "a.js", preloadDelay: 40, preload: true, loadDelay: 20, load: true, },
 651 | 			{ url: "b.js", preloadDelay: 10, preload: true, loadDelay: 30, load: true, },
 652 | 			{ url: "c.js", preloadDelay: 25, preload: true, loadDelay: 10, load: true, },
 653 | 		],
 654 | 	} );
 655 | 
 656 | 	preloadScripts();
 657 | 
 658 | 
 659 | 	// ***************************************
 660 | 
 661 | 	function preloadScripts() {
 662 | 		var preloadCount = 0;
 663 | 
 664 | 		var link1 = win.document.createElement( "link" );
 665 | 		link1.setAttribute( "rel", "preload" );
 666 | 		link1.setAttribute( "as", "script" );
 667 | 		link1.setAttribute( "href", "a.js" );
 668 | 		link1.addEventListener( "load", function onload(){
 669 | 			preloadCount++;
 670 | 			if (preloadCount == 3) loadScripts();
 671 | 		} );
 672 | 
 673 | 		var link2 = win.document.createElement( "link" );
 674 | 		link2.setAttribute( "rel", "preload" );
 675 | 		link2.setAttribute( "as", "script" );
 676 | 		link2.setAttribute( "href", "b.js" );
 677 | 		link2.addEventListener( "load", function onload(){
 678 | 			preloadCount++;
 679 | 			if (preloadCount == 3) loadScripts();
 680 | 		} );
 681 | 
 682 | 		var link3 = win.document.createElement( "link" );
 683 | 		link3.setAttribute( "rel", "preload" );
 684 | 		link3.setAttribute( "as", "script" );
 685 | 		link3.setAttribute( "href", "c.js" );
 686 | 		link3.addEventListener( "load", function onload(){
 687 | 			preloadCount++;
 688 | 			if (preloadCount == 3) loadScripts();
 689 | 		} );
 690 | 
 691 | 		win.document.head.appendChild( link1 );
 692 | 		win.document.head.appendChild( link2 );
 693 | 		win.document.head.appendChild( link3 );
 694 | 	}
 695 | 
 696 | 	function loadScripts() {
 697 | 		var script1 = win.document.createElement( "script" );
 698 | 		script1.setAttribute( "src", "a.js" );
 699 | 		script1.async = false;
 700 | 		script1.addEventListener( "load", done );
 701 | 
 702 | 		var script2 = win.document.createElement( "script" );
 703 | 		script2.setAttribute( "src", "b.js" );
 704 | 		script2.async = false;
 705 | 		script2.addEventListener( "load", done );
 706 | 
 707 | 		var script3 = win.document.createElement( "script" );
 708 | 		script3.setAttribute( "src", "c.js" );
 709 | 		script3.async = false;
 710 | 		script3.addEventListener( "load", function onload(){
 711 | 			var pActual =
 712 | 				win.performance.getEntriesByName( "a.js" )
 713 | 				.concat(
 714 | 					win.performance.getEntriesByName( "b.js" ),
 715 | 					win.performance.getEntriesByName( "c.js" )
 716 | 				);
 717 | 
 718 | 			assert.deepEqual( rActual, rExpected, "logs" );
 719 | 			assert.deepEqual( pActual, pExpected, "performance entries" );
 720 | 			done();
 721 | 		} );
 722 | 
 723 | 		win.document.head.appendChild( script1 );
 724 | 		win.document.head.appendChild( script2 );
 725 | 		win.document.head.appendChild( script3 );
 726 | 	}
 727 | } );
 728 | 
 729 | // probably not running in the browser?
 730 | if (typeof window == "undefined" || Function("return this")() !== window || !window.document) {
 731 | 	QUnit.test( "location (default); non-browser", function test(assert){
 732 | 		var rExpected = {
 733 | 			href: "https://some.thing/else",
 734 | 			protocol: "https:",
 735 | 			pathname: "/else",
 736 | 			port: "",
 737 | 			host: "some.thing",
 738 | 			hostname: "some.thing",
 739 | 			hash: "",
 740 | 			search: "",
 741 | 			origin: "https://some.thing",
 742 | 		};
 743 | 		var pExpected = "https://some.thing/else";
 744 | 		var qExpected = "https://some.thing/else";
 745 | 		var tExpected = "https://some.thing/else";
 746 | 		var sExpected = "https://some.thing/else";
 747 | 		var uExpected = "https://some.thing/else";
 748 | 
 749 | 		var win = $DOM( {
 750 | 			log: function log(){},
 751 | 			error: function error(){},
 752 | 		} );
 753 | 
 754 | 		var rActual = JSON.parse( JSON.stringify( win.location ) );
 755 | 		var pActual = win.location.href;
 756 | 		var qActual = win.location.href.toString();
 757 | 		var tActual = win.location.toString();
 758 | 		var sActual = "" + win.location;
 759 | 		var uActual = win.document.baseURI;
 760 | 
 761 | 		assert.expect( 6 );
 762 | 		assert.deepEqual( rActual, rExpected, "location object" );
 763 | 		assert.strictEqual( pActual, pExpected, "location.href" );
 764 | 		assert.strictEqual( qActual, qExpected, "location.href.toString()" );
 765 | 		assert.strictEqual( tActual, tExpected, "location.toString()" );
 766 | 		assert.strictEqual( sActual, sExpected, "location + ''" );
 767 | 		assert.strictEqual( uActual, uExpected, "baseURI default" );
 768 | 	} );
 769 | 
 770 | 	QUnit.test( "location (changed); non-browser", function test(assert){
 771 | 		var rExpected = {
 772 | 			href: "http://user1:pw1@some.tld:8080/foo/bar?bam=baz#haha",
 773 | 			protocol: "http:",
 774 | 			pathname: "/foo/bar",
 775 | 			port: "8080",
 776 | 			host: "some.tld:8080",
 777 | 			hostname: "some.tld",
 778 | 			hash: "#haha",
 779 | 			search: "?bam=baz",
 780 | 			origin: "http://some.tld:8080",
 781 | 			username: "user1",
 782 | 			password: "pw1",
 783 | 		};
 784 | 		var pExpected = {
 785 | 			href: "https://some.thing/better",
 786 | 			protocol: "https:",
 787 | 			pathname: "/better",
 788 | 			port: "",
 789 | 			host: "some.thing",
 790 | 			hostname: "some.thing",
 791 | 			hash: "",
 792 | 			search: "",
 793 | 			origin: "https://some.thing",
 794 | 		};
 795 | 		var qExpected = "http://user1:pw1@some.tld:8080/foo/bar?bam=baz#haha";
 796 | 		var tExpected = "https://a.tld/funny";
 797 | 		var sExpected = "http://some.tld/foo/bar";
 798 | 		var uExpected = "https://other.tld";
 799 | 		var mExpected = "http://user1:pw1@some.tld:8080/foo/bar?bam=baz#haha";
 800 | 
 801 | 		var win = $DOM( {
 802 | 			replaceGlobals: true,
 803 | 			log: function log(){},
 804 | 			error: function error(){},
 805 | 			location: "http://user1:pw1@some.tld:8080/foo/bar?bam=baz#haha",
 806 | 		} );
 807 | 		win.location.reload();
 808 | 
 809 | 		var rActual = JSON.parse( JSON.stringify( win.document.location ) );
 810 | 
 811 | 		win.location = "https://some.thing/better";
 812 | 		var pActual = JSON.parse( JSON.stringify( win.location ) );
 813 | 
 814 | 		global.location = "http://user1:pw1@some.tld:8080/foo/bar?bam=baz#haha";
 815 | 		var qActual = win.location.href.toString();
 816 | 
 817 | 		document.location = "https://a.tld/funny";
 818 | 		var tActual = win.location.href.toString();
 819 | 
 820 | 		win.location.assign( "http://some.tld/foo/bar" );
 821 | 		var sActual = win.location.href.toString();
 822 | 
 823 | 		win.location.replace( "https://other.tld" );
 824 | 		var uActual = win.location.href.toString();
 825 | 		var mActual = win.document.baseURI;
 826 | 
 827 | 		$DOM.restoreGlobals();
 828 | 
 829 | 		assert.expect( 7 );
 830 | 		assert.deepEqual( rActual, rExpected, "location object" );
 831 | 		assert.deepEqual( pActual, pExpected, "win.location = .." );
 832 | 		assert.strictEqual( qActual, qExpected, "global.location = .." );
 833 | 		assert.strictEqual( tActual, tExpected, "document.location = .." );
 834 | 		assert.strictEqual( sActual, sExpected, "location.assign()" );
 835 | 		assert.strictEqual( uActual, uExpected, "location.replace()" );
 836 | 		assert.strictEqual( mActual, mExpected, "baseURI" );
 837 | 	} );
 838 | 
 839 | 	QUnit.test( "replace and restore globals; non-browser", function test(assert){
 840 | 		var globalObj = typeof global != "undefined" ? global : Function( "return this" )();
 841 | 
 842 | 		var pExpected = [
 843 | 			globalObj.window,
 844 | 			globalObj.document,
 845 | 			globalObj.performance,
 846 | 			globalObj.Event,
 847 | 			globalObj.location,
 848 | 		];
 849 | 
 850 | 		var win = $DOM( {
 851 | 			replaceGlobals: true,
 852 | 			log: function log(){},
 853 | 			error: function error(){},
 854 | 		} );
 855 | 
 856 | 		var rExpected = [
 857 | 			win,
 858 | 			win.document,
 859 | 			win.performance,
 860 | 			win.Event,
 861 | 			win.location,
 862 | 		];
 863 | 
 864 | 		var rActual = [
 865 | 			globalObj.window,
 866 | 			globalObj.document,
 867 | 			globalObj.performance,
 868 | 			globalObj.Event,
 869 | 			globalObj.location,
 870 | 		];
 871 | 
 872 | 		$DOM.restoreGlobals();
 873 | 
 874 | 		var pActual = [
 875 | 			globalObj.window,
 876 | 			globalObj.document,
 877 | 			globalObj.performance,
 878 | 			globalObj.Event,
 879 | 			globalObj.location,
 880 | 		];
 881 | 
 882 | 		assert.expect( 2 );
 883 | 		assert.deepEqual( rActual, rExpected, "replaced globals" );
 884 | 		assert.deepEqual( pActual, pExpected, "restored globals" );
 885 | 	} );
 886 | }
 887 | // otherwise, probably running in the browser
 888 | else {
 889 | 	QUnit.test( "replace and restore globals; browser", function test(assert){
 890 | 		var pExpected = [
 891 | 			window.document.createElement,
 892 | 			window.document.createEvent,
 893 | 			window.document.appendChild,
 894 | 			window.document.removeChild,
 895 | 			window.document.getElementsByTagName,
 896 | 			window.document.head.appendChild,
 897 | 			window.document.head.removeChild,
 898 | 			window.document.head.getElementsByTagName,
 899 | 			window.document.body.appendChild,
 900 | 			window.document.body.removeChild,
 901 | 			window.document.body.getElementsByTagName,
 902 | 			window.performance.getEntriesByName,
 903 | 			window.Event,
 904 | 		];
 905 | 
 906 | 		var win = $DOM( {
 907 | 			replaceGlobals: true,
 908 | 			log: function log(){},
 909 | 			error: function error(){},
 910 | 		} );
 911 | 
 912 | 		var rExpected = [
 913 | 			win.document.createElement,
 914 | 			win.document.createEvent,
 915 | 			win.document.appendChild,
 916 | 			win.document.removeChild,
 917 | 			win.document.getElementsByTagName,
 918 | 			win.document.head.appendChild,
 919 | 			win.document.head.removeChild,
 920 | 			win.document.head.getElementsByTagName,
 921 | 			win.document.body.appendChild,
 922 | 			win.document.body.removeChild,
 923 | 			win.document.body.getElementsByTagName,
 924 | 			win.performance.getEntriesByName,
 925 | 			win.Event,
 926 | 		];
 927 | 
 928 | 		var rActual = [
 929 | 			window.document.createElement,
 930 | 			window.document.createEvent,
 931 | 			window.document.appendChild,
 932 | 			window.document.removeChild,
 933 | 			window.document.getElementsByTagName,
 934 | 			window.document.head.appendChild,
 935 | 			window.document.head.removeChild,
 936 | 			window.document.head.getElementsByTagName,
 937 | 			window.document.body.appendChild,
 938 | 			window.document.body.removeChild,
 939 | 			window.document.body.getElementsByTagName,
 940 | 			window.performance.getEntriesByName,
 941 | 			window.Event,
 942 | 		];
 943 | 
 944 | 		// restore original globals
 945 | 		$DOM.restoreGlobals();
 946 | 
 947 | 		var pActual = [
 948 | 			window.document.createElement,
 949 | 			window.document.createEvent,
 950 | 			window.document.appendChild,
 951 | 			window.document.removeChild,
 952 | 			window.document.getElementsByTagName,
 953 | 			window.document.head.appendChild,
 954 | 			window.document.head.removeChild,
 955 | 			window.document.head.getElementsByTagName,
 956 | 			window.document.body.appendChild,
 957 | 			window.document.body.removeChild,
 958 | 			window.document.body.getElementsByTagName,
 959 | 			window.performance.getEntriesByName,
 960 | 			window.Event,
 961 | 		];
 962 | 
 963 | 		assert.expect( 2 );
 964 | 		assert.deepEqual( rActual, rExpected, "replaced globals" );
 965 | 		assert.deepEqual( pActual, pExpected, "restored globals" );
 966 | 	} );
 967 | }
 968 | 
 969 | QUnit.test( "document.readyState", function test(assert){
 970 | 	var done = assert.async( 6 );
 971 | 	assert.expect( 5 );
 972 | 
 973 | 	var rExpected = [
 974 | 		{ window: WINDOW_ID, },
 975 | 		{ document: DOCUMENT_ID, },
 976 | 		{ head: HEAD_ID, },
 977 | 		{ body: BODY_ID, },
 978 | 		{ addEventListener: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 979 | 		{ addEventListener: "load", internal_id: WINDOW_ID, },
 980 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
 981 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 982 | 	];
 983 | 	var pExpected = [
 984 | 		{ window: WINDOW_ID, },
 985 | 		{ document: DOCUMENT_ID, },
 986 | 		{ head: HEAD_ID, },
 987 | 		{ body: BODY_ID, },
 988 | 		{ addEventListener: "DOMContentLoaded", internal_id: WINDOW_ID, },
 989 | 		{ addEventListener: "load", internal_id: WINDOW_ID, },
 990 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
 991 | 	];
 992 | 	var qExpected = [
 993 | 		{ window: WINDOW_ID, },
 994 | 		{ document: DOCUMENT_ID, },
 995 | 		{ head: HEAD_ID, },
 996 | 		{ body: BODY_ID, },
 997 | 		{ addEventListener: "DOMContentLoaded", internal_id: WINDOW_ID, },
 998 | 		{ addEventListener: "load", internal_id: WINDOW_ID, },
 999 | 	];
1000 | 	var tExpected = [
1001 | 		{ window: WINDOW_ID, },
1002 | 		{ document: DOCUMENT_ID, },
1003 | 		{ head: HEAD_ID, },
1004 | 		{ body: BODY_ID, },
1005 | 		{ addEventListener: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
1006 | 		{ addEventListener: "load", internal_id: WINDOW_ID, },
1007 | 		{ dispatchEvent: "DOMContentLoaded", internal_id: DOCUMENT_ID, },
1008 | 		{ dispatchEvent: "load", internal_id: WINDOW_ID, },
1009 | 	];
1010 | 	var sExpected = "complete";
1011 | 
1012 | 	var callDone = function callDone(){ done(); };
1013 | 	var reportError = function reportError(err){ throw err; };
1014 | 
1015 | 	var { logs: rActual, log: log1, error: error1, } = collectLogs();
1016 | 	var { logs: pActual, log: log2, error: error2, } = collectLogs();
1017 | 	var { logs: qActual, log: log3, error: error3, } = collectLogs();
1018 | 	var { logs: tActual, log: log4, error: error4, } = collectLogs();
1019 | 
1020 | 	var win1 = $DOM( {
1021 | 		sequentialIds: true,
1022 | 		log: log1,
1023 | 		error: error1,
1024 | 		docReadyDelay: 30,
1025 | 	} );
1026 | 	win1.document.addEventListener( "DOMContentLoaded", callDone );
1027 | 	win1.addEventListener( "load", callDone );
1028 | 	win1.onload = function onload(){
1029 | 		win1.document.readyState = "ignored";
1030 | 		var sActual = win1.document.readyState;
1031 | 
1032 | 		assert.deepEqual( rActual, rExpected, "300ms DOMContentLoaded" );
1033 | 		assert.deepEqual( pActual, pExpected, "invalid delay" );
1034 | 		assert.deepEqual( qActual, qExpected, "document already complete" );
1035 | 		assert.deepEqual( tActual, tExpected, "invalid ready-state" );
1036 | 		assert.strictEqual( sActual, sExpected, "document.readyState" );
1037 | 
1038 | 		done();
1039 | 	};
1040 | 
1041 | 	var win2 = $DOM( {
1042 | 		sequentialIds: true,
1043 | 		log: log2,
1044 | 		error: error2,
1045 | 		docReadyState: "interactive",
1046 | 		docReadyDelay: "anything but a number like it should be",
1047 | 	} );
1048 | 	win2.addEventListener( "DOMContentLoaded", reportError );
1049 | 	win2.addEventListener( "load", callDone );
1050 | 
1051 | 	var win3 = $DOM( {
1052 | 		sequentialIds: true,
1053 | 		log: log3,
1054 | 		error: error3,
1055 | 		docReadyState: "complete",
1056 | 	} );
1057 | 	win3.addEventListener( "DOMContentLoaded", reportError );
1058 | 	win3.addEventListener( "load", reportError );
1059 | 
1060 | 	var win4 = $DOM( {
1061 | 		sequentialIds: true,
1062 | 		log: log4,
1063 | 		error: error4,
1064 | 		docReadyState: "other",
1065 | 	} );
1066 | 	win4.document.addEventListener( "DOMContentLoaded", callDone );
1067 | 	win4.addEventListener( "load", callDone );
1068 | } );
1069 | 
1070 | QUnit.test( "scripts: initial and API", function test(assert){
1071 | 	var done = assert.async();
1072 | 	assert.expect( 1 );
1073 | 
1074 | 	var rExpected = [
1075 | 	];
1076 | 
1077 | 	var { logs: rActual, log, error, } = collectLogs();
1078 | 
1079 | 	var win = $DOM( {
1080 | 		sequentialIds: true,
1081 | 		log,
1082 | 		error,
1083 | 		docReadyDelay: 30,
1084 | 		resources: [
1085 | 			{ url: "a.js", loadDelay: 50, load: true, },
1086 | 			{ url: "b.js", loadDelay: 10, load: true, },
1087 | 			{ url: "c.js", loadDelay: 20, load: true, },
1088 | 		],
1089 | 		initialDOM: {
1090 | 			head: [
1091 | 				{ tagName: "script", src: "a.js", },
1092 | 			],
1093 | 			body: [
1094 | 				{ tagName: "script", src: "b.js", },
1095 | 			],
1096 | 		},
1097 | 	} );
1098 | 
1099 | 	var script = win.document.createElement( "script" );
1100 | 	script.setAttribute( "src", "c.js" );
1101 | 	win.document.body.appendChild( script );
1102 | 
1103 | 	win.document.head.childNodes[0].addEventListener( "load", function load(){
1104 | 		assert.deepEqual( rActual, rExpected, "all scripts" );
1105 | 		done();
1106 | 	} );
1107 | } );
1108 | 
1109 | 
1110 | 
1111 | 
1112 | 
1113 | 
1114 | // ************************************
1115 | 
1116 | function collectLogs() {
1117 | 	var logs = [];
1118 | 	return {
1119 | 		logs,
1120 | 		log(msg){ logs.push( msg ); },
1121 | 		error(msg) { logs.push( msg ); },
1122 | 	};
1123 | }
1124 | 


--------------------------------------------------------------------------------