From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- testing/marionette/test_session.js | 370 +++++++++++++++++++++++++++++++++++++ 1 file changed, 370 insertions(+) create mode 100644 testing/marionette/test_session.js (limited to 'testing/marionette/test_session.js') diff --git a/testing/marionette/test_session.js b/testing/marionette/test_session.js new file mode 100644 index 000000000..ef45573a7 --- /dev/null +++ b/testing/marionette/test_session.js @@ -0,0 +1,370 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const {utils: Cu} = Components; + +Cu.import("resource://gre/modules/Preferences.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); + +Cu.import("chrome://marionette/content/error.js"); +Cu.import("chrome://marionette/content/session.js"); + +add_test(function test_Timeouts_ctor() { + let ts = new session.Timeouts(); + equal(ts.implicit, 0); + equal(ts.pageLoad, 300000); + equal(ts.script, 30000); + + run_next_test(); +}); + +add_test(function test_Timeouts_toString() { + equal(new session.Timeouts().toString(), "[object session.Timeouts]"); + + run_next_test(); +}); + +add_test(function test_Timeouts_toJSON() { + let ts = new session.Timeouts(); + deepEqual(ts.toJSON(), {"implicit": 0, "page load": 300000, "script": 30000}); + + run_next_test(); +}); + +add_test(function test_Timeouts_fromJSON() { + let json = { + "implicit": 10, + "page load": 20, + "script": 30, + }; + let ts = session.Timeouts.fromJSON(json); + equal(ts.implicit, json["implicit"]); + equal(ts.pageLoad, json["page load"]); + equal(ts.script, json["script"]); + + run_next_test(); +}); + +add_test(function test_PageLoadStrategy() { + equal(session.PageLoadStrategy.None, "none"); + equal(session.PageLoadStrategy.Eager, "eager"); + equal(session.PageLoadStrategy.Normal, "normal"); + + run_next_test(); +}); + +add_test(function test_Proxy_ctor() { + let p = new session.Proxy(); + let props = [ + "proxyType", + "httpProxy", + "httpProxyPort", + "sslProxy", + "sslProxyPort", + "ftpProxy", + "ftpProxyPort", + "socksProxy", + "socksProxyPort", + "socksVersion", + "proxyAutoconfigUrl", + ]; + for (let prop of props) { + ok(prop in p, `${prop} in ${JSON.stringify(props)}`); + equal(p[prop], null); + } + + run_next_test(); +}); + +add_test(function test_Proxy_init() { + let p = new session.Proxy(); + + // no changed made, and 5 (system) is default + equal(p.init(), false); + equal(Preferences.get("network.proxy.type"), 5); + + // pac + p.proxyType = "pac"; + p.proxyAutoconfigUrl = "http://localhost:1234"; + ok(p.init()); + + equal(Preferences.get("network.proxy.type"), 2); + equal(Preferences.get("network.proxy.autoconfig_url"), + "http://localhost:1234"); + + // autodetect + p = new session.Proxy(); + p.proxyType = "autodetect"; + ok(p.init()); + equal(Preferences.get("network.proxy.type"), 4); + + // system + p = new session.Proxy(); + p.proxyType = "system"; + ok(p.init()); + equal(Preferences.get("network.proxy.type"), 5); + + // noproxy + p = new session.Proxy(); + p.proxyType = "noproxy"; + ok(p.init()); + equal(Preferences.get("network.proxy.type"), 0); + + run_next_test(); +}); + +add_test(function test_Proxy_toString() { + equal(new session.Proxy().toString(), "[object session.Proxy]"); + + run_next_test(); +}); + +add_test(function test_Proxy_toJSON() { + let p = new session.Proxy(); + deepEqual(p.toJSON(), {}); + + p = new session.Proxy(); + p.proxyType = "manual"; + deepEqual(p.toJSON(), {proxyType: "manual"}); + + run_next_test(); +}); + +add_test(function test_Proxy_fromJSON() { + deepEqual({}, session.Proxy.fromJSON(undefined).toJSON()); + deepEqual({}, session.Proxy.fromJSON(null).toJSON()); + + for (let typ of [true, 42, "foo", []]) { + Assert.throws(() => session.Proxy.fromJSON(typ), InvalidArgumentError); + } + + // must contain proxyType + Assert.throws(() => session.Proxy.fromJSON({}), InvalidArgumentError); + deepEqual({proxyType: "foo"}, + session.Proxy.fromJSON({proxyType: "foo"}).toJSON()); + + // manual + session.Proxy.fromJSON({proxyType: "manual"}); + + for (let proxy of ["httpProxy", "sslProxy", "ftpProxy", "socksProxy"]) { + let manual = {proxyType: "manual"}; + + for (let typ of [true, 42, [], {}, null]) { + manual[proxy] = typ; + Assert.throws(() => session.Proxy.fromJSON(manual), + InvalidArgumentError); + } + + manual[proxy] = "foo"; + Assert.throws(() => session.Proxy.fromJSON(manual), + InvalidArgumentError); + + for (let typ of ["bar", true, [], {}, null, undefined]) { + manual[proxy + "Port"] = typ; + Assert.throws(() => session.Proxy.fromJSON(manual), + InvalidArgumentError); + } + + manual[proxy] = "foo"; + manual[proxy + "Port"] = 1234; + + let expected = { + "proxyType": "manual", + [proxy]: "foo", + [proxy + "Port"]: 1234, + }; + + if (proxy == "socksProxy") { + manual.socksProxyVersion = 42; + expected.socksProxyVersion = 42; + } + deepEqual(expected, session.Proxy.fromJSON(manual).toJSON()); + } + + Assert.throws(() => session.Proxy.fromJSON( + {proxyType: "manual", socksProxy: "foo", socksProxyPort: 1234}), + InvalidArgumentError); + + run_next_test(); +}); + +add_test(function test_Capabilities_ctor() { + let caps = new session.Capabilities(); + ok(caps.has("browserName")); + ok(caps.has("browserVersion")); + ok(caps.has("platformName")); + ok(caps.has("platformVersion")); + equal(session.PageLoadStrategy.Normal, caps.get("pageLoadStrategy")); + equal(false, caps.get("acceptInsecureCerts")); + ok(caps.get("timeouts") instanceof session.Timeouts); + ok(caps.get("proxy") instanceof session.Proxy); + + ok(caps.has("rotatable")); + + equal(0, caps.get("specificationLevel")); + ok(caps.has("moz:processID")); + ok(caps.has("moz:profile")); + equal(false, caps.get("moz:accessibilityChecks")); + + run_next_test(); +}); + +add_test(function test_Capabilities_toString() { + equal("[object session.Capabilities]", new session.Capabilities().toString()); + + run_next_test(); +}); + +add_test(function test_Capabilities_toJSON() { + let caps = new session.Capabilities(); + let json = caps.toJSON(); + + equal(caps.get("browserName"), json.browserName); + equal(caps.get("browserVersion"), json.browserVersion); + equal(caps.get("platformName"), json.platformName); + equal(caps.get("platformVersion"), json.platformVersion); + equal(caps.get("pageLoadStrategy"), json.pageLoadStrategy); + equal(caps.get("acceptInsecureCerts"), json.acceptInsecureCerts); + deepEqual(caps.get("timeouts").toJSON(), json.timeouts); + equal(undefined, json.proxy); + + equal(caps.get("rotatable"), json.rotatable); + + equal(caps.get("specificationLevel"), json.specificationLevel); + equal(caps.get("moz:processID"), json["moz:processID"]); + equal(caps.get("moz:profile"), json["moz:profile"]); + equal(caps.get("moz:accessibilityChecks"), json["moz:accessibilityChecks"]); + + run_next_test(); +}); + +add_test(function test_Capabilities_fromJSON() { + const {fromJSON} = session.Capabilities; + + // plain + for (let typ of [{}, null, undefined]) { + ok(fromJSON(typ, {merge: true}).has("browserName")); + ok(fromJSON(typ, {merge: false}).has("browserName")); + } + for (let typ of [true, 42, "foo", []]) { + Assert.throws(() => + fromJSON(typ, {merge: true}), InvalidArgumentError); + Assert.throws(() => + fromJSON(typ, {merge: false}), InvalidArgumentError); + } + + // merging + let desired = {"moz:accessibilityChecks": false}; + let required = {"moz:accessibilityChecks": true}; + let matched = fromJSON( + {desiredCapabilities: desired, requiredCapabilities: required}, + {merge: true}); + ok(matched.has("moz:accessibilityChecks")); + equal(true, matched.get("moz:accessibilityChecks")); + + // desiredCapabilities/requriedCapabilities types + for (let typ of [undefined, null, {}]) { + ok(fromJSON({desiredCapabilities: typ}, {merge: true})); + ok(fromJSON({requiredCapabilities: typ}, {merge: true})); + } + for (let typ of [true, 42, "foo", []]) { + Assert.throws(() => fromJSON({desiredCapabilities: typ}, {merge: true})); + Assert.throws(() => fromJSON({requiredCapabilities: typ}, {merge: true})); + } + + // matching + let caps = new session.Capabilities(); + + ok(fromJSON({browserName: caps.get("browserName")})); + ok(fromJSON({browserName: null})); + ok(fromJSON({browserName: undefined})); + ok(fromJSON({browserName: "*"})); + Assert.throws(() => fromJSON({browserName: "foo"})); + + ok(fromJSON({browserVersion: caps.get("browserVersion")})); + ok(fromJSON({browserVersion: null})); + ok(fromJSON({browserVersion: undefined})); + ok(fromJSON({browserVersion: "*"})); + Assert.throws(() => fromJSON({browserVersion: "foo"})); + + ok(fromJSON({platformName: caps.get("platformName")})); + ok(fromJSON({platformName: null})); + ok(fromJSON({platformName: undefined})); + ok(fromJSON({platformName: "*"})); + Assert.throws(() => fromJSON({platformName: "foo"})); + + ok(fromJSON({platformVersion: caps.get("platformVersion")})); + ok(fromJSON({platformVersion: null})); + ok(fromJSON({platformVersion: undefined})); + ok(fromJSON({platformVersion: "*"})); + Assert.throws(() => fromJSON({platformVersion: "foo"})); + + caps = fromJSON({acceptInsecureCerts: true}); + equal(true, caps.get("acceptInsecureCerts")); + caps = fromJSON({acceptInsecureCerts: false}); + equal(false, caps.get("acceptInsecureCerts")); + Assert.throws(() => fromJSON({acceptInsecureCerts: "foo"})); + + for (let strategy of Object.values(session.PageLoadStrategy)) { + caps = fromJSON({pageLoadStrategy: strategy}); + equal(strategy, caps.get("pageLoadStrategy")); + } + Assert.throws(() => fromJSON({pageLoadStrategy: "foo"})); + + let proxyConfig = {proxyType: "manual"}; + caps = fromJSON({proxy: proxyConfig}); + equal("manual", caps.get("proxy").proxyType); + + let timeoutsConfig = {implicit: 123}; + caps = fromJSON({timeouts: timeoutsConfig}); + equal(123, caps.get("timeouts").implicit); + + equal(0, caps.get("specificationLevel")); + caps = fromJSON({specificationLevel: 123}); + equal(123, caps.get("specificationLevel")); + Assert.throws(() => fromJSON({specificationLevel: "foo"})); + Assert.throws(() => fromJSON({specificationLevel: -1})); + + caps = fromJSON({"moz:accessibilityChecks": true}); + equal(true, caps.get("moz:accessibilityChecks")); + caps = fromJSON({"moz:accessibilityChecks": false}); + equal(false, caps.get("moz:accessibilityChecks")); + Assert.throws(() => fromJSON({"moz:accessibilityChecks": "foo"})); + + run_next_test(); +}); + +// use session.Proxy.toJSON to test marshal +add_test(function test_marshal() { + let proxy = new session.Proxy(); + + // drop empty fields + deepEqual({}, proxy.toJSON()); + proxy.proxyType = "manual"; + deepEqual({proxyType: "manual"}, proxy.toJSON()); + proxy.proxyType = null; + deepEqual({}, proxy.toJSON()); + proxy.proxyType = undefined; + deepEqual({}, proxy.toJSON()); + + // iterate over object literals + proxy.proxyType = {foo: "bar"}; + deepEqual({proxyType: {foo: "bar"}}, proxy.toJSON()); + + // iterate over complex object that implement toJSON + proxy.proxyType = new session.Proxy(); + deepEqual({}, proxy.toJSON()); + proxy.proxyType.proxyType = "manual"; + deepEqual({proxyType: {proxyType: "manual"}}, proxy.toJSON()); + + // drop objects with no entries + proxy.proxyType = {foo: {}}; + deepEqual({}, proxy.toJSON()); + proxy.proxyType = {foo: new session.Proxy()}; + deepEqual({}, proxy.toJSON()); + + run_next_test(); +}); -- cgit v1.2.3