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 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_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_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_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_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_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_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_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 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, 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_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 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 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_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_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 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 _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 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_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_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'))
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 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 init_default_drive(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 return syn, local, remote
def test_synchronize_remote_deletion(self): raise SkipTest("Skipped for the moment as it generates too much" " error logs") """Test that deleting remote root document while uploading is handled See https://jira.nuxeo.com/browse/NXDRIVE-39 See TestIntegrationSecurityUpdates.test_synchronize_denying_read_access as the same uses cases are tested """ # Bind the server and root workspace ctl = self.controller_1 # Override the behavior to force use of trash ctl.trash_modified_file = lambda: True 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 syn = ctl.synchronizer self._synchronize(syn) # Create documents in the local root workspace # then synchronize local.make_folder('/', 'Test folder') i = 0 while i < 400: local.make_file('/Test folder', ('joe%d.bin' % i), 'Some content') i += 1 self._synchronize(syn) # All files should not be synchronized self.assertTrue(remote.exists('/Test folder')) self.assertTrue(remote.exists('/Test folder/joe0.bin')) self.assertFalse(remote.exists('/Test folder/joe399.bin')) # Delete remote folder then synchronize remote.delete('/Test folder') # Error counter should be in place self._synchronize(syn) self.assertFalse(local.exists('/Test 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 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_replace(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(self.local_test_folder_1) remote = self.remote_document_client_1 # 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) copyfile(os.path.join(self.local_test_folder_1, 'folder', 'test.odt'), os.path.join(sync_root, 'test.odt')) syn.loop(delay=0.1, max_loops=1) 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(self.OS_STAT_MTIME_RESOLUTION) copyfile(os.path.join(self.local_test_folder_1, 'test.odt'), os.path.join(sync_root, 'test.odt')) syn.loop(delay=0.1, max_loops=1) self.assertTrue(remote.exists('/test.odt')) self.assertEquals(remote.get_content('/test.odt'), 'Some content.')