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_synchronization_loop(self):
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
syn = ctl.synchronizer
expected_folder = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
self.assertEquals(ctl.list_pending(), [])
self.assertEquals(syn.synchronize(), 0)
# Perform first scan and sync
syn.loop(delay=0, max_loops=3)
self.assertEquals(ctl.list_pending(), [])
self.assertEquals(syn.synchronize(), 0)
# Let's create some document on the client and the server
local = LocalClient(expected_folder)
local.make_folder('/', 'Folder 3')
self.make_server_tree()
time.sleep(self.OS_STAT_MTIME_RESOLUTION)
self.wait()
# Run the full synchronization loop a limited amount of times
syn.loop(delay=0.010, max_loops=3)
# All is synchronized
self.assertEquals(ctl.list_pending(), [])
self.assertEquals(ctl.children_states(expected_folder), [
(u'File 5.txt', u'synchronized'),
(u'Folder 1', u'synchronized'),
(u'Folder 2', u'synchronized'),
(u'Folder 3', u'synchronized'),
])
def test_streaming_upload(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a text file
file_path = remote_client.make_tmp_file("Some content.")
doc_ref = remote_client.stream_file(
self.workspace, "Streamed text file", file_path, filename="My streamed file.txt"
)
self.assertEquals(remote_client.get_info(doc_ref).name, "Streamed text file")
self.assertEquals(remote_client.get_content(doc_ref), "Some content.")
# Update a document by streaming a new text file
file_path = remote_client.make_tmp_file("Other content.")
remote_client.stream_update(doc_ref, file_path, filename="My updated file.txt")
# As a workaround for https://jira.nuxeo.com/browse/NXP-10964,
# wait for a while to ensure transaction is committed before
# Blob response is serialized and sent to the client
sleep(1.0)
self.assertEquals(remote_client.get_content(doc_ref), "Other content.")
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, "testFile.pdf")
copyfile("nxdrive/tests/resources/testFile.pdf", file_path)
doc_ref = remote_client.stream_file(self.workspace, "Streamed binary file", file_path)
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEquals(doc_info.name, "Streamed binary file")
self.assertEquals(doc_info.digest, local_client.get_info("/testFile.pdf").get_digest())
def test_streaming_upload(self):
remote_client = self.remote_file_system_client_1
# Create a document by streaming a text file
file_path = remote_client.make_tmp_file("Some content.")
try:
fs_item_info = remote_client.stream_file(self.workspace_id, file_path, filename='My streamed file.txt')
finally:
os.remove(file_path)
fs_item_id = fs_item_info.uid
self.assertEquals(fs_item_info.name,
'My streamed file.txt')
self.assertEquals(remote_client.get_content(fs_item_id),
"Some content.")
# Update a document by streaming a new text file
file_path = remote_client.make_tmp_file("Other content.")
try:
fs_item_info = remote_client.stream_update(fs_item_id, file_path, filename='My updated file.txt')
finally:
os.remove(file_path)
self.assertEqual(fs_item_info.uid, fs_item_id)
self.assertEquals(fs_item_info.name,
'My updated file.txt')
self.assertEquals(remote_client.get_content(fs_item_id),
"Other content.")
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
fs_item_info = remote_client.stream_file(self.workspace_id, file_path)
local_client = LocalClient(self.upload_tmp_dir)
self.assertEquals(fs_item_info.name, 'testFile.pdf')
self.assertEquals(fs_item_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
def test_synchronization_loop():
ctl.bind_server(LOCAL_NXDRIVE_FOLDER, NUXEO_URL, USER, PASSWORD)
ctl.bind_root(LOCAL_NXDRIVE_FOLDER, TEST_WORKSPACE)
expected_folder = os.path.join(LOCAL_NXDRIVE_FOLDER, TEST_WORKSPACE_TITLE)
assert_equal(ctl.list_pending(), [])
assert_equal(ctl.synchronize(), 0)
# Let's create some document on the client and the server
local = LocalClient(expected_folder)
local.make_folder("/", "Folder 3")
make_server_tree()
# Run the full synchronization loop a limited amount of times
ctl.loop(full_local_scan=True, full_remote_scan=True, delay=0.010, max_loops=3, fault_tolerant=False)
# All is synchronized
assert_equal(len(ctl.list_pending()), 0)
assert_equal(
ctl.children_states(expected_folder),
[
(u"/File 5.txt", u"synchronized"),
(u"/Folder 1", u"synchronized"),
(u"/Folder 2", u"synchronized"),
(u"/Folder 3", u"synchronized"),
],
)
def _local_bind_root(self, server_binding, remote_info, nxclient, session):
# Check that this workspace does not already exist locally
# TODO: shall we handle deduplication for root names too?
local_root = os.path.join(server_binding.local_folder,
safe_filename(remote_info.name))
repository = nxclient.repository
if not os.path.exists(local_root):
os.makedirs(local_root)
lcclient = LocalClient(local_root)
local_info = lcclient.get_info('/')
try:
existing_binding = session.query(RootBinding).filter_by(
local_root=local_root,
).one()
if (existing_binding.remote_repo != repository
or existing_binding.remote_root != remote_info.uid):
raise RuntimeError(
"%r is already bound to %r on repo %r of %r" % (
local_root,
existing_binding.remote_root,
existing_binding.remote_repo,
existing_binding.server_binding.server_url))
except NoResultFound:
# Register the new binding itself
log.info("Binding local root '%s' to '%s' (id=%s) on server '%s'",
local_root, remote_info.name, remote_info.uid,
server_binding.server_url)
session.add(RootBinding(local_root, repository, remote_info.uid))
# Initialize the metadata info by recursive walk on the remote
# folder structure
self._recursive_init(lcclient, local_info, nxclient, remote_info)
session.commit()
def test_synchronize_deleted_blob(self):
# Bind the server and root workspace
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
# Launch first synchronization
time.sleep(self.AUDIT_CHANGE_FINDER_TIME_RESOLUTION)
self.wait()
syn = ctl.synchronizer
syn.loop(delay=0.1, max_loops=1)
# Get local and remote clients
local = LocalClient(os.path.join(self.local_nxdrive_folder_1,
self.workspace_title))
remote = self.remote_document_client_1
# Create a doc with a blob in the remote root workspace
# then synchronize
remote.make_file('/', 'test.odt', 'Some content.')
time.sleep(self.AUDIT_CHANGE_FINDER_TIME_RESOLUTION)
self.wait()
syn.loop(delay=0.1, max_loops=1)
self.assertTrue(local.exists('/test.odt'))
# Delete the blob from the remote doc then synchronize
remote.delete_content('/test.odt')
time.sleep(self.AUDIT_CHANGE_FINDER_TIME_RESOLUTION)
self.wait()
syn.loop(delay=0.1, max_loops=1)
self.assertFalse(local.exists('/test.odt'))
def setUp(self):
super(TestIntegrationVersioning, self).setUp()
self.controller_1.bind_server(self.local_nxdrive_folder_1,
self.nuxeo_url, self.user_1, self.password_1)
self.controller_2.bind_server(self.local_nxdrive_folder_2,
self.nuxeo_url, self.user_2, self.password_2)
self.sb_1 = self.controller_1.get_server_binding(
self.local_nxdrive_folder_1)
self.sb_2 = self.controller_2.get_server_binding(
self.local_nxdrive_folder_2)
self.controller_1.bind_root(self.local_nxdrive_folder_1,
self.workspace)
self.controller_2.bind_root(self.local_nxdrive_folder_2,
self.workspace)
self.syn_1 = self.controller_1.synchronizer
self.syn_2 = self.controller_2.synchronizer
self.syn_1.loop(delay=0.010, max_loops=1)
self.syn_2.loop(delay=0.010, max_loops=1)
self.remote_client_1 = self.remote_document_client_1
self.remote_client_2 = self.remote_document_client_2
sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2,
self.workspace_title)
self.local_client_1 = LocalClient(sync_root_folder_1)
self.local_client_2 = LocalClient(sync_root_folder_2)
# Call the Nuxeo operation to set the versioning delay to 3 seconds
self.versioning_delay = self.OS_STAT_MTIME_RESOLUTION * 3
self.root_remote_client.execute(
"NuxeoDrive.SetVersioningOptions",
delay=str(self.versioning_delay))
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_streaming_upload(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a text file
file_path = remote_client.make_tmp_file("Some content.")
try:
doc_ref = remote_client.stream_file(self.workspace, 'Streamed text file', file_path,
filename='My streamed file.txt')
finally:
os.remove(file_path)
self.assertEqual(remote_client.get_info(doc_ref).name,
'Streamed text file')
self.assertEqual(remote_client.get_content(doc_ref), "Some content.")
# Update a document by streaming a new text file
file_path = remote_client.make_tmp_file("Other content.")
try:
remote_client.stream_update(doc_ref, file_path, filename='My updated file.txt')
finally:
os.remove(file_path)
self.assertEqual(remote_client.get_content(doc_ref), "Other content.")
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile(self.location + '/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file', file_path)
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEqual(doc_info.name, 'Streamed binary file')
self.assertEqual(doc_info.digest_algorithm, 'md5')
self.assertEqual(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
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_find_changes_with_many_doc_creations(self):
# Setup a controller and bind a root for user_1
ctl = self.controller_1
remote_client = self.remote_document_client_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
syn = ctl.synchronizer
# Synchronize the workspace folder
self.wait()
syn.loop(delay=0.010, max_loops=1)
# Open a local client on the local workspace root
expected_folder = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
local_client = LocalClient(expected_folder)
self.assertEquals(local_client.get_children_info(u'/'), [])
# List of children names to create
n_children = 5
child_name_pattern = "child_%03d.txt"
children_names = [child_name_pattern % i
for i in range(n_children)]
# Launch a synchronizer thread concurrently that will stop
# automatically as soon as all the children are synchronized
def synchronization_loop():
for i in range(3):
syn.loop(delay=1, max_loops=2)
local_children_names = [
c.name for c in local_client.get_children_info(u'/')]
local_children_names.sort()
if local_children_names == children_names:
# All remote children have been successfully synchronized
# in the local folder
return
sync_thread = Thread(target=synchronization_loop)
sync_thread.start()
# Create the children to synchronize on the remote server concurrently
# in a long running transaction
remote_client.timeout = 10 # extend the timeout
self.create_docs(self.workspace, n_children,
name_pattern=child_name_pattern, delay=0.5)
# Wait for the synchronizer thread to complete
self.wait_audit_change_finder_if_needed()
self.wait()
sync_thread.join()
# Check that all the children creations where detected despite the
# creation transaction spanning longer than the individual audit
# query time ranges.
local_children_names = [
c.name for c in local_client.get_children_info(u'/')]
local_children_names.sort()
self.assertEquals(local_children_names, children_names)
def test_local_rename_sync_root_folder(self):
# Use the Administrator to be able to introspect the container of the
# test workspace.
remote_client = RemoteDocumentClientForTests(
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.assertEqual(workspace_info.name,
u"Renamed Nuxeo Drive Test Workspace")
folder_1_info = remote_client.get_info(folder_1_uid)
self.assertEqual(folder_1_info.name, u"Original Folder 1")
self.assertEqual(folder_1_info.parent_uid, self.workspace)
self.assertEqual(
len(remote_client.get_children_info(self.workspace_1)), 4)
def test_find_changes_with_many_doc_creations(self):
raise SkipTest("WIP in https://jira.nuxeo.com/browse/NXDRIVE-170")
# Setup a controller and bind a root for user_1
ctl = self.controller_1
remote_client = self.remote_document_client_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
syn = ctl.synchronizer
# Synchronize the workspace folder
self.wait()
syn.loop(delay=0.010, max_loops=1)
# Open a local client on the local workspace root
expected_folder = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
local_client = LocalClient(expected_folder)
self.assertEquals(local_client.get_children_info(u'/'), [])
# List of children names to create
n_children = 5
child_name_pattern = "child_%03d.txt"
children_names = [child_name_pattern % i
for i in range(n_children)]
# Launch a synchronizer thread concurrently that will stop
# automatically as soon as all the children are synchronized
def synchronization_loop():
for i in range(3):
syn.loop(delay=1, max_loops=2)
local_children_names = [
c.name for c in local_client.get_children_info(u'/')]
local_children_names.sort()
if local_children_names == children_names:
# All remote children have been successfully synchronized
# in the local folder
return
sync_thread = Thread(target=synchronization_loop)
sync_thread.start()
# Create the children to synchronize on the remote server concurrently
# in a long running transaction
remote_client.timeout = 10 # extend the timeout
self.create_docs(self.workspace, n_children,
name_pattern=child_name_pattern, delay=0.5)
# Wait for the synchronizer thread to complete
self.wait()
sync_thread.join()
# Check that all the children creations where detected despite the
# creation transaction spanning longer than the individual audit
# query time ranges.
local_children_names = [
c.name for c in local_client.get_children_info(u'/')]
local_children_names.sort()
self.assertEquals(local_children_names, children_names)
def test_streaming_upload(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a text file
file_path = remote_client.make_tmp_file("Some content.")
doc_ref = remote_client.stream_file(self.workspace,
'Streamed text file', file_path,
filename='My streamed file.txt')
self.assertEquals(remote_client.get_info(doc_ref).name,
'Streamed text file')
self.assertEquals(remote_client.get_content(doc_ref), "Some content.")
# Update a document by streaming a new text file
file_path = remote_client.make_tmp_file("Other content.")
remote_client.stream_update(doc_ref, file_path,
filename='My updated file.txt')
self.assertEquals(remote_client.get_content(doc_ref), "Other content.")
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file', file_path)
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEquals(doc_info.name, 'Streamed binary file')
self.assertEquals(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
def test_streaming_upload(self):
remote_client = self.remote_file_system_client_1
# Create a document by streaming a text file
file_path = remote_client.make_tmp_file("Some content.")
try:
fs_item_info = remote_client.stream_file(
self.workspace_id, file_path, filename='My streamed file.txt')
finally:
os.remove(file_path)
fs_item_id = fs_item_info.uid
self.assertEquals(fs_item_info.name, 'My streamed file.txt')
self.assertEquals(remote_client.get_content(fs_item_id),
"Some content.")
# Update a document by streaming a new text file
file_path = remote_client.make_tmp_file("Other content.")
try:
fs_item_info = remote_client.stream_update(
fs_item_id, file_path, filename='My updated file.txt')
finally:
os.remove(file_path)
self.assertEqual(fs_item_info.uid, fs_item_id)
self.assertEquals(fs_item_info.name, 'My updated file.txt')
self.assertEquals(remote_client.get_content(fs_item_id),
"Other content.")
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
fs_item_info = remote_client.stream_file(self.workspace_id, file_path)
local_client = LocalClient(self.upload_tmp_dir)
self.assertEquals(fs_item_info.name, 'testFile.pdf')
self.assertEquals(fs_item_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
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 setUp(self):
super(TestIntegrationLocalRootDeletion, self).setUp()
self.sb_1 = self.controller_1.bind_server(self.local_nxdrive_folder_1,
self.nuxeo_url, self.user_1,
self.password_1)
self.controller_1.bind_root(self.local_nxdrive_folder_1,
self.workspace)
# Deactivate Watchdog as it prevents the Nuxeo Drive folder from being
# well removed later on by shutil.rmtree, thus re-created by the
# synchronizer during rollback if activated.
def no_watchdog():
return False
self.controller_1.use_watchdog = no_watchdog
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
self.local_client_1 = LocalClient(self.sync_root_folder_1)
self.local_client_1.make_file(
'/',
u'Original File 1.txt',
content=u'Some Content 1'.encode('utf-8'))
self.local_client_1.make_file(
'/',
u'Original File 2.txt',
content=u'Some Content 2'.encode('utf-8'))
self.local_client_1.make_folder(u'/', u'Original Folder 1')
self.local_client_1.make_folder(u'/Original Folder 1',
u'Sub-Folder 1.1')
self.local_client_1.make_folder(u'/Original Folder 1',
u'Sub-Folder 1.2')
self.local_client_1.make_file(
u'/Original Folder 1',
u'Original File 1.1.txt',
content=u'Some Content 1'.encode('utf-8')) # Same content as OF1
self.local_client_1.make_folder('/', 'Original Folder 2')
self.local_client_1.make_file(
'/Original Folder 2',
u'Original File 3.txt',
content=u'Some Content 3'.encode('utf-8'))
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
self.local_client_1.unlock_path(self.sync_root_folder_1)
# Force the write mode under Windows
import stat
if os.access(self.local_nxdrive_folder_1, os.W_OK):
os.chmod(
self.local_nxdrive_folder_1, stat.S_IXUSR | stat.S_IRGRP
| stat.S_IXGRP | stat.S_IRUSR | stat.S_IWGRP | stat.S_IWUSR)
shutil.rmtree(self.local_nxdrive_folder_1, False)
def get_local_client(self):
client = LocalClient(
self.local_folder,
case_sensitive=self._case_sensitive,
)
if self._case_sensitive is None and os.path.exists(self.local_folder):
self._case_sensitive = client.is_case_sensitive()
return client
def setUpApp(self):
super(TestDirectEdit, self).setUpApp()
self.direct_edit = self.manager_1.direct_edit
self.direct_edit._test = True
self.direct_edit.directEditUploadCompleted.connect(self.app.sync_completed)
self.direct_edit.start()
self.remote = self.remote_document_client_1
self.local = LocalClient(os.path.join(self.nxdrive_conf_folder_1, 'edit'))
def test_delete_local_folder_delay_remote_changes_fetch(self):
# Get local and remote clients
local = LocalClient(self.local_nxdrive_folder_1)
remote = self.remote_document_client_1
# Bind server and test workspace for nuxeoDriveTestUser_user_1
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
# Launch first synchronization
self.wait_audit_change_finder_if_needed()
self.wait()
sync = ctl.synchronizer
sync.loop(delay=0.1, max_loops=1)
# Test workspace should be created locally
self.assertTrue(local.exists('/Nuxeo Drive Test Workspace'))
# Create a local folder in the test workspace and a file inside
# this folder, then synchronize
local.make_folder('/Nuxeo Drive Test Workspace', 'Test folder')
local.make_file('/Nuxeo Drive Test Workspace/Test folder',
'test.odt', 'Some content.')
sync.loop(delay=0.1, max_loops=1)
# Test folder should be created remotely in the test workspace
self.assertTrue(remote.exists('/Test folder'))
self.assertTrue(remote.exists('/Test folder/test.odt'))
# Delete Test folder locally before fetching remote changes,
# then synchronize
local.delete('/Nuxeo Drive Test Workspace/Test folder')
self.assertFalse(local.exists(
'/Nuxeo Drive Test Workspace/Test folder'))
self.wait_audit_change_finder_if_needed()
self.wait()
sync.loop(delay=0.1, max_loops=1)
# Test folder should be deleted remotely in the test workspace.
# Even though fetching the remote changes will send
# 'documentCreated' events for Test folder and its child file
# as a result of the previous synchronization loop, since the folder
# will not have been renamed nor moved since last synchronization,
# its remote pair state will not be marked as 'modified',
# see Model.update_remote().
# Thus the pair state will be ('deleted', 'synchronized'), resolved as
# 'locally_deleted'.
self.assertFalse(remote.exists('Test folder'))
# Check Test folder has not been re-created locally
self.assertFalse(local.exists(
'/Nuxeo Drive Test Workspace/Test folder'))
def setup_temp_folder():
global lcclient, LOCAL_TEST_FOLDER, TEST_WORKSPACE
build_workspace = os.environ.get('WORKSPACE')
tmpdir = None
if build_workspace is not None:
tmpdir = os.path.join(build_workspace, "tmp")
if not os.path.isdir(tmpdir):
os.makedirs(tmpdir)
LOCAL_TEST_FOLDER = tempfile.mkdtemp(u'-nuxeo-drive-tests', dir=tmpdir)
lcclient = LocalClient(LOCAL_TEST_FOLDER)
TEST_WORKSPACE = lcclient.make_folder(u'/', u'Some Workspace')
def setup_temp_folder():
global lcclient, LOCAL_TEST_FOLDER, TEST_WORKSPACE
build_workspace = os.environ.get('WORKSPACE')
tmpdir = None
if build_workspace is not None:
tmpdir = os.path.join(build_workspace, "tmp")
if not os.path.isdir(tmpdir):
os.makedirs(tmpdir)
LOCAL_TEST_FOLDER = tempfile.mkdtemp(u'-nuxeo-drive-tests', dir=tmpdir)
lcclient = LocalClient(LOCAL_TEST_FOLDER)
TEST_WORKSPACE = lcclient.make_folder(u'/', u'Some Workspace')
def test_bad_mime_type(self):
remote_client = self.remote_file_system_client_1
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, "testFile.pdf")
copyfile("nxdrive/tests/resources/testFile.pdf", file_path)
fs_item_id = remote_client.stream_file(self.workspace_id, file_path, mime_type="pdf")
local_client = LocalClient(self.upload_tmp_dir)
fs_item_info = remote_client.get_info(fs_item_id)
self.assertEquals(fs_item_info.name, "testFile.pdf")
self.assertEquals(fs_item_info.digest, local_client.get_info("/testFile.pdf").get_digest())
def test_bad_mime_type(self):
remote_client = self.remote_file_system_client_1
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile(self.location + '/resources/testFile.pdf', file_path)
fs_item_info = remote_client.stream_file(self.workspace_id, file_path,
mime_type='pdf')
local_client = LocalClient(self.upload_tmp_dir)
self.assertEqual(fs_item_info.name, 'testFile.pdf')
self.assertEqual(fs_item_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
def _add_top_level_state(self, server_binding, session):
local_client = LocalClient(server_binding.local_folder)
local_info = local_client.get_info(u'/')
remote_client = self.get_remote_fs_client(server_binding)
remote_info = remote_client.get_filesystem_root_info()
state = LastKnownState(server_binding.local_folder,
local_info=local_info,
local_state='synchronized',
remote_info=remote_info,
remote_state='synchronized')
session.add(state)
def _add_top_level_state(self, server_binding, session):
local_client = LocalClient(server_binding.local_folder)
local_info = local_client.get_info(u'/')
remote_client = self.get_remote_fs_client(server_binding)
remote_info = remote_client.get_filesystem_root_info()
state = LastKnownState(server_binding.local_folder,
local_info=local_info,
local_state='synchronized',
remote_info=remote_info,
remote_state='synchronized')
session.add(state)
def get_local_client(self, path):
if AbstractOSIntegration.is_mac() and (
self._testMethodName == 'test_local_delete_readonly_folder' or
self._testMethodName == 'test_local_rename_readonly_folder'):
return LocalClient(path)
# Old mac dont handle case rename
if AbstractOSIntegration.is_mac(
) and AbstractOSIntegration.os_version_below("10.10") and (
self._testMethodName
== 'test_local_rename_file_uppercase_stopped'
or self._testMethodName == 'test_local_rename_file_uppercase'):
return LocalClient(path)
return super(TestLocalMoveAndRename, self).get_local_client(path)
def test_single_quote_escaping(self):
remote = self.remote_document_client_1
local = LocalClient(self.local_nxdrive_folder_1)
remote.unregister_as_root(self.workspace)
self.engine_1.start()
remote.make_folder('/', "APPEL D'OFFRES")
remote.register_as_root("/APPEL D'OFFRES")
self.wait_sync(wait_for_async=True)
self.assertTrue(local.exists("/APPEL D'OFFRES"))
remote.unregister_as_root("/APPEL D'OFFRES")
self.wait_sync(wait_for_async=True)
self.assertFalse(local.exists("/APPEL D'OFFRES"))
def test_local_replace(self):
local = LocalClient(self.local_test_folder_1)
remote = self.remote_document_client_1
self.engine_1.start()
self.wait_sync(wait_for_async=True)
# Create 2 files with the same name but different content
# in separate folders
local.make_file('/', 'test.odt', 'Some content.')
local.make_folder('/', 'folder')
shutil.copyfile(
os.path.join(self.local_test_folder_1, 'test.odt'),
os.path.join(self.local_test_folder_1, 'folder', 'test.odt'))
local.update_content('/folder/test.odt', 'Updated content.')
# Copy the newest file to the root workspace and synchronize it
sync_root = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
test_file = os.path.join(self.local_test_folder_1, 'folder',
'test.odt')
shutil.copyfile(test_file, os.path.join(sync_root, 'test.odt'))
self.wait_sync()
self.assertTrue(remote.exists('/test.odt'))
self.assertEqual(remote.get_content('/test.odt'), 'Updated content.')
# Copy the oldest file to the root workspace and synchronize it.
# First wait a bit for file time stamps to increase enough.
time.sleep(OS_STAT_MTIME_RESOLUTION)
shutil.copyfile(os.path.join(self.local_test_folder_1, 'test.odt'),
os.path.join(sync_root, 'test.odt'))
self.wait_sync()
self.assertTrue(remote.exists('/test.odt'))
self.assertEqual(remote.get_content('/test.odt'), 'Some content.')
def test_synchronization_offline(self):
raise SkipTest("WIP in https://jira.nuxeo.com/browse/NXDRIVE-170")
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
syn = ctl.synchronizer
expected_folder = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
# Bound root but nothing is synced yet
self.assertEquals(ctl.list_pending(), [])
self.assertEquals(syn.synchronize(), 0)
# Perform first scan and sync
syn.loop(delay=0, max_loops=3)
self.assertEquals(ctl.list_pending(), [])
self.assertEquals(syn.synchronize(), 0)
# Let's create some document on the client and the server
local = LocalClient(expected_folder)
local.make_folder('/', 'Folder 3')
self.make_server_tree()
self.wait()
# Find various ways to simulate a network or server failure
errors = [
urllib2.URLError('Test error'),
socket.error('Test error'),
httplib.HTTPException('Test error'),
]
for error in errors:
ctl.make_remote_raise(error)
# Synchronization does not occur but does not fail either
syn.loop(delay=0, max_loops=1)
# Only the local change has been detected
self.assertEquals(len(ctl.list_pending()), 1)
# Reenable network
ctl.make_remote_raise(None)
syn.loop(delay=0, max_loops=2)
# All is synchronized
self.assertEquals(ctl.list_pending(), [])
self.assertEquals(ctl.children_states(expected_folder), [
(u'File 5.txt', u'synchronized'),
(u'Folder 1', u'synchronized'),
(u'Folder 2', u'synchronized'),
(u'Folder 3', u'synchronized'),
])
def test_bad_mime_type(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile(self.location + '/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file',
file_path, mime_type='pdf')
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEqual(doc_info.name, 'Streamed binary file')
self.assertEqual(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest(digest_func=doc_info.digest_algorithm))
def test_single_quote_escaping(self):
remote = self.remote_document_client_1
local = LocalClient(self.local_nxdrive_folder_1)
remote.unregister_as_root(self.workspace)
self.engine_1.start()
remote.make_folder('/', "APPEL D'OFFRES")
remote.register_as_root("/APPEL D'OFFRES")
self.wait_sync(wait_for_async=True)
self.assertTrue(local.exists("/APPEL D'OFFRES"))
remote.unregister_as_root("/APPEL D'OFFRES")
self.wait_sync(wait_for_async=True)
self.assertFalse(local.exists("/APPEL D'OFFRES"))
def test_bad_mime_type(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file',
file_path, mime_type='pdf')
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEquals(doc_info.name, 'Streamed binary file')
self.assertEquals(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
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)
# Make sure user workspace is created
user_remote_client.make_file_in_user_workspace('File in user workspace', filename='USFile.txt')
# 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)
# 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_path)
# 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 admin_remote_client.exists(user_workspace_path):
admin_remote_client.delete(user_workspace_path,
use_trash=False)
def setUp(self):
self.admin = self.root_remote_client
self.user1 = RemoteDocumentClientForTests(
self.nuxeo_url, self.user_1, 'nxdrive-test-device-1', self.version,
password=self.password_1, upload_tmp_dir=self.upload_tmp_dir)
self.user2 = RemoteDocumentClientForTests(
self.nuxeo_url, self.user_2, 'nxdrive-test-device-2', self.version,
password=self.password_2, upload_tmp_dir=self.upload_tmp_dir)
self.local_client_1 = LocalClient(self.local_nxdrive_folder_1)
self.local_client_2 = LocalClient(self.local_nxdrive_folder_2)
# Make sure user workspace is created and fetch its UID
self.workspace_uid = self.user1.make_file_in_user_workspace(
'File in user workspace', filename='USFile.txt')['parentRef']
self.addCleanup(self.delete_wspace)
def test_single_quote_escaping(self):
remote = self.remote_document_client_1
local = LocalClient(self.local_nxdrive_folder_1)
self.setUpDrive_1(bind_root=False)
remote.make_folder('/', "APPEL D'OFFRES")
remote.register_as_root("/APPEL D'OFFRES")
self.wait()
self.ndrive()
self.assertTrue(local.exists("/APPEL D'OFFRES"))
remote.unregister_as_root("/APPEL D'OFFRES")
self.wait()
self.ndrive()
self.assertFalse(local.exists("/APPEL D'OFFRES"))
def setUpApp(self):
super(TestDriveEdit, self).setUpApp()
self.drive_edit = self.manager_1.get_drive_edit()
self.drive_edit.driveEditUploadCompleted.connect(self.app.sync_completed)
self.drive_edit.start()
self.remote = self.remote_document_client_1
self.local = LocalClient(os.path.join(self.nxdrive_conf_folder_1, "edit"))
def get_local_client(self, path):
if AbstractOSIntegration.is_windows():
from tests.win_local_client import WindowsLocalClient
return WindowsLocalClient(path)
if AbstractOSIntegration.is_mac():
from tests.mac_local_client import MacLocalClient
return MacLocalClient(path)
return LocalClient(path)
def test_drive_edit_non_synced_doc(self):
raise SkipTest("WIP in https://jira.nuxeo.com/browse/NXDRIVE-170")
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
local = LocalClient(self.local_nxdrive_folder_1)
remote = self.remote_document_client_1
syn = ctl.synchronizer
# Create file in test workspace (non sync root)
doc_id = remote.make_file('/', 'test.odt', 'Some content.')
# Drive edit file
ctl.download_edit(self.nuxeo_url, 'default', doc_id, 'test.odt',
open_file=False)
# Check file is downloaded to the Locally Edited folder
self.assertTrue(local.exists('/%s/test.odt'
% LOCALLY_EDITED_FOLDER_NAME))
self.assertEquals(local.get_content('/%s/test.odt'
% LOCALLY_EDITED_FOLDER_NAME),
'Some content.')
# Check Locally Edited collection exists, is registered as a sync root
# for test user and file is member of it
self.assertTrue(self.root_remote_client.exists(
self.locally_edited_path))
sync_roots = remote.get_roots()
self.assertEquals(len(sync_roots), 1)
self.assertEquals(sync_roots[0].path, self.locally_edited_path)
self.assertTrue(doc_id in
self.root_remote_client.get_collection_members(
self.locally_edited_path))
# Update locally edited file
# Let's first sync because of https://jira.nuxeo.com/browse/NXDRIVE-144
self._sync(syn)
time.sleep(OS_STAT_MTIME_RESOLUTION)
local.update_content('/%s/test.odt' % LOCALLY_EDITED_FOLDER_NAME,
'Updated content.')
self._sync(syn, wait_for_async=False)
self.assertEquals(remote.get_content('/test.odt'), 'Updated content.')
# Drive edit file a second time (should not download a new file but
# detect the existing one)
ctl.download_edit(self.nuxeo_url, 'default', doc_id, 'test.odt',
open_file=False)
self.assertEquals(len(local.get_children_info('/%s'
% LOCALLY_EDITED_FOLDER_NAME)), 1)
# Update locally edited file
time.sleep(OS_STAT_MTIME_RESOLUTION)
local.update_content('/%s/test.odt' % LOCALLY_EDITED_FOLDER_NAME,
'Twice updated content.')
self._sync(syn, wait_for_async=False)
self.assertEquals(remote.get_content('/test.odt'),
'Twice updated content.')
def test_local_replace(self):
local = LocalClient(self.local_test_folder_1)
remote = self.remote_document_client_1
self.engine_1.start()
self.wait_sync(wait_for_async=True)
# Create 2 files with the same name but different content
# in separate folders
local.make_file('/', 'test.odt', 'Some content.')
local.make_folder('/', 'folder')
copyfile(os.path.join(self.local_test_folder_1, 'test.odt'),
os.path.join(self.local_test_folder_1, 'folder', 'test.odt'))
local.update_content('/folder/test.odt', 'Updated content.')
# Copy the newest file to the root workspace and synchronize it
sync_root = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
test_file = os.path.join(self.local_test_folder_1, 'folder',
'test.odt')
copyfile(test_file, os.path.join(sync_root, 'test.odt'))
self.wait_sync()
self.assertTrue(remote.exists('/test.odt'))
self.assertEquals(remote.get_content('/test.odt'), 'Updated content.')
# Copy the oldest file to the root workspace and synchronize it.
# First wait a bit for file time stamps to increase enough.
time.sleep(OS_STAT_MTIME_RESOLUTION)
copyfile(os.path.join(self.local_test_folder_1, 'test.odt'),
os.path.join(sync_root, 'test.odt'))
self.wait_sync()
self.assertTrue(remote.exists('/test.odt'))
self.assertEquals(remote.get_content('/test.odt'), 'Some content.')
def test_local_rename_top_level_folder(self):
sb, ctl = self.sb_1, self.controller_1
local_client = LocalClient(self.local_test_folder_1)
session = ctl.get_session()
# Check top level folder
self.assertTrue(local_client.exists(u'/Nuxeo Drive'))
top_level_folder_info = local_client.get_info(u'/Nuxeo Drive')
self.assertEquals(top_level_folder_info.name, u'Nuxeo Drive')
self.assertEquals(
top_level_folder_info.filepath,
os.path.join(self.local_test_folder_1, u'Nuxeo Drive'))
# Check top level folder state
top_level_folder_state = session.query(LastKnownState).filter_by(
local_name=u'Nuxeo Drive').one()
self.assertEquals(top_level_folder_state.local_path, '/')
self.assertEquals(top_level_folder_state.local_name, u'Nuxeo Drive')
# Rename top level folder
local_client.rename(u'/Nuxeo Drive', u'Nuxeo Drive renamed')
top_level_folder_info = local_client.get_info(u'/Nuxeo Drive renamed')
self.assertEquals(top_level_folder_info.name, u'Nuxeo Drive renamed')
self.assertEquals(
top_level_folder_info.filepath,
os.path.join(self.local_test_folder_1, u'Nuxeo Drive renamed'))
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 1)
# Check deleted server binding
self.assertRaises(RuntimeError,
ctl.get_server_binding,
self.local_nxdrive_folder_1,
raise_if_missing=True)
# Check deleted pair state
self.assertEquals(len(session.query(LastKnownState).all()), 0)
def test_bad_mime_type(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file',
file_path, mime_type='pdf')
# Wait to make sure transaction is commited
# TODO: remove when https://jira.nuxeo.com/browse/NXP-10964 is
# fixed
sleep(1.0)
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEquals(doc_info.name, 'Streamed binary file')
self.assertEquals(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
def setUp(self):
super(TestIntegrationEncoding, self).setUp()
self.ctl = self.controller_1
self.ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
self.ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
self.syn = self.ctl.synchronizer
self.syn.loop(delay=0.010, max_loops=1, no_event_init=True)
# Fetch server binding after sync loop as it closes the Session
self.sb = self.ctl.get_server_binding(self.local_nxdrive_folder_1)
self.remote_client = self.remote_document_client_1
sync_root_folder = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
self.local_client = LocalClient(sync_root_folder)
def test_bad_mime_type(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file',
file_path,
mime_type='pdf')
# Wait to make sure transaction is commited
# TODO: remove when https://jira.nuxeo.com/browse/NXP-10964 is
# fixed
sleep(1.0)
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEquals(doc_info.name, 'Streamed binary file')
self.assertEquals(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
def get_root_id(self, file_path):
from nxdrive.client import LocalClient
ref = LocalClient.get_path_remote_id(file_path, 'ndriveroot')
if ref is None:
parent = os.path.dirname(file_path)
# We can't find in any parent
if parent == file_path or parent is None:
return None
return self.get_root_id(parent)
return ref
def setUp(self):
super(TestIntegrationLocalMoveAndRename, self).setUp()
self.sb_1 = self.controller_1.bind_server(self.local_nxdrive_folder_1,
self.nuxeo_url, self.user_1,
self.password_1)
self.controller_1.bind_root(self.local_nxdrive_folder_1,
self.workspace)
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
self.local_client_1 = LocalClient(self.sync_root_folder_1)
self.local_client_1.make_file(
'/',
u'Original File 1.txt',
content=u'Some Content 1'.encode('utf-8'))
self.local_client_1.make_file(
'/',
u'Original File 2.txt',
content=u'Some Content 2'.encode('utf-8'))
self.local_client_1.make_folder(u'/', u'Original Folder 1')
self.local_client_1.make_folder(u'/Original Folder 1',
u'Sub-Folder 1.1')
self.local_client_1.make_folder(u'/Original Folder 1',
u'Sub-Folder 1.2')
self.local_client_1.make_file(
u'/Original Folder 1',
u'Original File 1.1.txt',
content=u'Some Content 1'.encode('utf-8')) # Same content as OF1
self.local_client_1.make_folder('/', 'Original Folder 2')
self.local_client_1.make_file(
'/Original Folder 2',
u'Original File 3.txt',
content=u'Some Content 3'.encode('utf-8'))
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
def get_root_id(self, file_path):
from nxdrive.client import LocalClient
ref = LocalClient.get_path_remote_id(file_path, 'ndriveroot')
if ref is None:
parent = os.path.dirname(file_path)
# We can't find in any parent
if parent == file_path or parent is None:
return None
return self.get_root_id(parent)
return ref
def test_streaming_upload(self):
remote_client = self.remote_document_client_1
# Create a document by streaming a text file
file_path = remote_client.make_tmp_file("Some content.")
doc_ref = remote_client.stream_file(self.workspace,
'Streamed text file',
file_path,
filename='My streamed file.txt')
# Wait to make sure transaction is commited
# TODO: remove when https://jira.nuxeo.com/browse/NXP-10964 is
# fixed
sleep(1.0)
self.assertEquals(
remote_client.get_info(doc_ref).name, 'Streamed text file')
self.assertEquals(remote_client.get_content(doc_ref), "Some content.")
# Update a document by streaming a new text file
file_path = remote_client.make_tmp_file("Other content.")
remote_client.stream_update(doc_ref,
file_path,
filename='My updated file.txt')
# As a workaround for https://jira.nuxeo.com/browse/NXP-10964,
# wait for a while to ensure transaction is committed before
# Blob response is serialized and sent to the client
sleep(1.0)
self.assertEquals(remote_client.get_content(doc_ref), "Other content.")
# Create a document by streaming a binary file
file_path = os.path.join(self.upload_tmp_dir, 'testFile.pdf')
copyfile('nxdrive/tests/resources/testFile.pdf', file_path)
doc_ref = remote_client.stream_file(self.workspace,
'Streamed binary file', file_path)
# Wait to make sure transaction is commited
# TODO: remove when https://jira.nuxeo.com/browse/NXP-10964 is
# fixed
sleep(1.0)
local_client = LocalClient(self.upload_tmp_dir)
doc_info = remote_client.get_info(doc_ref)
self.assertEquals(doc_info.name, 'Streamed binary file')
self.assertEquals(doc_info.digest,
local_client.get_info('/testFile.pdf').get_digest())
def test_local_delete_top_level_folder(self):
sb, ctl = self.sb_1, self.controller_1
local_client = LocalClient(self.local_test_folder_1)
session = ctl.get_session()
# Check top level folder
self.assertTrue(local_client.exists(u'/Nuxeo Drive'))
# Delete top level folder
local_client.delete(u'/Nuxeo Drive')
self.assertRaises(NotFound, local_client.get_info, u'/Nuxeo Drive')
self.assertEquals(ctl.synchronizer.update_synchronize_server(sb), 1)
# Check deleted server binding
self.assertRaises(RuntimeError,
ctl.get_server_binding,
self.local_nxdrive_folder_1,
raise_if_missing=True)
# Check deleted pair state
self.assertEquals(len(session.query(LastKnownState).all()), 0)
def setUp(self):
super(TestIntegrationRemoteMoveAndRename, self).setUp()
self.sb_1 = self.controller_1.bind_server(self.local_nxdrive_folder_1,
self.nuxeo_url, self.user_1,
self.password_1)
self.controller_1.bind_root(self.local_nxdrive_folder_1,
self.workspace)
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
self.local_client_1 = LocalClient(self.sync_root_folder_1)
self.remote_client_1 = self.remote_file_system_client_1
self.workspace_id = ('defaultSyncRootFolderItemFactory#default#' +
self.workspace)
self.workspace_pair_local_path = u'/' + self.workspace_title
self.file_1_id = self.remote_client_1.make_file(
self.workspace_id,
u'Original File 1.txt',
content=u'Some Content 1'.encode('utf-8'))
self.file_2_id = self.remote_client_1.make_file(
self.workspace_id,
u'Original File 2.txt',
content=u'Some Content 2'.encode('utf-8'))
self.folder_1_id = self.remote_client_1.make_folder(
self.workspace_id, u'Original Folder 1')
self.folder_1_1_id = self.remote_client_1.make_folder(
self.folder_1_id, u'Sub-Folder 1.1')
self.folder_1_2_id = self.remote_client_1.make_folder(
self.folder_1_id, u'Sub-Folder 1.2')
self.file_1_1_id = self.remote_client_1.make_file(
self.folder_1_id,
u'Original File 1.1.txt',
content=u'Some Content 1'.encode('utf-8')) # Same content as OF1
self.folder_2_id = self.remote_client_1.make_folder(
self.workspace_id, 'Original Folder 2')
self.file_3_id = self.remote_client_1.make_file(
self.folder_2_id,
u'Original File 3.txt',
content=u'Some Content 3'.encode('utf-8'))
self.wait_audit_change_finder_if_needed()
self.wait()
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
def setUp(self):
super(TestIntegrationVersioning, self).setUp()
self.controller_1.bind_server(self.local_nxdrive_folder_1,
self.nuxeo_url, self.user_1,
self.password_1)
self.controller_2.bind_server(self.local_nxdrive_folder_2,
self.nuxeo_url, self.user_2,
self.password_2)
self.controller_1.bind_root(self.local_nxdrive_folder_1,
self.workspace)
self.controller_2.bind_root(self.local_nxdrive_folder_2,
self.workspace)
self.syn_1 = self.controller_1.synchronizer
self.syn_2 = self.controller_2.synchronizer
self.syn_1.loop(delay=0.010, max_loops=1, no_event_init=True)
self.syn_2.loop(delay=0.010, max_loops=1, no_event_init=True)
# Fetch server bindings after sync loop as it closes the Session
self.sb_1 = self.controller_1.get_server_binding(
self.local_nxdrive_folder_1)
self.sb_2 = self.controller_2.get_server_binding(
self.local_nxdrive_folder_2)
self.remote_client_1 = self.remote_document_client_1
self.remote_client_2 = self.remote_document_client_2
sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2,
self.workspace_title)
self.local_client_1 = LocalClient(sync_root_folder_1)
self.local_client_2 = LocalClient(sync_root_folder_2)
# Call the Nuxeo operation to set the versioning delay to 10 seconds
self.versioning_delay = self.OS_STAT_MTIME_RESOLUTION * 10
self.root_remote_client.execute("NuxeoDrive.SetVersioningOptions",
delay=str(self.versioning_delay))
def test_synchronize_local_folder_rename_remote_deletion(self):
"""Test local folder rename followed by remote deletion"""
raise SkipTest("Skipped waiting for"
" https://jira.nuxeo.com/browse/NXDRIVE-80 to be fixed")
# Bind the server and root workspace
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
# Get local and remote clients
local = LocalClient(os.path.join(self.local_nxdrive_folder_1,
self.workspace_title))
remote = self.remote_document_client_1
# Create a folder with a child file in the remote root workspace
# then synchronize
test_folder_uid = remote.make_folder('/', 'Test folder')
remote.make_file(test_folder_uid, 'joe.odt', 'Some content')
syn = ctl.synchronizer
self._synchronize(syn)
self.assertTrue(local.exists('/Test folder'))
self.assertTrue(local.exists('/Test folder/joe.odt'))
# Locally rename the folder then synchronize
time.sleep(self.OS_STAT_MTIME_RESOLUTION)
local.rename('/Test folder', 'Test folder renamed')
self._synchronize(syn)
self.assertFalse(local.exists('/Test folder'))
self.assertTrue(local.exists('/Test folder renamed'))
self.assertEquals(remote.get_info(test_folder_uid).name,
'Test folder renamed')
# Delete remote folder then synchronize
remote.delete('/Test folder')
self._synchronize(syn)
self.assertFalse(remote.exists('/Test folder renamed'))
self.assertFalse(local.exists('/Test folder renamed'))
def get_metadata_infos(self, file_path):
from nxdrive.client import LocalClient
remote_ref = LocalClient.get_path_remote_id(file_path)
if remote_ref is None:
raise ValueError('Could not find file %s as Nuxeo Drive managed' % file_path)
root_id = self.get_root_id(file_path)
# TODO Add a class to handle root info
root_values = root_id.split("|")
try:
engine = self.get_engines()[root_values[3]]
except:
raise ValueError('Unknown engine %s for %s' %
(root_values[3], file_path))
metadata_url = engine.get_metadata_url(remote_ref)
return (metadata_url, engine.get_remote_token(), engine, remote_ref)
def setUp(self):
super(TestIntegrationReadOnly, self).setUp()
self.sb_1 = self.controller_1.bind_server(self.local_nxdrive_folder_1,
self.nuxeo_url, self.user_1,
self.password_1)
self.controller_1.bind_root(self.local_nxdrive_folder_1,
self.workspace)
self.controller_1.synchronizer.update_synchronize_server(self.sb_1)
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title)
self.local_client_1 = LocalClient(self.sync_root_folder_1)
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_synchronize_local_filter_with_remote_trash(self):
# Bind the server and root workspace
ctl = self.controller_1
ctl.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url,
self.user_1, self.password_1)
ctl.bind_root(self.local_nxdrive_folder_1, self.workspace)
# Get local and remote clients
local = LocalClient(
os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
remote = self.remote_document_client_1
session = ctl.get_session()
# Create documents in the remote root workspace
# then synchronize
remote.make_folder('/', 'Test')
remote.make_file('/Test', 'joe.txt', 'Some content')
syn = ctl.synchronizer
self._synchronize(syn)
self.assertTrue(local.exists('/Test'))
self.assertTrue(local.exists('/Test/joe.txt'))
# Add remote folder as filter then synchronize
doc = remote.get_info('/Test')
root_path = "/org.nuxeo.drive.service.impl.DefaultTopLevelFolderItemFactory#/defaultSyncRootFolderItemFactory#default#"
root_path = root_path + doc.root
doc_path = (root_path + "/defaultFileSystemItemFactory#default#" +
doc.uid)
server_binding = ctl.get_server_binding(self.local_nxdrive_folder_1,
session=session)
Filter.add(session, server_binding, doc_path)
self._synchronize(syn)
self.assertFalse(local.exists('/Test'))
# Delete remote folder then synchronize
remote.delete('/Test')
self._synchronize(syn)
self.assertFalse(local.exists('/Test'))
# Restore folder from trash then synchronize
# Undeleting each item as following 'undelete' transition
# doesn't act recursively, should use TrashService instead
# through a dedicated operation
remote.undelete('/Test')
remote.undelete('/Test/joe.txt')
# NXDRIVE-xx check that the folder is not created as it is filtered
self._synchronize(syn)
self.assertFalse(local.exists('/Test'))
