def test_logs(tmp):
log = getLogger(__name__)
with Manager(tmp()) as manager:
log.info("Strange encoding \xe8 \xe9")
# Crafted problematic logRecord
try:
raise ValueError("[Mock] folder/\xeatre ou ne pas \xeatre.odt")
except ValueError as e:
log.exception("Oups!")
log.exception(repr(e))
log.exception(str(e))
log.exception(e)
# Test raw report (calling the Report class manually)
report = Report(manager)
report.generate()
path = report.get_path()
assert path.is_file()
assert path.suffix == ".zip"
# Test the report managed by the Manager
path_managed = manager.generate_report()
assert path_managed.is_file()
assert path_managed.suffix == ".zip"
def test_csv_generation(tmp):
session = Session(
uid=2,
remote_path="/default-domain/UserWorkspaces/Administrator/test_csv",
remote_ref="08716a45-7154-4c2a-939c-bb70a7a2805e",
status=TransferStatus.DONE,
uploaded_items=10,
total_items=10,
engine="f513f5b371cc11eb85d008002733076e",
created_on="2021-02-18 15:15:38",
completed_on="2021-02-18 15:15:39",
description="icons-svg (+9)",
planned_items=10,
)
with Manager(tmp()) as manager:
session_csv = SessionCsv(manager, session)
assert session_csv.output_file.name == "session_2021-02-18_15-15-39.csv"
assert session_csv.output_tmp.name == "session_2021-02-18_15-15-39.tmp"
session_csv.create_tmp()
assert session_csv.output_tmp.is_file()
assert not session_csv.output_file.is_file()
session_csv.store_data([{
"path":
"/default-domain/UserWorkspaces/Administrator/test_csv/toto.txt",
"properties": {
"dc:title": "Toto file"
},
"type": "File",
}])
assert not session_csv.output_tmp.is_file()
assert session_csv.output_file.is_file()
def test_logs():
log = get_logger(__name__)
folder = tempfile.mkdtemp(u'-nxdrive-tests')
Options.nxdrive_home = folder
manager = Manager()
try:
log.debug("Strange encoding \xe9")
log.debug(u"Unicode encoding \xe8")
# Crafted problematic logRecord
try:
raise ValueError(u'[tests] folder/\xeatre ou ne pas \xeatre.odt')
except ValueError as e:
log.exception('Oups!')
log.exception(repr(e))
log.exception(unicode(e)) # Works but not recommended
with pytest.raises(UnicodeEncodeError):
log.exception(str(e))
# Using the syntax below will raise the same UnicodeEncodeError
# but the logging module takes care of it and just prints out
# the exception without raising it. So I let it there FI.
# log.exception(e)
report = Report(manager, os.path.join(folder, 'report'))
report.generate()
finally:
manager.dispose_db()
Manager._singleton = None
def test_temporary_csv_cleanup(tmp, user_factory, nuxeo_url):
session = Session(
uid=2,
remote_path="/default-domain/UserWorkspaces/Administrator/test_csv",
remote_ref="08716a45-7154-4c2a-939c-bb70a7a2805e",
status=TransferStatus.DONE,
uploaded_items=10,
total_items=10,
engine="f513f5b371cc11eb85d008002733076e",
created_on="2021-02-18 15:15:38",
completed_on="2021-02-18 15:15:39",
description="icons-svg (+9)",
planned_items=10,
)
with Manager(tmp()) as manager:
session_csv = SessionCsv(manager, session)
session_csv.create_tmp()
assert session_csv.output_tmp.is_file()
assert not session_csv.output_file.is_file()
conf_folder = manager.home / "nuxeo-conf"
user = user_factory()
manager.bind_server(
conf_folder,
nuxeo_url,
user.uid,
password=user.properties["password"],
start_engine=False,
)
assert not session_csv.output_tmp.is_file()
def _make_manager(home: str = "", with_engine: bool = True):
manager = Manager(home or tmp())
# Force deletion behavior to real deletion for all tests
manager.dao.update_config("deletion_behavior", "delete_server")
manager.dao.store_bool("show_deletion_prompt", False)
request.addfinalizer(manager.close)
log.info(f"[FIXTURE] Created {manager}")
if with_engine:
conf_folder = manager.home / "nuxeo-conf"
user = user_factory()
manager.bind_server(conf_folder,
nuxeo_url,
user.uid,
user.password,
start_engine=False)
# Let the possibility to access user's attributes from the manager
manager.user_details = user
engine = None
for engine_ in manager.engines.values():
engine = engine_
return manager, engine
return manager
def test_cli_args(tmp):
url = "http://*****:*****@localhost:8899"
Options.set("proxy_server", url, setter="cli")
with Manager(tmp()) as manager:
proxy = manager.proxy
assert isinstance(proxy, ManualProxy)
assert proxy.url == url
settings = proxy.settings()
assert settings["http"] == settings["https"] == url
def _create_manager(self):
options = Mock()
options.debug = False
options.force_locale = None
options.log_level_file = None
options.proxy_server = None
options.update_site_url = None
options.beta_update_site_url = None
options.nxdrive_home = self.test_folder
manager = Manager(options)
return manager
def setUp(self):
self.folder = tempfile.mkdtemp(u'-nxdrive-tests')
from mock import Mock
options = Mock()
options.debug = False
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.nxdrive_home = self.folder
self.manager = Manager(options)
def test_bind_local_folder_on_config_folder(self):
Options.delay = TEST_DEFAULT_DELAY
Options.nxdrive_home = self.nxdrive_conf_folder
self.manager = Manager()
self.addCleanup(self.manager.unbind_all)
self.addCleanup(self.manager.dispose_all)
with self.assertRaises(FolderAlreadyUsed):
self.manager.bind_server(self.nxdrive_conf_folder,
self.nuxeo_url,
self.user,
self.password,
start_engine=False)
def test_bind_local_folder_on_config_folder(self):
options = Mock()
options.debug = False
options.delay = TEST_DEFAULT_DELAY
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.nxdrive_home = self.nxdrive_conf_folder
self.manager = Manager(options)
with self.assertRaises(FolderAlreadyUsed):
self.manager.bind_server(self.nxdrive_conf_folder,
self.nuxeo_url,
self.user,
self.password,
start_engine=False)
def test_cli_args():
url = "http://*****:*****@localhost:8899"
Options.set("proxy_server", url, setter="cli")
manager = Manager()
proxy = manager.proxy
assert proxy
assert isinstance(proxy, ManualProxy)
assert proxy.authenticated
assert proxy.scheme == "http"
assert proxy.host == "localhost"
assert proxy.port == 8899
assert proxy.username == "username"
assert proxy.password == "password"
settings = proxy.settings()
assert settings["http"] == settings["https"] == url
manager.stop()
manager.unbind_all()
manager.dispose_all()
Manager._singleton = None
def test_notifications(tmp):
from nxdrive.notification import Notification
notif = Notification("warning", flags=Notification.FLAG_DISCARDABLE)
notif2 = Notification("plop")
with Manager(tmp()) as manager:
dao = manager.dao
dao.insert_notification(notif)
dao.insert_notification(notif2)
assert len(dao.get_notifications()) == 2
dao.discard_notification(notif.uid)
assert len(dao.get_notifications(discarded=False)) == 1
assert len(dao.get_notifications()) == 2
dao.remove_notification(notif.uid)
assert len(dao.get_notifications()) == 1
dao.discard_notification(notif2.uid)
assert len(dao.get_notifications()) == 1
assert len(dao.get_notifications(discarded=True)) == 1
def test_autolock(tmp):
with Manager(tmp()) as manager:
dao = manager.dao
dao.lock_path("/test_1", 1, "doc_id_1")
dao.lock_path("/test_2", 2, "doc_id_2")
dao.lock_path("/test_3", 3, "doc_id_3")
# Verify that it does fail
dao.lock_path("/test_3", 4, "doc_id_4")
assert len(dao.get_locked_paths()) == 3
dao.unlock_path("/test")
assert len(dao.get_locked_paths()) == 3
dao.unlock_path("/test_1")
locks = dao.get_locks()
assert len(locks) == 2
assert locks[0].path == "/test_2"
assert locks[0].process == 2
assert locks[0].remote_id == "doc_id_2"
assert locks[1].path == "/test_3"
# Verify it has auto-update
assert locks[1].process == 4
assert locks[1].remote_id == "doc_id_4"
def test_logs():
log = getLogger(__name__)
folder = tempfile.mkdtemp("-nxdrive-tests")
Options.nxdrive_home = folder
manager = Manager()
try:
log.debug("Strange encoding \xe8 \xe9")
# Crafted problematic logRecord
try:
raise ValueError("[tests] folder/\xeatre ou ne pas \xeatre.odt")
except ValueError as e:
log.exception("Oups!")
log.exception(repr(e))
log.exception(str(e))
log.exception(e)
report = Report(manager, os.path.join(folder, "report"))
report.generate()
finally:
manager.dispose_db()
Manager._singleton = None
def get_manager(self, options):
from nxdrive.manager import Manager
return Manager(options)
def _append_user_attrs(self, number: int, register_roots: bool) -> None:
"""Create all stuff needed for one user. Ugly but useful."""
# Create all what we need
local_test_folder = self.tmpdir / str(number)
local_nxdrive_folder = local_test_folder / "drive"
local_nxdrive_folder.mkdir(parents=True)
nxdrive_conf_folder = local_test_folder / "conf"
nxdrive_conf_folder.mkdir()
manager = Manager(nxdrive_conf_folder)
user = getattr(self, f"user_{number}")
password = getattr(self, f"password_{number}")
engine = self.bind_engine(
number,
start_engine=False,
manager=manager,
user=user,
password=password,
folder=local_nxdrive_folder,
)
queue_manager = engine.queue_manager
sync_root_folder = local_nxdrive_folder / self.workspace_title
local_root_client = self.get_local_client(engine.local.base_folder)
local = self.get_local_client(sync_root_folder)
remote_document_client = DocRemote(
self.nuxeo_url,
getattr(self, f"user_{number}"),
f"nxdrive-test-device-{number}",
self.version,
password=getattr(self, f"password_{number}"),
base_folder=self.workspace,
upload_tmp_dir=self.upload_tmp_dir,
dao=engine.dao,
)
remote = RemoteBase(
self.nuxeo_url,
getattr(self, f"user_{number}"),
f"nxdrive-test-device-{number}",
self.version,
password=getattr(self, f"password_{number}"),
base_folder=self.workspace,
upload_tmp_dir=self.upload_tmp_dir,
dao=engine.dao,
)
if register_roots:
remote.register_as_root(self.workspace)
# Force deletion behavior to real deletion for all tests
manager.set_config("deletion_behavior", "delete_server")
manager.dao.store_bool("show_deletion_prompt", False)
# And now persist in attributes
setattr(self, f"manager_{number}", manager)
setattr(self, f"local_test_folder_{number}", local_test_folder)
setattr(self, f"local_nxdrive_folder_{number}", local_nxdrive_folder)
setattr(self, f"nxdrive_conf_folder_{number}", nxdrive_conf_folder)
setattr(self, f"queue_manager_{number}", queue_manager)
setattr(self, f"sync_root_folder_{number}", sync_root_folder)
setattr(self, f"local_root_client_{number}", local_root_client)
setattr(self, f"local_{number}", local)
setattr(self, f"remote_document_client_{number}",
remote_document_client)
setattr(self, f"remote_{number}", remote)
def _create_manager(self):
Options.nxdrive_home = self.test_folder
manager = Manager()
return manager
def setUpApp(self, server_profile=None):
# Check the Nuxeo server test environment
self.nuxeo_url = os.environ.get('NXDRIVE_TEST_NUXEO_URL')
self.admin_user = os.environ.get('NXDRIVE_TEST_USER')
self.password = os.environ.get('NXDRIVE_TEST_PASSWORD')
self.build_workspace = os.environ.get('WORKSPACE')
self.result = None
self.tearedDown = False
# Take default parameter if none has been set
if self.nuxeo_url is None:
self.nuxeo_url = "http://localhost:8080/nuxeo"
if self.admin_user is None:
self.admin_user = "******"
if self.password is None:
self.password = "******"
self.tmpdir = None
if self.build_workspace is not None:
self.tmpdir = os.path.join(self.build_workspace, "tmp")
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads',
dir=self.tmpdir)
if None in (self.nuxeo_url, self.admin_user, self.password):
raise unittest.SkipTest(
"No integration server configuration found in environment.")
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'drive-1',
dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'drive-2',
dir=self.tmpdir)
self.local_nxdrive_folder_1 = os.path.join(self.local_test_folder_1,
u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_1)
self.local_nxdrive_folder_2 = os.path.join(self.local_test_folder_2,
u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_2)
self.nxdrive_conf_folder_1 = os.path.join(self.local_test_folder_1,
u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_1)
self.nxdrive_conf_folder_2 = os.path.join(self.local_test_folder_2,
u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_2)
from mock import Mock
options = Mock()
options.debug = False
options.delay = TEST_DEFAULT_DELAY
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.autolock_interval = 30
options.nxdrive_home = self.nxdrive_conf_folder_1
self.manager_1 = Manager(options)
self.connected = False
import nxdrive
nxdrive_path = os.path.dirname(nxdrive.__file__)
i18n_path = os.path.join(nxdrive_path, 'tests', 'resources', "i18n.js")
Translator(self.manager_1, i18n_path)
options.nxdrive_home = self.nxdrive_conf_folder_2
Manager._singleton = None
self.manager_2 = Manager(options)
self.version = __version__
url = self.nuxeo_url
log.debug("Will use %s as url", url)
if '#' in url:
# Remove the engine type for the rest of the test
self.nuxeo_url = url.split('#')[0]
self.setUpServer(server_profile)
self.engine_1 = self.manager_1.bind_server(self.local_nxdrive_folder_1,
url,
self.user_1,
self.password_1,
start_engine=False)
self.engine_2 = self.manager_2.bind_server(self.local_nxdrive_folder_2,
url,
self.user_2,
self.password_2,
start_engine=False)
self.engine_1.syncCompleted.connect(self.app.sync_completed)
self.engine_1.get_remote_watcher().remoteScanFinished.connect(
self.app.remote_scan_completed)
self.engine_1.get_remote_watcher().changesFound.connect(
self.app.remote_changes_found)
self.engine_1.get_remote_watcher().noChangesFound.connect(
self.app.no_remote_changes_found)
self.engine_2.syncCompleted.connect(self.app.sync_completed)
self.engine_2.get_remote_watcher().remoteScanFinished.connect(
self.app.remote_scan_completed)
self.engine_2.get_remote_watcher().changesFound.connect(
self.app.remote_changes_found)
self.engine_2.get_remote_watcher().noChangesFound.connect(
self.app.no_remote_changes_found)
self.queue_manager_1 = self.engine_1.get_queue_manager()
self.queue_manager_2 = self.engine_2.get_queue_manager()
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title_1)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2,
self.workspace_title_2)
self.local_root_client_1 = self.engine_1.get_local_client()
self.local_root_client_2 = self.engine_2.get_local_client()
self.local_client_1 = self.get_local_client(
os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
self.local_client_2 = self.get_local_client(
os.path.join(self.local_nxdrive_folder_2, self.workspace_title))
# Document client to be used to create remote test documents
# and folders
remote_document_client_1 = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
base_folder=self.workspace_1,
upload_tmp_dir=self.upload_tmp_dir)
remote_document_client_2 = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
base_folder=self.workspace_2,
upload_tmp_dir=self.upload_tmp_dir)
# File system client to be used to create remote test documents
# and folders
remote_file_system_client_1 = RemoteFileSystemClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
remote_file_system_client_2 = RemoteFileSystemClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
self.remote_restapi_client_1 = RestAPIClient(self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1)
self.remote_restapi_client_2 = RestAPIClient(self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2)
self.remote_restapi_client_admin = RestAPIClient(
self.nuxeo_url,
self.admin_user,
u'nxdrive-test-device-2',
self.version,
password=self.password)
# Register root
remote_document_client_1.register_as_root(self.workspace_1)
remote_document_client_2.register_as_root(self.workspace_2)
self.remote_document_client_1 = remote_document_client_1
self.remote_document_client_2 = remote_document_client_2
self.remote_file_system_client_1 = remote_file_system_client_1
self.remote_file_system_client_2 = remote_file_system_client_2
self._wait_sync = {
self.engine_1.get_uid(): True,
self.engine_2.get_uid(): True
}
self._wait_remote_scan = {
self.engine_1.get_uid(): True,
self.engine_2.get_uid(): True
}
self._remote_changes_count = {
self.engine_1.get_uid(): 0,
self.engine_2.get_uid(): 0
}
self._no_remote_changes = {
self.engine_1.get_uid(): False,
self.engine_2.get_uid(): False
}
def get_manager(self):
from nxdrive.manager import Manager
return Manager()
def get_manager(self, options):
from nxdrive.manager import Manager
setattr(options, 'version', __version__)
return Manager(options)
def setUpApp(self, server_profile=None, register_roots=True):
if Manager._singleton:
Manager._singleton = None
# Save the current path for test files
self.location = dirname(__file__)
# Install callback early to be called the last
self.addCleanup(self._check_cleanup)
# Check the Nuxeo server test environment
self.nuxeo_url = os.environ.get('NXDRIVE_TEST_NUXEO_URL',
'http://localhost:8080/nuxeo')
self.admin_user = os.environ.get('NXDRIVE_TEST_USER', 'Administrator')
self.password = os.environ.get('NXDRIVE_TEST_PASSWORD',
'Administrator')
self.report_path = os.environ.get('REPORT_PATH')
self.tearedDown = False
self.tmpdir = os.path.join(os.environ.get('WORKSPACE', ''), 'tmp')
self.addCleanup(clean_dir, self.tmpdir)
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads',
dir=self.tmpdir)
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'drive-1',
dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'drive-2',
dir=self.tmpdir)
# Correct the casing of the temp folders for windows
if sys.platform == 'win32':
import win32api
self.local_test_folder_1 = win32api.GetLongPathNameW(
self.local_test_folder_1)
self.local_test_folder_2 = win32api.GetLongPathNameW(
self.local_test_folder_2)
self.local_nxdrive_folder_1 = os.path.join(self.local_test_folder_1,
u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_1)
self.local_nxdrive_folder_2 = os.path.join(self.local_test_folder_2,
u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_2)
self.nxdrive_conf_folder_1 = os.path.join(self.local_test_folder_1,
u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_1)
self.nxdrive_conf_folder_2 = os.path.join(self.local_test_folder_2,
u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_2)
Options.delay = TEST_DEFAULT_DELAY
# Options.autolock_interval = 30
Options.nxdrive_home = self.nxdrive_conf_folder_1
self.manager_1 = Manager()
self.connected = False
i18n_path = self.location + '/resources/i18n.js'
Translator(self.manager_1, i18n_path)
Options.nxdrive_home = self.nxdrive_conf_folder_2
Manager._singleton = None
self.manager_2 = Manager()
self.version = __version__
url = self.nuxeo_url
log.debug("Will use %s as url", url)
if '#' in url:
# Remove the engine type for the rest of the test
self.nuxeo_url = url.split('#')[0]
self.setUpServer(server_profile)
self.addCleanup(self.tearDownServer, server_profile)
self.addCleanup(self._stop_managers)
self._wait_sync = {}
self._wait_remote_scan = {}
self._remote_changes_count = {}
self._no_remote_changes = {}
# Set engine_1 and engine_2 attributes
self.bind_engine(1, start_engine=False)
self.queue_manager_1 = self.engine_1.get_queue_manager()
self.bind_engine(2, start_engine=False)
self.queue_manager_2 = self.engine_2.get_queue_manager()
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title_1)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2,
self.workspace_title_2)
self.local_root_client_1 = self.engine_1.get_local_client()
self.local_root_client_2 = self.engine_2.get_local_client()
self.local_client_1 = self.get_local_client(self.sync_root_folder_1)
self.local_client_2 = self.get_local_client(self.sync_root_folder_2)
# Document client to be used to create remote test documents
# and folders
self.remote_document_client_1 = RemoteDocumentClientForTests(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
base_folder=self.workspace_1,
upload_tmp_dir=self.upload_tmp_dir)
self.remote_document_client_2 = RemoteDocumentClientForTests(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
base_folder=self.workspace_2,
upload_tmp_dir=self.upload_tmp_dir)
# File system client to be used to create remote test documents
# and folders
self.remote_file_system_client_1 = RemoteFileSystemClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
self.remote_file_system_client_2 = RemoteFileSystemClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
self.remote_restapi_client_admin = RestAPIClient(
self.nuxeo_url,
self.admin_user,
u'nxdrive-test-device-2',
self.version,
password=self.password)
# Register sync roots
if register_roots:
self.remote_document_client_1.register_as_root(self.workspace_1)
self.addCleanup(self._unregister, self.workspace_1)
self.remote_document_client_2.register_as_root(self.workspace_2)
self.addCleanup(self._unregister, self.workspace_2)
def setUpApp(self, server_profile=None, register_roots=True):
if Manager._singleton:
Manager._singleton = None
# Install callback early to be called the last
self.addCleanup(self._check_cleanup)
self.report_path = os.environ.get("REPORT_PATH")
self.tmpdir = os.path.join(os.environ.get("WORKSPACE", ""), "tmp")
self.addCleanup(clean_dir, self.tmpdir)
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.upload_tmp_dir = tempfile.mkdtemp("-nxdrive-uploads",
dir=self.tmpdir)
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp("drive-1", dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp("drive-2", dir=self.tmpdir)
# Correct the casing of the temp folders for windows
if WINDOWS:
import win32api
self.local_test_folder_1 = win32api.GetLongPathNameW(
self.local_test_folder_1)
self.local_test_folder_2 = win32api.GetLongPathNameW(
self.local_test_folder_2)
self.local_nxdrive_folder_1 = os.path.join(self.local_test_folder_1,
"Nuxeo Drive")
os.mkdir(self.local_nxdrive_folder_1)
self.local_nxdrive_folder_2 = os.path.join(self.local_test_folder_2,
"Nuxeo Drive")
os.mkdir(self.local_nxdrive_folder_2)
self.nxdrive_conf_folder_1 = os.path.join(self.local_test_folder_1,
"nuxeo-drive-conf")
os.mkdir(self.nxdrive_conf_folder_1)
self.nxdrive_conf_folder_2 = os.path.join(self.local_test_folder_2,
"nuxeo-drive-conf")
os.mkdir(self.nxdrive_conf_folder_2)
Options.delay = TEST_DEFAULT_DELAY
Options.nxdrive_home = self.nxdrive_conf_folder_1
self.manager_1 = Manager()
self.connected = False
i18n_path = self.location + "/resources/i18n"
Translator(self.manager_1, i18n_path)
Options.nxdrive_home = self.nxdrive_conf_folder_2
Manager._singleton = None
self.manager_2 = Manager()
self.setUpServer(server_profile)
self.addCleanup(self.tearDownServer, server_profile)
self.addCleanup(self._stop_managers)
self.addCleanup(self.generate_report)
self._wait_sync = {}
self._wait_remote_scan = {}
self._remote_changes_count = {}
self._no_remote_changes = {}
# Set engine_1 and engine_2 attributes
self.bind_engine(1, start_engine=False)
self.queue_manager_1 = self.engine_1.get_queue_manager()
self.bind_engine(2, start_engine=False)
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title_1)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2,
self.workspace_title_2)
self.local_root_client_1 = self.engine_1.local
self.local_1 = self.get_local_client(self.sync_root_folder_1)
self.local_2 = self.get_local_client(self.sync_root_folder_2)
# Document client to be used to create remote test documents
# and folders
self.remote_document_client_1 = DocRemote(
pytest.nuxeo_url,
self.user_1,
"nxdrive-test-device-1",
pytest.version,
password=self.password_1,
base_folder=self.workspace_1,
upload_tmp_dir=self.upload_tmp_dir,
)
self.remote_document_client_2 = DocRemote(
pytest.nuxeo_url,
self.user_2,
"nxdrive-test-device-2",
pytest.version,
password=self.password_2,
base_folder=self.workspace_2,
upload_tmp_dir=self.upload_tmp_dir,
)
# File system client to be used to create remote test documents
# and folders
self.remote_1 = RemoteBase(
pytest.nuxeo_url,
self.user_1,
"nxdrive-test-device-1",
pytest.version,
password=self.password_1,
base_folder=self.workspace_1,
upload_tmp_dir=self.upload_tmp_dir,
)
self.remote_2 = RemoteBase(
pytest.nuxeo_url,
self.user_2,
"nxdrive-test-device-2",
pytest.version,
password=self.password_2,
base_folder=self.workspace_2,
upload_tmp_dir=self.upload_tmp_dir,
)
# Register sync roots
if register_roots:
self.remote_1.register_as_root(self.workspace_1)
self.addCleanup(self._unregister, self.workspace_1)
self.remote_2.register_as_root(self.workspace_2)
self.addCleanup(self._unregister, self.workspace_2)
