Merge lp:~mandel/ubuntuone-client/add_ipc_client_code_7 into lp:ubuntuone-client

[Manuel de la Peña]

Adds a client side object that allows to access to the public files API provided by the sync daemon. This allows client applications to perform the IPC more easily.

Adds a client side object that allows to access to the public files API provided by the sync daemon. This allows client applications to perform the IPC more easily.

This is a windows only change and the way to test it is:

C:\Users\Mandel\Documents\ubuntuone-client\continue-ipc>python C:\Python27\Scripts\u1trial tests\platform\windows\test_ipc.py

[Shane Fagan (shanepatrickfagan)]

review: Approve

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'tests/platform/windows/test_ipc.py'
--- tests/platform/windows/test_ipc.py	2011-04-29 14:11:08 +0000
+++ tests/platform/windows/test_ipc.py	2011-04-29 14:11:09 +0000
@@ -46,6 +46,7 @@
     EventsClient,
     FoldersClient,
     FileSystemClient,
+    PublicFilesClient,
     StatusClient,
     SyncDaemonClient,
     SharesClient
@@ -2693,4 +2694,188 @@
         d.addCallback(test_emit)
         # pylint: enable=E1101
         return d
-        
\ No newline at end of file
+
+
+class TestPublicFilesClient(TestCase):
+    """Test the status client class."""
+
+    def setUp(self):
+        """Setup tests."""
+        super(TestPublicFilesClient, self).setUp()
+        self.mocker = Mocker()
+        self.root = self.mocker.mock()
+        self.files = PublicFiles(None, None)
+        self.files.syncdaemon_public_files = self.root
+        # start pb
+        self.syncdaemon_root = SyncDaemonRoot(None, None, None, None,
+                                              None, None, None, self.files)
+        self.server_factory = SaveProtocolServerFactory(self.syncdaemon_root)
+        # pylint: disable=E1101
+        self.listener = reactor.listenTCP(0, self.server_factory)
+        self.client_factory = PBClientFactory()
+        self.connector = reactor.connectTCP('localhost',
+                                            self.listener.getHost().port,
+                                            self.client_factory)
+        # pylint: enable=E1101
+
+    def tearDown(self):
+        """Clean reactor."""
+        if self.server_factory.protocolInstance is not None:
+            self.server_factory.protocolInstance.transport.loseConnection()
+        return defer.gatherResults([self._tearDownServer(),
+                                    self._tearDownClient()])
+
+    def _tearDownServer(self):
+        """Teardown the server."""
+        return defer.maybeDeferred(self.listener.stopListening)
+
+    def _tearDownClient(self):
+        """Tear down the client."""
+        self.connector.disconnect()
+        return defer.succeed(None)
+
+    @defer.inlineCallbacks
+    def _get_client(self):
+        """Get the client."""
+        # request the remote object and create a client
+        root = yield self.client_factory.getRootObject()
+        remote = yield root.callRemote('get_public_files')
+        client = PublicFilesClient(remote)
+        yield client.register_to_signals()
+        # set the cb
+        for signal in ['on_public_access_changed_cb',
+                       'on_public_access_change_error_cb',
+                       'on_public_files_list_cb',
+                       'on_public_files_list_error_cb']:
+            setattr(client, signal, self.mocker.mock())
+        defer.returnValue(client)
+
+    def test_change_public_access(self):
+        """Change the public access of a file."""
+        share_id = 'share_id'
+        node_id = 'node_id'
+        is_public = False
+
+        @defer.inlineCallbacks
+        def test_execution(client):
+            """Actual test."""
+            self.root.change_public_access(share_id, node_id, is_public)
+            self.mocker.replay()
+            yield client.change_public_access(share_id, node_id, is_public)
+            yield client.unregister_to_signals()
+            self.mocker.verify()
+    
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_get_public_files(self):
+        """Request the list of public files to the server."""
+
+        @defer.inlineCallbacks
+        def test_execution(client):
+            """Actual test."""
+            self.root.get_public_files()
+            self.mocker.replay()
+            yield client.get_public_files()
+            yield client.unregister_to_signals()
+            self.mocker.verify()
+    
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_execution)
+        # pylint: enable=E1101
+        return d
+
+    def test_on_public_access_changed(self):
+        """Emit the PublicAccessChanged signal."""
+        share_id = 'share_id'
+        node_id = 'node_id'
+        is_public = False
+        public_url = 'public_url'
+        path = 'path'
+        info_dict = dict(path=path, public_url=public_url, share_id=share_id,
+                         node_id=node_id, is_public='')
+
+        @defer.inlineCallbacks
+        def test_emit(client):
+            """Actual test."""
+            self.root.get_path(share_id, node_id)
+            self.mocker.result(path)
+            client.on_public_access_changed_cb(info_dict)
+            self.mocker.replay()
+            self.files.emit_public_access_changed(share_id, node_id, is_public,
+                                                  public_url)
+            yield client.unregister_to_signals()
+            self.mocker.verify()
+
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_emit)
+        # pylint: enable=E1101
+        return d
+
+    def test_on_public_access_change_error(self):
+        """Emit the PublicAccessChangeError signal."""
+        share_id = 'share_id'
+        node_id = 'node_id'
+        error = 'error'
+        path = 'path'
+        info = dict(share_id=share_id, node_id=node_id, path=path)
+
+        @defer.inlineCallbacks
+        def test_emit(client):
+            """Actual test."""
+            self.root.get_path(share_id, node_id)
+            self.mocker.result(path)
+            client.on_public_access_change_error_cb(info, error)
+            self.mocker.replay()
+            self.files.emit_public_access_change_error(share_id, node_id, error)
+            yield client.unregister_to_signals()
+            self.mocker.verify()
+
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_emit)
+        # pylint: enable=E1101
+        return d
+
+    def test_on_public_files_list(self):
+        """Emit the PublicFilesList signal."""
+        public_files = []
+
+        @defer.inlineCallbacks
+        def test_emit(client):
+            """Actual test."""
+            client.on_public_files_list_cb(public_files)
+            self.mocker.replay()
+            self.files.emit_public_files_list(public_files)
+            yield client.unregister_to_signals()
+            self.mocker.verify()
+
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_emit)
+        # pylint: enable=E1101
+        return d
+
+    def test_on_public_files_list_error(self):
+        """Emit the PublicFilesListError signal."""
+        error = 'error'
+
+        @defer.inlineCallbacks
+        def test_emit(client):
+            """Actual test."""
+            client.on_public_files_list_error_cb(error)
+            self.mocker.replay()
+            self.files.emit_public_files_list_error(error)
+            yield client.unregister_to_signals()
+            self.mocker.verify()
+
+        d = self._get_client()
+        # pylint: disable=E1101
+        d.addCallback(test_emit)
+        # pylint: enable=E1101
+        return d
\ No newline at end of file

=== modified file 'ubuntuone/platform/windows/ipc_client.py'
--- ubuntuone/platform/windows/ipc_client.py	2011-04-29 14:11:08 +0000
+++ ubuntuone/platform/windows/ipc_client.py	2011-04-29 14:11:09 +0000
@@ -614,3 +614,46 @@
     @signal
     def on_folder_unsubscribe_error(self, folder_id, error):
         """Emit the FolderUnSubscribeError signal"""
+
+
+class PublicFilesClient(RemoteClient, Referenceable):
+    """An IPC interface for handling public files."""
+
+    __metaclass__ = RemoteMeta
+
+    # calls that will be accessible remotely
+    remote_calls = ['on_public_access_changed',
+                    'on_public_access_change_error',
+                    'on_public_files_list',
+                    'on_public_files_list_error']
+
+    def __init__(self, remote_public_files):
+        super(PublicFilesClient, self).__init__(remote_public_files)
+
+    @remote
+    def change_public_access(self, share_id, node_id, is_public):
+        """Change the public access of a file."""
+
+    @remote
+    def get_public_files(self):
+        """Request the list of public files to the server.
+
+        The result will be send in a PublicFilesList signal.
+        """
+
+    @signal
+    def on_public_access_changed(self, share_id, node_id, is_public,
+                                   public_url):
+        """Emit the PublicAccessChanged signal."""
+
+    @signal
+    def on_public_access_change_error(self, share_id, node_id, error):
+        """Emit the PublicAccessChangeError signal."""
+
+    @signal
+    def on_public_files_list(self, public_files):
+        """Emit the PublicFilesList signal."""
+
+    @signal
+    def on_public_files_list_error(self, error):
+        """Emit the PublicFilesListError signal."""