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_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 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_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 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):
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):
# 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_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')
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_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'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_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_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_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 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_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')
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
