1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
import os
from datetime import datetime as dt
import pytest
from peewee import SqliteDatabase
import vorta
import vorta.application
import vorta.borg.jobs_manager
from vorta.store.models import (
ArchiveModel,
BackupProfileModel,
EventLogModel,
RepoModel,
RepoPassword,
SchemaVersion,
SettingsModel,
SourceFileModel,
WifiSettingModel,
)
from vorta.views.main_window import ArchiveTab, MainWindow
models = [
RepoModel,
RepoPassword,
BackupProfileModel,
SourceFileModel,
SettingsModel,
ArchiveModel,
WifiSettingModel,
EventLogModel,
SchemaVersion,
]
def load_window(qapp: vorta.application.VortaApp):
"""
Reload the main window of the given application
Used to repopulate fields after loading mock data
"""
qapp.main_window.deleteLater()
del qapp.main_window
qapp.main_window = MainWindow(qapp)
@pytest.fixture
def window_load(qapp):
"""
A function to call to load fixture data into the app window.
This is normally done by init_db, but if this fixture is used,
the window load will be skipped to allow the test to load
further data before then calling the returned function
"""
return lambda: load_window(qapp)
@pytest.fixture(scope='function', autouse=True)
def init_db(qapp, qtbot, tmpdir_factory, request):
tmp_db = tmpdir_factory.mktemp('Vorta').join('settings.sqlite')
mock_db = SqliteDatabase(
str(tmp_db),
pragmas={
'journal_mode': 'wal',
},
)
vorta.store.connection.init_db(mock_db)
# Force use of DB keyring instead of system keyring to avoid keychain prompts during tests
keyring_setting = SettingsModel.get(key='use_system_keyring')
keyring_setting.value = False
keyring_setting.save()
default_profile = BackupProfileModel(name='Default')
default_profile.save()
new_repo = RepoModel(url='i0fi93@i593.repo.borgbase.com:repo')
new_repo.encryption = 'none'
new_repo.save()
default_profile.repo = new_repo.id
default_profile.dont_run_on_metered_networks = False
default_profile.validation_on = False
default_profile.save()
test_archive = ArchiveModel(snapshot_id='99999', name='test-archive', time=dt(2000, 1, 1, 0, 0), repo=1)
test_archive.save()
test_archive1 = ArchiveModel(snapshot_id='99998', name='test-archive1', time=dt(2000, 1, 1, 0, 0), repo=1)
test_archive1.save()
source_dir = SourceFileModel(dir='/tmp/another', repo=new_repo, dir_size=100, dir_files_count=18, path_isdir=True)
source_dir.save()
# Disconnect signals before destroying main_window to avoid "deleted object" errors
try:
qapp.scheduler.schedule_changed.disconnect()
except TypeError:
pass
# Reload the window to apply the mock data
# If this test has the `window_load` fixture,
# it is responsible for calling this instead
if 'window_load' not in request.fixturenames:
load_window(qapp)
yield
qapp.jobs_manager.cancel_all_jobs()
qapp.backup_finished_event.disconnect()
qapp.scheduler.schedule_changed.disconnect()
qtbot.waitUntil(lambda: not qapp.jobs_manager.is_worker_running(), **pytest._wait_defaults)
mock_db.close()
@pytest.fixture
def choose_file_dialog(*args):
class MockFileDialog:
def __init__(self, *args, **kwargs):
pass
def open(self, func):
func()
def selectedFiles(self):
return ['/tmp']
return MockFileDialog
@pytest.fixture
def borg_json_output():
def _read_json(subcommand):
stdout = open(f'tests/unit/borg_json_output/{subcommand}_stdout.json')
stderr = open(f'tests/unit/borg_json_output/{subcommand}_stderr.json')
return stdout, stderr
return _read_json
@pytest.fixture
def rootdir():
return os.path.dirname(os.path.abspath(__file__))
@pytest.fixture()
def archive_env(qapp, qtbot):
"""
Common setup for unit tests involving the archive tab.
"""
main: MainWindow = qapp.main_window
tab: ArchiveTab = main.archiveTab
main.tabWidget.setCurrentIndex(3)
tab.populate_from_profile()
qtbot.waitUntil(lambda: tab.archiveTable.rowCount() == 2, **pytest._wait_defaults)
return main, tab
|
