Source/WebInspectorUI/UserInterface/Models/AuditTestGroup.js - WebKit - Git at Google

 /*
  * Copyright (C) 2018 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */

 WI.AuditTestGroup = class AuditTestGroup extends WI.AuditTestBase
 {
     constructor(name, tests, options = {})
     {
         console.assert(Array.isArray(tests), tests);

         // Set disabled once `_tests` is set so that it propagates.
         let disabled = options.disabled;
         options.disabled = false;

         super(name, options);

         this._tests = [];
         for (let test of tests)
             this.addTest(test);

         if (disabled)
             this.updateDisabled(true);
     }

     // Static

     static async fromPayload(payload)
     {
         if (typeof payload !== "object" || payload === null)
             return null;

         if (payload.type !== WI.AuditTestGroup.TypeIdentifier)
             return null;

         if (typeof payload.name !== "string") {
             WI.AuditManager.synthesizeError(WI.UIString("\u0022%s\u0022 has a non-string \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("name")));
             return null;
         }

         if (!Array.isArray(payload.tests)) {
             WI.AuditManager.synthesizeError(WI.UIString("\u0022%s\u0022 has a non-array \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("tests")));
             return null;
         }

         let tests = await Promise.all(payload.tests.map(async (test) => {
             let testCase = await WI.AuditTestCase.fromPayload(test);
             if (testCase)
                 return testCase;

             let testGroup = await WI.AuditTestGroup.fromPayload(test);
             if (testGroup)
                 return testGroup;

             return null;
         }));
         tests = tests.filter((test) => !!test);
         if (!tests.length)
             return null;

         let options = {};

         if (typeof payload.description === "string")
             options.description = payload.description;
         else if ("description" in payload)
             WI.AuditManager.synthesizeWarning(WI.UIString("\u0022%s\u0022 has a non-string \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("description")));

         if (typeof payload.supports === "number")
             options.supports = payload.supports;
         else if ("supports" in payload)
             WI.AuditManager.synthesizeWarning(WI.UIString("\u0022%s\u0022 has a non-number \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("supports")));

         if (typeof payload.setup === "string")
             options.setup = payload.setup;
         else if ("setup" in payload)
             WI.AuditManager.synthesizeWarning(WI.UIString("\u0022%s\u0022 has a non-string \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("setup")));

         if (typeof payload.disabled === "boolean")
             options.disabled = payload.disabled;

         return new WI.AuditTestGroup(payload.name, tests, options);
     }

     // Public

     get tests() { return this._tests; }

     addTest(test)
     {
         console.assert(test instanceof WI.AuditTestBase, test);
         console.assert(!this._tests.includes(test), test);
         console.assert(!test._parent, test);

         this._tests.push(test);
         test._parent = this;

         test.addEventListener(WI.AuditTestBase.Event.Completed, this._handleTestCompleted, this);
         test.addEventListener(WI.AuditTestBase.Event.DisabledChanged, this._handleTestDisabledChanged, this);
         test.addEventListener(WI.AuditTestBase.Event.Progress, this._handleTestProgress, this);
         if (this.editable) {
             test.addEventListener(WI.AuditTestBase.Event.SupportedChanged, this._handleTestSupportedChanged, this);
             test.addEventListener(WI.AuditTestBase.Event.TestChanged, this._handleTestChanged, this);
         }

         this.dispatchEventToListeners(WI.AuditTestGroup.Event.TestAdded, {test});

         this.determineIfSupported();

         if (this._checkDisabled(test))
             test.updateDisabled(true, {silent: true});
     }

     removeTest(test)
     {
         console.assert(this.editable);
         console.assert(WI.auditManager.editing);
         console.assert(test instanceof WI.AuditTestBase, test);
         console.assert(test.editable, test);
         console.assert(this._tests.includes(test), test);
         console.assert(test._parent === this, test);

         test.removeEventListener(WI.AuditTestBase.Event.Completed, this._handleTestCompleted, this);
         test.removeEventListener(WI.AuditTestBase.Event.DisabledChanged, this._handleTestDisabledChanged, this);
         test.removeEventListener(WI.AuditTestBase.Event.Progress, this._handleTestProgress, this);
         test.removeEventListener(WI.AuditTestBase.Event.SupportedChanged, this._handleTestSupportedChanged, this);
         test.removeEventListener(WI.AuditTestBase.Event.TestChanged, this._handleTestChanged, this);

         this._tests.remove(test);
         test._parent = null;

         this.dispatchEventToListeners(WI.AuditTestGroup.Event.TestRemoved, {test});

         this.determineIfSupported();

         this._checkDisabled();
     }

     stop()
     {
         // Called from WI.AuditManager.

         for (let test of this._tests)
             test.stop();

         super.stop();
     }

     clearResult(options = {})
     {
         let cleared = !!this.result;

         if (!options.excludeTests && this._tests) {
             for (let test of this._tests) {
                 if (test.clearResult(options))
                     cleared = true;
             }
         }

         return super.clearResult({
             ...options,
             suppressResultChangedEvent: !cleared,
         });
     }

     toJSON(key)
     {
         let json = super.toJSON(key);
         json.tests = this._tests.map((testCase) => testCase.toJSON(key));
         return json;
     }

     // Protected

     async run()
     {
         let count = this._tests.length;
         for (let index = 0; index < count && this._runningState === WI.AuditManager.RunningState.Active; ++index) {
             let test = this._tests[index];
             if (test.disabled || !test.supported)
                 continue;

             await test.start();

             if (test instanceof WI.AuditTestCase)
                 this.dispatchEventToListeners(WI.AuditTestBase.Event.Progress, {index, count});
         }

         this.updateResult();
     }

     determineIfSupported(options = {})
     {
         if (this._tests) {
             for (let test of this._tests)
                 test.determineIfSupported({...options, warn: false, silent: true});
         }

         return super.determineIfSupported(options);
     }

     updateSupported(supported, options = {})
     {
         if (this._tests && (!supported || this._tests.every((test) => !test.supported))) {
             supported = false;

             for (let test of this._tests)
                 test.updateSupported(supported, {silent: true});
         }

         super.updateSupported(supported, options);
     }

     updateDisabled(disabled, options = {})
     {
         if (!options.excludeTests && this._tests) {
             for (let test of this._tests)
                 test.updateDisabled(disabled, options);
         }

         super.updateDisabled(disabled, options);
     }

     updateResult()
     {
         let results = this._tests.map((test) => test.result).filter((result) => !!result);
         if (!results.length)
             return;

         super.updateResult(new WI.AuditTestGroupResult(this.name, results, {
             description: this.description,
         }));
     }

     // Private

     _checkDisabled(test)
     {
         let testDisabled = !test || !test.supported || test.disabled;
         let enabledTestCount = this._tests.filter((existing) => existing.supported && !existing.disabled).length;

         if (testDisabled && !enabledTestCount)
             this.updateDisabled(true);
         else if (!testDisabled && enabledTestCount === 1)
             this.updateDisabled(false, {excludeTests: true});
         else {
             // Don't change `disabled`, as we're currently in an "indeterminate" state.
             this.dispatchEventToListeners(WI.AuditTestBase.Event.DisabledChanged);
         }

         return this.disabled;
     }

     _handleTestCompleted(event)
     {
         if (this._runningState === WI.AuditManager.RunningState.Active)
             return;

         this.updateResult();

         this.dispatchEventToListeners(WI.AuditTestBase.Event.Completed);
     }

     _handleTestDisabledChanged(event)
     {
         this._checkDisabled(event.target);
     }

     _handleTestProgress(event)
     {
         if (this._runningState !== WI.AuditManager.RunningState.Active)
             return;

         let walk = (tests) => {
             let count = 0;
             for (let test of tests) {
                 if (test.disabled || !test.supported)
                     continue;

                 if (test instanceof WI.AuditTestCase)
                     ++count;
                 else if (test instanceof WI.AuditTestGroup)
                     count += walk(test.tests);
             }
             return count;
         };

         this.dispatchEventToListeners(WI.AuditTestBase.Event.Progress, {
             index: event.data.index + walk(this._tests.slice(0, this._tests.indexOf(event.target))),
             count: walk(this._tests),
         });
     }

     _handleTestSupportedChanged(event)
     {
         this.determineIfSupported();
     }

     _handleTestChanged(event)
     {
         console.assert(WI.auditManager.editing);

         this.clearResult({excludeTests: true});

         this.dispatchEventToListeners(WI.AuditTestBase.Event.TestChanged);
     }
 };

 WI.AuditTestGroup.TypeIdentifier = "test-group";

 WI.AuditTestGroup.Event = {
     TestAdded: "audit-test-group-test-added",
     TestRemoved: "audit-test-group-test-removed",
 };
	/*
	* Copyright (C) 2018 Apple Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	* THE POSSIBILITY OF SUCH DAMAGE.
	*/

	WI.AuditTestGroup = class AuditTestGroup extends WI.AuditTestBase
	{
	constructor(name, tests, options = {})
	{
	console.assert(Array.isArray(tests), tests);

	// Set disabled once `_tests` is set so that it propagates.
	let disabled = options.disabled;
	options.disabled = false;

	super(name, options);

	this._tests = [];
	for (let test of tests)
	this.addTest(test);

	if (disabled)
	this.updateDisabled(true);
	}

	// Static

	static async fromPayload(payload)
	{
	if (typeof payload !== "object" \|\| payload === null)
	return null;

	if (payload.type !== WI.AuditTestGroup.TypeIdentifier)
	return null;

	if (typeof payload.name !== "string") {
	WI.AuditManager.synthesizeError(WI.UIString("\u0022%s\u0022 has a non-string \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("name")));
	return null;
	}

	if (!Array.isArray(payload.tests)) {
	WI.AuditManager.synthesizeError(WI.UIString("\u0022%s\u0022 has a non-array \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("tests")));
	return null;
	}

	let tests = await Promise.all(payload.tests.map(async (test) => {
	let testCase = await WI.AuditTestCase.fromPayload(test);
	if (testCase)
	return testCase;

	let testGroup = await WI.AuditTestGroup.fromPayload(test);
	if (testGroup)
	return testGroup;

	return null;
	}));
	tests = tests.filter((test) => !!test);
	if (!tests.length)
	return null;

	let options = {};

	if (typeof payload.description === "string")
	options.description = payload.description;
	else if ("description" in payload)
	WI.AuditManager.synthesizeWarning(WI.UIString("\u0022%s\u0022 has a non-string \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("description")));

	if (typeof payload.supports === "number")
	options.supports = payload.supports;
	else if ("supports" in payload)
	WI.AuditManager.synthesizeWarning(WI.UIString("\u0022%s\u0022 has a non-number \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("supports")));

	if (typeof payload.setup === "string")
	options.setup = payload.setup;
	else if ("setup" in payload)
	WI.AuditManager.synthesizeWarning(WI.UIString("\u0022%s\u0022 has a non-string \u0022%s\u0022 value").format(payload.name, WI.unlocalizedString("setup")));

	if (typeof payload.disabled === "boolean")
	options.disabled = payload.disabled;

	return new WI.AuditTestGroup(payload.name, tests, options);
	}

	// Public

	get tests() { return this._tests; }

	addTest(test)
	{
	console.assert(test instanceof WI.AuditTestBase, test);
	console.assert(!this._tests.includes(test), test);
	console.assert(!test._parent, test);

	this._tests.push(test);
	test._parent = this;

	test.addEventListener(WI.AuditTestBase.Event.Completed, this._handleTestCompleted, this);
	test.addEventListener(WI.AuditTestBase.Event.DisabledChanged, this._handleTestDisabledChanged, this);
	test.addEventListener(WI.AuditTestBase.Event.Progress, this._handleTestProgress, this);
	if (this.editable) {
	test.addEventListener(WI.AuditTestBase.Event.SupportedChanged, this._handleTestSupportedChanged, this);
	test.addEventListener(WI.AuditTestBase.Event.TestChanged, this._handleTestChanged, this);
	}

	this.dispatchEventToListeners(WI.AuditTestGroup.Event.TestAdded, {test});

	this.determineIfSupported();

	if (this._checkDisabled(test))
	test.updateDisabled(true, {silent: true});
	}

	removeTest(test)
	{
	console.assert(this.editable);
	console.assert(WI.auditManager.editing);
	console.assert(test instanceof WI.AuditTestBase, test);
	console.assert(test.editable, test);
	console.assert(this._tests.includes(test), test);
	console.assert(test._parent === this, test);

	test.removeEventListener(WI.AuditTestBase.Event.Completed, this._handleTestCompleted, this);
	test.removeEventListener(WI.AuditTestBase.Event.DisabledChanged, this._handleTestDisabledChanged, this);
	test.removeEventListener(WI.AuditTestBase.Event.Progress, this._handleTestProgress, this);
	test.removeEventListener(WI.AuditTestBase.Event.SupportedChanged, this._handleTestSupportedChanged, this);
	test.removeEventListener(WI.AuditTestBase.Event.TestChanged, this._handleTestChanged, this);

	this._tests.remove(test);
	test._parent = null;

	this.dispatchEventToListeners(WI.AuditTestGroup.Event.TestRemoved, {test});

	this.determineIfSupported();

	this._checkDisabled();
	}

	stop()
	{
	// Called from WI.AuditManager.

	for (let test of this._tests)
	test.stop();

	super.stop();
	}

	clearResult(options = {})
	{
	let cleared = !!this.result;

	if (!options.excludeTests && this._tests) {
	for (let test of this._tests) {
	if (test.clearResult(options))
	cleared = true;
	}
	}

	return super.clearResult({
	...options,
	suppressResultChangedEvent: !cleared,
	});
	}

	toJSON(key)
	{
	let json = super.toJSON(key);
	json.tests = this._tests.map((testCase) => testCase.toJSON(key));
	return json;
	}

	// Protected

	async run()
	{
	let count = this._tests.length;
	for (let index = 0; index < count && this._runningState === WI.AuditManager.RunningState.Active; ++index) {
	let test = this._tests[index];
	if (test.disabled \|\| !test.supported)
	continue;

	await test.start();

	if (test instanceof WI.AuditTestCase)
	this.dispatchEventToListeners(WI.AuditTestBase.Event.Progress, {index, count});
	}

	this.updateResult();
	}

	determineIfSupported(options = {})
	{
	if (this._tests) {
	for (let test of this._tests)
	test.determineIfSupported({...options, warn: false, silent: true});
	}

	return super.determineIfSupported(options);
	}

	updateSupported(supported, options = {})
	{
	if (this._tests && (!supported \|\| this._tests.every((test) => !test.supported))) {
	supported = false;

	for (let test of this._tests)
	test.updateSupported(supported, {silent: true});
	}

	super.updateSupported(supported, options);
	}

	updateDisabled(disabled, options = {})
	{
	if (!options.excludeTests && this._tests) {
	for (let test of this._tests)
	test.updateDisabled(disabled, options);
	}

	super.updateDisabled(disabled, options);
	}

	updateResult()
	{
	let results = this._tests.map((test) => test.result).filter((result) => !!result);
	if (!results.length)
	return;

	super.updateResult(new WI.AuditTestGroupResult(this.name, results, {
	description: this.description,
	}));
	}

	// Private

	_checkDisabled(test)
	{
	let testDisabled = !test \|\| !test.supported \|\| test.disabled;
	let enabledTestCount = this._tests.filter((existing) => existing.supported && !existing.disabled).length;

	if (testDisabled && !enabledTestCount)
	this.updateDisabled(true);
	else if (!testDisabled && enabledTestCount === 1)
	this.updateDisabled(false, {excludeTests: true});
	else {
	// Don't change `disabled`, as we're currently in an "indeterminate" state.
	this.dispatchEventToListeners(WI.AuditTestBase.Event.DisabledChanged);
	}

	return this.disabled;
	}

	_handleTestCompleted(event)
	{
	if (this._runningState === WI.AuditManager.RunningState.Active)
	return;

	this.updateResult();

	this.dispatchEventToListeners(WI.AuditTestBase.Event.Completed);
	}

	_handleTestDisabledChanged(event)
	{
	this._checkDisabled(event.target);
	}

	_handleTestProgress(event)
	{
	if (this._runningState !== WI.AuditManager.RunningState.Active)
	return;

	let walk = (tests) => {
	let count = 0;
	for (let test of tests) {
	if (test.disabled \|\| !test.supported)
	continue;

	if (test instanceof WI.AuditTestCase)
	++count;
	else if (test instanceof WI.AuditTestGroup)
	count += walk(test.tests);
	}
	return count;
	};

	this.dispatchEventToListeners(WI.AuditTestBase.Event.Progress, {
	index: event.data.index + walk(this._tests.slice(0, this._tests.indexOf(event.target))),
	count: walk(this._tests),
	});
	}

	_handleTestSupportedChanged(event)
	{
	this.determineIfSupported();
	}

	_handleTestChanged(event)
	{
	console.assert(WI.auditManager.editing);

	this.clearResult({excludeTests: true});

	this.dispatchEventToListeners(WI.AuditTestBase.Event.TestChanged);
	}
	};

	WI.AuditTestGroup.TypeIdentifier = "test-group";

	WI.AuditTestGroup.Event = {
	TestAdded: "audit-test-group-test-added",
	TestRemoved: "audit-test-group-test-removed",
	};