def pytest_configure(config):
""" This runs after command line options have been parsed """
with_testing_base = config.getoption('with_testing_base')
if with_testing_base:
log_path = config.getoption('log_path')
log_helper.log_folder_setup(log_path)
proxy_helper.remove_proxy_zip_if_present()
def pytest_configure(config):
""" This runs after command line options have been parsed """
sb_config.is_pytest = True
sb_config.browser = config.getoption('browser')
sb_config.data = config.getoption('data')
sb_config.environment = config.getoption('environment')
sb_config.with_selenium = config.getoption('with_selenium')
sb_config.user_agent = config.getoption('user_agent')
sb_config.headless = config.getoption('headless')
sb_config.with_testing_base = config.getoption('with_testing_base')
sb_config.with_db_reporting = config.getoption('with_db_reporting')
sb_config.with_s3_logging = config.getoption('with_s3_logging')
sb_config.with_screen_shots = config.getoption('with_screen_shots')
sb_config.with_basic_test_info = config.getoption('with_basic_test_info')
sb_config.with_page_source = config.getoption('with_page_source')
sb_config.servername = config.getoption('servername')
sb_config.port = config.getoption('port')
sb_config.proxy_string = config.getoption('proxy_string')
sb_config.cap_file = config.getoption('cap_file')
sb_config.database_env = config.getoption('database_env')
sb_config.log_path = config.getoption('log_path')
sb_config.archive_logs = config.getoption('archive_logs')
sb_config.demo_mode = config.getoption('demo_mode')
sb_config.demo_sleep = config.getoption('demo_sleep')
sb_config.highlights = config.getoption('highlights')
sb_config.message_duration = config.getoption('message_duration')
sb_config.js_checking_on = config.getoption('js_checking_on')
sb_config.ad_block_on = config.getoption('ad_block_on')
sb_config.verify_delay = config.getoption('verify_delay')
sb_config.save_screenshot = config.getoption('save_screenshot')
sb_config.timeout_multiplier = config.getoption('timeout_multiplier')
if sb_config.with_testing_base:
log_helper.log_folder_setup(sb_config.log_path, sb_config.archive_logs)
proxy_helper.remove_proxy_zip_if_present()
def pytest_configure(config):
""" This runs after command line options have been parsed """
sb_config.is_pytest = True
sb_config.browser = config.getoption('browser')
sb_config.data = config.getoption('data')
sb_config.environment = config.getoption('environment')
sb_config.with_selenium = config.getoption('with_selenium')
sb_config.user_agent = config.getoption('user_agent')
sb_config.headless = config.getoption('headless')
sb_config.headed = config.getoption('headed')
sb_config.start_page = config.getoption('start_page')
sb_config.extension_zip = config.getoption('extension_zip')
sb_config.extension_dir = config.getoption('extension_dir')
sb_config.with_testing_base = config.getoption('with_testing_base')
sb_config.with_db_reporting = config.getoption('with_db_reporting')
sb_config.with_s3_logging = config.getoption('with_s3_logging')
sb_config.with_screen_shots = config.getoption('with_screen_shots')
sb_config.with_basic_test_info = config.getoption('with_basic_test_info')
sb_config.with_page_source = config.getoption('with_page_source')
sb_config.servername = config.getoption('servername')
sb_config.port = config.getoption('port')
sb_config.proxy_string = config.getoption('proxy_string')
sb_config.cap_file = config.getoption('cap_file')
sb_config.settings_file = config.getoption('settings_file')
sb_config.user_data_dir = config.getoption('user_data_dir')
sb_config.database_env = config.getoption('database_env')
sb_config.log_path = config.getoption('log_path')
sb_config.archive_logs = config.getoption('archive_logs')
sb_config.demo_mode = config.getoption('demo_mode')
sb_config.demo_sleep = config.getoption('demo_sleep')
sb_config.highlights = config.getoption('highlights')
sb_config.message_duration = config.getoption('message_duration')
sb_config.js_checking_on = config.getoption('js_checking_on')
sb_config.ad_block_on = config.getoption('ad_block_on')
sb_config.verify_delay = config.getoption('verify_delay')
sb_config.disable_csp = config.getoption('disable_csp')
sb_config.enable_sync = config.getoption('enable_sync')
sb_config.maximize_window = config.getoption('maximize_window')
sb_config.save_screenshot = config.getoption('save_screenshot')
sb_config.visual_baseline = config.getoption('visual_baseline')
sb_config.timeout_multiplier = config.getoption('timeout_multiplier')
sb_config.pytest_html_report = config.getoption('htmlpath') # --html=FILE
if "linux" in sys.platform and (
not sb_config.headed and not sb_config.headless):
print(
"(Running with --headless on Linux. "
"Use --headed or --gui to override.)")
sb_config.headless = True
if not sb_config.headless:
sb_config.headed = True
if sb_config.with_testing_base:
log_helper.log_folder_setup(sb_config.log_path, sb_config.archive_logs)
proxy_helper.remove_proxy_zip_if_present()
def pytest_unconfigure():
""" This runs after all tests have completed with pytest. """
proxy_helper.remove_proxy_zip_if_present()
if sb_config.reuse_session:
# Close the shared browser session
if sb_config.shared_driver:
try:
sb_config.shared_driver.quit()
except AttributeError:
pass
except Exception:
pass
sb_config.shared_driver = None
def pytest_configure(config):
""" This runs after command line options have been parsed """
sb_config.is_pytest = True
sb_config.browser = config.getoption('browser')
sb_config.data = config.getoption('data')
sb_config.environment = config.getoption('environment')
sb_config.with_selenium = config.getoption('with_selenium')
sb_config.user_agent = config.getoption('user_agent')
sb_config.headless = config.getoption('headless')
sb_config.with_testing_base = config.getoption('with_testing_base')
sb_config.with_db_reporting = config.getoption('with_db_reporting')
sb_config.with_s3_logging = config.getoption('with_s3_logging')
sb_config.with_screen_shots = config.getoption('with_screen_shots')
sb_config.with_basic_test_info = config.getoption('with_basic_test_info')
sb_config.with_page_source = config.getoption('with_page_source')
sb_config.servername = config.getoption('servername')
sb_config.port = config.getoption('port')
sb_config.proxy_string = config.getoption('proxy_string')
sb_config.cap_file = config.getoption('cap_file')
sb_config.database_env = config.getoption('database_env')
sb_config.log_path = config.getoption('log_path')
sb_config.archive_logs = config.getoption('archive_logs')
sb_config.demo_mode = config.getoption('demo_mode')
sb_config.demo_sleep = config.getoption('demo_sleep')
sb_config.highlights = config.getoption('highlights')
sb_config.message_duration = config.getoption('message_duration')
sb_config.js_checking_on = config.getoption('js_checking_on')
sb_config.ad_block_on = config.getoption('ad_block_on')
sb_config.verify_delay = config.getoption('verify_delay')
sb_config.disable_csp = config.getoption('disable_csp')
sb_config.save_screenshot = config.getoption('save_screenshot')
sb_config.visual_baseline = config.getoption('visual_baseline')
sb_config.timeout_multiplier = config.getoption('timeout_multiplier')
sb_config.pytest_html_report = config.getoption("htmlpath") # --html=FILE
if sb_config.with_testing_base:
log_helper.log_folder_setup(sb_config.log_path, sb_config.archive_logs)
proxy_helper.remove_proxy_zip_if_present()
def pytest_configure(config):
""" This runs after command line options have been parsed """
sb_config.is_pytest = True
sb_config.browser = config.getoption('browser')
sb_config.data = config.getoption('data')
sb_config.var1 = config.getoption('var1')
sb_config.var2 = config.getoption('var2')
sb_config.var3 = config.getoption('var3')
sb_config.environment = config.getoption('environment')
sb_config.with_selenium = config.getoption('with_selenium')
sb_config.user_agent = config.getoption('user_agent')
sb_config.mobile_emulator = config.getoption('mobile_emulator')
sb_config.device_metrics = config.getoption('device_metrics')
sb_config.headless = config.getoption('headless')
sb_config.headed = config.getoption('headed')
sb_config.start_page = config.getoption('start_page')
sb_config.extension_zip = config.getoption('extension_zip')
sb_config.extension_dir = config.getoption('extension_dir')
sb_config.with_testing_base = config.getoption('with_testing_base')
sb_config.with_db_reporting = config.getoption('with_db_reporting')
sb_config.with_s3_logging = config.getoption('with_s3_logging')
sb_config.with_screen_shots = config.getoption('with_screen_shots')
sb_config.with_basic_test_info = config.getoption('with_basic_test_info')
sb_config.with_page_source = config.getoption('with_page_source')
sb_config.servername = config.getoption('servername')
sb_config.port = config.getoption('port')
sb_config.proxy_string = config.getoption('proxy_string')
sb_config.cap_file = config.getoption('cap_file')
sb_config.cap_string = config.getoption('cap_string')
sb_config.settings_file = config.getoption('settings_file')
sb_config.user_data_dir = config.getoption('user_data_dir')
sb_config.database_env = config.getoption('database_env')
sb_config.log_path = 'latest_logs/' # (No longer editable!)
sb_config.archive_logs = config.getoption('archive_logs')
sb_config._time_limit = config.getoption('time_limit')
sb_config.time_limit = config.getoption('time_limit')
sb_config.slow_mode = config.getoption('slow_mode')
sb_config.demo_mode = config.getoption('demo_mode')
sb_config.demo_sleep = config.getoption('demo_sleep')
sb_config.highlights = config.getoption('highlights')
sb_config.message_duration = config.getoption('message_duration')
sb_config.js_checking_on = config.getoption('js_checking_on')
sb_config.ad_block_on = config.getoption('ad_block_on')
sb_config.block_images = config.getoption('block_images')
sb_config.verify_delay = config.getoption('verify_delay')
sb_config.disable_csp = config.getoption('disable_csp')
sb_config.enable_sync = config.getoption('enable_sync')
sb_config.use_auto_ext = config.getoption('use_auto_ext')
sb_config.no_sandbox = config.getoption('no_sandbox')
sb_config.disable_gpu = config.getoption('disable_gpu')
sb_config.swiftshader = config.getoption('swiftshader')
sb_config.incognito = config.getoption('incognito')
sb_config.guest_mode = config.getoption('guest_mode')
sb_config.devtools = config.getoption('devtools')
sb_config.reuse_session = config.getoption('reuse_session')
sb_config.crumbs = config.getoption('crumbs')
sb_config.shared_driver = None # The default driver for session reuse
sb_config.maximize_option = config.getoption('maximize_option')
sb_config.save_screenshot = config.getoption('save_screenshot')
sb_config.visual_baseline = config.getoption('visual_baseline')
sb_config.timeout_multiplier = config.getoption('timeout_multiplier')
sb_config.pytest_html_report = config.getoption('htmlpath') # --html=FILE
sb_config._sb_node = {} # sb node dictionary (Used with the sb fixture)
if sb_config.reuse_session:
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join) or (arg_join == "-c"):
# sb_config.reuse_session = False
pass # Allow multithreaded browser sessions to be reused now
if "linux" in sys.platform and (not sb_config.headed
and not sb_config.headless):
print("(Running with --headless on Linux. "
"Use --headed or --gui to override.)")
sb_config.headless = True
if not sb_config.headless:
sb_config.headed = True
if sb_config.with_testing_base:
log_helper.log_folder_setup(sb_config.log_path, sb_config.archive_logs)
proxy_helper.remove_proxy_zip_if_present()
def pytest_unconfigure():
""" This runs after all tests have completed with pytest. """
proxy_helper.remove_proxy_zip_if_present()
if sb_config.reuse_session:
# Close the shared browser session
if sb_config.shared_driver:
try:
sb_config.shared_driver.quit()
except AttributeError:
pass
except Exception:
pass
sb_config.shared_driver = None
log_helper.archive_logs_if_set(sb_config.log_path, sb_config.archive_logs)
# Dashboard post-processing: Disable time-based refresh and stamp complete
if sb_config.dashboard and not sb_config._only_unittest:
stamp = ""
if sb_config._dash_is_html_report:
# (If the Dashboard URL is the same as the HTML Report URL:)
# Have the html report refresh back to a dashboard on update
stamp += ('\n<script type="text/javascript" src="%s">'
'</script>' % constants.Dashboard.LIVE_JS)
stamp += "\n<!--Test Run Complete-->"
find_it = constants.Dashboard.META_REFRESH_HTML
swap_with = '' # Stop refreshing the page after the run is done
try:
# Part 1: Finalizing the dashboard / integrating html report
time.sleep(0.3) # Add time for "livejs" to detect changes
abs_path = os.path.abspath('.')
dashboard_path = os.path.join(abs_path, "dashboard.html")
if os.path.exists(dashboard_path):
with open(dashboard_path, 'r', encoding='utf-8') as f:
the_html = f.read()
# If the test run doesn't complete by itself, stop refresh
the_html = the_html.replace(find_it, swap_with)
the_html += stamp
if sb_config._dash_is_html_report and (
sb_config._saved_dashboard_pie):
the_html = the_html.replace("<h1>dashboard.html</h1>",
sb_config._saved_dashboard_pie)
the_html = the_html.replace(
"</head>", '</head><link rel="shortcut icon" '
'href="https://seleniumbase.io/img/dash_pie_2.png">')
if sb_config._dash_final_summary:
the_html += sb_config._dash_final_summary
time.sleep(0.25)
with open(dashboard_path, "w", encoding='utf-8') as f:
f.write(the_html)
# Part 2: Appending a pytest html report with dashboard data
html_report_path = os.path.join(abs_path,
sb_config._html_report_name)
if sb_config._using_html_report and (
os.path.exists(html_report_path)
and not sb_config._dash_is_html_report):
# Add the dashboard pie to the pytest html report
with open(html_report_path, 'r', encoding='utf-8') as f:
the_html = f.read()
if sb_config._saved_dashboard_pie:
the_html = the_html.replace(
"<h1>%s</h1>" % sb_config._html_report_name,
sb_config._saved_dashboard_pie)
the_html = the_html.replace(
"</head>", '</head><link rel="shortcut icon" '
'href="https://seleniumbase.io/img/dash_pie_2.png">')
if sb_config._dash_final_summary:
the_html += sb_config._dash_final_summary
with open(html_report_path, "w", encoding='utf-8') as f:
f.write(the_html)
except Exception:
pass
def pytest_configure(config):
""" This runs after command line options have been parsed """
sb_config.item_count = 0
sb_config.item_count_passed = 0
sb_config.item_count_failed = 0
sb_config.item_count_skipped = 0
sb_config.item_count_untested = 0
sb_config.item_count_finalized = False
sb_config.is_pytest = True
sb_config.browser = config.getoption('browser')
sb_config.data = config.getoption('data')
sb_config.var1 = config.getoption('var1')
sb_config.var2 = config.getoption('var2')
sb_config.var3 = config.getoption('var3')
sb_config.environment = config.getoption('environment')
sb_config.with_selenium = config.getoption('with_selenium')
sb_config.user_agent = config.getoption('user_agent')
sb_config.mobile_emulator = config.getoption('mobile_emulator')
sb_config.device_metrics = config.getoption('device_metrics')
sb_config.headless = config.getoption('headless')
sb_config.headed = config.getoption('headed')
sb_config.locale_code = config.getoption('locale_code')
sb_config.start_page = config.getoption('start_page')
sb_config.extension_zip = config.getoption('extension_zip')
sb_config.extension_dir = config.getoption('extension_dir')
sb_config.with_testing_base = config.getoption('with_testing_base')
sb_config.with_db_reporting = config.getoption('with_db_reporting')
sb_config.with_s3_logging = config.getoption('with_s3_logging')
sb_config.with_screen_shots = config.getoption('with_screen_shots')
sb_config.with_basic_test_info = config.getoption('with_basic_test_info')
sb_config.with_page_source = config.getoption('with_page_source')
sb_config.servername = config.getoption('servername')
sb_config.port = config.getoption('port')
sb_config.proxy_string = config.getoption('proxy_string')
sb_config.cap_file = config.getoption('cap_file')
sb_config.cap_string = config.getoption('cap_string')
sb_config.settings_file = config.getoption('settings_file')
sb_config.user_data_dir = config.getoption('user_data_dir')
sb_config.database_env = config.getoption('database_env')
sb_config.log_path = 'latest_logs/' # (No longer editable!)
sb_config.archive_logs = config.getoption('archive_logs')
sb_config._time_limit = config.getoption('time_limit')
sb_config.time_limit = config.getoption('time_limit')
sb_config.slow_mode = config.getoption('slow_mode')
sb_config.demo_mode = config.getoption('demo_mode')
sb_config.demo_sleep = config.getoption('demo_sleep')
sb_config.highlights = config.getoption('highlights')
sb_config.message_duration = config.getoption('message_duration')
sb_config.js_checking_on = config.getoption('js_checking_on')
sb_config.ad_block_on = config.getoption('ad_block_on')
sb_config.block_images = config.getoption('block_images')
sb_config.verify_delay = config.getoption('verify_delay')
sb_config.disable_csp = config.getoption('disable_csp')
sb_config.disable_ws = config.getoption('disable_ws')
sb_config.enable_ws = config.getoption('enable_ws')
if not sb_config.disable_ws:
sb_config.enable_ws = True
sb_config.enable_sync = config.getoption('enable_sync')
sb_config.use_auto_ext = config.getoption('use_auto_ext')
sb_config.no_sandbox = config.getoption('no_sandbox')
sb_config.disable_gpu = config.getoption('disable_gpu')
sb_config.remote_debug = config.getoption('remote_debug')
sb_config.dashboard = config.getoption('dashboard')
sb_config.swiftshader = config.getoption('swiftshader')
sb_config.incognito = config.getoption('incognito')
sb_config.guest_mode = config.getoption('guest_mode')
sb_config.devtools = config.getoption('devtools')
sb_config.reuse_session = config.getoption('reuse_session')
sb_config.crumbs = config.getoption('crumbs')
sb_config.shared_driver = None # The default driver for session reuse
sb_config.maximize_option = config.getoption('maximize_option')
sb_config.save_screenshot = config.getoption('save_screenshot')
sb_config.visual_baseline = config.getoption('visual_baseline')
sb_config.timeout_multiplier = config.getoption('timeout_multiplier')
sb_config.pytest_html_report = config.getoption('htmlpath') # --html=FILE
sb_config._sb_node = {} # sb node dictionary (Used with the sb fixture)
# Dashboard-specific variables
sb_config._results = {} # SBase Dashboard test results
sb_config._duration = {} # SBase Dashboard test duration
sb_config._display_id = {} # SBase Dashboard display ID
sb_config._dashboard_initialized = False # Becomes True after init
sb_config._has_exception = False # This becomes True if any test fails
sb_config._multithreaded = False # This becomes True if multithreading
sb_config._only_unittest = True # If any test uses BaseCase, becomes False
sb_config._sbase_detected = False # Becomes True during SeleniumBase tests
sb_config._extra_dash_entries = [] # Dashboard entries for non-SBase tests
sb_config._using_html_report = False # Becomes True when using html report
sb_config._dash_is_html_report = False # Dashboard becomes the html report
sb_config._saved_dashboard_pie = None # Copy of pie chart for html report
sb_config._dash_final_summary = None # Dash status to add to html report
sb_config._html_report_name = None # The name of the pytest html report
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join):
sb_config._multithreaded = True
if ("--html" in sys.argv or "--html=" in arg_join):
sb_config._using_html_report = True
sb_config._html_report_name = config.getoption("htmlpath")
if sb_config.dashboard:
if sb_config._html_report_name == "dashboard.html":
sb_config._dash_is_html_report = True
if "linux" in sys.platform and (not sb_config.headed
and not sb_config.headless):
print("(Running with --headless on Linux. "
"Use --headed or --gui to override.)")
sb_config.headless = True
if not sb_config.headless:
sb_config.headed = True
if sb_config.with_testing_base:
log_helper.log_folder_setup(sb_config.log_path, sb_config.archive_logs)
proxy_helper.remove_proxy_zip_if_present()
def pytest_unconfigure():
""" This runs after all tests have completed with pytest. """
proxy_helper.remove_proxy_zip_if_present()
def _perform_behave_unconfigure_():
from seleniumbase.core import log_helper
from seleniumbase.core import proxy_helper
proxy_helper.remove_proxy_zip_if_present()
if hasattr(sb_config, "reuse_session") and sb_config.reuse_session:
# Close the shared browser session
if sb_config.shared_driver:
try:
if (
not is_windows
or sb_config.browser == "ie"
or sb_config.shared_driver.service.process
):
sb_config.shared_driver.quit()
except AttributeError:
pass
except Exception:
pass
sb_config.shared_driver = None
if hasattr(sb_config, "log_path"):
log_helper.archive_logs_if_set(
sb_config.log_path, sb_config.archive_logs
)
# Dashboard post-processing: Disable time-based refresh and stamp complete
if not hasattr(sb_config, "dashboard") or not sb_config.dashboard:
# Done with "behave_unconfigure" unless using the Dashboard
return
stamp = "\n<!--Test Run Complete-->"
find_it = constants.Dashboard.META_REFRESH_HTML
swap_with = "" # Stop refreshing the page after the run is done
find_it_2 = "Awaiting results... (Refresh the page for updates)"
swap_with_2 = (
"Test Run ENDED: Some results UNREPORTED due to skipped tearDown()"
)
find_it_3 = '<td class="col-result">Untested</td>'
swap_with_3 = '<td class="col-result">Unreported</td>'
find_it_4 = 'href="%s"' % constants.Dashboard.DASH_PIE_PNG_1
swap_with_4 = 'href="%s"' % constants.Dashboard.DASH_PIE_PNG_2
try:
abs_path = os.path.abspath(".")
dashboard_path = os.path.join(abs_path, "dashboard.html")
# Part 1: Finalizing the dashboard / integrating html report
if os.path.exists(dashboard_path):
the_html_d = None
with open(dashboard_path, "r", encoding="utf-8") as f:
the_html_d = f.read()
if sb_config._multithreaded and "-c" in sys.argv:
# Threads have "-c" in sys.argv, except for the last
raise Exception('Break out of "try" block.')
if sb_config._multithreaded:
dash_pie_loc = constants.Dashboard.DASH_PIE
pie_path = os.path.join(abs_path, dash_pie_loc)
if os.path.exists(pie_path):
import json
with open(pie_path, "r") as f:
dash_pie = f.read().strip()
sb_config._saved_dashboard_pie = json.loads(dash_pie)
# If the test run doesn't complete by itself, stop refresh
the_html_d = the_html_d.replace(find_it, swap_with)
the_html_d = the_html_d.replace(find_it_2, swap_with_2)
the_html_d = the_html_d.replace(find_it_3, swap_with_3)
the_html_d = the_html_d.replace(find_it_4, swap_with_4)
the_html_d += stamp
with open(dashboard_path, "w", encoding="utf-8") as f:
f.write(the_html_d) # Finalize the dashboard
except KeyboardInterrupt:
pass
except Exception:
pass
def pytest_configure(config):
""" This runs after command line options have been parsed """
sb_config.is_pytest = True
sb_config.browser = config.getoption("browser")
sb_config.data = config.getoption("data")
sb_config.var1 = config.getoption("var1")
sb_config.var2 = config.getoption("var2")
sb_config.var3 = config.getoption("var3")
sb_config.environment = config.getoption("environment")
sb_config.with_selenium = config.getoption("with_selenium")
sb_config.user_agent = config.getoption("user_agent")
sb_config.mobile_emulator = config.getoption("mobile_emulator")
sb_config.device_metrics = config.getoption("device_metrics")
sb_config.headless = config.getoption("headless")
sb_config.headed = config.getoption("headed")
sb_config.start_page = config.getoption("start_page")
sb_config.extension_zip = config.getoption("extension_zip")
sb_config.extension_dir = config.getoption("extension_dir")
sb_config.with_testing_base = config.getoption("with_testing_base")
sb_config.with_db_reporting = config.getoption("with_db_reporting")
sb_config.with_s3_logging = config.getoption("with_s3_logging")
sb_config.with_screen_shots = config.getoption("with_screen_shots")
sb_config.with_basic_test_info = config.getoption("with_basic_test_info")
sb_config.with_page_source = config.getoption("with_page_source")
sb_config.servername = config.getoption("servername")
sb_config.port = config.getoption("port")
sb_config.proxy_string = config.getoption("proxy_string")
sb_config.cap_file = config.getoption("cap_file")
sb_config.cap_string = config.getoption("cap_string")
sb_config.settings_file = config.getoption("settings_file")
sb_config.user_data_dir = config.getoption("user_data_dir")
sb_config.database_env = config.getoption("database_env")
sb_config.log_path = "latest_logs/" # (No longer editable!)
sb_config.archive_logs = config.getoption("archive_logs")
sb_config._time_limit = config.getoption("time_limit")
sb_config.time_limit = config.getoption("time_limit")
sb_config.slow_mode = config.getoption("slow_mode")
sb_config.demo_mode = config.getoption("demo_mode")
sb_config.demo_sleep = config.getoption("demo_sleep")
sb_config.highlights = config.getoption("highlights")
sb_config.message_duration = config.getoption("message_duration")
sb_config.js_checking_on = config.getoption("js_checking_on")
sb_config.ad_block_on = config.getoption("ad_block_on")
sb_config.verify_delay = config.getoption("verify_delay")
sb_config.disable_csp = config.getoption("disable_csp")
sb_config.enable_sync = config.getoption("enable_sync")
sb_config.use_auto_ext = config.getoption("use_auto_ext")
sb_config.no_sandbox = config.getoption("no_sandbox")
sb_config.disable_gpu = config.getoption("disable_gpu")
sb_config.incognito = config.getoption("incognito")
sb_config.guest_mode = config.getoption("guest_mode")
sb_config.devtools = config.getoption("devtools")
sb_config.reuse_session = config.getoption("reuse_session")
sb_config.crumbs = config.getoption("crumbs")
sb_config.shared_driver = None # The default driver for session reuse
sb_config.maximize_option = config.getoption("maximize_option")
sb_config.save_screenshot = config.getoption("save_screenshot")
sb_config.visual_baseline = config.getoption("visual_baseline")
sb_config.timeout_multiplier = config.getoption("timeout_multiplier")
sb_config.pytest_html_report = config.getoption("htmlpath") # --html=FILE
if sb_config.reuse_session:
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join) or (arg_join == "-c"):
# sb_config.reuse_session = False
pass # Allow multithreaded browser sessions to be reused now
if "linux" in sys.platform and (not sb_config.headed
and not sb_config.headless):
print("(Running with --headless on Linux. "
"Use --headed or --gui to override.)")
sb_config.headless = True
if not sb_config.headless:
sb_config.headed = True
if sb_config.with_testing_base:
log_helper.log_folder_setup(sb_config.log_path, sb_config.archive_logs)
proxy_helper.remove_proxy_zip_if_present()
def finalize(self, result):
""" This runs after all tests have completed with nosetests. """
proxy_helper.remove_proxy_zip_if_present()
def configure(self, options, conf):
super(SeleniumBrowser, self).configure(options, conf)
self.enabled = True # Used if test class inherits BaseCase
self.options = options
self.headless_active = False # Default setting
proxy_helper.remove_proxy_zip_if_present()
def pytest_unconfigure():
""" This runs after all tests have completed with pytest. """
proxy_helper.remove_proxy_zip_if_present()
def configure(self, options, conf):
super(SeleniumBrowser, self).configure(options, conf)
self.enabled = True # Used if test class inherits BaseCase
self.options = options
self.headless_active = False # Default setting
proxy_helper.remove_proxy_zip_if_present()
def finalize(self, result):
""" This runs after all tests have completed with nosetests. """
proxy_helper.remove_proxy_zip_if_present()
def get_configured_sb(context):
if not sb_config.__base_class:
from seleniumbase import BaseCase
sb_config.__base_class = BaseCase
sb_config.__base_class.test_method = {}
sb = sb_config.__base_class("test_method")
# Set default values
sb.browser = "chrome"
sb.is_behave = True
sb.headless = False
sb.headed = False
sb.xvfb = False
sb.start_page = None
sb.locale_code = None
sb.pdb_option = False
sb.protocol = "http"
sb.servername = "localhost"
sb.port = 4444
sb.data = None
sb.var1 = None
sb.var2 = None
sb.var3 = None
sb.variables = {}
sb.account = None
sb.environment = "test"
sb.user_agent = None
sb.incognito = False
sb.guest_mode = False
sb.devtools = False
sb.mobile_emulator = False
sb.device_metrics = None
sb.extension_zip = None
sb.extension_dir = None
sb.database_env = "test"
sb.log_path = "latest_logs/"
sb.archive_logs = False
sb.disable_csp = False
sb.disable_ws = False
sb.enable_ws = False
sb.enable_sync = False
sb.use_auto_ext = False
sb.no_sandbox = False
sb.disable_gpu = False
sb._multithreaded = False
sb._reuse_session = False
sb._crumbs = False
sb.visual_baseline = False
sb.window_size = None
sb.maximize_option = False
sb.save_screenshot_after_test = False
sb.timeout_multiplier = None
sb.pytest_html_report = None
sb.with_db_reporting = False
sb.with_s3_logging = False
sb.js_checking_on = False
sb.recorder_mode = False
sb.recorder_ext = False
sb.record_sleep = False
sb.rec_behave = False
sb.report_on = False
sb.is_pytest = False
sb.slow_mode = False
sb.demo_mode = False
sb.time_limit = None
sb.demo_sleep = None
sb.dashboard = False
sb.dash_title = None
sb._dash_initialized = False
sb.message_duration = None
sb.block_images = False
sb.external_pdf = False
sb.remote_debug = False
sb.settings_file = None
sb.user_data_dir = None
sb.chromium_arg = None
sb.firefox_arg = None
sb.firefox_pref = None
sb.proxy_string = None
sb.proxy_bypass_list = None
sb.swiftshader = False
sb.ad_block_on = False
sb.highlights = None
sb.interval = None
sb.cap_file = None
sb.cap_string = None
# Set a few sb_config vars early in case parsing args fails
sb_config.dashboard = None
sb_config._has_exception = None
sb_config.save_screenshot = None
browsers = set() # To error if selecting more than one
valid_browsers = constants.ValidBrowsers.valid_browsers
valid_envs = constants.ValidEnvs.valid_envs
# Process command-line options
userdata = context.config.userdata
for key in userdata.keys():
# Convert --ARG to ARG, etc.
if key.startswith("--"):
key = key[2:]
if key.startswith("-"):
key = key[1:]
low_key = key.lower()
# Handle: -D browser=BROWSER
if low_key == "browser":
browser = userdata[key].lower()
if browser in valid_browsers:
sb.browser = browser
browsers.add(browser)
elif browser == "true":
raise Exception(
'\nThe "browser" argument requires a value!'
"\nChoose from %s."
'\nEg. -D browser="edge"' % valid_browsers
)
else:
raise Exception(
'\n"%s" is not a valid "browser" selection!'
"\nChoose from %s."
'\nEg. -D browser="edge"' % (browser, valid_browsers)
)
continue
# Handle: -D BROWSER
if low_key in valid_browsers:
browser = low_key
sb.browser = browser
browsers.add(browser)
continue
# Handle: -D headless
if low_key == "headless":
sb.headless = True
continue
# Handle: -D headed / gui
if low_key in ["headed", "gui"]:
sb.headed = True
continue
# Handle: -D xvfb
if low_key == "xvfb":
sb.xvfb = True
continue
# Handle: -D start-page=URL / start_page=URL / url=URL
if low_key in ["start-page", "start_page", "url"]:
start_page = userdata[key]
if start_page == "true":
start_page = sb.start_page # revert to default
sb.start_page = start_page
continue
# Handle: -D locale-code=CODE / locale_code=CODE / locale=CODE
if low_key in ["locale-code", "locale_code", "locale"]:
sb.start_page = userdata[key]
continue
# Handle: -D pdb / ipdb
if low_key in ["pdb", "ipdb"]:
sb.pdb_option = True
continue
# Handle: -D protocol=PROTOCOL
if low_key == "protocol":
protocol = userdata[key].lower()
if protocol in ["http", "https"]:
sb.protocol = protocol
elif protocol == "true":
raise Exception(
'\nThe Selenium Grid "protocol" argument requires a value!'
'\nChoose from ["http", "https"]'
'\nEg. -D protocol="https"'
)
else:
raise Exception(
'\n"%s" is not a valid Selenium Grid "protocol" selection!'
'\nChoose from ["http", "https"]'
'\nEg. -D protocol="https"' % protocol
)
continue
# Handle: -D servername=SERVERNAME
if low_key == "servername":
servername = userdata[key]
if servername == "true":
servername = sb.servername # revert to default
sb.servername = servername
continue
# Handle: -D port=PORT
if low_key == "port":
port = int(userdata[key])
if port == "true":
port = sb.port # revert to default
sb.port = port
continue
# Handle: -D data=DATA
if low_key == "data":
sb.data = userdata[key]
continue
# Handle: -D var1=DATA
if low_key == "var1":
sb.var1 = userdata[key]
continue
# Handle: -D var2=DATA
if low_key == "var2":
sb.var2 = userdata[key]
continue
# Handle: -D var3=DATA
if low_key == "var3":
sb.var3 = userdata[key]
continue
# Handle: -D variables="{'KEY':'VALUE','KEY2':'VALUE2'}"
if low_key == "variables":
variables = userdata[key]
if variables and type(variables) is str and len(variables) > 0:
bad_input = False
if (
not variables.startswith("{")
or not variables.endswith("}")
):
bad_input = True
else:
try:
variables = ast.literal_eval(variables)
if not type(variables) is dict:
bad_input = True
except Exception:
bad_input = True
if bad_input:
raise Exception(
'\nExpecting a Python dictionary for "variables"!'
"\nEg. -D variables=\"{'KEY':'VALUE', 'KEY2':123}\""
)
else:
variables = {}
continue
# Handle: -D account=ACCOUNT
if low_key == "account":
sb.account = userdata[key]
continue
# Handle: -D env=ENVIRONMENT
if low_key == "environment":
environment = userdata[key].lower()
if environment in valid_envs:
sb.environment = environment
elif environment == "true":
raise Exception(
'\nThe "env" argument requires a value!'
"\nChoose from %s."
'\nEg. -D env="production"' % valid_envs
)
else:
raise Exception(
'\n"%s" is not a valid "env" selection!'
"\nChoose from %s."
'\nEg. -D env="production"' % (environment, valid_envs)
)
continue
# Handle: -D user-agent=STRING / user_agent=STRING / agent=STRING
if low_key in ["user-agent", "user_agent", "agent"]:
user_agent = userdata[key]
if user_agent == "true":
user_agent = sb.user_agent # revert to default
sb.user_agent = user_agent
continue
# Handle: -D incognito / incognito-mode / incognito_mode
if low_key in ["incognito", "incognito-mode", "incognito_mode"]:
sb.incognito = True
continue
# Handle: -D guest / guest-mode / guest_mode
if low_key in ["guest", "guest-mode", "guest_mode"]:
sb.guest_mode = True
continue
# Handle: -D devtools / open-devtools / open_devtools
if low_key in ["devtools", "open-devtools", "open_devtools"]:
sb.devtools = True
continue
# Handle: -D mobile / mobile-emulator / mobile_emulator
if low_key in ["mobile", "mobile-emulator", "mobile_emulator"]:
sb.mobile_emulator = True
continue
# Handle: -D metrics=STR / device-metrics=STR / device_metrics=STR
if low_key in ["metrics", "device-metrics", "device_metrics"]:
device_metrics = userdata[key]
if device_metrics == "true":
device_metrics = sb.device_metrics # revert to default
sb.device_metrics = device_metrics
continue
# Handle: -D crx=ZIP / extension-zip=ZIP / extension_zip=ZIP
if low_key in ["crx", "extension-zip", "extension_zip"]:
extension_zip = userdata[key]
if extension_zip == "true":
extension_zip = sb.extension_zip # revert to default
sb.extension_zip = extension_zip
continue
# Handle: -D extension-dir=DIR / extension_dir=DIR
if low_key in ["extension-dir", "extension_dir"]:
extension_dir = userdata[key]
if extension_dir == "true":
extension_dir = sb.extension_dir # revert to default
sb.extension_dir = extension_dir
continue
# Handle: -D database-env=ENVIRONMENT / database_env=ENVIRONMENT
if low_key in ["database-env", "database_env"]:
database_env = userdata[key].lower()
if database_env in valid_envs:
sb.database_env = database_env
elif database_env == "true":
raise Exception(
'\nThe "database-env" argument requires a value!'
"\nChoose from %s."
'\nEg. -D database-env="production"' % valid_envs
)
else:
raise Exception(
'\n"%s" is not a valid "database-env" selection!'
"\nChoose from %s."
'\nEg. -D database-env="production"'
% (environment, valid_envs)
)
continue
# Handle: -D archive-logs / archive_logs
if low_key in ["archive-logs", "archive_logs"]:
sb.archive_logs = True
continue
# Handle: -D disable-csp / disable_csp
if low_key in ["disable-csp", "disable_csp"]:
sb.disable_csp = True
continue
# Handle: -D disable-ws / disable_ws
if low_key in ["disable-ws", "disable_ws"]:
sb.disable_ws = True
continue
# Handle: -D enable-ws / enable_ws
if low_key in ["enable-ws", "enable_ws"]:
sb.enable_ws = True
continue
# Handle: -D enable-sync / enable_sync
if low_key in ["enable-sync", "enable_sync"]:
sb.enable_sync = True
continue
# Handle: -D use-auto-ext / use_auto_ext / auto-ext
if low_key in ["use-auto-ext", "use_auto_ext", "auto-ext"]:
sb.use_auto_ext = True
continue
# Handle: -D no-sandbox / no_sandbox
if low_key in ["no-sandbox", "no_sandbox"]:
sb.no_sandbox = True
continue
# Handle: -D disable-gpu / disable_gpu
if low_key in ["disable-gpu", "disable_gpu"]:
sb.disable_gpu = True
continue
# Handle: -D rs / reuse-session / reuse_session
if low_key in ["rs", "reuse-session", "reuse_session"]:
sb._reuse_session = True
continue
# Handle: -D crumbs
if low_key == "crumbs":
sb._crumbs = True
continue
# Handle: -D visual-baseline / visual_baseline
if low_key in ["visual-baseline", "visual_baseline"]:
sb.visual_baseline = True
continue
# Handle: -D window-size=Width,Height / window_size=Width,Height
if low_key in ["window-size", "window_size"]:
window_size = userdata[key]
if window_size == "true":
window_size = sb.window_size # revert to default
sb.window_size = window_size
continue
# Handle: -D maximize / fullscreen / maximize-window
if low_key in [
"maximize", "fullscreen", "maximize-window", "maximize_window"
]:
sb.maximize_option = True
continue
# Handle: -D screenshot / save-screenshot / save_screenshot / ss
if low_key in [
"screenshot", "save-screenshot", "save_screenshot", "ss"
]:
sb.save_screenshot_after_test = True
continue
# Handle: -D timeout-multiplier=FLOAT / timeout_multiplier=FLOAT
if low_key in ["timeout-multiplier", "timeout_multiplier"]:
timeout_multiplier = userdata[key]
if timeout_multiplier == "true":
timeout_multiplier = sb.timeout_multiplier # revert to default
sb.timeout_multiplier = timeout_multiplier
continue
# Handle: -D with-db-reporting / with-db_reporting
if low_key in ["with-db-reporting", "with-db_reporting"]:
sb.with_db_reporting = True
continue
# Handle: -D with-s3-logging / with-s3_logging
if low_key in ["with-s3-logging", "with-s3_logging"]:
sb.with_s3_logging = True
continue
# Handle: -D check-js / check_js
if low_key in ["check-js", "check_js"]:
sb.js_checking_on = True
continue
# Handle: -D recorder / record / rec / codegen
if low_key in ["recorder", "record", "rec", "codegen"]:
sb.recorder_mode = True
sb.recorder_ext = True
continue
# Handle: -D rec-behave / rec-gherkin
if low_key in ["rec-behave", "rec-gherkin"]:
sb.rec_behave = True
continue
# Handle: -D record-sleep / record_sleep / rec-sleep / rec_sleep
if low_key in ["record-sleep", "rec-sleep"]:
sb.record_sleep = True
continue
# Handle: -D slow / slowmo / slow-mode / slow_mode
if low_key in ["slow", "slowmo", "slow-mode", "slow_mode"]:
sb.slow_mode = True
continue
# Handle: -D demo / demo-mode / demo_mode
if low_key in ["demo", "demo-mode", "demo_mode"]:
sb.demo_mode = True
continue
# Handle: -D time-limit / time_limit / timelimit
if low_key in ["time-limit", "time_limit", "timelimit"]:
time_limit = userdata[key]
if time_limit == "true":
time_limit = sb.time_limit # revert to default
sb.time_limit = time_limit
continue
# Handle: -D demo-sleep / demo_sleep
if low_key in ["demo-sleep", "demo_sleep"]:
demo_sleep = userdata[key]
if demo_sleep == "true":
demo_sleep = sb.demo_sleep # revert to default
sb.demo_sleep = demo_sleep
continue
# Handle: -D dashboard
if low_key == "dashboard":
sb.dashboard = True
continue
# Handle: -D dash-title=TITLE / dash_title=TITLE
if low_key in ["dash-title", "dash_title"]:
sb.dash_title = userdata[key]
continue
# Handle: -D message-duration / message_duration
if low_key in ["message-duration", "message_duration"]:
message_duration = userdata[key]
if message_duration == "true":
message_duration = sb.message_duration # revert to default
sb.message_duration = message_duration
continue
# Handle: -D block-images / block_images
if low_key in ["block-images", "block_images"]:
sb.block_images = True
continue
# Handle: -D external-pdf / external_pdf
if low_key in ["external-pdf", "external_pdf"]:
sb.external_pdf = True
continue
# Handle: -D remote-debug / remote_debug
if low_key in ["remote-debug", "remote_debug"]:
sb.remote_debug = True
continue
# Handle: -D settings=FILE / settings-file=FILE / settings_file=FILE
if low_key in ["settings", "settings-file", "settings_file"]:
settings_file = userdata[key]
if settings_file == "true":
settings_file = sb.settings_file # revert to default
sb.settings_file = settings_file
continue
# Handle: -D user-data-dir=DIR / user_data_dir=DIR
if low_key in ["user-data-dir", "user_data_dir"]:
user_data_dir = userdata[key]
if user_data_dir == "true":
user_data_dir = sb.user_data_dir # revert to default
sb.user_data_dir = user_data_dir
continue
# Handle: -D chromium-arg="ARG=N,ARG2" / chromium_arg="ARG=N,ARG2"
if low_key in ["chromium-arg", "chromium_arg"]:
chromium_arg = userdata[key]
if chromium_arg == "true":
chromium_arg = sb.chromium_arg # revert to default
sb.chromium_arg = chromium_arg
continue
# Handle: -D firefox-arg="ARG=N,ARG2" / firefox_arg="ARG=N,ARG2"
if low_key in ["firefox-arg", "firefox_arg"]:
firefox_arg = userdata[key]
if firefox_arg == "true":
firefox_arg = sb.firefox_arg # revert to default
sb.firefox_arg = firefox_arg
continue
# Handle: -D firefox-pref="PREF:VAL" / firefox_pref="PREF:VAL"
if low_key in ["firefox-pref", "firefox_pref"]:
firefox_pref = userdata[key]
if firefox_pref == "true":
firefox_pref = sb.firefox_pref # revert to default
sb.firefox_pref = firefox_pref
continue
# Handle: -D proxy=SERVER:PORT / proxy=USERNAME:PASSWORD@SERVER:PORT
if low_key == "proxy":
proxy_string = userdata[key]
if proxy_string == "true":
proxy_string = sb.proxy_string # revert to default
sb.proxy_string = proxy_string
continue
# Handle: -D proxy-bypass-list="DOMAIN1;D2" / proxy_bypass_list="D1;D2"
if low_key in ["proxy-bypass-list", "proxy_bypass_list"]:
proxy_bypass_list = userdata[key]
if proxy_bypass_list == "true":
proxy_bypass_list = sb.proxy_bypass_list # revert to default
sb.proxy_bypass_list = proxy_bypass_list
continue
# Handle: -D swiftshader
if low_key == "swiftshader":
sb.swiftshader = True
continue
# Handle: -D adblock / ad-block / ad_block / block-ads / block_ads
if low_key in [
"adblock", "ad-block", "ad_block", "block-ads", "block_ads"
]:
sb.ad_block_on = True
continue
# Handle: -D highlights=NUM
if low_key == "highlights":
highlights = userdata[key]
if highlights == "true":
highlights = sb.highlights # revert to default
sb.highlights = highlights
continue
# Handle: -D interval=SECONDS
if low_key == "interval":
interval = userdata[key]
if interval == "true":
interval = sb.interval # revert to default
sb.interval = interval
continue
# Handle: -D cap-file=FILE / cap_file=FILE
if low_key in ["cap-file", "cap_file"]:
cap_file = userdata[key]
if cap_file == "true":
cap_file = sb.cap_file # revert to default
sb.cap_file = cap_file
continue
# Handle: -D cap-string=STRING / cap_string=STRING
if low_key == "cap_string":
cap_string = userdata[key]
if cap_string == "true":
cap_string = sb.cap_string # revert to default
sb.cap_string = cap_string
continue
# Fail immediately if trying to set more than one default browser.
if len(browsers) > 1:
raise Exception(
"\nOnly ONE default browser is allowed!\n"
"%s browsers were selected: %s" % (len(browsers), browsers)
)
# Recorder Mode does not support headless browser runs.
# Chromium does not allow extensions in Headless Mode.
if sb.recorder_ext and sb.headless:
raise Exception(
"\n\n Recorder Mode does NOT support Headless Mode!"
'\n (DO NOT combine "-D rec" with "-D headless"!)\n'
)
# Recorder Mode only supports Chromium browsers.
if sb.recorder_ext and (sb.browser not in ["chrome", "edge"]):
raise Exception(
"\n\n Recorder Mode ONLY supports Chrome and Edge!"
'\n (Your browser choice was: "%s")\n' % sb.browser
)
# The Xvfb virtual display server is for Linux OS Only.
if sb.xvfb and "linux" not in sys.platform:
sb.xvfb = False
if (
"linux" in sys.platform
and not sb.headed
and not sb.headless
and not sb.xvfb
):
print(
'(Linux uses "-D headless" by default. '
'To override, use "-D headed" / "-D gui". '
'For Xvfb mode instead, use "-D xvfb". '
'Or hide this info with "-D headless".)'
)
sb.headless = True
if not sb.headless:
sb.headed = True
if sb.servername != "localhost":
# Using Selenium Grid
# (Set -D server="127.0.0.1" for localhost Grid)
# If the port is "443", the protocol is "https"
if str(sb.port) == "443":
sb.protocol = "https"
if sb.window_size:
window_size = sb.window_size
if window_size.count(",") != 1:
message = (
'\n\n window_size expects a "width,height" string!'
'\n (Your input was: "%s")\n' % window_size
)
raise Exception(message)
window_size = window_size.replace(" ", "")
width = None
height = None
try:
width = int(window_size.split(",")[0])
height = int(window_size.split(",")[1])
except Exception:
message = (
'\n\n Expecting integer values for "width,height"!'
'\n (window_size input was: "%s")\n' % window_size
)
raise Exception(message)
settings.CHROME_START_WIDTH = width
settings.CHROME_START_HEIGHT = height
settings.HEADLESS_START_WIDTH = width
settings.HEADLESS_START_HEIGHT = height
# Set sb_config
sb_config.browser = sb.browser
sb_config.headless = sb.headless
sb_config.headed = sb.headed
sb_config.window_size = sb.window_size
sb_config.maximize_option = sb.maximize_option
sb_config.xvfb = sb.xvfb
sb_config.save_screenshot = sb.save_screenshot_after_test
sb_config._has_logs = False
sb_config.variables = sb.variables
sb_config.dashboard = sb.dashboard
sb_config.dash_title = sb.dash_title
sb_config.pdb_option = sb.pdb_option
sb_config.rec_behave = sb.rec_behave
sb_config.record_sleep = sb.record_sleep
sb_config._is_timeout_changed = False
sb_config._SMALL_TIMEOUT = settings.SMALL_TIMEOUT
sb_config._LARGE_TIMEOUT = settings.LARGE_TIMEOUT
sb_config._recorded_actions = {}
sb_config._behave_recorded_actions = {}
# Dashboard-specific variables
sb_config._results = {} # SBase Dashboard test results
sb_config._duration = {} # SBase Dashboard test duration
sb_config._display_id = {} # SBase Dashboard display ID
sb_config._d_t_log_path = {} # SBase Dashboard test log path
sb_config._dash_html = None # SBase Dashboard HTML copy
sb_config._test_id = None # SBase Dashboard test id
sb_config._latest_display_id = None # The latest SBase display id
sb_config._dashboard_initialized = False # Becomes True after init
sb_config._has_exception = False # This becomes True if any test fails
sb_config._multithreaded = False # This becomes True if multithreading
sb_config._only_unittest = True # If any test uses BaseCase, becomes False
sb_config._sbase_detected = False # Becomes True during SeleniumBase tests
sb_config._extra_dash_entries = [] # Dashboard entries for non-SBase tests
sb_config._using_html_report = False # Becomes True when using html report
sb_config._dash_is_html_report = False # Dashboard becomes the html report
sb_config._saved_dashboard_pie = None # Copy of pie chart for html report
sb_config._dash_final_summary = None # Dash status to add to html report
sb_config._html_report_name = None # The name of the pytest html report
if sb_config.dash_title:
constants.Dashboard.TITLE = sb_config.dash_title.replace("_", " ")
log_helper.log_folder_setup(sb.log_path, sb.archive_logs)
download_helper.reset_downloads_folder()
proxy_helper.remove_proxy_zip_if_present()
return sb
