arelle-release 2.17.1__py3-none-any.whl → 2.37.71__py3-none-any.whl

tests/unit_tests/arelle/test_betafeatures.py

@@ -1,81 +0,0 @@
-import importlib
-
-import pytest
-from lxml import etree
-
-from arelle import BetaFeatures
-
-
-@pytest.fixture(autouse=True)
-def reset():
-    BetaFeatures._NEW_OBJECT_MODEL_STATUS_ACCESSED = False
-    BetaFeatures._USE_NEW_OBJECT_MODEL = False
-    yield
-    BetaFeatures._NEW_OBJECT_MODEL_STATUS_ACCESSED = False
-    BetaFeatures._USE_NEW_OBJECT_MODEL = False
-
-
-def test_use_lxml_base_classes():
-    import arelle.model
-
-    importlib.reload(arelle.model)
-
-    from arelle.model import CommentBase as InitCommentBase
-    from arelle.model import ElementBase as InitElementBase
-    from arelle.model import PIBase as InitPIBase
-
-    from arelle.model.CommentBase import CommentBase
-    from arelle.model.ElementBase import ElementBase
-    from arelle.model.PIBase import PIBase
-
-    element = InitElementBase()
-    assert isinstance(element, etree.ElementBase)
-    assert not isinstance(element, ElementBase)
-
-    comment = InitCommentBase("comment")
-    assert isinstance(comment, etree.CommentBase)
-    assert not isinstance(comment, CommentBase)
-
-    pi = InitPIBase("instruction")
-    assert isinstance(pi, etree.PIBase)
-    assert not isinstance(pi, PIBase)
-
-
-def test_use_pure_python_base_classes():
-    BetaFeatures.enableNewObjectModel()
-    import arelle.model
-
-    importlib.reload(arelle.model)
-
-    from arelle.model import CommentBase as InitCommentBase
-    from arelle.model import ElementBase as InitElementBase
-    from arelle.model import PIBase as InitPIBase
-
-    from arelle.model.CommentBase import CommentBase
-    from arelle.model.ElementBase import ElementBase
-    from arelle.model.PIBase import PIBase
-
-    element = InitElementBase()
-    assert not isinstance(element, etree.ElementBase)
-    assert isinstance(element, ElementBase)
-
-    comment = InitCommentBase("comment")
-    assert not isinstance(comment, etree.CommentBase)
-    assert isinstance(comment, CommentBase)
-
-    pi = InitPIBase("instruction")
-    assert not isinstance(pi, etree.PIBase)
-    assert isinstance(pi, PIBase)
-
-
-def test_enable_new_models_after_access_exception():
-    import arelle.model
-
-    importlib.reload(arelle.model)
-
-    assert arelle.model.CommentBase is etree.CommentBase
-    assert arelle.model.ElementBase is etree.ElementBase
-    assert arelle.model.PIBase is etree.PIBase
-
-    with pytest.raises(RuntimeError):
-        BetaFeatures.enableNewObjectModel()

tests/unit_tests/arelle/test_cntlr.py

@@ -1,28 +0,0 @@
-from mock import patch
-
-from arelle import Cntlr
-
-
-@patch('io.open')
-@patch('os.path.exists')
-@patch('arelle.Cntlr.Cntlr.setUiLanguage')
-@patch('arelle.ModelManager.ModelManager.setLocale')
-def test_cntlr_cache_enabled(_, mock_codes, mock_exists, mock_open):
-    mock_codes.return_value = ['en-US', 'en_US', 'en']
-    mock_exists.return_value = True
-    cntlr = Cntlr.Cntlr(uiLang=None)
-    assert mock_open.call_count == 3
-    cntlr.saveConfig()
-    assert mock_open.call_count == 4
-
-@patch('io.open')
-@patch('os.path.exists')
-@patch('arelle.Cntlr.Cntlr.setUiLanguage')
-@patch('arelle.ModelManager.ModelManager.setLocale')
-def test_cntlr_cache_disabled(_, mock_codes, mock_exists, mock_open):
-    mock_codes.return_value = ['en-US', 'en_US', 'en']
-    mock_exists.return_value = True
-    cntlr = Cntlr.Cntlr(uiLang=None, disable_persistent_config=True)
-    assert mock_open.call_count == 1
-    cntlr.saveConfig()
-    assert mock_open.call_count == 1

tests/unit_tests/arelle/test_import.py

@@ -1,40 +0,0 @@
-import glob
-import subprocess
-import sys
-
-import pytest
-
-KNOWN_FAILURES = frozenset([
-    'arelle.CntlrProfiler',
-    'arelle.FunctionXfi',
-    'arelle.PrototypeDtsObject',
-    'arelle.ViewCsvRelationshipSet',
-    'arelle.ViewWinRenderedGrid',
-    'arelle.examples.LoadSavePreLbCsv',
-    'arelle.examples.SaveTableToExelle',
-    'arelle.examples.TR3toTR4',
-    'arelle.formula.FormulaEvaluator',
-    'arelle.plugin.loadFromOIM-2018',
-    'arelle.plugin.sphinx.SphinxEvaluator',
-    'arelle.plugin.validate.EFM-htm.Const',
-    'arelle.plugin.validate.EFM-htm.__init__',
-    'arelle.plugin.validate.XFsyntax.xf',
-])
-MODULE_NAMES = [
-    g.replace('/', '.').replace('\\', '.').replace('.py', '')
-    for g in glob.glob('arelle/**/*.py', recursive=True)
-    if not g.startswith(tuple(f'arelle/plugin/{p}/' for p in ['EdgarRenderer', 'iXBRLViewerPlugin', 'xule']))
-]
-TEST_PARAMS = [
-    pytest.param(
-        module_name,
-        id=module_name,
-        marks=[pytest.mark.xfail()] if module_name in KNOWN_FAILURES else []
-    ) for module_name in MODULE_NAMES
-]
-
-
-@pytest.mark.slow
-@pytest.mark.parametrize('module_name', TEST_PARAMS)
-def test(module_name):
-    subprocess.run([sys.executable, '-c', f'import {module_name}'], check=True)

tests/unit_tests/arelle/test_locale.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-from typing import Any
-import locale
-import pytest
-from decimal import Decimal
-from arelle.Locale import format_decimal
-from arelle.Locale import getUserLocale
-
-
-d = Decimal('-1234567.8901')
-
-@pytest.mark.parametrize(
-    'params, result',
-    [
-        (
-            {
-                'conv': getUserLocale()[0],
-                'value': d,
-                'curr': '$',
-                'neg': '-'
-            },
-            '-$1,234,567.89'
-        ),
-        (
-            {
-                'conv': getUserLocale()[0],
-                'value': d,
-                'fractPlaces': 0,
-                'sep': '.',
-                'dp': '',
-                'trailneg': '-'
-            },
-            '1.234.568-'
-        ),
-        (
-            {
-                'conv': getUserLocale()[0],
-                'value': d,
-                'curr': '$',
-                'neg': '(',
-                'trailneg': ')'
-            },
-            '($1,234,567.89)'
-        ),
-        (
-            {
-                'conv': getUserLocale()[0],
-                'value': Decimal(123456789),
-                'sep': ' '
-            },
-            '123 456 789.00'
-        ),
-        (
-            {
-                'conv': getUserLocale()[0],
-                'value': Decimal('-0.02'),
-                'neg': '<',
-                'trailneg': '>'
-            },
-            '<0.02>'
-        ),
-    ]
-)
-def test_format_decimal(params: dict[str, Any], result: str) -> None:
-    assert format_decimal(**params) == result
-
-
-@pytest.mark.parametrize('locale_code', ['', 'C', 'invalid'])
-def test_get_user_locale_reset(locale_code) -> None:
-    before_locale = locale.setlocale(locale.LC_ALL)
-    getUserLocale(locale_code)
-    after_locale = locale.setlocale(locale.LC_ALL)
-    assert after_locale == before_locale

tests/unit_tests/arelle/test_modelmanager.py

@@ -1,15 +0,0 @@
-from arelle import ModelManager
-from arelle.CntlrCmdLine import CntlrCmdLine
-from arelle.FileSource import openFileSource
-
-
-def test_independent_model_manager():
-    """Test creating a new ModelManager and associating it with a Cntlr.
-
-    XULE does this.
-    """
-    cntlr = CntlrCmdLine(uiLang='en')
-    file_source = openFileSource('arelle/config/empty-instance.xml', cntlr)
-    modelManager = ModelManager.initialize(cntlr)
-    modelXbrl = modelManager.load(file_source)
-    assert modelXbrl

tests/unit_tests/arelle/test_packagemanager.py

@@ -1,65 +0,0 @@
-from mock import Mock
-
-from arelle import PackageManager
-
-
-def test_package_manager_init_first_pass():
-    """
-    Test that packagesConfig is correctly setup during init on fresh pass
-    """
-    cntlr = Mock()
-    PackageManager.init(cntlr, loadPackagesConfig=False)
-    assert len(PackageManager.packagesConfig) == 2
-    assert 'packages' in PackageManager.packagesConfig
-    assert isinstance(PackageManager.packagesConfig.get('packages'), list)
-    assert len(PackageManager.packagesConfig.get('packages')) == 0
-    assert 'remappings' in PackageManager.packagesConfig
-    assert isinstance(PackageManager.packagesConfig.get('remappings'), dict)
-    assert len(PackageManager.packagesConfig.get('remappings')) == 0
-    assert PackageManager._cntlr == cntlr
-
-
-def test_package_manager_init_config_already_exists():
-    """
-    Test that packagesConfig is correctly setup during init on a second pass
-    """
-    cntlr = Mock()
-    PackageManager.init(cntlr, loadPackagesConfig=False)
-    PackageManager.close()
-    PackageManager.init(cntlr, loadPackagesConfig=False)
-    assert len(PackageManager.packagesConfig) == 2
-    assert 'packages' in PackageManager.packagesConfig
-    assert isinstance(PackageManager.packagesConfig.get('packages'), list)
-    assert len(PackageManager.packagesConfig.get('packages')) == 0
-    assert 'remappings' in PackageManager.packagesConfig
-    assert isinstance(PackageManager.packagesConfig.get('remappings'), dict)
-    assert len(PackageManager.packagesConfig.get('remappings')) == 0
-    assert PackageManager._cntlr == cntlr
-
-
-def test_package_manager_close():
-    """
-    Test that packagesConfig and packagesMappings are cleared when close is called
-    """
-    cntlr = Mock()
-    PackageManager.init(cntlr, loadPackagesConfig=False)
-    assert len(PackageManager.packagesMappings) == 0
-    PackageManager.packagesMappings['mapping'] = 'package'
-    PackageManager.close()
-    assert len(PackageManager.packagesConfig) == 0
-    assert len(PackageManager.packagesMappings) == 0
-    assert PackageManager._cntlr == cntlr
-
-
-def test_package_manager_reset():
-    """
-    Test that packagesConfig and packagesMappings are cleared when reset is called
-    """
-    cntlr = Mock()
-    PackageManager.init(cntlr, loadPackagesConfig=False)
-    assert len(PackageManager.packagesMappings) == 0
-    PackageManager.packagesMappings['mapping'] = 'package'
-    PackageManager.reset()
-    assert len(PackageManager.packagesConfig) == 0
-    assert len(PackageManager.packagesMappings) == 0
-    assert PackageManager._cntlr == cntlr

tests/unit_tests/arelle/test_pluginmanager.py

@@ -1,176 +0,0 @@
-"""Tests for the PluginManager module."""
-from __future__ import annotations
-import os
-import sys
-
-import pytest
-from mock import Mock
-
-from arelle import PluginManager
-from arelle.Cntlr import Cntlr
-
-
-def test_plugin_manager_init_first_pass():
-    """
-    Test that pluginConfig is correctly setup during init on fresh pass
-    """
-    cntlr = Mock(pluginDir='some_dir')
-    PluginManager.init(cntlr, loadPluginConfig=False)
-    assert len(PluginManager.pluginConfig) == 2
-    assert 'modules' in PluginManager.pluginConfig
-    assert isinstance(PluginManager.pluginConfig.get('modules'), dict)
-    assert len(PluginManager.pluginConfig.get('modules')) == 0
-    assert 'classes' in PluginManager.pluginConfig
-    assert isinstance(PluginManager.pluginConfig.get('classes'), dict)
-    assert len(PluginManager.pluginConfig.get('classes')) == 0
-    assert len(PluginManager.modulePluginInfos) == 0
-    assert len(PluginManager.pluginMethodsForClasses) == 0
-    assert PluginManager._cntlr == cntlr
-
-
-def test_plugin_manager_init_config_already_exists():
-    """
-    Test that pluginConfig is correctly setup during init on a second pass
-    """
-    cntlr = Mock(pluginDir='some_dir')
-    PluginManager.init(cntlr, loadPluginConfig=False)
-    PluginManager.close()
-    PluginManager.init(cntlr, loadPluginConfig=False)
-    assert len(PluginManager.pluginConfig) == 2
-    assert 'modules' in PluginManager.pluginConfig
-    assert isinstance(PluginManager.pluginConfig.get('modules'), dict)
-    assert len(PluginManager.pluginConfig.get('modules')) == 0
-    assert 'classes' in PluginManager.pluginConfig
-    assert isinstance(PluginManager.pluginConfig.get('classes'), dict)
-    assert len(PluginManager.pluginConfig.get('classes')) == 0
-    assert len(PluginManager.modulePluginInfos) == 0
-    assert len(PluginManager.pluginMethodsForClasses) == 0
-    assert PluginManager._cntlr == cntlr
-
-
-def test_plugin_manager_close():
-    """
-    Test that pluginConfig, modulePluginInfos and pluginMethodsForClasses are cleared when close is called
-    """
-    cntlr = Mock(pluginDir='some_dir')
-    PluginManager.init(cntlr, loadPluginConfig=False)
-    assert len(PluginManager.modulePluginInfos) == 0
-    assert len(PluginManager.pluginMethodsForClasses) == 0
-    PluginManager.modulePluginInfos['module'] = 'plugin_info'
-    PluginManager.pluginMethodsForClasses['class'] = 'plugin_method'
-    PluginManager.close()
-    assert len(PluginManager.pluginConfig) == 0
-    assert len(PluginManager.modulePluginInfos) == 0
-    assert len(PluginManager.pluginMethodsForClasses) == 0
-    assert PluginManager._cntlr == cntlr
-
-
-def test_plugin_manager_reset():
-    """
-    Test that modulePluginInfos and pluginMethodsForClasses are cleared when close is called, pluginConfig remains unchanged
-    """
-    cntlr = Mock(pluginDir='some_dir')
-    PluginManager.init(cntlr, loadPluginConfig=False)
-    assert len(PluginManager.modulePluginInfos) == 0
-    assert len(PluginManager.pluginMethodsForClasses) == 0
-    PluginManager.modulePluginInfos['module'] = 'plugin_info'
-    PluginManager.pluginMethodsForClasses['class'] = 'plugin_method'
-    PluginManager.reset()
-    assert len(PluginManager.pluginConfig) == 2
-    assert len(PluginManager.modulePluginInfos) == 0
-    assert len(PluginManager.pluginMethodsForClasses) == 0
-    assert PluginManager._cntlr == cntlr
-
-@pytest.mark.parametrize(
-    "test_data, expected_result",
-    [
-        # Test case 1
-        (
-            # Test data
-            ("tests/unit_tests/arelle", "functionsMaths", "xyz"),
-            # Expected result
-            ("functionsMaths", "tests/unit_tests", "xyz")
-        ),
-        # Test case 2
-        (
-            # Test data
-            ("arelle/plugin/", "sphinx/__init__.py", "xyz"),
-            # Expected result
-            ("sphinx", "arelle/plugin", "sphinx.")
-        ),
-        # Test case 3
-        (
-            # Test data
-            ("plugin/sphinx", None, "xyz"),
-            # Expected result
-            (None, None, None)
-        ),
-    ]
-)
-def test_function_get_name_dir_prefix(
-    test_data: tuple[str, str, str],
-    expected_result: tuple[str, str, str],
-    ):
-    """Test util function get_name_dir_prefix."""
-    class Controller(Cntlr):
-        """Controller."""
-
-        pluginDir = test_data[0]
-
-        def __init__(self) -> None:
-            """Init controller with logging."""
-            super().__init__(logFileName="logToPrint")
-
-    cntlr = Controller()
-
-    moduleName, moduleDir, packageImportPrefix = PluginManager._get_name_dir_prefix(
-        controller=cntlr,
-        pluginBase=Controller.pluginDir,
-        moduleURL=test_data[1],
-        packagePrefix=test_data[2],
-    )
-
-    assert moduleName == expected_result[0]
-    assert moduleDir == (None if expected_result[1] is None else os.path.normcase(expected_result[1]))
-    assert packageImportPrefix == expected_result[2]
-
-    PluginManager.close()
-
-def test_function_loadModule():
-    """
-    Test helper function loadModule.
-
-    This test asserts that a plugin module is loaded when running
-    the function.
-    """
-
-    class Controller(Cntlr):
-        """Controller."""
-
-        pluginDir = "tests/unit_tests/arelle"
-
-        def __init__(self) -> None:
-            """Init controller with logging."""
-            super().__init__(logFileName="logToPrint")
-
-    Controller()
-
-    PluginManager.loadModule(
-        moduleInfo={
-            "name": "mock",
-            "moduleURL": "functionsMath",
-        }
-    )
-
-    all_modules_list: list[str] = [m.__name__ for m in sys.modules.values() if m]
-
-    assert "arelle.formula.XPathContext" in all_modules_list
-    assert "arelle.FunctionUtil" in all_modules_list
-    assert "arelle.FunctionXs" in all_modules_list
-    assert "isodate.isoduration" in all_modules_list
-    assert "functionsMath" in all_modules_list
-
-    PluginManager.close()
-
-def teardown_function():
-    PluginManager.close()

tests/unit_tests/arelle/test_qname.py

@@ -1,140 +0,0 @@
-import pytest
-from arelle.ModelValue import QName
-from itertools import product
-
-prefixes = ['pre', 1, '', None]
-ns_uris = ['http://valid.com', 'invalid', '', 1,  None]
-local_names = ['Cash', 1, '', None]
-
-general_test_data = list(product(*[prefixes, ns_uris, local_names]))
-
-
-@pytest.mark.parametrize('prefix, ns_uri, local_name', general_test_data)
-class TestQnameGeneralUsage:
-    def test_create(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name) is not None, 'create'
-
-    def test_prefix(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name).prefix == prefix, 'prefix'
-
-    def test_namespace_uri(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name).namespaceURI == ns_uri, 'namespace uri'
-
-    def test_local_name(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name).localName == local_name, 'local_name'
-
-    def test_expanded_name(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name).expandedName == "{}#{}".format(ns_uri or '', local_name), 'expanded name'
-
-    def test_clark_notation(self, prefix, ns_uri, local_name):
-        qname_clark = QName(prefix, ns_uri, local_name).clarkNotation
-        assertion = '{{{}}}{}'.format(ns_uri, local_name) if ns_uri else local_name
-        assert qname_clark == assertion, 'clark name'
-
-    def test_qname_value_hash(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name).qnameValueHash == hash((ns_uri, local_name)), 'qname value hash'
-
-    def test_repr(self, prefix, ns_uri, local_name):
-        qname_string = QName(prefix, ns_uri, local_name).__repr__()
-        assertion = '{}:{}'.format(prefix, local_name) if prefix else local_name
-        if qname_string is None:
-            assert qname_string is assertion, 'str'
-        else:
-            assert qname_string == assertion, 'str'
-
-    def test_str(self, prefix, ns_uri, local_name):
-        qname_string = QName(prefix, ns_uri, local_name).__str__()
-        assertion = '{}:{}'.format(prefix, local_name) if prefix else local_name
-        if qname_string is None:
-            assert qname_string is assertion, 'str'
-        else:
-            assert qname_string == assertion, 'str'
-
-    def test_eq(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name) == QName(prefix, ns_uri, local_name), 'qname eq'
-
-    def test_ne(self, prefix, ns_uri, local_name):
-        assert QName(prefix, ns_uri, local_name) != QName('non_matching_prefix', 'http://nonmatchingnamespaceuri', 'NonMatchingLocalName'), 'qname ne'
-
-
-comparison_test_data = [
-    (None, 'AnyString'),  # ns_uri sorts first
-    ('a', 'AnyString'),  # ns_uri sorts first
-    ('http://ns.com', None),  # ns_uri eq so None local_name sorts first
-    ('http://ns.com', 'A'),  # ns_uri eq so local_name sorts first
-]
-
-
-@pytest.mark.parametrize('ns_uri, local_name', comparison_test_data)
-class TestQnameComparisons:
-    def test_lt(self, ns_uri, local_name):
-        assert QName(None, ns_uri, local_name) < QName(None, 'http://ns.com', 'B'), 'qname lt'
-
-    def test_gt(self, ns_uri, local_name):
-        assert QName(None, 'http://ns.com', 'B') > QName(None, ns_uri, local_name), 'qname gt'
-
-
-comparison_equal_test_data = comparison_test_data + [
-    ('http://ns.com', 'B'),  # ns_uri eq and local_name eq
-]
-
-
-@pytest.mark.parametrize('ns_uri, local_name', comparison_equal_test_data)
-class TestQnameComparisonEqual:
-    def test_le(self, ns_uri, local_name):
-        assert QName(None, ns_uri, local_name) <= QName(None, 'http://ns.com', 'B'), 'qname le'
-
-    def test_ge(self, ns_uri, local_name):
-        assert QName(None, 'http://ns.com', 'B') >= QName(None, ns_uri, local_name), 'qname ge'
-
-
-bad_comparison_test_data = [
-    'Random Object',
-    None,
-    True,
-    1
-]
-
-@pytest.mark.parametrize('random_object', bad_comparison_test_data)
-class TestQnameBadComparisons:
-    def test_lt_bad_comparison(self, random_object):
-        with pytest.raises(TypeError):
-            qname = QName(None, None, None)
-            qname < random_object
-
-    def test_le_bad_comparison(self, random_object):
-        with pytest.raises(TypeError):
-            qname = QName(None, None, None)
-            qname <= random_object
-
-    def test_gt_bad_comparison(self, random_object):
-        with pytest.raises(TypeError) as ex_info:
-            qname = QName(None, None, None)
-            qname > random_object
-
-    def test_ge_bad_comparison(self, random_object):
-        with pytest.raises(TypeError):
-            qname = QName(None, None, None)
-            qname >= random_object
-
-
-def test_ne_bad_comparison():
-    assert QName('pre', 'http://namespace.com', 'Cash') != 'Random Object', 'qname ne'
-
-
-@pytest.mark.parametrize('local_name', [
-    'Cash',
-    1,
-    True
-])
-def test_bool_true(local_name):
-    assert QName(None, None, local_name), 'qname bool'
-
-
-@pytest.mark.parametrize('local_name', [
-    '',
-    0,
-    False
-])
-def test_bool_false(local_name):
-    assert not QName('pre', 'http://namespace.com', local_name), 'qname bool'

tests/unit_tests/arelle/test_runtimeoptions.py

@@ -1,56 +0,0 @@
-import pytest
-import re
-
-from mock import patch
-from arelle.RuntimeOptions import RuntimeOptions, RuntimeOptionsException
-
-
-def test_existing_plugin_options_collision():
-    with pytest.raises(RuntimeOptionsException, match=re.escape("Provided plugin options already exist as base options ['uiLang']")):
-        RuntimeOptions(
-            entrypointFile='fr',
-            pluginOptions={
-                'uiLang': 'fr',
-            },
-        )
-
-
-@patch('arelle.RuntimeOptions.hasWebServer')
-def test_webserver_requires_module(mockwebserver):
-    mockwebserver.return_value = False
-    with pytest.raises(RuntimeOptionsException, match='Webserver option requires webserver module'):
-        RuntimeOptions(
-            webserver='webserver',
-        )
-
-
-def test_incorrect_arguments_with_webserver():
-    with pytest.raises(RuntimeOptionsException, match='Incorrect arguments with webserver'):
-        RuntimeOptions(
-            entrypointFile='File',
-            webserver='webserver',
-        )
-
-
-@patch('arelle.RuntimeOptions.hasWebServer')
-def test_incorrect_arguments(mockwebserver):
-    with pytest.raises(RuntimeOptionsException, match="Incorrect arguments"):
-        mockwebserver.return_value = False
-        RuntimeOptions(
-            entrypointFile=None,
-            proxy=None,
-            plugins=None,
-            pluginOptions=None,
-            webserver=None,
-        )
-
-
-def test_set_runtime_options():
-    runtimeOptions = RuntimeOptions(
-        abortOnMajorError=True,
-        pluginOptions={
-            'dynamicNamedOptionDefinedByPlugin': 42,
-        },
-    )
-    assert runtimeOptions.abortOnMajorError
-    assert runtimeOptions.dynamicNamedOptionDefinedByPlugin == 42