25264717828

Committed 02 May 2026 11:36PM UTC coverage: 86.618% (+0.1%) from 86.52%

Build # 25264717828

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1383 from fiduswriter/feature/e2ee

Add E2E Encryption mode

Coverage Stats

8764 of 10118 relevant lines covered (86.62%)

5.27 hits per line

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

91.73

fiduswriter/testing/selenium_helper.py

import re
import os
import time
from urllib3.exceptions import MaxRetryError, ReadTimeoutError
from selenium.common.exceptions import (
    ElementClickInterceptedException,
    TimeoutException,
    WebDriverException,
)
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
from django.contrib.contenttypes.models import ContentType
import logging

logger = logging.getLogger(__name__)


class SeleniumHelper:
    """
    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(f"{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("{}{}".format(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)

    def click_new_document_button(self, driver):
        """Click the new document button and handle the encryption choice dialog if present."""
        WebDriverWait(driver, self.wait_time).until(
            EC.element_to_be_clickable(
                (By.CSS_SELECTOR, ".new_document button")
            )
        ).click()
        try:
            WebDriverWait(driver, 2).until(
                EC.presence_of_element_located((By.CSS_SELECTOR, ".ui-dialog"))
            )
            driver.find_element(By.CSS_SELECTOR, ".ui-dialog .fw-dark").click()
        except TimeoutException:
            pass

    @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")
        options.add_argument("--window-size=1920,1080")
        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(f"user-agent={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 = 10
        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 setUp(self):
        # Clear ContentType cache during testing to prevent FK constraint errors
        # Content types get new IDs after each test but cached values don't update
        ContentType.objects.clear_cache()
        self.addCleanup(ContentType.objects.clear_cache)
        return super().setUp()

    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;}"
                # Suppress any 'Leave site?' beforeunload dialog so that
                # driver.get() below cannot be blocked by it.
                "window.onbeforeunload = null;"
            )
            driver.get("data:,")
        except (MaxRetryError, ReadTimeoutError, WebDriverException):
            pass

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

fiduswriter / fiduswriter / 25264717828

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