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