def setUpServer(self, server_profile=None):
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
self.root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Activate given profile if needed, eg. permission hierarchy
if server_profile is not None:
self.root_remote_client.activate_profile(server_profile)
# Call the Nuxeo operation to setup the integration test environment
credentials = self.root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = self.root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
self.workspace_1 = self.workspace
self.workspace_2 = self.workspace
self.workspace_title_1 = self.workspace_title
self.workspace_title_2 = self.workspace_title
def test_local_rename_sync_root_folder(self):
if sys.platform.startswith('linux'):
raise SkipTest("WIP in https://jira.nuxeo.com/browse/NXDRIVE-170")
# Use the Administrator to be able to introspect the container of the
# test workspace.
remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=self.workspace)
folder_1_uid = remote_client.get_info(u'/Original Folder 1').uid
# Create new clients to be able to introspect the test sync root
toplevel_local_client = LocalClient(self.local_nxdrive_folder_1)
toplevel_local_client.rename('/' + self.workspace_title,
'Renamed Nuxeo Drive Test Workspace')
self.wait_sync()
workspace_info = remote_client.get_info(self.workspace)
self.assertEquals(workspace_info.name,
u"Renamed Nuxeo Drive Test Workspace")
folder_1_info = remote_client.get_info(folder_1_uid)
self.assertEquals(folder_1_info.name, u"Original Folder 1")
self.assertEquals(folder_1_info.parent_uid, self.workspace)
def test_local_rename_sync_root_folder(self):
sb, ctl = self.sb_1, self.controller_1
# Use the Administrator to be able to introspect the container of the
# test workspace.
remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
'nxdrive-test-administrator-device',
self.password, base_folder=self.workspace)
folder_1_uid = remote_client.get_info(u'/Original Folder 1').uid
# Create new clients to be able to introspect the test sync root
toplevel_local_client = LocalClient(self.local_nxdrive_folder_1)
toplevel_local_client.rename('/' + self.workspace_title,
'Renamed Nuxeo Drive Test Workspace')
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 1)
workspace_info = remote_client.get_info(self.workspace)
self.assertEquals(workspace_info.name,
u"Renamed Nuxeo Drive Test Workspace")
folder_1_info = remote_client.get_info(folder_1_uid)
self.assertEquals(folder_1_info.name, u"Original Folder 1")
self.assertEquals(folder_1_info.parent_uid, self.workspace)
# TODO: implement me once canDelete is checked in the synchronizer
# def test_local_move_sync_root_folder(self):
# pass
def test_local_rename_sync_root_folder(self):
sb, ctl = self.sb_1, self.controller_1
# Use the Administrator to be able to introspect the container of the
# test workspace.
remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.admin_user,
'nxdrive-test-administrator-device',
self.version,
password=self.password,
base_folder=self.workspace)
folder_1_uid = remote_client.get_info(u'/Original Folder 1').uid
# Create new clients to be able to introspect the test sync root
toplevel_local_client = LocalClient(self.local_nxdrive_folder_1)
toplevel_local_client.rename('/' + self.workspace_title,
'Renamed Nuxeo Drive Test Workspace')
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 1)
workspace_info = remote_client.get_info(self.workspace)
self.assertEquals(workspace_info.name,
u"Renamed Nuxeo Drive Test Workspace")
folder_1_info = remote_client.get_info(folder_1_uid)
self.assertEquals(folder_1_info.name, u"Original Folder 1")
self.assertEquals(folder_1_info.parent_uid, self.workspace)
def test_local_rename_sync_root_folder(self):
# Use the Administrator to be able to introspect the container of the
# test workspace.
remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=self.workspace)
folder_1_uid = remote_client.get_info(u'/Original Folder 1').uid
# Create new clients to be able to introspect the test sync root
toplevel_local_client = LocalClient(self.local_nxdrive_folder_1)
toplevel_local_client.rename('/' + self.workspace_title,
'Renamed Nuxeo Drive Test Workspace')
self.wait_sync()
workspace_info = remote_client.get_info(self.workspace)
self.assertEquals(workspace_info.name,
u"Renamed Nuxeo Drive Test Workspace")
folder_1_info = remote_client.get_info(folder_1_uid)
self.assertEquals(folder_1_info.name, u"Original Folder 1")
self.assertEquals(folder_1_info.parent_uid, self.workspace)
self.assertEqual(len(remote_client.get_children_info(self.workspace_1)), 4)
def test_register_sync_root_parent(self):
remote = RemoteDocumentClient(self.nuxeo_url, self.user_1, u'nxdrive-test-device-1', self.version,
password=self.password_1, upload_tmp_dir=self.upload_tmp_dir)
local = self.local_root_client_1
# First unregister test Workspace
remote.unregister_as_root(self.workspace)
# Create a child folder and register it as a synchronization root
child = remote.make_folder(self.workspace, 'child')
remote.make_file(child, 'aFile.txt', u'My content')
remote.register_as_root(child)
# Start engine and wait for synchronization
self.engine_1.start()
self.wait_sync(wait_for_async=True)
self.assertFalse(local.exists('/Nuxeo Drive Test Workspace'))
self.assertTrue(local.exists('/child'))
self.assertTrue(local.exists('/child/aFile.txt'))
# Register parent folder
remote.register_as_root(self.workspace)
# Start engine and wait for synchronization
self.wait_sync(wait_for_async=True)
self.assertFalse(local.exists('/child'))
self.assertTrue(local.exists('/Nuxeo Drive Test Workspace'))
self.assertTrue(local.exists('/Nuxeo Drive Test Workspace/child'))
self.assertTrue(local.exists('/Nuxeo Drive Test Workspace/child/aFile.txt'))
def test_sync_delete_root(self):
user_workspace_uid = None
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
local_client = LocalClient(self.local_nxdrive_folder_1)
# Make sure user workspace is created and fetch its uid
user_workspace_uid = user_remote_client.make_file_in_user_workspace(
'File in user workspace', filename='USFile.txt')['parentRef']
# Create test folder in user workspace as test user
test_folder_uid = user_remote_client.make_folder(
user_workspace_uid, 'test_folder')
# Create a document in the test folder
user_remote_client.make_file(test_folder_uid, 'test_file.txt',
"Some content.")
# Register test folder as a sync root
user_remote_client.register_as_root(test_folder_uid)
# Start engine
self.engine_1.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertTrue(local_client.exists('/My Docs/test_folder'))
self.assertTrue(
local_client.exists('/My Docs/test_folder/test_file.txt'))
# Delete test folder
user_remote_client.delete(test_folder_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertFalse(local_client.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client.get_children_info('/My Docs')),
0)
finally:
# Cleanup user workspace
if user_workspace_uid is not None and admin_remote_client.exists(
user_workspace_uid):
admin_remote_client.delete(user_workspace_uid, use_trash=False)
def test_authentication_failure(self):
with self.assertRaises(Unauthorized):
RemoteDocumentClient(
self.remote_document_client_1.server_url,
'someone else', 'test-device', self.version,
password='******')
with self.assertRaises(Unauthorized):
RemoteDocumentClient(
self.remote_document_client_1.server_url,
'someone else', 'test-device', self.version,
token='some-bad-token')
def setUpServer(self, server_profile=None):
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
self.root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Activate given profile if needed, eg. permission hierarchy
if server_profile is not None:
self.root_remote_client.activate_profile(server_profile)
# Call the Nuxeo operation to setup the integration test environment
credentials = self.root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = self.root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
self.workspace_1 = self.workspace
self.workspace_2 = self.workspace
self.workspace_title_1 = self.workspace_title
self.workspace_title_2 = self.workspace_title
def test_remote_move_to_non_sync_root(self):
# Grant ReadWrite permission on Workspaces for test user
workspaces_path = u'/default-domain/workspaces'
op_input = "doc:" + workspaces_path
self.root_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
workspaces_info = self.root_remote_client.fetch(workspaces_path)
workspaces = workspaces_info[u'uid']
# Get remote client with Workspaces as base folder and local client
remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
base_folder=workspaces,
upload_tmp_dir=self.upload_tmp_dir)
local_client = self.local_client_1
# Create a non synchronized folder
unsync_folder = remote_client.make_folder(u'/',
u'Non synchronized folder')
try:
# Move Original Folder 1 to Non synchronized folder
remote_client.move(
u'/nuxeo-drive-test-workspace/Original Folder 1',
u'/Non synchronized folder')
self.assertFalse(
remote_client.exists(
u'/nuxeo-drive-test-workspace/Original Folder 1'))
self.assertTrue(
remote_client.exists(
u'/Non synchronized folder/Original Folder 1'))
# Synchronize: the folder move is detected as a deletion
self.wait_sync(wait_for_async=True)
# Check local folder
self.assertFalse(local_client.exists(u'/Original Folder 1'))
# Check folder state
folder_1_state = self._get_state(self.folder_1_id)
self.assertEquals(folder_1_state, None)
finally:
# Clean the non synchronized folder
remote_client.delete(unsync_folder, use_trash=False)
def test_remote_move_to_non_sync_root(self):
sb, ctl = self.sb_1, self.controller_1
session = ctl.get_session()
# Grant ReadWrite permission on Workspaces for test user
workspaces_path = u'/default-domain/workspaces'
op_input = "doc:" + workspaces_path
self.root_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
workspaces_info = self.root_remote_client.fetch(workspaces_path)
workspaces = workspaces_info[u'uid']
# Get remote client with Workspaces as base folder and local client
remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
base_folder=workspaces,
upload_tmp_dir=self.upload_tmp_dir)
local_client = self.local_client_1
# Create a non synchronized folder
remote_client.make_folder(u'/', u'Non synchronized folder')
# Move Original Folder 1 to Non synchronized folder
remote_client.move(u'/nuxeo-drive-test-workspace/Original Folder 1',
u'/Non synchronized folder')
self.assertFalse(
remote_client.exists(
u'/nuxeo-drive-test-workspace/Original Folder 1'))
self.assertTrue(
remote_client.exists(
u'/Non synchronized folder/Original Folder 1'))
# Synchronize: the folder move is detected as a deletion
self.wait_audit_change_finder_if_needed()
self.wait()
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 1)
# Check local folder
self.assertFalse(local_client.exists(u'/Original Folder 1'))
# Check folder state
folder_1_state = session.query(LastKnownState).filter_by(
remote_name=u'Original Folder 1').all()
self.assertEquals(len(folder_1_state), 0)
# The more things change, the more they remain the same.
self.wait_audit_change_finder_if_needed()
self.wait()
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 0)
def test_sync_delete_root(self):
user_workspace_uid = None
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version, password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
local_client = LocalClient(self.local_nxdrive_folder_1)
# Make sure user workspace is created and fetch its uid
user_workspace_uid = user_remote_client.make_file_in_user_workspace('File in user workspace',
filename='USFile.txt')['parentRef']
# Create test folder in user workspace as test user
test_folder_uid = user_remote_client.make_folder(user_workspace_uid, 'test_folder')
# Create a document in the test folder
user_remote_client.make_file(test_folder_uid, 'test_file.txt', "Some content.")
# Register test folder as a sync root
user_remote_client.register_as_root(test_folder_uid)
# Start engine
self.engine_1.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertTrue(local_client.exists('/My Docs/test_folder'))
self.assertTrue(local_client.exists('/My Docs/test_folder/test_file.txt'))
# Delete test folder
user_remote_client.delete(test_folder_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertFalse(local_client.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client.get_children_info('/My Docs')), 0)
finally:
# Cleanup user workspace
if user_workspace_uid is not None and admin_remote_client.exists(user_workspace_uid):
admin_remote_client.delete(user_workspace_uid,
use_trash=False)
def test_remote_move_to_non_sync_root(self):
sb, ctl = self.sb_1, self.controller_1
session = ctl.get_session()
# Grant ReadWrite permission on Workspaces for test user
workspaces_path = u'/default-domain/workspaces'
op_input = "doc:" + workspaces_path
self.root_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
workspaces_info = self.root_remote_client.fetch(workspaces_path)
workspaces = workspaces_info[u'uid']
# Get remote client with Workspaces as base folder and local client
remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1, base_folder=workspaces,
upload_tmp_dir=self.upload_tmp_dir)
local_client = self.local_client_1
# Create a non synchronized folder
remote_client.make_folder(u'/', u'Non synchronized folder')
# Move Original Folder 1 to Non synchronized folder
remote_client.move(u'/nuxeo-drive-test-workspace/Original Folder 1',
u'/Non synchronized folder')
self.assertFalse(remote_client.exists(
u'/nuxeo-drive-test-workspace/Original Folder 1'))
self.assertTrue(remote_client.exists(
u'/Non synchronized folder/Original Folder 1'))
# Synchronize: the folder move is detected as a deletion
self.wait_audit_change_finder_if_needed()
self.wait()
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 1)
# Check local folder
self.assertFalse(local_client.exists(u'/Original Folder 1'))
# Check folder state
folder_1_state = session.query(LastKnownState).filter_by(
remote_name=u'Original Folder 1').all()
self.assertEquals(len(folder_1_state), 0)
# The more things change, the more they remain the same.
self.wait_audit_change_finder_if_needed()
self.wait()
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 0)
def test_remote_move_to_non_sync_root(self):
# Grant ReadWrite permission on Workspaces for test user
workspaces_path = u'/default-domain/workspaces'
op_input = "doc:" + workspaces_path
self.root_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
workspaces_info = self.root_remote_client.fetch(workspaces_path)
workspaces = workspaces_info[u'uid']
# Get remote client with Workspaces as base folder and local client
remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1, base_folder=workspaces,
upload_tmp_dir=self.upload_tmp_dir)
local_client = self.local_client_1
# Create a non synchronized folder
unsync_folder = remote_client.make_folder(u'/', u'Non synchronized folder')
try:
# Move Original Folder 1 to Non synchronized folder
remote_client.move(u'/nuxeo-drive-test-workspace/Original Folder 1',
u'/Non synchronized folder')
self.assertFalse(remote_client.exists(
u'/nuxeo-drive-test-workspace/Original Folder 1'))
self.assertTrue(remote_client.exists(
u'/Non synchronized folder/Original Folder 1'))
# Synchronize: the folder move is detected as a deletion
self.wait_sync(wait_for_async=True)
# Check local folder
self.assertFalse(local_client.exists(u'/Original Folder 1'))
# Check folder state
folder_1_state = self._get_state(self.folder_1_id)
self.assertEquals(folder_1_state, None)
finally:
# Clean the non synchronized folder
remote_client.delete(unsync_folder, use_trash=False)
def test_move_sync_root_child_to_user_workspace(self):
"""See https://jira.nuxeo.com/browse/NXP-14870"""
admin_remote_client = self.root_remote_client
user1_workspace_path = ('/default-domain/UserWorkspaces/'
'nuxeoDriveTestUser-user-1')
try:
# Get remote and local clients
remote_user1 = RemoteDocumentClient(
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_user2 = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version, password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_user2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure personal workspace is created for user1
remote_user1.make_file_in_user_workspace('File in user workspace',
filename='UWFile.txt')
# As user1 register personal workspace as a sync root
remote_user1.register_as_root(user1_workspace_path)
# As user1 create a parent folder in user1's personal workspace
remote_user1.make_folder(user1_workspace_path, 'Parent')
# As user1 grant Everything permission to user2 on parent folder
parent_folder_path = user1_workspace_path + '/Parent'
op_input = "doc:" + parent_folder_path
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="Everything",
grant="true")
# As user1 create a child folder in parent folder
remote_user1.make_folder(parent_folder_path, 'Child')
# As user2 register parent folder as a sync root
remote_user2.register_as_root(parent_folder_path)
# Bind server for user2
ctl_2 = self.controller_2
ctl_2.bind_server(self.local_nxdrive_folder_2, self.nuxeo_url,
self.user_2, self.password_2)
# Launch first synchronization
syn_2 = ctl_2.synchronizer
self._synchronize(syn_2)
# Check locally synchronized content
self.assertEquals(len(local_user2.get_children_info('/')), 1)
self.assertTrue(local_user2.exists('/Parent'))
self.assertTrue(local_user2.exists('/Parent/Child'))
# As user1 move child folder to user1's personal workspace
remote_user1.move(parent_folder_path + '/Child',
user1_workspace_path)
# Synchronize
self._synchronize(syn_2)
# Check locally synchronized content
self.assertFalse(local_user2.exists('/Parent/Child'))
finally:
# Cleanup user1 personal workspace
if admin_remote_client.exists(user1_workspace_path):
admin_remote_client.delete(user1_workspace_path,
use_trash=False)
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'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title_1))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title_2))
# 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
)
# 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 test_migration_db_v1(self):
# Initialize old DB
db = open(self._get_db('test_manager_migration.db'), 'rb')
old_db = os.path.join(self.test_folder, 'nxdrive.db')
with open(old_db, 'wb') as f:
f.write(db.read())
db.close()
# Update token with one acquired against the test server
conn = sqlite3.connect(old_db)
c = conn.cursor()
device_id = c.execute("SELECT device_id FROM device_config LIMIT 1").fetchone()[0]
remote_client = RemoteDocumentClient(self.nuxeo_url, self.admin_user, device_id, nxdrive.__version__,
password=self.admin_password)
token = remote_client.request_token()
c.execute("UPDATE server_bindings SET remote_token='%s' WHERE local_folder='%s'" % (
token, '/home/ataillefer/Nuxeo Drive'))
# Update server URL with test server URL
c.execute("UPDATE server_bindings SET server_url='%s' WHERE local_folder='%s'" % (
self.nuxeo_url, '/home/ataillefer/Nuxeo Drive'))
# Update local folder with test temp dir
local_folder = os.path.join(self.test_folder, 'Nuxeo Drive')
c.execute("UPDATE server_bindings SET local_folder='%s' WHERE local_folder='%s'" % (
local_folder, '/home/ataillefer/Nuxeo Drive'))
conn.commit()
conn.close()
# Create Manager with old DB migration
manager = self._create_manager()
dao = manager.get_dao()
# Check Manager config
self.assertEquals(dao.get_config('device_id'), device_id)
self.assertEquals(dao.get_config('proxy_config'), 'Manual')
self.assertEquals(dao.get_config('proxy_type'), 'http')
self.assertEquals(dao.get_config('proxy_server'), 'proxy.server.com')
self.assertEquals(dao.get_config('proxy_port'), '80')
self.assertEquals(dao.get_config('proxy_authenticated'), '1')
self.assertEquals(dao.get_config('proxy_username'), 'Administrator')
self.assertEquals(dao.get_config('auto_update'), '1')
self.assertEquals(dao.get_config('proxy_config'), 'Manual')
# Check engine definition
engines = dao.get_engines()
self.assertEquals(len(engines), 1)
engine = engines[0]
self.assertEquals(engine.engine, 'NXDRIVE')
self.assertEquals(engine.name, manager._get_engine_name(self.nuxeo_url))
self.assertTrue(local_folder in engine.local_folder)
# Check engine config
engine_uid = engine.uid
engine_db = os.path.join(self.test_folder, 'ndrive_%s.db' % engine_uid)
engine_dao = EngineDAO(engine_db)
self.assertEquals(engine_dao.get_config('server_url'), self.nuxeo_url)
self.assertEquals(engine_dao.get_config('remote_user'), 'Administrator')
self.assertEquals(engine_dao.get_config('remote_token'), token)
engine_dao.dispose()
manager.dispose_all()
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 test_sync_unshared_folder(self):
user_workspace_uid = None
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user1_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
user2_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_client_1 = LocalClient(self.local_nxdrive_folder_1)
local_client_2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure user1 workspace is created and fetch its uid
user_workspace_uid = user1_remote_client.make_file_in_user_workspace(
'File in user workspace', filename='USFile.txt')['parentRef']
# Register user workspace as a sync root for user1
user1_remote_client.register_as_root(user_workspace_uid)
# Start engine
self.engine_2.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True,
wait_for_engine_2=True,
wait_for_engine_1=False)
# Check locally synchronized content
self.assertTrue(local_client_2.exists('/My Docs'))
self.assertTrue(local_client_2.exists('/Other Docs'))
# Create test folder in user workspace as user1
test_folder_uid = user1_remote_client.make_folder(
user_workspace_uid, 'Folder A')
folder_b = user1_remote_client.make_folder(test_folder_uid,
'Folder B')
folder_c = user1_remote_client.make_folder(folder_b, 'Folder C')
folder_d = user1_remote_client.make_folder(folder_c, 'Folder D')
folder_e = user1_remote_client.make_folder(folder_d, 'Folder E')
# Grant ReadWrite permission to user2 on test folder
op_input = "doc:" + test_folder_uid
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user=self.user_2,
permission="ReadWrite",
grant="true")
# Register test folder as a sync root for user2
user2_remote_client.register_as_root(test_folder_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True,
wait_for_engine_2=True,
wait_for_engine_1=False)
self.assertTrue(local_client_2.exists('/Other Docs/Folder A'))
self.assertTrue(
local_client_2.exists(
'/Other Docs/Folder A/Folder B/Folder C/Folder D/Folder E')
)
# Use for later get_fs_item checks
folder_b_fs = local_client_2.get_remote_id(
'/Other Docs/Folder A/Folder B')
folder_a_fs = local_client_2.get_remote_id('/Other Docs/Folder A')
# Unshare Folder A and share Folder C
admin_remote_client.execute("Document.RemoveACL",
op_input=op_input,
acl='local')
op_input = "doc:" + folder_c
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user=self.user_2,
permission="Read",
grant="true")
user2_remote_client.register_as_root(folder_c)
self.wait_sync(wait_for_async=True,
wait_for_engine_2=True,
wait_for_engine_1=False)
self.assertFalse(local_client_2.exists('/Other Docs/Folder A'))
self.assertTrue(local_client_2.exists('/Other Docs/Folder C'))
self.assertTrue(
local_client_2.exists(
'/Other Docs/Folder C/Folder D/Folder E'))
# Verify that we dont have any 403 errors
self.assertIsNone(
self.remote_file_system_client_2.get_fs_item(folder_a_fs))
self.assertIsNone(
self.remote_file_system_client_2.get_fs_item(folder_b_fs))
finally:
# Cleanup user workspace
if user_workspace_uid is not None and admin_remote_client.exists(
user_workspace_uid):
admin_remote_client.delete(user_workspace_uid, use_trash=False)
def test_sync_delete_root(self):
user_workspaces_path = '/default-domain/UserWorkspaces/'
user_workspace_title = 'nuxeoDriveTestUser-user-1'
user_workspace_path = user_workspaces_path + user_workspace_title
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
local_client = LocalClient(self.local_nxdrive_folder_1)
# Activate permission hierarchy profile as Administrator
admin_remote_client.activate_profile('permission')
# Make sure user workspace is created
user_remote_client.make_file_in_user_workspace(
'File in user workspace', filename='USFile.txt')
# Bind server
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
syn = ctl.synchronizer
# Create test folder in user workspace as test user
user_remote_client.make_folder(user_workspace_path, 'test_folder')
test_folder_path = user_workspace_path + '/test_folder'
# Create a document in the test folder
user_remote_client.make_file(test_folder_path, 'test_file.txt',
"Some content.")
# Register test folder as a sync root
user_remote_client.register_as_root(test_folder_path)
# Synchronize
self._synchronize(syn)
# Check locally synchronized content
self.assertTrue(local_client.exists('/My Docs/test_folder'))
self.assertTrue(
local_client.exists('/My Docs/test_folder/test_file.txt'))
# Delete test folder
user_remote_client.delete(test_folder_path)
# Synchronize
self._synchronize(syn)
# Check locally synchronized content
self.assertFalse(local_client.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client.get_children_info('/My Docs')),
0)
finally:
# Cleanup user workspace
if admin_remote_client.exists(user_workspace_path):
admin_remote_client.delete(user_workspace_path,
use_trash=False)
# Deactivate permission hierarchy profile
admin_remote_client.deactivate_profile('permission')
def test_move_sync_root_child_to_user_workspace(self):
"""See https://jira.nuxeo.com/browse/NXP-14870"""
admin_remote_client = self.root_remote_client
user1_workspace_uid = None
try:
# Get remote and local clients
remote_user1 = RemoteDocumentClient(
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_user2 = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version, password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_user2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure personal workspace is created for user1 and fetch its uid
user1_workspace_uid = remote_user1.make_file_in_user_workspace('File in user workspace',
filename='UWFile.txt')['parentRef']
# As user1 register personal workspace as a sync root
remote_user1.register_as_root(user1_workspace_uid)
# As user1 create a parent folder in user1's personal workspace
parent_folder_uid = remote_user1.make_folder(user1_workspace_uid, 'Parent')
# As user1 grant Everything permission to user2 on parent folder
op_input = "doc:" + parent_folder_uid
admin_remote_client.execute("Document.SetACE", op_input=op_input, user="******",
permission="Everything", grant="true")
# As user1 create a child folder in parent folder
child_folder_uid = remote_user1.make_folder(parent_folder_uid, 'Child')
# As user2 register parent folder as a sync root
remote_user2.register_as_root(parent_folder_uid)
remote_user2.unregister_as_root(self.workspace)
# Start engine for user2
self.engine_2.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True, wait_for_engine_1=False, wait_for_engine_2=True)
# Check locally synchronized content
self.assertEquals(len(local_user2.get_children_info('/')), 1)
self.assertTrue(local_user2.exists('/Parent'))
self.assertTrue(local_user2.exists('/Parent/Child'))
# As user1 move child folder to user1's personal workspace
remote_user1.move(child_folder_uid, user1_workspace_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True, wait_for_engine_1=False, wait_for_engine_2=True)
# Check locally synchronized content
self.assertFalse(local_user2.exists('/Parent/Child'))
finally:
# Cleanup user1 personal workspace
if user1_workspace_uid is not None and admin_remote_client.exists(user1_workspace_uid):
admin_remote_client.delete(user1_workspace_uid,
use_trash=False)
def test_sync_delete_root(self):
try:
user_workspaces_path = '/default-domain/UserWorkspaces/'
user_workspace_title = 'nuxeoDriveTestUser_user_1'
user_workspace_path = user_workspaces_path + user_workspace_title
# Get remote and local clients
admin_remote_client = self.root_remote_client
user_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version, password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
local_client = LocalClient(self.local_nxdrive_folder_1)
# Activate permission hierarchy profile as Administrator
admin_remote_client.activate_profile('permission')
# Bind server
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
syn = ctl.synchronizer
# Create user workspace parent as Administrator if it doesn't exist
if not admin_remote_client.exists(user_workspaces_path):
admin_remote_client.make_folder('/default-domain',
'UserWorkspaces',
doc_type='UserWorkspacesRoot')
# Create test user workspace as Administrator
admin_remote_client.make_folder(user_workspaces_path,
user_workspace_title,
doc_type='Workspace')
# Grant ReadWrite permission to test user on its workspace
op_input = "doc:" + user_workspace_path
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
# Create test folder in user workspace as test user
user_remote_client.make_folder(user_workspace_path, 'test_folder')
test_folder_path = user_workspace_path + '/test_folder'
# Create a document in the test folder
user_remote_client.make_file(test_folder_path, 'test_file.txt',
"Some content.")
# Register test folder as a sync root
user_remote_client.register_as_root(test_folder_path)
# Synchronize
self._synchronize(syn)
# Check locally synchronized content
self.assertTrue(local_client.exists('/My Docs/test_folder'))
self.assertTrue(local_client.exists(
'/My Docs/test_folder/test_file.txt'))
# Delete test folder
user_remote_client.delete(test_folder_path)
# Synchronize
self._synchronize(syn)
# Check locally synchronized content
self.assertFalse(local_client.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client.get_children_info('/My Docs')),
0)
finally:
# Cleanup user workspace
if admin_remote_client.exists(user_workspace_path):
admin_remote_client.delete(user_workspace_path,
use_trash=False)
# Deactivate permission hierarchy profile
admin_remote_client.deactivate_profile('permission')
def test_register_sync_root_parent(self):
remote = RemoteDocumentClient(self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
local = self.local_root_client_1
# First unregister test Workspace
remote.unregister_as_root(self.workspace)
# Create a child folder and register it as a synchronization root
child = remote.make_folder(self.workspace, 'child')
remote.make_file(child, 'aFile.txt', u'My content')
remote.register_as_root(child)
# Start engine and wait for synchronization
self.engine_1.start()
self.wait_sync(wait_for_async=True)
self.assertFalse(local.exists('/Nuxeo Drive Test Workspace'))
self.assertTrue(local.exists('/child'))
self.assertTrue(local.exists('/child/aFile.txt'))
# Register parent folder
remote.register_as_root(self.workspace)
# Start engine and wait for synchronization
self.wait_sync(wait_for_async=True)
self.assertFalse(local.exists('/child'))
self.assertTrue(local.exists('/Nuxeo Drive Test Workspace'))
self.assertTrue(local.exists('/Nuxeo Drive Test Workspace/child'))
self.assertTrue(
local.exists('/Nuxeo Drive Test Workspace/child/aFile.txt'))
def test_move_sync_root_child_to_user_workspace(self):
"""See https://jira.nuxeo.com/browse/NXP-14870"""
admin_remote_client = self.root_remote_client
user1_workspace_uid = None
try:
# Get remote and local clients
remote_user1 = RemoteDocumentClient(
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_user2 = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_user2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure personal workspace is created for user1 and fetch its uid
user1_workspace_uid = remote_user1.make_file_in_user_workspace(
'File in user workspace', filename='UWFile.txt')['parentRef']
# As user1 register personal workspace as a sync root
remote_user1.register_as_root(user1_workspace_uid)
# As user1 create a parent folder in user1's personal workspace
parent_folder_uid = remote_user1.make_folder(
user1_workspace_uid, 'Parent')
# As user1 grant Everything permission to user2 on parent folder
op_input = "doc:" + parent_folder_uid
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user=self.user_2,
permission="Everything",
grant="true")
# As user1 create a child folder in parent folder
child_folder_uid = remote_user1.make_folder(
parent_folder_uid, 'Child')
# As user2 register parent folder as a sync root
remote_user2.register_as_root(parent_folder_uid)
remote_user2.unregister_as_root(self.workspace)
# Start engine for user2
self.engine_2.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True,
wait_for_engine_1=False,
wait_for_engine_2=True)
# Check locally synchronized content
self.assertEquals(len(local_user2.get_children_info('/')), 1)
self.assertTrue(local_user2.exists('/Parent'))
self.assertTrue(local_user2.exists('/Parent/Child'))
# As user1 move child folder to user1's personal workspace
remote_user1.move(child_folder_uid, user1_workspace_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True,
wait_for_engine_1=False,
wait_for_engine_2=True)
# Check locally synchronized content
self.assertFalse(local_user2.exists('/Parent/Child'))
finally:
# Cleanup user1 personal workspace
if user1_workspace_uid is not None and admin_remote_client.exists(
user1_workspace_uid):
admin_remote_client.delete(user1_workspace_uid,
use_trash=False)
def test_move_sync_root_child_to_user_workspace(self):
"""See https://jira.nuxeo.com/browse/NXP-14870"""
admin_remote_client = self.root_remote_client
user1_workspace_path = ('/default-domain/UserWorkspaces/'
'nuxeoDriveTestUser-user-1')
try:
# Get remote and local clients
remote_user1 = RemoteDocumentClient(
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_user2 = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_user2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure personal workspace is created for user1
remote_user1.make_file_in_user_workspace('File in user workspace',
filename='UWFile.txt')
# As user1 register personal workspace as a sync root
remote_user1.register_as_root(user1_workspace_path)
# As user1 create a parent folder in user1's personal workspace
remote_user1.make_folder(user1_workspace_path, 'Parent')
# As user1 grant Everything permission to user2 on parent folder
parent_folder_path = user1_workspace_path + '/Parent'
op_input = "doc:" + parent_folder_path
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="Everything",
grant="true")
# As user1 create a child folder in parent folder
remote_user1.make_folder(parent_folder_path, 'Child')
# As user2 register parent folder as a sync root
remote_user2.register_as_root(parent_folder_path)
# Bind server for user2
ctl_2 = self.controller_2
ctl_2.bind_server(self.local_nxdrive_folder_2, self.nuxeo_url,
self.user_2, self.password_2)
# Launch first synchronization
syn_2 = ctl_2.synchronizer
self._synchronize(syn_2)
# Check locally synchronized content
self.assertEquals(len(local_user2.get_children_info('/')), 1)
self.assertTrue(local_user2.exists('/Parent'))
self.assertTrue(local_user2.exists('/Parent/Child'))
# As user1 move child folder to user1's personal workspace
remote_user1.move(parent_folder_path + '/Child',
user1_workspace_path)
# Synchronize
self._synchronize(syn_2)
# Check locally synchronized content
self.assertFalse(local_user2.exists('/Parent/Child'))
finally:
# Cleanup user1 personal workspace
if admin_remote_client.exists(user1_workspace_path):
admin_remote_client.delete(user1_workspace_path,
use_trash=False)
def test_make_token(self):
remote_client = self.remote_document_client_1
token = remote_client.request_token()
if token is None:
raise SkipTest('nuxeo-platform-login-token is not deployed')
self.assertGreater(len(token), 5)
self.assertEqual(remote_client.auth[0], 'X-Authentication-Token')
self.assertEqual(remote_client.auth[1], token)
remote_client.unregister_as_root(self.workspace)
self.wait()
# Requesting token is an idempotent operation
token2 = remote_client.request_token()
self.assertEqual(token, token2)
# It's possible to create a new client using the same token
remote_client2 = RemoteDocumentClient(
remote_client.server_url, remote_client.user_id,
remote_client.device_id, remote_client.client_version,
token=token, base_folder=self.workspace)
token3 = remote_client.request_token()
self.assertEqual(token, token3)
# Register a root with client 2 and see it with client one
folder_1 = remote_client2.make_folder('/', 'Folder 1')
remote_client2.register_as_root(folder_1)
roots = remote_client.get_roots()
self.assertEqual(len(roots), 1)
self.assertEqual(roots[0].name, 'Folder 1')
# The root can also been seen with a new client connected using
# password based auth
remote_client3 = RemoteDocumentClient(
remote_client.server_url, remote_client.user_id,
remote_client.device_id, remote_client.client_version,
password=self.password_1, base_folder=None)
roots = remote_client3.get_roots()
self.assertEqual(len(roots), 1)
self.assertEqual(roots[0].name, 'Folder 1')
# Another device using the same user credentials will get a different
# token
remote_client4 = RemoteDocumentClient(
remote_client.server_url, remote_client.user_id,
'other-test-device', remote_client.client_version,
password=self.password_1, base_folder=None)
token4 = remote_client4.request_token()
self.assertNotEquals(token, token4)
# A client can revoke a token explicitly and thus lose credentials
remote_client4.revoke_token()
with self.assertRaises(IOError):
remote_client4.get_roots()
def test_sync_unshared_folder(self):
user_workspace_uid = None
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user1_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version, password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
user2_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version, password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_client_1 = LocalClient(self.local_nxdrive_folder_1)
local_client_2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure user1 workspace is created and fetch its uid
user_workspace_uid = user1_remote_client.make_file_in_user_workspace('File in user workspace',
filename='USFile.txt')['parentRef']
# Register user workspace as a sync root for user1
user1_remote_client.register_as_root(user_workspace_uid)
# Start engine
self.engine_2.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True, wait_for_engine_2=True, wait_for_engine_1=False)
# Check locally synchronized content
self.assertTrue(local_client_2.exists('/My Docs'))
self.assertTrue(local_client_2.exists('/Other Docs'))
# Create test folder in user workspace as user1
test_folder_uid = user1_remote_client.make_folder(user_workspace_uid, 'Folder A')
folder_b = user1_remote_client.make_folder(test_folder_uid, 'Folder B')
folder_c = user1_remote_client.make_folder(folder_b, 'Folder C')
folder_d = user1_remote_client.make_folder(folder_c, 'Folder D')
folder_e = user1_remote_client.make_folder(folder_d, 'Folder E')
# Grant ReadWrite permission to user2 on test folder
op_input = "doc:" + test_folder_uid
admin_remote_client.execute("Document.SetACE", op_input=op_input, user=self.user_2,
permission="ReadWrite", grant="true")
# Register test folder as a sync root for user2
user2_remote_client.register_as_root(test_folder_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True, wait_for_engine_2=True, wait_for_engine_1=False)
self.assertTrue(local_client_2.exists('/Other Docs/Folder A'))
self.assertTrue(local_client_2.exists('/Other Docs/Folder A/Folder B/Folder C/Folder D/Folder E'))
# Use for later get_fs_item checks
folder_b_fs = local_client_2.get_remote_id('/Other Docs/Folder A/Folder B')
folder_a_fs = local_client_2.get_remote_id('/Other Docs/Folder A')
# Unshare Folder A and share Folder C
admin_remote_client.execute("Document.RemoveACL", op_input=op_input, acl='local')
op_input = "doc:" + folder_c
admin_remote_client.execute("Document.SetACE", op_input=op_input, user=self.user_2,
permission="Read", grant="true")
user2_remote_client.register_as_root(folder_c)
self.wait_sync(wait_for_async=True, wait_for_engine_2=True, wait_for_engine_1=False)
self.assertFalse(local_client_2.exists('/Other Docs/Folder A'))
self.assertTrue(local_client_2.exists('/Other Docs/Folder C'))
self.assertTrue(local_client_2.exists('/Other Docs/Folder C/Folder D/Folder E'))
# Verify that we dont have any 403 errors
self.assertIsNone(self.remote_file_system_client_2.get_fs_item(folder_a_fs))
self.assertIsNone(self.remote_file_system_client_2.get_fs_item(folder_b_fs))
finally:
# Cleanup user workspace
if user_workspace_uid is not None and admin_remote_client.exists(user_workspace_uid):
admin_remote_client.delete(user_workspace_uid,
use_trash=False)
def test_migration_db_v1(self):
# Initialize old DB
db = open(self._get_db('test_manager_migration.db'), 'rb')
old_db = os.path.join(self.test_folder, 'nxdrive.db')
with open(old_db, 'wb') as f:
f.write(db.read())
db.close()
# Update token with one acquired against the test server
conn = sqlite3.connect(old_db)
c = conn.cursor()
device_id = c.execute(
"SELECT device_id FROM device_config LIMIT 1").fetchone()[0]
remote_client = RemoteDocumentClient(self.nuxeo_url,
self.admin_user,
device_id,
nxdrive.__version__,
password=self.admin_password)
token = remote_client.request_token()
c.execute(
"UPDATE server_bindings SET remote_token='%s' WHERE local_folder='%s'"
% (token, '/home/ataillefer/Nuxeo Drive'))
# Update server URL with test server URL
c.execute(
"UPDATE server_bindings SET server_url='%s' WHERE local_folder='%s'"
% (self.nuxeo_url, '/home/ataillefer/Nuxeo Drive'))
# Update local folder with test temp dir
local_folder = os.path.join(self.test_folder, 'Nuxeo Drive')
c.execute(
"UPDATE server_bindings SET local_folder='%s' WHERE local_folder='%s'"
% (local_folder, '/home/ataillefer/Nuxeo Drive'))
conn.commit()
conn.close()
# Create Manager with old DB migration
manager = self._create_manager()
dao = manager.get_dao()
# Check Manager config
self.assertEquals(dao.get_config('device_id'), device_id)
self.assertEquals(dao.get_config('proxy_config'), 'Manual')
self.assertEquals(dao.get_config('proxy_type'), 'http')
self.assertEquals(dao.get_config('proxy_server'), 'proxy.server.com')
self.assertEquals(dao.get_config('proxy_port'), '80')
self.assertEquals(dao.get_config('proxy_authenticated'), '1')
self.assertEquals(dao.get_config('proxy_username'), 'Administrator')
self.assertEquals(dao.get_config('auto_update'), '1')
self.assertEquals(dao.get_config('proxy_config'), 'Manual')
# Check engine definition
engines = dao.get_engines()
self.assertEquals(len(engines), 1)
engine = engines[0]
self.assertEquals(engine.engine, 'NXDRIVE')
self.assertEquals(engine.name,
manager._get_engine_name(self.nuxeo_url))
self.assertTrue(local_folder in engine.local_folder)
# Check engine config
engine_uid = engine.uid
engine_db = os.path.join(self.test_folder, 'ndrive_%s.db' % engine_uid)
engine_dao = EngineDAO(engine_db)
self.assertEquals(engine_dao.get_config('server_url'), self.nuxeo_url)
self.assertEquals(engine_dao.get_config('remote_user'),
'Administrator')
self.assertEquals(engine_dao.get_config('remote_token'), token)
engine_dao.dispose()
manager.dispose_all()
def setUp(self):
# 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')
# 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 = "******"
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'-nxdrive-tests-user-1')
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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)
# Set echo to True to enable SQL statements and transactions logging
# and echo_pool to True to enable connection pool logging
self.controller_1 = Controller(self.nxdrive_conf_folder_1,
echo=False,
echo_pool=False)
self.controller_2 = Controller(self.nxdrive_conf_folder_2,
echo=False,
echo_pool=False)
self.controller_1.synchronizer.test_delay = 3
self.controller_2.synchronizer.test_delay = 3
self.version = self.controller_1.get_version()
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
root_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.admin_user,
u'nxdrive-test-administrator-device',
self.version,
password=self.password,
base_folder=u'/',
timeout=60)
# Call the Nuxeo operation to setup the integration test environment
credentials = root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2",
permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = root_remote_client.fetch(self.TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
# Document client to be used to create remote test documents
# and folders
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads')
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,
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,
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.root_remote_client = root_remote_client
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
def test_sync_delete_root(self):
user_workspaces_path = '/default-domain/UserWorkspaces/'
user_workspace_title = 'nuxeoDriveTestUser-user-1'
user_workspace_path = user_workspaces_path + user_workspace_title
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version, password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
local_client = LocalClient(self.local_nxdrive_folder_1)
# Activate permission hierarchy profile as Administrator
admin_remote_client.activate_profile('permission')
# Make sure user workspace is created
user_remote_client.make_file_in_user_workspace(
'File in user workspace',
filename='USFile.txt')
# Bind server
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
syn = ctl.synchronizer
# Create test folder in user workspace as test user
user_remote_client.make_folder(user_workspace_path, 'test_folder')
test_folder_path = user_workspace_path + '/test_folder'
# Create a document in the test folder
user_remote_client.make_file(test_folder_path, 'test_file.txt',
"Some content.")
# Register test folder as a sync root
user_remote_client.register_as_root(test_folder_path)
# Synchronize
self._synchronize(syn)
# Check locally synchronized content
self.assertTrue(local_client.exists('/My Docs/test_folder'))
self.assertTrue(local_client.exists(
'/My Docs/test_folder/test_file.txt'))
# Delete test folder
user_remote_client.delete(test_folder_path)
# Synchronize
self._synchronize(syn)
# Check locally synchronized content
self.assertFalse(local_client.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client.get_children_info('/My Docs')),
0)
finally:
# Cleanup user workspace
if admin_remote_client.exists(user_workspace_path):
admin_remote_client.delete(user_workspace_path,
use_trash=False)
# Deactivate permission hierarchy profile
admin_remote_client.deactivate_profile('permission')
def setUp(self):
# 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')
# 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)
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'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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)
self.version = nxdrive.__version__
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Call the Nuxeo operation to setup the integration test environment
credentials = root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
# Document client to be used to create remote test documents
# and folders
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads', dir=self.tmpdir)
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,
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,
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.root_remote_client = root_remote_client
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.local_client_1 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title))
ndrive_path = os.path.dirname(nxdrive.__file__)
self.ndrive_exec = os.path.join(ndrive_path, '..', 'scripts', 'ndrive.py')
cmdline_options = '--log-level-console=%s' % DEFAULT_CONSOLE_LOG_LEVEL
cmdline_options += ' --log-level-file=TRACE'
cmdline_options += ' --nxdrive-home="%s"'
if os.environ.get('PYDEV_DEBUG') == 'True':
cmdline_options += ' --debug-pydev'
self.ndrive_1_options = cmdline_options % self.nxdrive_conf_folder_1
self.ndrive_2_options = cmdline_options % self.nxdrive_conf_folder_2
def test_sync_delete_shared_folder(self):
user_workspace_uid = None
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user1_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
user2_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_client_1 = LocalClient(self.local_nxdrive_folder_1)
# Make sure user1 workspace is created and fetch its uid
user_workspace_uid = user1_remote_client.make_file_in_user_workspace(
'File in user workspace', filename='USFile.txt')['parentRef']
# Register user workspace as a sync root for user1
user1_remote_client.register_as_root(user_workspace_uid)
# Start engine
self.engine_1.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs'))
# Create test folder in user workspace as user1
test_folder_uid = user1_remote_client.make_folder(
user_workspace_uid, 'test_folder')
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs/test_folder'))
# Grant ReadWrite permission to user2 on test folder
op_input = "doc:" + test_folder_uid
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Register test folder as a sync root for user2
user2_remote_client.register_as_root(test_folder_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Delete test folder
user1_remote_client.delete(test_folder_uid)
# Synchronize deletion
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertFalse(local_client_1.exists('/My Docs/test_folder'))
self.assertEquals(
len(local_client_1.get_children_info('/My Docs')), 1)
finally:
# Cleanup user workspace
if user_workspace_uid is not None and admin_remote_client.exists(
user_workspace_uid):
admin_remote_client.delete(user_workspace_uid, use_trash=False)
def test_sync_delete_shared_folder(self):
user_workspaces_path = '/default-domain/UserWorkspaces/'
user1_workspace_title = 'nuxeoDriveTestUser-user-1'
user1_workspace_path = user_workspaces_path + user1_workspace_title
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user1_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
user2_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_client_1 = LocalClient(self.local_nxdrive_folder_1)
# Activate permission hierarchy profile as Administrator
admin_remote_client.activate_profile('permission')
# Make sure user1 workspace is created
user1_remote_client.make_file_in_user_workspace(
'File in user workspace', filename='USFile.txt')
# Register user workspace as a sync root for user1
user1_remote_client.register_as_root(user1_workspace_path)
# Bind server for user1
ctl_1 = self.controller_1
ctl_1.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
syn_1 = ctl_1.synchronizer
# Synchronize
self._synchronize(syn_1)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs'))
# Create test folder in user workspace as user1
user1_remote_client.make_folder(user1_workspace_path,
'test_folder')
# Synchronize
self._synchronize(syn_1)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs/test_folder'))
# Grant ReadWrite permission to user2 on test folder
test_folder_path = user1_workspace_path + '/test_folder'
op_input = "doc:" + test_folder_path
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
# Register test folder as a sync root for user2
user2_remote_client.register_as_root(test_folder_path)
# Wait for a while:
time.sleep(2.0)
# Delete test folder
user1_remote_client.delete(test_folder_path)
# Synchronize
self._synchronize(syn_1)
# Check locally synchronized content
self.assertFalse(local_client_1.exists('/My Docs/test_folder'))
self.assertEquals(
len(local_client_1.get_children_info('/My Docs')), 1)
finally:
# Cleanup user workspace
if admin_remote_client.exists(user1_workspace_path):
admin_remote_client.delete(user1_workspace_path,
use_trash=False)
# Deactivate permission hierarchy profile
admin_remote_client.deactivate_profile('permission')
class UnitTestCase(unittest.TestCase):
def setUpServer(self, server_profile=None):
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
self.root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Activate given profile if needed, eg. permission hierarchy
if server_profile is not None:
self.root_remote_client.activate_profile(server_profile)
# Call the Nuxeo operation to setup the integration test environment
credentials = self.root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = self.root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
self.workspace_1 = self.workspace
self.workspace_2 = self.workspace
self.workspace_title_1 = self.workspace_title
self.workspace_title_2 = self.workspace_title
def tearDownServer(self, server_profile=None):
# Don't need to revoke tokens for the file system remote clients
# since they use the same users as the remote document clients
self.root_remote_client.execute("NuxeoDrive.TearDownIntegrationTests")
# Deactivate given profile if needed, eg. permission hierarchy
if server_profile is not None:
self.root_remote_client.deactivate_profile(server_profile)
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'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title_1))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title_2))
# 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
)
# 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 wait_sync(self, wait_for_async=False, timeout=DEFAULT_WAIT_SYNC_TIMEOUT, fail_if_timeout=True,
wait_for_engine_1=True, wait_for_engine_2=False, wait_win=False, enforce_errors=True):
log.debug("Wait for sync")
# First wait for server if needed
if wait_for_async:
self.wait()
if sys.platform == "win32" and wait_win:
from nxdrive.engine.watcher.local_watcher import WIN_MOVE_RESOLUTION_PERIOD
log.trace("Need to wait for Windows delete resolution")
sleep(WIN_MOVE_RESOLUTION_PERIOD/1000)
self._wait_sync = {
self.engine_1.get_uid(): wait_for_engine_1,
self.engine_2.get_uid(): wait_for_engine_2
}
self._no_remote_changes = {self.engine_1.get_uid(): not wait_for_engine_1,
self.engine_2.get_uid(): not wait_for_engine_2}
if enforce_errors:
if not self.connected:
self.engine_1.syncPartialCompleted.connect(self.engine_1.get_queue_manager().requeue_errors)
self.engine_2.syncPartialCompleted.connect(self.engine_1.get_queue_manager().requeue_errors)
self.connected = True
elif self.connected:
self.engine_1.syncPartialCompleted.disconnect(self.engine_1.get_queue_manager().requeue_errors)
self.engine_2.syncPartialCompleted.disconnect(self.engine_1.get_queue_manager().requeue_errors)
self.connected = False
while timeout > 0:
sleep(1)
timeout = timeout - 1
if sum(self._wait_sync.values()) == 0:
if wait_for_async:
log.debug('Sync completed, _wait_remote_scan = %r, remote changes count = %r,'
' no remote changes = %r',
self._wait_remote_scan, self._remote_changes_count, self._no_remote_changes)
wait_remote_scan = False
if wait_for_engine_1:
wait_remote_scan = self._wait_remote_scan[self.engine_1.get_uid()]
if wait_for_engine_2:
wait_remote_scan = wait_remote_scan or self._wait_remote_scan[self.engine_2.get_uid()]
is_remote_changes = True
is_change_summary_over = True
if wait_for_engine_1:
is_remote_changes = self._remote_changes_count[self.engine_1.get_uid()] > 0
is_change_summary_over = self._no_remote_changes[self.engine_1.get_uid()]
if wait_for_engine_2:
is_remote_changes = (is_remote_changes
and self._remote_changes_count[self.engine_2.get_uid()] > 0)
is_change_summary_over = (is_change_summary_over
and self._no_remote_changes[self.engine_2.get_uid()])
if (not wait_remote_scan or is_remote_changes and is_change_summary_over):
self._wait_remote_scan = {self.engine_1.get_uid(): wait_for_engine_1,
self.engine_2.get_uid(): wait_for_engine_2}
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}
log.debug('Ended wait for sync, setting _wait_remote_scan values to True,'
' _remote_changes_count values to 0 and _no_remote_changes values to False')
return
else:
log.debug("Sync completed, ended wait for sync")
return
if fail_if_timeout:
log.warn("Wait for sync timeout has expired")
if wait_for_engine_1 and self.engine_1.get_dao().get_syncing_count() != 0:
self.fail("Wait for sync timeout expired")
if wait_for_engine_2 and self.engine_2.get_dao().get_syncing_count() != 0:
self.fail("Wait for sync timeout expired")
else:
log.debug("Wait for sync timeout")
def wait_remote_scan(self, timeout=DEFAULT_WAIT_REMOTE_SCAN_TIMEOUT, wait_for_engine_1=True,
wait_for_engine_2=False):
log.debug("Wait for remote scan")
self._wait_remote_scan = {self.engine_1.get_uid(): wait_for_engine_1,
self.engine_2.get_uid(): wait_for_engine_2}
while timeout > 0:
sleep(1)
if sum(self._wait_remote_scan.values()) == 0:
log.debug("Ended wait for remote scan")
return
timeout = timeout - 1
self.fail("Wait for remote scan timeout expired")
def is_profiling(self):
return 'DRIVE_YAPPI' in os.environ and yappi is not None
def setup_profiler(self):
if not self.is_profiling():
return
yappi.start()
def teardown_profiler(self):
if not self.is_profiling():
return
path = os.environ["DRIVE_YAPPI"]
if not os.path.exists(path):
os.mkdir(path)
report_path = os.path.join(path, self.id() + '-yappi-threads')
with open(report_path, 'w') as fd:
columns = {0: ("name", 80), 1: ("tid", 15), 2: ("ttot", 8), 3: ("scnt", 10)}
yappi.get_thread_stats().print_all(out=fd, columns=columns)
report_path = os.path.join(path, self.id() + '-yappi-fcts')
with open(report_path, 'w') as fd:
columns = {0: ("name", 80), 1: ("ncall", 5), 2: ("tsub", 8), 3: ("ttot", 8), 4: ("tavg", 8)}
stats = yappi.get_func_stats()
stats.strip_dirs()
stats.print_all(out=fd, columns=columns)
log.debug("Profiler Report generated in '%s'", report_path)
def run(self, result=None):
self.app = TestQApplication([], self)
self.setUpApp()
self.result = result
# TODO Should use a specific application
def launch_test():
log.debug("UnitTest thread started")
sleep(1)
self.setup_profiler()
super(UnitTestCase, self).run(result)
self.teardown_profiler()
self.app.quit()
log.debug("UnitTest thread finished")
sync_thread = Thread(target=launch_test)
sync_thread.start()
self.app.exec_()
sync_thread.join(30)
self.tearDownApp()
del self.app
log.debug("UnitTest run finished")
def tearDown(self):
unittest.TestCase.tearDown(self)
if not self.tearedDown:
self.tearDownApp()
def tearDownApp(self, server_profile=None):
if self.tearedDown:
return
if sys.exc_info() != (None, None, None):
self.generate_report()
elif self.result is not None:
if hasattr(self.result, "wasSuccessful") and not self.result.wasSuccessful():
self.generate_report()
log.debug("TearDown unit test")
# Unbind all
self.manager_1.unbind_all()
self.manager_1.dispose_db()
self.manager_2.unbind_all()
self.manager_2.dispose_db()
Manager._singleton = None
self.tearDownServer(server_profile)
clean_dir(self.upload_tmp_dir)
clean_dir(self.local_test_folder_1)
clean_dir(self.local_test_folder_2)
del self.engine_1
self.engine_1 = None
del self.engine_2
self.engine_2 = None
del self.local_client_1
self.local_client_1 = None
del self.local_client_2
self.local_client_2 = None
del self.remote_document_client_1
self.remote_document_client_1 = None
del self.remote_document_client_2
self.remote_document_client_2 = None
del self.remote_file_system_client_1
self.remote_file_system_client_1 = None
del self.remote_file_system_client_2
self.remote_file_system_client_2 = None
self.tearedDown = True
def _interact(self, pause=0):
self.app.processEvents()
if pause > 0:
sleep(pause)
while (self.app.hasPendingEvents()):
self.app.processEvents()
def make_local_tree(self, root=None, local_client=None):
if local_client is None:
local_client = self.local_root_client_1
if root is None:
root = u"/" + self.workspace_title
if not local_client.exists(root):
local_client.make_folder(u"/", self.workspace_title)
# create some folders
folder_1 = local_client.make_folder(root, u'Folder 1')
folder_1_1 = local_client.make_folder(folder_1, u'Folder 1.1')
folder_1_2 = local_client.make_folder(folder_1, u'Folder 1.2')
folder_2 = local_client.make_folder(root, u'Folder 2')
# create some files
local_client.make_file(folder_2, u'Duplicated File.txt', content=b"Some content.")
local_client.make_file(folder_1, u'File 1.txt', content=b"aaa")
local_client.make_file(folder_1_1, u'File 2.txt', content=b"bbb")
local_client.make_file(folder_1_2, u'File 3.txt', content=b"ccc")
local_client.make_file(folder_2, u'File 4.txt', content=b"ddd")
local_client.make_file(root, u'File 5.txt', content=b"eee")
return (6, 5)
def make_server_tree(self, deep=True):
remote_client = self.remote_document_client_1
# create some folders on the server
folder_1 = remote_client.make_folder(self.workspace, u'Folder 1')
folder_2 = remote_client.make_folder(self.workspace, u'Folder 2')
if deep:
folder_1_1 = remote_client.make_folder(folder_1, u'Folder 1.1')
folder_1_2 = remote_client.make_folder(folder_1, u'Folder 1.2')
# create some files on the server
if deep:
self._duplicate_file_1 = remote_client.make_file(folder_2, u'Duplicated File.txt',
content=b"Some content.")
self._duplicate_file_2 = remote_client.make_file(folder_2, u'Duplicated File.txt',
content=b"Other content.")
if deep:
remote_client.make_file(folder_1, u'File 1.txt', content=b"aaa")
remote_client.make_file(folder_1_1, u'File 2.txt', content=b"bbb")
remote_client.make_file(folder_1_2, u'File 3.txt', content=b"ccc")
remote_client.make_file(folder_2, u'File 4.txt', content=b"ddd")
remote_client.make_file(self.workspace, u'File 5.txt', content=b"eee")
return (7, 4) if deep else (1, 2)
def get_local_child_count(self, path):
dir_count = 0
file_count = 0
for _, dirnames, filenames in os.walk(path):
dir_count += len(dirnames)
file_count += len(filenames)
if os.path.exists(os.path.join(path, '.partials')):
dir_count -= 1
return (dir_count, file_count)
def get_full_queue(self, queue, dao=None):
if dao is None:
dao = self.engine_1.get_dao()
result = []
while (len(queue) > 0):
result.append(dao.get_state_from_id(queue.pop().id))
return result
def generate_report(self):
if "REPORT_PATH" not in os.environ:
return
report_path = os.path.join(os.environ["REPORT_PATH"], self.id())
self.manager_1.generate_report(report_path)
log.debug("Report generated in '%s'", report_path)
def wait(self, retry=3):
try:
self.root_remote_client.wait()
except Exception as e:
log.debug("Exception while waiting for server : %r", e)
# Not the nicest
if retry > 0:
log.debug("Retry to wait")
self.wait(retry - 1)
def generate_random_jpg(self, filename, size):
try:
import numpy
from PIL import Image
except:
# Create random file
with open(filename, 'wb') as f:
f.write(os.urandom(1024 * size))
return
a = numpy.random.rand(size, size, 3) * 255
im_out = Image.fromarray(a.astype('uint8')).convert('RGBA')
im_out.save(filename)
def assertNxPart(self, path, name=None, present=True):
os_path = self.local_client_1._abspath(path)
children = os.listdir(os_path)
for child in children:
if len(child) < 8:
continue
if name is not None and len(child) < len(name) + 8:
continue
if child[0] == "." and child[-7:] == ".nxpart":
if name is None or child[1:len(name)+1] == name:
if present:
return
else:
self.fail("nxpart found in : '%s'" % (path))
if present:
self.fail("nxpart not found in : '%s'" % (path))
def get_dao_state_from_engine_1(self, path):
"""
Returns the pair from dao of engine 1 according to the path.
:param path: The path to document (from workspace, ex: /Folder is converted to /{{workspace_title_1}}/Folder).
:return: The pair from dao of engine 1 according to the path.
"""
abs_path = '/' + self.workspace_title_1 + path
return self.engine_1.get_dao().get_state_from_local(abs_path)
def test_sync_delete_shared_folder(self):
user_workspaces_path = '/default-domain/UserWorkspaces/'
user1_workspace_title = 'nuxeoDriveTestUser-user-1'
user1_workspace_path = user_workspaces_path + user1_workspace_title
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user1_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version, password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
user2_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version, password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_client_1 = LocalClient(self.local_nxdrive_folder_1)
# Activate permission hierarchy profile as Administrator
admin_remote_client.activate_profile('permission')
# Make sure user1 workspace is created
user1_remote_client.make_file_in_user_workspace(
'File in user workspace',
filename='USFile.txt')
# Register user workspace as a sync root for user1
user1_remote_client.register_as_root(user1_workspace_path)
# Bind server for user1
ctl_1 = self.controller_1
ctl_1.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
syn_1 = ctl_1.synchronizer
# Synchronize
self._synchronize(syn_1)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs'))
# Create test folder in user workspace as user1
user1_remote_client.make_folder(user1_workspace_path,
'test_folder')
# Synchronize
self._synchronize(syn_1)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs/test_folder'))
# Grant ReadWrite permission to user2 on test folder
test_folder_path = user1_workspace_path + '/test_folder'
op_input = "doc:" + test_folder_path
admin_remote_client.execute("Document.SetACE",
op_input=op_input,
user="******",
permission="ReadWrite",
grant="true")
# Register test folder as a sync root for user2
user2_remote_client.register_as_root(test_folder_path)
# Wait for a while:
time.sleep(2.0)
# Delete test folder
user1_remote_client.delete(test_folder_path)
# Synchronize
self._synchronize(syn_1)
# Check locally synchronized content
self.assertFalse(local_client_1.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client_1.get_children_info(
'/My Docs')), 1)
finally:
# Cleanup user workspace
if admin_remote_client.exists(user1_workspace_path):
admin_remote_client.delete(user1_workspace_path,
use_trash=False)
# Deactivate permission hierarchy profile
admin_remote_client.deactivate_profile('permission')
class UnitTestCase(unittest.TestCase):
def setUpServer(self, server_profile=None):
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
self.root_remote_client = RemoteDocumentClient(
self.nuxeo_url,
self.admin_user,
u'nxdrive-test-administrator-device',
self.version,
password=self.password,
base_folder=u'/',
timeout=60)
# Activate given profile if needed, eg. permission hierarchy
if server_profile is not None:
self.root_remote_client.activate_profile(server_profile)
# Call the Nuxeo operation to setup the integration test environment
credentials = self.root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2",
permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = self.root_remote_client.fetch(u'/default-domain/workspaces/')
children = self.root_remote_client.get_children(ws_info['uid'])
log.debug("SuperWorkspace info: %r", ws_info)
log.debug("SuperWorkspace children: %r", children)
ws_info = self.root_remote_client.fetch(TEST_WORKSPACE_PATH)
log.debug("Workspace info: %r", ws_info)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
self.workspace_1 = self.workspace
self.workspace_2 = self.workspace
self.workspace_title_1 = self.workspace_title
self.workspace_title_2 = self.workspace_title
def tearDownServer(self, server_profile=None):
# Don't need to revoke tokens for the file system remote clients
# since they use the same users as the remote document clients
self.root_remote_client.execute("NuxeoDrive.TearDownIntegrationTests")
# Deactivate given profile if needed, eg. permission hierarchy
if server_profile is not None:
self.root_remote_client.deactivate_profile(server_profile)
def get_local_client(self, path):
if AbstractOSIntegration.is_windows():
from nxdrive.tests.win_local_client import WindowsLocalClient
return WindowsLocalClient(path)
if AbstractOSIntegration.is_mac():
from nxdrive.tests.mac_local_client import MacLocalClient
return MacLocalClient(path)
return LocalClient(path)
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 wait_sync(self,
wait_for_async=False,
timeout=DEFAULT_WAIT_SYNC_TIMEOUT,
fail_if_timeout=True,
wait_for_engine_1=True,
wait_for_engine_2=False,
wait_win=False,
enforce_errors=True):
log.debug("Wait for sync")
# First wait for server if needed
if wait_for_async:
self.wait()
if sys.platform == "win32" and wait_win:
from nxdrive.engine.watcher.local_watcher import WIN_MOVE_RESOLUTION_PERIOD
log.trace("Need to wait for Windows delete resolution")
sleep(WIN_MOVE_RESOLUTION_PERIOD / 1000)
self._wait_sync = {
self.engine_1.get_uid(): wait_for_engine_1,
self.engine_2.get_uid(): wait_for_engine_2
}
self._no_remote_changes = {
self.engine_1.get_uid(): not wait_for_engine_1,
self.engine_2.get_uid(): not wait_for_engine_2
}
if enforce_errors:
if not self.connected:
self.engine_1.syncPartialCompleted.connect(
self.engine_1.get_queue_manager().requeue_errors)
self.engine_2.syncPartialCompleted.connect(
self.engine_1.get_queue_manager().requeue_errors)
self.connected = True
elif self.connected:
self.engine_1.syncPartialCompleted.disconnect(
self.engine_1.get_queue_manager().requeue_errors)
self.engine_2.syncPartialCompleted.disconnect(
self.engine_1.get_queue_manager().requeue_errors)
self.connected = False
while timeout > 0:
sleep(1)
timeout = timeout - 1
if sum(self._wait_sync.values()) == 0:
if wait_for_async:
log.debug(
'Sync completed, _wait_remote_scan = %r, remote changes count = %r,'
' no remote changes = %r', self._wait_remote_scan,
self._remote_changes_count, self._no_remote_changes)
wait_remote_scan = False
if wait_for_engine_1:
wait_remote_scan = self._wait_remote_scan[
self.engine_1.get_uid()]
if wait_for_engine_2:
wait_remote_scan = wait_remote_scan or self._wait_remote_scan[
self.engine_2.get_uid()]
is_remote_changes = True
is_change_summary_over = True
if wait_for_engine_1:
is_remote_changes = self._remote_changes_count[
self.engine_1.get_uid()] > 0
is_change_summary_over = self._no_remote_changes[
self.engine_1.get_uid()]
if wait_for_engine_2:
is_remote_changes = (
is_remote_changes and
self._remote_changes_count[self.engine_2.get_uid()]
> 0)
is_change_summary_over = (
is_change_summary_over and
self._no_remote_changes[self.engine_2.get_uid()])
if (not wait_remote_scan
or is_remote_changes and is_change_summary_over):
self._wait_remote_scan = {
self.engine_1.get_uid(): wait_for_engine_1,
self.engine_2.get_uid(): wait_for_engine_2
}
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
}
log.debug(
'Ended wait for sync, setting _wait_remote_scan values to True,'
' _remote_changes_count values to 0 and _no_remote_changes values to False'
)
return
else:
log.debug("Sync completed, ended wait for sync")
return
if fail_if_timeout:
log.warn("Wait for sync timeout has expired")
if wait_for_engine_1 and self.engine_1.get_dao().get_syncing_count(
) != 0:
self.fail("Wait for sync timeout expired")
if wait_for_engine_2 and self.engine_2.get_dao().get_syncing_count(
) != 0:
self.fail("Wait for sync timeout expired")
else:
log.debug("Wait for sync timeout")
def wait_remote_scan(self,
timeout=DEFAULT_WAIT_REMOTE_SCAN_TIMEOUT,
wait_for_engine_1=True,
wait_for_engine_2=False):
log.debug("Wait for remote scan")
self._wait_remote_scan = {
self.engine_1.get_uid(): wait_for_engine_1,
self.engine_2.get_uid(): wait_for_engine_2
}
while timeout > 0:
sleep(1)
if sum(self._wait_remote_scan.values()) == 0:
log.debug("Ended wait for remote scan")
return
timeout = timeout - 1
self.fail("Wait for remote scan timeout expired")
def is_profiling(self):
return 'DRIVE_YAPPI' in os.environ and yappi is not None
def setup_profiler(self):
if not self.is_profiling():
return
yappi.start()
def teardown_profiler(self):
if not self.is_profiling():
return
path = os.environ["DRIVE_YAPPI"]
if not os.path.exists(path):
os.mkdir(path)
report_path = os.path.join(path, self.id() + '-yappi-threads')
with open(report_path, 'w') as fd:
columns = {
0: ("name", 80),
1: ("tid", 15),
2: ("ttot", 8),
3: ("scnt", 10)
}
yappi.get_thread_stats().print_all(out=fd, columns=columns)
report_path = os.path.join(path, self.id() + '-yappi-fcts')
with open(report_path, 'w') as fd:
columns = {
0: ("name", 80),
1: ("ncall", 5),
2: ("tsub", 8),
3: ("ttot", 8),
4: ("tavg", 8)
}
stats = yappi.get_func_stats()
stats.strip_dirs()
stats.print_all(out=fd, columns=columns)
log.debug("Profiler Report generated in '%s'", report_path)
def run(self, result=None):
self.logger = log
repeat = 1
testMethod = getattr(self, self._testMethodName)
if hasattr(testMethod, '_repeat'):
repeat = testMethod._repeat
while repeat > 0:
self.app = TestQApplication([], self)
self.setUpApp()
self.result = result
# TODO Should use a specific application
def launch_test():
log.debug("UnitTest thread started")
sleep(1)
self.setup_profiler()
super(UnitTestCase, self).run(result)
self.teardown_profiler()
self.app.quit()
log.debug("UnitTest thread finished")
sync_thread = Thread(target=launch_test)
sync_thread.start()
self.app.exec_()
sync_thread.join(30)
self.tearDownApp()
del self.app
repeat -= 1
log.debug("UnitTest run finished")
def tearDown(self):
unittest.TestCase.tearDown(self)
if not self.tearedDown:
self.tearDownApp()
def tearDownApp(self, server_profile=None):
if self.tearedDown:
return
if sys.exc_info() != (None, None, None):
self.generate_report()
elif self.result is not None:
if hasattr(self.result,
"wasSuccessful") and not self.result.wasSuccessful():
self.generate_report()
log.debug("TearDown unit test")
# Unbind all
self.manager_1.unbind_all()
self.manager_1.dispose_db()
self.manager_2.unbind_all()
self.manager_2.dispose_db()
Manager._singleton = None
self.tearDownServer(server_profile)
clean_dir(self.upload_tmp_dir)
clean_dir(self.local_test_folder_1)
clean_dir(self.local_test_folder_2)
del self.engine_1
self.engine_1 = None
del self.engine_2
self.engine_2 = None
del self.local_client_1
self.local_client_1 = None
del self.local_client_2
self.local_client_2 = None
del self.remote_document_client_1
self.remote_document_client_1 = None
del self.remote_document_client_2
self.remote_document_client_2 = None
del self.remote_file_system_client_1
self.remote_file_system_client_1 = None
del self.remote_file_system_client_2
self.remote_file_system_client_2 = None
self.tearedDown = True
def _interact(self, pause=0):
self.app.processEvents()
if pause > 0:
sleep(pause)
while (self.app.hasPendingEvents()):
self.app.processEvents()
def make_local_tree(self, root=None, local_client=None):
if local_client is None:
local_client = self.local_root_client_1
if root is None:
root = u"/" + self.workspace_title
if not local_client.exists(root):
local_client.make_folder(u"/", self.workspace_title)
# create some folders
folder_1 = local_client.make_folder(root, u'Folder 1')
folder_1_1 = local_client.make_folder(folder_1, u'Folder 1.1')
folder_1_2 = local_client.make_folder(folder_1, u'Folder 1.2')
folder_2 = local_client.make_folder(root, u'Folder 2')
# create some files
local_client.make_file(folder_2,
u'Duplicated File.txt',
content=b"Some content.")
local_client.make_file(folder_1, u'File 1.txt', content=b"aaa")
local_client.make_file(folder_1_1, u'File 2.txt', content=b"bbb")
local_client.make_file(folder_1_2, u'File 3.txt', content=b"ccc")
local_client.make_file(folder_2, u'File 4.txt', content=b"ddd")
local_client.make_file(root, u'File 5.txt', content=b"eee")
return (6, 5)
def make_server_tree(self, deep=True):
remote_client = self.remote_document_client_1
# create some folders on the server
folder_1 = remote_client.make_folder(self.workspace, u'Folder 1')
folder_2 = remote_client.make_folder(self.workspace, u'Folder 2')
if deep:
folder_1_1 = remote_client.make_folder(folder_1, u'Folder 1.1')
folder_1_2 = remote_client.make_folder(folder_1, u'Folder 1.2')
# create some files on the server
if deep:
self._duplicate_file_1 = remote_client.make_file(
folder_2, u'Duplicated File.txt', content=b"Some content.")
self._duplicate_file_2 = remote_client.make_file(
folder_2, u'Duplicated File.txt', content=b"Other content.")
if deep:
remote_client.make_file(folder_1, u'File 1.txt', content=b"aaa")
remote_client.make_file(folder_1_1, u'File 2.txt', content=b"bbb")
remote_client.make_file(folder_1_2, u'File 3.txt', content=b"ccc")
remote_client.make_file(folder_2, u'File 4.txt', content=b"ddd")
remote_client.make_file(self.workspace, u'File 5.txt', content=b"eee")
return (7, 4) if deep else (1, 2)
def get_local_child_count(self, path):
dir_count = 0
file_count = 0
for _, dirnames, filenames in os.walk(path):
dir_count += len(dirnames)
file_count += len(filenames)
if os.path.exists(os.path.join(path, '.partials')):
dir_count -= 1
return (dir_count, file_count)
def get_full_queue(self, queue, dao=None):
if dao is None:
dao = self.engine_1.get_dao()
result = []
while (len(queue) > 0):
result.append(dao.get_state_from_id(queue.pop().id))
return result
def generate_report(self):
if "REPORT_PATH" not in os.environ:
return
report_path = os.path.join(os.environ["REPORT_PATH"], self.id())
self.manager_1.generate_report(report_path)
log.debug("Report generated in '%s'", report_path)
def wait(self, retry=3):
try:
self.root_remote_client.wait()
except Exception as e:
log.debug("Exception while waiting for server : %r", e)
# Not the nicest
if retry > 0:
log.debug("Retry to wait")
self.wait(retry - 1)
def _set_read_permission(self, user, doc_path, grant):
op_input = "doc:" + doc_path
if grant:
self.root_remote_client.execute("Document.SetACE",
op_input=op_input,
user=user,
permission="Read",
grant="true")
else:
self.root_remote_client.block_inheritance(doc_path)
def generate_random_jpg(self, filename, size):
try:
import numpy
from PIL import Image
except:
# Create random file
with open(filename, 'wb') as f:
f.write(os.urandom(1024 * size))
return
a = numpy.random.rand(size, size, 3) * 255
im_out = Image.fromarray(a.astype('uint8')).convert('RGBA')
im_out.save(filename)
def assertNxPart(self, path, name=None, present=True):
os_path = self.local_client_1._abspath(path)
children = os.listdir(os_path)
for child in children:
if len(child) < 8:
continue
if name is not None and len(child) < len(name) + 8:
continue
if child[0] == "." and child[-7:] == ".nxpart":
if name is None or child[1:len(name) + 1] == name:
if present:
return
else:
self.fail("nxpart found in : '%s'" % (path))
if present:
self.fail("nxpart not found in : '%s'" % (path))
def get_dao_state_from_engine_1(self, path):
"""
Returns the pair from dao of engine 1 according to the path.
:param path: The path to document (from workspace, ex: /Folder is converted to /{{workspace_title_1}}/Folder).
:return: The pair from dao of engine 1 according to the path.
"""
abs_path = '/' + self.workspace_title_1 + path
return self.engine_1.get_dao().get_state_from_local(abs_path)
def test_sync_delete_shared_folder(self):
user_workspace_uid = None
try:
# Get remote and local clients
admin_remote_client = self.root_remote_client
user1_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version, password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
user2_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version, password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
local_client_1 = LocalClient(self.local_nxdrive_folder_1)
# Make sure user1 workspace is created and fetch its uid
user_workspace_uid = user1_remote_client.make_file_in_user_workspace('File in user workspace',
filename='USFile.txt')['parentRef']
# Register user workspace as a sync root for user1
user1_remote_client.register_as_root(user_workspace_uid)
# Start engine
self.engine_1.start()
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs'))
# Create test folder in user workspace as user1
test_folder_uid = user1_remote_client.make_folder(user_workspace_uid, 'test_folder')
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertTrue(local_client_1.exists('/My Docs/test_folder'))
# Grant ReadWrite permission to user2 on test folder
op_input = "doc:" + test_folder_uid
admin_remote_client.execute("Document.SetACE", op_input=op_input, user=self.user_2,
permission="ReadWrite", grant="true")
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Register test folder as a sync root for user2
user2_remote_client.register_as_root(test_folder_uid)
# Wait for synchronization
self.wait_sync(wait_for_async=True)
# Delete test folder
user1_remote_client.delete(test_folder_uid)
# Synchronize deletion
self.wait_sync(wait_for_async=True)
# Check locally synchronized content
self.assertFalse(local_client_1.exists('/My Docs/test_folder'))
self.assertEquals(len(local_client_1.get_children_info('/My Docs')), 1)
finally:
# Cleanup user workspace
if user_workspace_uid is not None and admin_remote_client.exists(user_workspace_uid):
admin_remote_client.delete(user_workspace_uid,
use_trash=False)
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)
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'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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)
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__
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Activate given profile if needed, eg. permission hierarchy
if server_profile is not None:
root_remote_client.activate_profile(server_profile)
# Call the Nuxeo operation to setup the integration test environment
credentials = root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
self.engine_1 = self.manager_1.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url, self.user_1,
self.password_1, start_engine=False)
self.engine_2 = self.manager_2.bind_server(self.local_nxdrive_folder_2, self.nuxeo_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()
ws_info = root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1, self.workspace_title)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2, self.workspace_title)
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 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title))
# Document client to be used to create remote test documents
# and folders
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads', dir=self.tmpdir)
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,
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,
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
)
# Register root
remote_document_client_1.register_as_root(self.workspace)
remote_document_client_2.register_as_root(self.workspace)
self.root_remote_client = root_remote_client
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 setUp(self):
# 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')
if None in (self.nuxeo_url, self.admin_user, self.password):
raise unittest.SkipTest(
"No integration server configuration found in environment.")
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device',
password=self.password, base_folder=u'/', timeout=60)
# Call the Nuxeo operation to setup the integration test environment
credentials = root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2")
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = root_remote_client.fetch(self.TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
# Document client to be used to create remote test documents
# and folders
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads')
remote_document_client_1 = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
password=self.password_1, base_folder=self.workspace,
upload_tmp_dir=self.upload_tmp_dir)
remote_document_client_2 = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
password=self.password_2, base_folder=self.workspace,
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',
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',
password=self.password_2, upload_tmp_dir=self.upload_tmp_dir)
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'-nxdrive-tests-user-1')
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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)
# Set echo to True to enable SQL statements logging
self.controller_1 = Controller(self.nxdrive_conf_folder_1,
echo=False)
self.controller_2 = Controller(self.nxdrive_conf_folder_2,
echo=False)
self.root_remote_client = root_remote_client
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
def setUp(self):
# 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')
# 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)
if None in (self.nuxeo_url, self.admin_user, self.password):
raise unittest.SkipTest(
"No integration server configuration found in environment.")
self.full_nuxeo_url = self.nuxeo_url
if '#' in self.nuxeo_url:
self.nuxeo_url = self.nuxeo_url.split('#')[0]
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-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)
self.version = nxdrive.__version__
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Call the Nuxeo operation to setup the integration test environment
credentials = root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
ws_info = root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
# Document client to be used to create remote test documents
# and folders
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads', dir=self.tmpdir)
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,
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,
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
)
# 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.root_remote_client = root_remote_client
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.local_client_1 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title))
ndrive_path = os.path.dirname(nxdrive.__file__)
self.ndrive_exec = os.path.join(ndrive_path, '..', 'scripts', 'ndrive.py')
cmdline_options = '--log-level-console=%s' % DEFAULT_CONSOLE_LOG_LEVEL
cmdline_options += ' --log-level-file=TRACE'
cmdline_options += ' --nxdrive-home="%s"'
if os.environ.get('PYDEV_DEBUG') == 'True':
cmdline_options += ' --debug-pydev'
self.ndrive_1_options = cmdline_options % self.nxdrive_conf_folder_1
self.ndrive_2_options = cmdline_options % self.nxdrive_conf_folder_2
