[Gecko Bug 1470659] Move platformName test to separate file.

webdriver/tests/new_session/conftest.py

@@ -1,5 +1,3 @@
-import sys
-
 import pytest
 
 from webdriver.transport import HTTPWireProtocol
@@ -66,13 +64,3 @@ def new_session(body, delete_existing_session=False):
     if custom_session.get("session") is not None:
         _delete_session(custom_session["session"]["sessionId"])
         custom_session = None
-
-
-@pytest.fixture(scope="session")
-def platform_name():
-    return {
-        "linux2": "linux",
-        "win32": "windows",
-        "cygwin": "windows",
-        "darwin": "mac"
-    }.get(sys.platform)

webdriver/tests/new_session/merge.py

@@ -3,13 +3,13 @@
 import pytest
 
 from tests.support.asserts import assert_error, assert_success
-from conftest import platform_name
+from tests.support import platform_name
 
 
-@pytest.mark.skipif(platform_name() is None, reason="Unsupported platform")
+@pytest.mark.skipif(platform_name is None, reason="Unsupported platform {}".format(platform_name))
 @pytest.mark.parametrize("body", [lambda key, value: {"alwaysMatch": {key: value}},
                                   lambda key, value: {"firstMatch": [{key: value}]}])
-def test_platform_name(new_session, add_browser_capabilities, platform_name, body):
+def test_platform_name(new_session, add_browser_capabilities, body):
     capabilities = body("platformName", platform_name)
     if "alwaysMatch" in capabilities:
         capabilities["alwaysMatch"] = add_browser_capabilities(capabilities["alwaysMatch"])
@@ -40,8 +40,8 @@ def test_merge_invalid(new_session, add_browser_capabilities, key, value):
     assert_error(response, "invalid argument")
 
 
-@pytest.mark.skipif(platform_name() is None, reason="Unsupported platform")
-def test_merge_platformName(new_session, add_browser_capabilities, platform_name):
+@pytest.mark.skipif(platform_name is None, reason="Unsupported platform {}".format(platform_name))
+def test_merge_platformName(new_session, add_browser_capabilities):
     response, _ = new_session({"capabilities": {
         "alwaysMatch": add_browser_capabilities({"timeouts": {"script": 10}}),
         "firstMatch": [{

webdriver/tests/new_session/page_load_strategy.py

@@ -0,0 +1,7 @@
+from tests.support.asserts import assert_success
+
+def test_pageLoadStrategy(new_session, add_browser_capabilities):
+    response, _ = new_session({"capabilities": {
+        "alwaysMatch": add_browser_capabilities({"pageLoadStrategy": "eager"})}})
+    value = assert_success(response)
+    assert value["capabilities"]["pageLoadStrategy"] == "eager"

webdriver/tests/new_session/platform_name.py

@@ -0,0 +1,11 @@
+import pytest
+
+from tests.support import platform_name
+from tests.support.asserts import assert_success
+
+
+@pytest.mark.skip_if(platform_name is None, reason="Unsupported platform {}".format(platform_name))
+def test_corresponds_to_local_system(new_session, add_browser_capabilities):
+    response, _ = new_session({"capabilities": {"alwaysMatch": add_browser_capabilities({})}})
+    value = assert_success(response)
+    assert value["capabilities"]["platformName"] == platform_name

webdriver/tests/new_session/response.py

@@ -1,7 +1,7 @@
-# META: timeout=long
-
 import uuid
 
+import pytest
+
 from tests.support.asserts import assert_success
 
 
@@ -12,63 +12,32 @@ def test_sessionid(new_session, add_browser_capabilities):
     uuid.UUID(hex=value["sessionId"])
 
 
-def test_capabilites(new_session, add_browser_capabilities):
-    response, _ = new_session({"capabilities": {"alwaysMatch": add_browser_capabilities({})}})
-    value = assert_success(response)
-    assert isinstance(value["capabilities"], dict)
-
-    all_capabilities = set(value["capabilities"].keys())
-    expected_capabilities = {
-        "browserName",
-        "browserVersion",
-        "platformName",
-        "acceptInsecureCerts",
-        "setWindowRect",
-        "timeouts",
-        "proxy",
-        "pageLoadStrategy",
-    }
-
-    assert expected_capabilities.issubset(all_capabilities), (
-        "{0} cannot be found in {1}".format(
-            list(expected_capabilities - all_capabilities), all_capabilities))
-
-
-def test_data(new_session, add_browser_capabilities, platform_name):
-    response, _ = new_session({"capabilities": {"alwaysMatch": add_browser_capabilities({})}})
-    value = assert_success(response)
-
-    assert isinstance(value["capabilities"]["browserName"], basestring)
-    assert isinstance(value["capabilities"]["browserVersion"], basestring)
-    if platform_name:
-        assert value["capabilities"]["platformName"] == platform_name
-    else:
-        assert "platformName" in value["capabilities"]
-    assert value["capabilities"]["acceptInsecureCerts"] is False
-    assert isinstance(value["capabilities"]["setWindowRect"], bool)
-    assert value["capabilities"]["timeouts"]["implicit"] == 0
-    assert value["capabilities"]["timeouts"]["pageLoad"] == 300000
-    assert value["capabilities"]["timeouts"]["script"] == 30000
-    assert value["capabilities"]["proxy"] == {}
-    assert value["capabilities"]["pageLoadStrategy"] == "normal"
-
-
-def test_timeouts(new_session, add_browser_capabilities, platform_name):
-    response, _ = new_session({"capabilities": {
-        "alwaysMatch": add_browser_capabilities({"timeouts": {"implicit": 1000}}),
-    }})
-    value = assert_success(response)
-
-    assert value["capabilities"]["timeouts"] == {
-        "implicit": 1000,
-        "pageLoad": 300000,
-        "script": 30000
-    }
-
-
-def test_pageLoadStrategy(new_session, add_browser_capabilities, platform_name):
-    response, _ = new_session({"capabilities": {
-        "alwaysMatch": add_browser_capabilities({"pageLoadStrategy": "eager"})}})
-    value = assert_success(response)
-
-    assert value["capabilities"]["pageLoadStrategy"] == "eager"
+@pytest.mark.parametrize("capability, type", [
+    ("browserName", basestring),
+    ("browserVersion", basestring),
+    ("platformName", basestring),
+    ("acceptInsecureCerts", bool),
+    ("pageLoadStrategy", basestring),
+    ("proxy", dict),
+    ("setWindowRect", bool),
+    ("timeouts", dict),
+    ("unhandledPromptBehavior", basestring),
+])
+def test_capability_type(session, capability, type):
+    assert isinstance(session.capabilities, dict)
+    assert capability in session.capabilities
+    assert isinstance(session.capabilities[capability], type)
+
+
+@pytest.mark.parametrize("capability, default_value", [
+    ("acceptInsecureCerts", False),
+    ("pageLoadStrategy", "normal"),
+    ("proxy", {}),
+    ("setWindowRect", True),
+    ("timeouts", {"implicit": 0, "pageLoad": 300000, "script": 30000}),
+    ("unhandledPromptBehavior", "dismiss and notify"),
+])
+def test_capability_default_value(session, capability, default_value):
+    assert isinstance(session.capabilities, dict)
+    assert capability in session.capabilities
+    assert session.capabilities[capability] == default_value

webdriver/tests/new_session/timeouts.py

@@ -0,0 +1,22 @@
+import pytest
+
+from tests.support.asserts import assert_success
+
+
+def test_default_values(session):
+    timeouts = session.capabilities["timeouts"]
+
+    assert timeouts["implicit"] == 0
+    assert timeouts["pageLoad"] == 300000
+    assert timeouts["script"] == 30000
+
+
+@pytest.mark.parametrize("timeouts", [
+    {"implicit": 444, "pageLoad": 300000,"script": 30000},
+    {"implicit": 0, "pageLoad": 444,"script": 30000},
+    {"implicit": 0, "pageLoad": 300000,"script": 444},
+])
+def test_timeouts(new_session, add_browser_capabilities, timeouts):
+    response, _ = new_session({"capabilities": {"alwaysMatch": add_browser_capabilities({"timeouts": timeouts})}})
+    value = assert_success(response)
+    assert value["capabilities"]["timeouts"] == timeouts

webdriver/tests/support/__init__.py

@@ -1 +1,10 @@
+import sys
+
 from merge_dictionaries import merge_dictionaries
+
+platform_name = {
+    "linux2": "linux",
+    "win32": "windows",
+    "cygwin": "windows",
+    "darwin": "mac"
+}.get(sys.platform)