14446284799

Committed 14 Apr 2025 12:58PM UTC coverage: 91.3% (-0.1%) from 91.404%

Build # 14446284799

Build Type

push

github

Committed by

johanneswilm

Commit Message

4.0.9

Run Details

6118 of 6701 relevant lines covered (91.3%)

4.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.3

fiduswriter/testing/selenium_helper.py

from builtins import object
import re
import os
import time
from urllib3.exceptions import MaxRetryError
from selenium.common.exceptions import ElementClickInterceptedException
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromiumService
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.core.os_manager import ChromeType

from allauth.account.models import EmailAddress
from django.contrib.auth.hashers import make_password
from django.contrib.auth import get_user_model
from django.conf import settings
from django.test import Client
import logging

logger = logging.getLogger(__name__)


class SeleniumHelper(object):
    """
    Methods for manipulating django and the browser for testing purposes.
    """

    login_page = "/"

    def find_urls(self, string):
        return re.findall(
            (
                "http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*(),]|"
                "(?:%[0-9a-fA-F][0-9a-fA-F]))+"
            ),
            string,
        )

    # create django data
    def create_user(
        self, username="User", email="test@example.com", passtext="p4ssw0rd"
    ):
        User = get_user_model()
        user = User.objects.create(
            username=username,
            email=email,
            password=make_password(passtext),
            is_active=True,
        )
        user.save()

        # avoid the unverified-email login trap
        EmailAddress.objects.create(
            user=user, email=email, verified=True, primary=True
        ).save()

        return user

    # drive browser
    def login_user(self, user, driver, client):
        client.force_login(user=user)
        cookie = client.cookies[settings.SESSION_COOKIE_NAME]
        # output the cookie to the console for debugging
        logger.debug("cookie: %s" % cookie.value)
        if driver.current_url == "data:,":
            # To set the cookie at the right domain we load the front page.
            driver.get("%s%s" % (self.live_server_url, self.login_page))
            WebDriverWait(driver, self.wait_time).until(
                EC.presence_of_element_located((By.ID, "id-login"))
            )
        driver.add_cookie(
            {
                "name": settings.SESSION_COOKIE_NAME,
                "value": cookie.value,
                "secure": False,
                "path": "/",
            }
        )

    def login_user_manually(self, user, driver, passtext="p4ssw0rd"):
        username = user.username
        driver.delete_cookie(settings.SESSION_COOKIE_NAME)
        driver.get("%s%s" % (self.live_server_url, "/"))
        driver.find_element(By.ID, "id-login").send_keys(username)
        driver.find_element(By.ID, "id-password").send_keys(passtext)
        driver.find_element(By.ID, "login-submit").click()
        # Wait until there is an element with the ID user-preferences
        # which is only present on the dashboard.
        WebDriverWait(driver, self.wait_time).until(
            EC.presence_of_element_located((By.ID, "user-preferences"))
        )

    def logout_user(self, driver, client):
        client.logout()
        driver.delete_cookie(settings.SESSION_COOKIE_NAME)

    def wait_until_file_exists(self, path, wait_time):
        count = 0
        while not os.path.exists(path):
            time.sleep(1)
            count += 1
            if count > wait_time:
                break

    def retry_click(self, driver, selector, retries=5):
        count = 0
        while count < retries:
            try:
                WebDriverWait(driver, self.wait_time).until(
                    EC.element_to_be_clickable(selector)
                ).click()
                break
            except ElementClickInterceptedException:
                count += 1
                time.sleep(1)

    @classmethod
    def get_drivers(cls, number, download_dir=False, user_agent=False):
        # django native clients, to be used for faster login.
        clients = []
        for i in range(number):
            clients.append(Client())
        drivers = []
        wait_time = 0
        options = webdriver.ChromeOptions()
        options.add_argument("--kiosk-printing")
        options.add_argument("--safebrowsing-disable-download-protection")
        options.add_argument("--safebrowsing-disable-extension-blacklist")
        prefs = {
            "profile.password_manager_leak_detection": False,
        }
        if download_dir:
            prefs["download.default_directory"] = download_dir
            prefs["download.prompt_for_download"] = False
            prefs["download.directory_upgrade"] = True
        options.add_experimental_option("prefs", prefs)
        if user_agent:
            options.add_argument("user-agent={}".format(user_agent))
        if os.getenv("CI"):
            options.binary_location = "/usr/bin/google-chrome-stable"
            if os.getenv("DEBUG_MODE") != "1":
                options.add_argument("--headless=new")
            options.add_argument("--disable-gpu")
            wait_time = 20
        else:
            wait_time = 6
        for i in range(number):
            driver_env = os.environ.copy()
            if os.getenv("CI") and os.getenv("DEBUG_MODE") == "1" and i < 2:
                driver_env["DISPLAY"] = f":{99 - i}"
            driver = webdriver.Chrome(
                service=ChromiumService(
                    ChromeDriverManager(
                        chrome_type=ChromeType.GOOGLE
                    ).install(),
                    env=driver_env,
                ),
                options=options,
            )
            # Set sizes of browsers so that all buttons are visible.
            driver.set_window_position(0, 0)
            driver.set_window_size(1920, 1080)
            drivers.append(driver)
        cls.drivers = drivers
        return {"clients": clients, "drivers": drivers, "wait_time": wait_time}

    def tearDown(self):
        # Source: https://stackoverflow.com/a/39606065
        result = self._outcome.result
        ok = all(
            test != self for test, text in result.errors + result.failures
        )
        if ok:
            for driver in self.drivers:
                self.leave_site(driver)
        else:
            if not os.path.exists("screenshots"):
                os.makedirs("screenshots")
            for id, driver in enumerate(self.drivers, start=1):
                screenshotfile = (
                    f"screenshots/driver{id}-{self._testMethodName}.png"
                )
                logger.info(f"Saving {screenshotfile}")
                driver.save_screenshot(screenshotfile)
                self.leave_site(driver)
        return super().tearDown()

    def leave_site(self, driver):
        try:
            driver.execute_script(
                "if (window.theApp) {window.theApp.page = null;}"
            )
            driver.get("data:,")
        except MaxRetryError:
            pass

1	from builtins import object	13✔
2	import re	13✔
3	import os	13✔
4	import time	13✔
5	from urllib3.exceptions import MaxRetryError	13✔
6	from selenium.common.exceptions import ElementClickInterceptedException	13✔
7	from selenium.webdriver.support.wait import WebDriverWait	13✔
8	from selenium.webdriver.support import expected_conditions as EC	13✔
9	from selenium.webdriver.common.by import By	13✔
10	from selenium import webdriver	13✔
11	from selenium.webdriver.chrome.service import Service as ChromiumService	13✔
12	from webdriver_manager.chrome import ChromeDriverManager	13✔
13	from webdriver_manager.core.os_manager import ChromeType	13✔
14
15	from allauth.account.models import EmailAddress	13✔
16	from django.contrib.auth.hashers import make_password	13✔
17	from django.contrib.auth import get_user_model	13✔
18	from django.conf import settings	13✔
19	from django.test import Client	13✔
20	import logging	13✔
21
22	logger = logging.getLogger(__name__)	13✔
23
24
25	class SeleniumHelper(object):	13✔
26	"""
27	Methods for manipulating django and the browser for testing purposes.
28	"""
29
30	login_page = "/"	13✔
31
32	def find_urls(self, string):	13✔
33	return re.findall(	2✔
34	(
35	"http[s]?://(?:[a-zA-Z]\|[0-9]\|[$-_@.&+]\|[!*(),]\|"
36	"(?:%[0-9a-fA-F][0-9a-fA-F]))+"
37	),
38	string,
39	)
40
41	# create django data
42	def create_user(	13✔
43	self, username="User", email="test@example.com", passtext="p4ssw0rd"
44	):
45	User = get_user_model()	13✔
46	user = User.objects.create(	13✔
47	username=username,
48	email=email,
49	password=make_password(passtext),
50	is_active=True,
51	)
52	user.save()	13✔
53
54	# avoid the unverified-email login trap
55	EmailAddress.objects.create(	13✔
56	user=user, email=email, verified=True, primary=True
57	).save()
58
59	return user	13✔
60
61	# drive browser
62	def login_user(self, user, driver, client):	13✔
63	client.force_login(user=user)	8✔
64	cookie = client.cookies[settings.SESSION_COOKIE_NAME]	8✔
65	# output the cookie to the console for debugging
66	logger.debug("cookie: %s" % cookie.value)	8✔
67	if driver.current_url == "data:,":	8✔
68	# To set the cookie at the right domain we load the front page.
69	driver.get("%s%s" % (self.live_server_url, self.login_page))	8✔
70	WebDriverWait(driver, self.wait_time).until(	8✔
71	EC.presence_of_element_located((By.ID, "id-login"))
72	)
73	driver.add_cookie(	8✔
74	{
75	"name": settings.SESSION_COOKIE_NAME,
76	"value": cookie.value,
77	"secure": False,
78	"path": "/",
79	}
80	)
81
82	def login_user_manually(self, user, driver, passtext="p4ssw0rd"):	13✔
83	username = user.username	×
84	driver.delete_cookie(settings.SESSION_COOKIE_NAME)	×
85	driver.get("%s%s" % (self.live_server_url, "/"))	×
86	driver.find_element(By.ID, "id-login").send_keys(username)	×
87	driver.find_element(By.ID, "id-password").send_keys(passtext)	×
88	driver.find_element(By.ID, "login-submit").click()	×
89	# Wait until there is an element with the ID user-preferences
90	# which is only present on the dashboard.
91	WebDriverWait(driver, self.wait_time).until(	×
92	EC.presence_of_element_located((By.ID, "user-preferences"))
93	)
94
95	def logout_user(self, driver, client):	13✔
96	client.logout()	×
97	driver.delete_cookie(settings.SESSION_COOKIE_NAME)	×
98
99	def wait_until_file_exists(self, path, wait_time):	13✔
100	count = 0	4✔
101	while not os.path.exists(path):	4✔
102	time.sleep(1)	4✔
103	count += 1	4✔
104	if count > wait_time:	4✔
105	break	×
106
107	def retry_click(self, driver, selector, retries=5):	13✔
108	count = 0	1✔
109	while count < retries:	1✔
110	try:	1✔
111	WebDriverWait(driver, self.wait_time).until(	1✔
112	EC.element_to_be_clickable(selector)
113	).click()
114	break	1✔
115	except ElementClickInterceptedException:	1✔
116	count += 1	1✔
117	time.sleep(1)	1✔
118
119	@classmethod	13✔
120	def get_drivers(cls, number, download_dir=False, user_agent=False):	13✔
121	# django native clients, to be used for faster login.
122	clients = []	13✔
123	for i in range(number):	13✔
124	clients.append(Client())	13✔
125	drivers = []	13✔
126	wait_time = 0	13✔
127	options = webdriver.ChromeOptions()	13✔
128	options.add_argument("--kiosk-printing")	13✔
129	options.add_argument("--safebrowsing-disable-download-protection")	13✔
130	options.add_argument("--safebrowsing-disable-extension-blacklist")	13✔
131	prefs = {	13✔
132	"profile.password_manager_leak_detection": False,
133	}
134	if download_dir:	13✔
135	prefs["download.default_directory"] = download_dir	5✔
136	prefs["download.prompt_for_download"] = False	5✔
137	prefs["download.directory_upgrade"] = True	5✔
138	options.add_experimental_option("prefs", prefs)	13✔
139	if user_agent:	13✔
140	options.add_argument("user-agent={}".format(user_agent))	1✔
141	if os.getenv("CI"):	13✔
142	options.binary_location = "/usr/bin/google-chrome-stable"	13✔
143	if os.getenv("DEBUG_MODE") != "1":	13✔
144	options.add_argument("--headless=new")	13✔
145	options.add_argument("--disable-gpu")	13✔
146	wait_time = 20	13✔
147	else:
148	wait_time = 6	×
149	for i in range(number):	13✔
150	driver_env = os.environ.copy()	13✔
151	if os.getenv("CI") and os.getenv("DEBUG_MODE") == "1" and i < 2:	13✔
152	driver_env["DISPLAY"] = f":{99 - i}"	×
153	driver = webdriver.Chrome(	13✔
154	service=ChromiumService(
155	ChromeDriverManager(
156	chrome_type=ChromeType.GOOGLE
157	).install(),
158	env=driver_env,
159	),
160	options=options,
161	)
162	# Set sizes of browsers so that all buttons are visible.
163	driver.set_window_position(0, 0)	13✔
164	driver.set_window_size(1920, 1080)	13✔
165	drivers.append(driver)	13✔
166	cls.drivers = drivers	13✔
167	return {"clients": clients, "drivers": drivers, "wait_time": wait_time}	13✔
168
169	def tearDown(self):	13✔
170	# Source: https://stackoverflow.com/a/39606065
171	result = self._outcome.result	13✔
172	ok = all(	13✔
173	test != self for test, text in result.errors + result.failures
174	)
175	if ok:	13✔
176	for driver in self.drivers:	13✔
177	self.leave_site(driver)	13✔
178	else:
179	if not os.path.exists("screenshots"):	×
180	os.makedirs("screenshots")	×
181	for id, driver in enumerate(self.drivers, start=1):	×
182	screenshotfile = (	×
183	f"screenshots/driver{id}-{self._testMethodName}.png"
184	)
185	logger.info(f"Saving {screenshotfile}")	×
186	driver.save_screenshot(screenshotfile)	×
187	self.leave_site(driver)	×
188	return super().tearDown()	13✔
189
190	def leave_site(self, driver):	13✔
191	try:	13✔
192	driver.execute_script(	13✔
193	"if (window.theApp) {window.theApp.page = null;}"
194	)
195	driver.get("data:,")	13✔
196	except MaxRetryError:	1✔
197	pass	1✔

fiduswriter / fiduswriter / 14446284799

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous