tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_proxy.py (5488B)

      1 # This Source Code Form is subject to the terms of the Mozilla Public
      2 # License, v. 2.0. If a copy of the MPL was not distributed with this
      3 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
      4 
      5 from marionette_driver import errors
      6 
      7 from marionette_harness import MarionetteTestCase
      8 
      9 
     10 class TestProxyCapabilities(MarionetteTestCase):
     11    def setUp(self):
     12        super(TestProxyCapabilities, self).setUp()
     13 
     14        self.marionette.delete_session()
     15 
     16    def tearDown(self):
     17        if not self.marionette.session:
     18            self.marionette.start_session()
     19 
     20        with self.marionette.using_context("chrome"):
     21            self.marionette.execute_script(
     22                """
     23                const { Preferences } = ChromeUtils.importESModule(
     24                  "resource://gre/modules/Preferences.sys.mjs"
     25                );
     26                Preferences.resetBranch("network.proxy");
     27            """
     28            )
     29 
     30        super(TestProxyCapabilities, self).tearDown()
     31 
     32    def test_proxy_object_in_returned_capabilities(self):
     33        capabilities = {"proxy": {"proxyType": "system"}}
     34 
     35        self.marionette.start_session(capabilities)
     36        self.assertEqual(
     37            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
     38        )
     39 
     40    def test_proxy_type_autodetect(self):
     41        capabilities = {"proxy": {"proxyType": "autodetect"}}
     42 
     43        self.marionette.start_session(capabilities)
     44        self.assertEqual(
     45            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
     46        )
     47 
     48    def test_proxy_type_direct(self):
     49        capabilities = {"proxy": {"proxyType": "direct"}}
     50 
     51        self.marionette.start_session(capabilities)
     52        self.assertEqual(
     53            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
     54        )
     55 
     56    def test_proxy_type_manual(self):
     57        proxy_hostname = "marionette.test"
     58        capabilities = {
     59            "proxy": {
     60                "proxyType": "manual",
     61                "httpProxy": "{}:80".format(proxy_hostname),
     62                "sslProxy": "{}:443".format(proxy_hostname),
     63                "socksProxy": proxy_hostname,
     64                "socksVersion": 4,
     65            }
     66        }
     67 
     68        self.marionette.start_session(capabilities)
     69        self.assertEqual(
     70            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
     71        )
     72 
     73    def test_proxy_type_manual_socks_requires_version(self):
     74        proxy_port = 4444
     75        proxy_hostname = "marionette.test"
     76        proxy_host = "{}:{}".format(proxy_hostname, proxy_port)
     77        capabilities = {
     78            "proxy": {
     79                "proxyType": "manual",
     80                "socksProxy": proxy_host,
     81            }
     82        }
     83 
     84        with self.assertRaises(errors.SessionNotCreatedException):
     85            self.marionette.start_session(capabilities)
     86 
     87    def test_proxy_type_manual_no_proxy_on(self):
     88        capabilities = {
     89            "proxy": {
     90                "proxyType": "manual",
     91                "noProxy": ["foo", "bar"],
     92            }
     93        }
     94 
     95        self.marionette.start_session(capabilities)
     96        self.assertEqual(
     97            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
     98        )
     99 
    100    def test_proxy_type_manual_invalid_no_proxy_on(self):
    101        capabilities = {
    102            "proxy": {
    103                "proxyType": "manual",
    104                "noProxy": "foo, bar",
    105            }
    106        }
    107 
    108        with self.assertRaises(errors.SessionNotCreatedException):
    109            self.marionette.start_session(capabilities)
    110 
    111    def test_proxy_type_pac(self):
    112        pac_url = "http://marionette.test"
    113        capabilities = {"proxy": {"proxyType": "pac", "proxyAutoconfigUrl": pac_url}}
    114 
    115        self.marionette.start_session(capabilities)
    116        self.assertEqual(
    117            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
    118        )
    119 
    120    def test_proxy_type_system(self):
    121        capabilities = {"proxy": {"proxyType": "system"}}
    122 
    123        self.marionette.start_session(capabilities)
    124        self.assertEqual(
    125            self.marionette.session_capabilities["proxy"], capabilities["proxy"]
    126        )
    127 
    128    def test_invalid_proxy_object(self):
    129        capabilities = {"proxy": "I really should be a dictionary"}
    130 
    131        with self.assertRaises(errors.SessionNotCreatedException):
    132            self.marionette.start_session(capabilities)
    133 
    134    def test_missing_proxy_type(self):
    135        with self.assertRaises(errors.SessionNotCreatedException):
    136            self.marionette.start_session({"proxy": {"proxyAutoconfigUrl": "foobar"}})
    137 
    138    def test_invalid_proxy_type(self):
    139        capabilities = {"proxy": {"proxyType": "NOPROXY"}}
    140 
    141        with self.assertRaises(errors.SessionNotCreatedException):
    142            self.marionette.start_session(capabilities)
    143 
    144    def test_invalid_autoconfig_url_for_pac(self):
    145        with self.assertRaises(errors.SessionNotCreatedException):
    146            self.marionette.start_session({"proxy": {"proxyType": "pac"}})
    147 
    148        with self.assertRaises(errors.SessionNotCreatedException):
    149            self.marionette.start_session(
    150                {"proxy": {"proxyType": "pac", "proxyAutoconfigUrl": None}}
    151            )
    152 
    153    def test_missing_socks_version_for_manual(self):
    154        capabilities = {
    155            "proxy": {"proxyType": "manual", "socksProxy": "marionette.test"}
    156        }
    157 
    158        with self.assertRaises(errors.SessionNotCreatedException):
    159            self.marionette.start_session(capabilities)