Merge lp:~facundo/magicicada-server/publicfiles into lp:magicicada-server

[Facundo Batista]

Support public files changing and listing through the normal Server.

Support public files changing and listing through the normal Server.

You need Protocol and Client changes for this to work:

    lp:~facundo/magicicada-protocol/publicfiles
    lp:~facundo/magicicada-client/publicfiles

[lp:~facundo/magicicada-server/publicfiles]

81. By Facundo Batista on 2016-12-27

New sourcedeps and aesthetics issues

[Facundo Batista (facundo)]

Now the client and protocol new stuff is properly indicated in the sourcedeps, so this is all set for review.

[Natalia Bidart (nataliabidart)]

Looks good. I don't like the tests that use mocker but I understand is following the existing test infrastructure.

review: Approve

=== modified file 'config-manager.txt'
--- config-manager.txt	2016-09-01 17:12:32 +0000
+++ config-manager.txt	2016-12-27 22:00:10 +0000
@@ -29,5 +29,5 @@
 ./.sourcecode/requests                    ~ubuntuone-pqm-team/requests/stable;revno=816
 ./.sourcecode/requests_oauthlib           ~ubuntuone-pqm-team/requests-oauthlib/stable;revno=16
 ./.sourcecode/u1sync                      ~facundo/u1sync/opensourcing;revno=10
-./.sourcecode/magicicada-client           ~chicharreros/magicicada-client/trunk;revno=1429
-./.sourcecode/magicicada-protocol         ~chicharreros/magicicada-protocol/trunk;revno=166
+./.sourcecode/magicicada-client           ~chicharreros/magicicada-client/trunk;revno=1433
+./.sourcecode/magicicada-protocol         ~chicharreros/magicicada-protocol/trunk;revno=169

=== modified file 'magicicada/filesync/services.py'
--- magicicada/filesync/services.py	2016-06-03 00:35:53 +0000
+++ magicicada/filesync/services.py	2016-12-27 22:00:10 +0000
@@ -1090,6 +1090,7 @@
             return result
         return wrapper
 
+
 timing_metric = TimingMetrics()
 
 

=== modified file 'magicicada/filesync/utilities/make_abundant_files.py'
--- magicicada/filesync/utilities/make_abundant_files.py	2016-06-03 20:57:04 +0000
+++ magicicada/filesync/utilities/make_abundant_files.py	2016-12-27 22:00:10 +0000
@@ -133,6 +133,7 @@
     if sys.stdout.isatty():
         sys.stdout.write(home + curses.tigetstr('el'))
 
+
 if __name__ == '__main__':
     from optparse import OptionParser
     parser = OptionParser("%prog [options] username")

=== modified file 'magicicada/rpcdb/backend.py'
--- magicicada/rpcdb/backend.py	2016-05-29 20:37:49 +0000
+++ magicicada/rpcdb/backend.py	2016-12-27 22:00:10 +0000
@@ -1,5 +1,5 @@
 # Copyright 2008-2015 Canonical
-# Copyright 2015 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@@ -100,6 +100,22 @@
                       shares=shares, udfs=udfs)
         return result
 
+    def list_public_files(self, user_id):
+        """List all the public files for the user."""
+        user = self._get_user(user_id)
+
+        public_files = [self._process_node(n) for n in user.get_public_files()]
+        result = dict(public_files=public_files)
+        return result
+
+    def change_public_access(self, user_id, volume_id, node_id,
+                             is_public, session_id=None):
+        """Change the public access for a node."""
+        user = self._get_user(user_id, session_id)
+        node = user.volume(volume_id).node(node_id)
+        node = node.change_public_access(is_public)
+        return dict(public_url=node.public_url)
+
     def move(self, user_id, volume_id, node_id,
              new_parent_id, new_name, session_id=None):
         """Move a node and/or rename it."""
@@ -308,7 +324,8 @@
                  storage_key=storage_key, is_live=is_live,
                  size=size, is_file=is_file, volume_id=node.vol_id,
                  parent_id=node.parent_id, content_hash=node.content_hash,
-                 path=node.path, has_content=has_content)
+                 path=node.path, has_content=has_content,
+                 public_url=node.public_url)
         return d
 
     def get_delta(self, user_id, volume_id, from_generation, limit):

=== modified file 'magicicada/rpcdb/tests/test_backend.py'
--- magicicada/rpcdb/tests/test_backend.py	2016-06-03 20:57:04 +0000
+++ magicicada/rpcdb/tests/test_backend.py	2016-12-27 22:00:10 +0000
@@ -1,5 +1,5 @@
 # Copyright 2008-2015 Canonical
-# Copyright 2015 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@@ -243,6 +243,118 @@
         self.assertEqual(udf2['path'], 'path2')
         self.assertEqual(udf2['generation'], 8)
 
+    def test_change_public_access(self):
+        """Change the public acces of a node."""
+        mocker = Mocker()
+
+        # node, with a generation attribute
+        node = mocker.mock()
+        expect(node.public_url).result('test public url')
+
+        # user, with the chained calls to the action
+        user = mocker.mock()
+        expect(
+            user.volume('vol_id').node('node_id').change_public_access(True)
+        ).result(node)
+        self.backend._get_user = lambda *a: user
+
+        with mocker:
+            kwargs = dict(user_id='user_id', volume_id='vol_id',
+                          node_id='node_id', is_public=True,
+                          session_id='session_id')
+            result = self.backend.change_public_access(**kwargs)
+
+        self.assertEqual(result, dict(public_url='test public url'))
+
+    def test_list_public_files(self):
+        """List public files."""
+        mocker = Mocker()
+
+        # node 1
+        node1 = mocker.mock()
+        expect(node1.id).result('node_id1')
+        expect(node1.path).result('path1')
+        expect(node1.name).result('name1')
+        expect(node1.vol_id).result('volume_id1')
+        expect(node1.generation).result('generation1')
+        expect(node1.is_public).result(True)
+        expect(node1.parent_id).result('parent_id1')
+        expect(node1.status).result(STATUS_LIVE)
+        expect(node1.content_hash).result('content_hash1')
+        expect(node1.kind).result(StorageObject.FILE)
+        expect(node1.when_last_modified).result('last_modified1')
+        content1 = mocker.mock()
+        expect(content1.size).result('size1')
+        expect(content1.crc32).result('crc321')
+        expect(content1.deflated_size).result('deflated_size1')
+        expect(content1.storage_key).result('storage_key1')
+        expect(node1.content).result(content1)
+        expect(node1.public_url).result('public url 1')
+
+        # node 2
+        node2 = mocker.mock()
+        expect(node2.id).result('node_id2')
+        expect(node2.path).result('path2')
+        expect(node2.name).result('name2')
+        expect(node2.vol_id).result('volume_id2')
+        expect(node2.generation).result('generation2')
+        expect(node2.is_public).result(True)
+        expect(node2.parent_id).result('parent_id2')
+        expect(node2.status).result(STATUS_DEAD)
+        expect(node2.content_hash).result('content_hash2')
+        expect(node2.kind).result(StorageObject.DIRECTORY)
+        expect(node2.when_last_modified).result('last_modified2')
+        content2 = mocker.mock()
+        expect(content2.size).result('size2')
+        expect(content2.crc32).result('crc322')
+        expect(content2.deflated_size).result('deflated_size2')
+        expect(content2.storage_key).result('storage_key2')
+        expect(node2.content).result(content2)
+        expect(node2.public_url).result('public url 2')
+
+        # user
+        user = mocker.mock()
+        self.backend._get_user = lambda *a: user
+        expect(user.get_public_files()).result([node1, node2])
+
+        with mocker:
+            result = self.backend.list_public_files(user_id='user_id',)
+        node1, node2 = result['public_files']
+
+        self.assertEqual(node1['id'], 'node_id1')
+        self.assertEqual(node1['path'], 'path1')
+        self.assertEqual(node1['name'], 'name1')
+        self.assertEqual(node1['volume_id'], 'volume_id1')
+        self.assertEqual(node1['parent_id'], 'parent_id1')
+        self.assertEqual(node1['is_live'], True)
+        self.assertEqual(node1['generation'], 'generation1')
+        self.assertEqual(node1['is_public'], True)
+        self.assertEqual(node1['content_hash'], 'content_hash1')
+        self.assertEqual(node1['is_file'], True)
+        self.assertEqual(node1['size'], 'size1')
+        self.assertEqual(node1['crc32'], 'crc321')
+        self.assertEqual(node1['deflated_size'], 'deflated_size1')
+        self.assertEqual(node1['storage_key'], 'storage_key1')
+        self.assertEqual(node1['last_modified'], 'last_modified1')
+        self.assertEqual(node1['public_url'], 'public url 1')
+
+        self.assertEqual(node2['id'], 'node_id2')
+        self.assertEqual(node2['path'], 'path2')
+        self.assertEqual(node2['name'], 'name2')
+        self.assertEqual(node2['volume_id'], 'volume_id2')
+        self.assertEqual(node2['parent_id'], 'parent_id2')
+        self.assertEqual(node2['is_live'], False)
+        self.assertEqual(node2['generation'], 'generation2')
+        self.assertEqual(node2['is_public'], True)
+        self.assertEqual(node2['content_hash'], 'content_hash2')
+        self.assertEqual(node2['is_file'], False)
+        self.assertEqual(node2['size'], 'size2')
+        self.assertEqual(node2['crc32'], 'crc322')
+        self.assertEqual(node2['deflated_size'], 'deflated_size2')
+        self.assertEqual(node2['storage_key'], 'storage_key2')
+        self.assertEqual(node2['last_modified'], 'last_modified2')
+        self.assertEqual(node2['public_url'], 'public url 2')
+
     def test_move(self):
         """Move."""
         mocker = Mocker()
@@ -706,6 +818,7 @@
         expect(content.deflated_size).result('deflated_size')
         expect(content.storage_key).result('storage_key')
         expect(node.content).count(1).result(content)
+        expect(node.public_url).result(None)
 
         # user
         user = mocker.mock()
@@ -722,7 +835,8 @@
                       last_modified='last_modified', crc32='crc32',
                       generation='generation', content_hash='content_hash',
                       deflated_size='deflated_size', storage_key='storage_key',
-                      volume_id='volume_id', path='path', has_content=True)
+                      volume_id='volume_id', path='path', has_content=True,
+                      public_url=None)
         self.assertEqual(result, should)
 
     def test_get_node_no_content(self):
@@ -743,6 +857,7 @@
         expect(node.kind).result(StorageObject.FILE)
         expect(node.when_last_modified).result('last_modified')
         expect(node.content).result(None)
+        expect(node.public_url).result(None)
 
         # user
         user = mocker.mock()
@@ -758,7 +873,7 @@
                       is_public=False, is_live=True, is_file=True, size=None,
                       last_modified='last_modified', crc32=None,
                       generation='generation', content_hash='content_hash',
-                      deflated_size=None, storage_key=None,
+                      deflated_size=None, storage_key=None, public_url=None,
                       volume_id='volume_id', path="path", has_content=False)
         self.assertEqual(result, should)
 
@@ -780,6 +895,7 @@
         expect(node.kind).result(StorageObject.FILE)
         expect(node.when_last_modified).result('last_modified')
         expect(node.content).count(1).result(None)
+        expect(node.public_url).result(None)
 
         # user
         user = mocker.mock()
@@ -798,7 +914,7 @@
                       is_public=False, is_live=True, is_file=True, size=None,
                       last_modified='last_modified', crc32=None,
                       generation='generation', content_hash='content_hash',
-                      deflated_size=None, storage_key=None,
+                      deflated_size=None, storage_key=None, public_url=None,
                       volume_id='volume_id', path='path', has_content=False)
         self.assertEqual(result, should)
 
@@ -825,6 +941,7 @@
         expect(content1.deflated_size).count(2).result('deflated_size1')
         expect(content1.storage_key).count(2).result('storage_key1')
         expect(node1.content).count(2).result(content1)
+        expect(node1.public_url).count(2).result('public url')
 
         # node 2
         node2 = mocker.mock()
@@ -845,6 +962,7 @@
         expect(content2.deflated_size).count(2).result('deflated_size2')
         expect(content2.storage_key).count(2).result('storage_key2')
         expect(node2.content).count(2).result(content2)
+        expect(node2.public_url).count(2).result(None)
 
         # user
         user = mocker.mock()
@@ -880,6 +998,7 @@
         self.assertEqual(node1['deflated_size'], 'deflated_size1')
         self.assertEqual(node1['storage_key'], 'storage_key1')
         self.assertEqual(node1['last_modified'], 'last_modified1')
+        self.assertEqual(node1['public_url'], 'public url')
 
         self.assertEqual(node2['id'], 'node_id2')
         self.assertEqual(node2['path'], 'path2')
@@ -896,6 +1015,7 @@
         self.assertEqual(node2['deflated_size'], 'deflated_size2')
         self.assertEqual(node2['storage_key'], 'storage_key2')
         self.assertEqual(node2['last_modified'], 'last_modified2')
+        self.assertEqual(node2['public_url'], None)
 
     def test_get_user(self):
         """Get accessable nodes and their hashes."""

=== modified file 'magicicada/server/content.py'
--- magicicada/server/content.py	2016-08-07 22:40:29 +0000
+++ magicicada/server/content.py	2016-12-27 22:00:10 +0000
@@ -95,6 +95,7 @@
         self.is_live = node['is_live']
         self.generation = node['generation']
         self.is_public = node['is_public']
+        self.public_url = node['public_url']
         last_modif = node['last_modified']
 
         # special cases for no content
@@ -774,6 +775,27 @@
                            r['name'], r['mimetype']))
 
     @defer.inlineCallbacks
+    def list_public_files(self):
+        """List the public files for an user."""
+        r = yield self.rpc_dal.call('list_public_files', user_id=self.id)
+        nodes = [Node(self.manager, n) for n in r['public_files']]
+        defer.returnValue(nodes)
+
+    @defer.inlineCallbacks
+    def change_public_access(self, volume_id, node_id,
+                             is_public, session_id=None):
+        """Change public access of a node.
+
+        @param volume_id: the id of the volume of the node.
+        @param node_id: the id of the node.
+        @param is_public: if the node should be public or not.
+        """
+        r = yield self.rpc_dal.call('change_public_access', user_id=self.id,
+                                    volume_id=volume_id, node_id=node_id,
+                                    is_public=is_public, session_id=session_id)
+        defer.returnValue(r['public_url'])
+
+    @defer.inlineCallbacks
     def get_upload_job(self, vol_id, node_id, previous_hash, hash_value, crc32,
                        inflated_size, deflated_size, session_id=None,
                        magic_hash=None, upload_id=None):

=== modified file 'magicicada/server/integration/integtests_udf.py'
--- magicicada/server/integration/integtests_udf.py	2016-05-29 20:58:45 +0000
+++ magicicada/server/integration/integtests_udf.py	2016-12-27 22:00:10 +0000
@@ -300,6 +300,7 @@
         assert actual2 == expected_with_conflict, \
             'directory merge must be correct for SD2'
 
+
 test_merge_directories_with_overlap.skip = """
     The noconflict.txt file gets into conflict! Bug: #711389
 """
@@ -419,6 +420,7 @@
     debug(prefix, 'contents for SD2', udf_content)
     assert udf_content == [], msg
 
+
 test_remove_udf.skip = """
     This test exposes a problem we have now in SD: deleting everything
     under the UDF depends on timing of operations between one client

=== modified file 'magicicada/server/integtests/test_sync.py'
--- magicicada/server/integtests/test_sync.py	2016-06-03 21:44:35 +0000
+++ magicicada/server/integtests/test_sync.py	2016-12-27 22:00:10 +0000
@@ -112,7 +112,6 @@
         self.source_dir = self.mktemp("source/root")
         self.share_source_dir = self.mktemp("source/share")
 
-        self.patch(Main, "start_status_listener", self.no_op)
         self.patch(hash_queue, "HASHQUEUE_DELAY", 0.1)
         self.main = Main(root_dir, shares_dir, data_dir, partials_dir,
                          "localhost", self.ssl_port, dns_srv=None, ssl=True,

=== modified file 'magicicada/server/server.py'
--- magicicada/server/server.py	2016-08-14 21:51:15 +0000
+++ magicicada/server/server.py	2016-12-27 22:00:10 +0000
@@ -535,6 +535,16 @@
         request = Unlink(self, message)
         request.start()
 
+    def handle_LIST_PUBLIC_FILES(self, message):
+        """Handle LIST_PUBLIC_FILES message."""
+        request = ListPublicFiles(self, message)
+        request.start()
+
+    def handle_CHANGE_PUBLIC_ACCESS(self, message):
+        """Handle UNLINK message."""
+        request = ChangePublicAccess(self, message)
+        request.start()
+
     def handle_CREATE_UDF(self, message):
         """Handle CREATE_UDF message."""
         request = CreateUDF(self, message)
@@ -1299,6 +1309,74 @@
             share_id, node_id, kind, mime, extension)
 
 
+class ListPublicFiles(SimpleRequestResponse):
+    """LIST_PUBLIC_FILES Request Response."""
+
+    __slots__ = ()
+
+    @inlineCallbacks
+    def _process(self):
+        """List public files for the client."""
+        user = self.protocol.user
+        public_files = yield user.list_public_files()
+
+        counter = 0
+        for node in public_files:
+            message = protocol_pb2.Message()
+            message.type = protocol_pb2.Message.PUBLIC_FILE_INFO
+            message.public_file_info.share = node.volume_id or ''
+            message.public_file_info.node = str(node.id)
+            message.public_file_info.is_public = node.is_public
+            message.public_file_info.public_url = str(node.public_url)
+            self.sendMessage(message)
+            counter += 1
+
+        # we're done!
+        self.length = counter
+        response = protocol_pb2.Message()
+        response.type = protocol_pb2.Message.PUBLIC_FILE_INFO_END
+        self.sendMessage(response)
+
+        # save data to be logged on operation end
+        self.operation_data = 'public_files=%d' % len(public_files)
+
+
+class ChangePublicAccess(SimpleRequestResponse):
+    """CHANGE_PUBLIC_ACCESS Request Response."""
+
+    __slots__ = ()
+
+    expected_foreign_errors = [dataerror.NoPermission]
+
+    user_activity = 'sync_activity'
+
+    def _get_node_info(self):
+        """Return node info from the message."""
+        node_id = self.source_message.change_public_access.node
+        return 'node: %r' % (node_id,)
+
+    @inlineCallbacks
+    def _process(self):
+        """Change the public access to a node."""
+        share_id = self.convert_share_id(
+            self.source_message.change_public_access.share)
+        node_id = self.source_message.change_public_access.node
+        is_public = self.source_message.change_public_access.is_public
+        public_url = yield self.protocol.user.change_public_access(
+            share_id, node_id, is_public, session_id=self.protocol.session_id)
+
+        # answer the ok to original user
+        response = protocol_pb2.Message()
+        response.public_url = bytes(public_url)
+        response.type = protocol_pb2.Message.OK
+        self.sendMessage(response)
+
+        # save data to be logged on operation end
+        self.operation_data = (
+            'vol_id=%s node_id=%s is_public=%s public_url=%r' % (
+                share_id, node_id, is_public, public_url))
+
+
 class BytesMessageProducer(object):
     """Adapt a bytes producer to produce BYTES messages."""
 

=== modified file 'magicicada/server/testing/aq_helpers.py'
--- magicicada/server/testing/aq_helpers.py	2016-08-30 00:50:31 +0000
+++ magicicada/server/testing/aq_helpers.py	2016-12-27 22:00:10 +0000
@@ -573,6 +573,7 @@
     def __cmp__(self, other):
         return cmp(self.shares, other.shares)
 
+
 aHash = _HashPlaceholder('a hash')
 anUUID = _UUIDPlaceholder('an UUID')
 aShareUUID = _UUIDPlaceholder('a share UUID', ('',))

=== modified file 'magicicada/server/testing/testcase.py'
--- magicicada/server/testing/testcase.py	2016-08-14 21:51:15 +0000
+++ magicicada/server/testing/testcase.py	2016-12-27 22:00:10 +0000
@@ -55,6 +55,7 @@
         """In the present we trust."""
         return int(time.time())
 
+
 # need to patch this timestamp checker so it doesn't go to the real server
 client.tx_timestamp_checker = FakeTimestampChecker()
 

=== modified file 'magicicada/server/tests/test_content.py'
--- magicicada/server/tests/test_content.py	2016-09-15 11:46:39 +0000
+++ magicicada/server/tests/test_content.py	2016-12-27 22:00:10 +0000
@@ -1700,13 +1700,13 @@
         root = yield client.get_root()
         filename = 'hola_12'
         mkfile_req = yield client.make_file(request.ROOT, root, filename)
-        upload_id = []
+        upload_info = []
         try:
             yield client.put_content(
                 request.ROOT, mkfile_req.new_id, NO_CONTENT_HASH,
                 hash_value, crc32_value, size, deflated_size,
                 StringIO(deflated_data),
-                upload_id_cb=upload_id.append)
+                upload_id_cb=lambda *a: upload_info.append(a))
         except EOFError:
             # check upload stat and log, with the offset sent,
             # first time tarts from beginning.
@@ -1745,7 +1745,7 @@
         req = sp_client.PutContent(
             client, request.ROOT, mkfile_req.new_id, NO_CONTENT_HASH,
             hash_value, crc32_value, size, deflated_size,
-            StringIO(deflated_data), upload_id=str(upload_id[0]))
+            StringIO(deflated_data), upload_id=str(upload_info[0][0]))
         req.start()
         yield req.deferred
 
@@ -1800,19 +1800,21 @@
             yield client.dummy_authenticate("open sesame")
             root = yield client.get_root()
             mkfile_req = yield client.make_file(request.ROOT, root, 'hola')
-            upload_id = []
+            upload_info = []
             req = client.put_content_request(
                 request.ROOT, mkfile_req.new_id, NO_CONTENT_HASH,
                 hash_value, crc32_value, size, deflated_size,
                 StringIO(deflated_data), upload_id="invalid id",
-                upload_id_cb=upload_id.append)
+                upload_id_cb=lambda *a: upload_info.append(a))
             yield req.deferred
             self.assertTrue(('UploadJob.upload', 0) in gauge)
             self.assertTrue(('UploadJob.upload.begin', 1) in meter)
             self.handler.assert_debug(
                 "UploadJob begin content from offset 0")
-            self.assertEqual(len(upload_id), 1)
-            self.assertIsInstance(uuid.UUID(upload_id[0]), uuid.UUID)
+            self.assertEqual(len(upload_info), 1)
+            upload_id, start_from = upload_info[0]
+            self.assertIsInstance(uuid.UUID(upload_id), uuid.UUID)
+            self.assertEqual(start_from, 0)
 
         yield self.callback_test(auth, add_default_callbacks=True)
 
@@ -2302,6 +2304,36 @@
         d = self.user.get_free_bytes(share.id)
         yield self.assertFailure(d, errors.DoesNotExist)
 
+    @defer.inlineCallbacks
+    def test_change_public_access(self):
+        """Test change public access action."""
+        root_id, root_gen = yield self.user.get_root()
+        volume_id = yield self.user.get_volume_id(root_id)
+        node_id, generation, _ = yield self.user.make_file(
+            volume_id, root_id, u"name")
+        public_url = yield self.user.change_public_access(
+            volume_id, node_id, True)
+        self.assertTrue(public_url.startswith(settings.PUBLIC_URL_PREFIX))
+
+    @defer.inlineCallbacks
+    def test_list_public_files(self):
+        """Test the public files listing."""
+        root_id, _ = yield self.user.get_root()
+        volume_id = yield self.user.get_volume_id(root_id)
+
+        # create three files, make two public
+        node_id_1, _, _ = yield self.user.make_file(
+            volume_id, root_id, u"name1")
+        yield self.user.make_file(volume_id, root_id, u"name2")
+        node_id_3, _, _ = yield self.user.make_file(
+            volume_id, root_id, u"name3")
+        yield self.user.change_public_access(volume_id, node_id_1, True)
+        yield self.user.change_public_access(volume_id, node_id_3, True)
+
+        public_files = yield self.user.list_public_files()
+        self.assertEqual(set(node.id for node in public_files),
+                         {node_id_1, node_id_3})
+
 
 class TestUploadJob(TestWithDatabase):
     """Tests for UploadJob class."""

=== modified file 'magicicada/server/tests/test_fileops.py'
--- magicicada/server/tests/test_fileops.py	2016-05-29 20:58:45 +0000
+++ magicicada/server/tests/test_fileops.py	2016-12-27 22:00:10 +0000
@@ -1,5 +1,5 @@
 # Copyright 2008-2015 Canonical
-# Copyright 2015 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@@ -421,3 +421,90 @@
             self.assertEqual(unlink_req.new_generation,
                              make_req.new_generation + 1)
         return self.callback_test(test, add_default_callbacks=True)
+
+
+class TestPublicFiles(TestWithDatabase):
+    """Test the public files management."""
+
+    def test_set_public_file_true(self):
+        @defer.inlineCallbacks
+        def auth(client):
+            yield client.dummy_authenticate("open sesame")
+            root = yield client.get_root()
+            req = yield client.make_file(request.ROOT, root, "hola")
+            resp = yield client.change_public_access(
+                request.ROOT, req.new_id, True)
+            fileobj = self.usr0.get_node(req.new_id)
+            self.assertTrue(fileobj.is_public)
+            self.assertEqual(resp.public_url, fileobj.public_url)
+
+        return self.callback_test(auth, add_default_callbacks=True)
+
+    def test_set_public_file_false(self):
+        @defer.inlineCallbacks
+        def auth(client):
+            yield client.dummy_authenticate("open sesame")
+            root = yield client.get_root()
+            req = yield client.make_file(request.ROOT, root, "hola")
+
+            # set it to public first
+            yield client.change_public_access(request.ROOT, req.new_id, True)
+            fileobj = self.usr0.get_node(req.new_id)
+            assert fileobj.is_public
+
+            # set it to false, check
+            yield client.change_public_access(request.ROOT, req.new_id, False)
+            fileobj = self.usr0.get_node(req.new_id)
+            self.assertFalse(fileobj.is_public)
+
+        return self.callback_test(auth, add_default_callbacks=True)
+
+    def test_list_public_files_none(self):
+        @defer.inlineCallbacks
+        def auth(client):
+            yield client.dummy_authenticate("open sesame")
+
+            # list and check
+            resp = yield client.list_public_files()
+            self.assertEqual(resp.public_files, [])
+
+        return self.callback_test(auth, add_default_callbacks=True)
+
+    def test_list_public_files_several(self):
+        @defer.inlineCallbacks
+        def auth(client):
+            yield client.dummy_authenticate("open sesame")
+            root = yield client.get_root()
+
+            # create three files, and set two of them to be public
+            req1 = yield client.make_file(request.ROOT, root, "file1")
+            yield client.make_file(request.ROOT, root, "file2")
+            req3 = yield client.make_file(request.ROOT, root, "file3")
+            yield client.change_public_access(request.ROOT, req1.new_id, True)
+            yield client.change_public_access(request.ROOT, req3.new_id, True)
+
+            # list and check
+            resp = yield client.list_public_files()
+            self.assertEqual({node.node_id for node in resp.public_files},
+                             set([req1.new_id, req3.new_id]))
+
+        return self.callback_test(auth, add_default_callbacks=True)
+
+    def test_list_public_files_unpublished(self):
+        @defer.inlineCallbacks
+        def auth(client):
+            yield client.dummy_authenticate("open sesame")
+            root = yield client.get_root()
+
+            # create a file, publish, and assert
+            req = yield client.make_file(request.ROOT, root, "file")
+            yield client.change_public_access(request.ROOT, req.new_id, True)
+            resp = yield client.list_public_files()
+            assert [node.node_id for node in resp.public_files] == [req.new_id]
+
+            # unpublish it and check
+            yield client.change_public_access(request.ROOT, req.new_id, False)
+            resp = yield client.list_public_files()
+            self.assertEqual(resp.public_files, [])
+
+        return self.callback_test(auth, add_default_callbacks=True)

=== modified file 'magicicada/server/tests/test_server.py'
--- magicicada/server/tests/test_server.py	2016-08-26 21:53:42 +0000
+++ magicicada/server/tests/test_server.py	2016-12-27 22:00:10 +0000
@@ -48,6 +48,7 @@
     Action,
     AuthenticateResponse,
     BytesMessageProducer,
+    ChangePublicAccess,
     CreateShare,
     CreateUDF,
     DeleteShare,
@@ -56,6 +57,7 @@
     GetContentResponse,
     GetDeltaResponse,
     ListShares,
+    ListPublicFiles,
     ListVolumes,
     LoopingPing,
     MakeResponse,
@@ -99,6 +101,8 @@
     last_modified = 2334524
     is_public = False
     path = u"path"
+    volume_id = 'volumeid'
+    public_url = 'public_url'
 
 
 class FakeUser(object):
@@ -1177,6 +1181,35 @@
         self.assertEqual(self.response.length, 6)
 
 
+class ChangePublicAccessTestCase(SimpleRequestResponseTestCase):
+    """Test the ChangePublicAccess class."""
+
+    response_class = ChangePublicAccess
+
+
+class ListPublicFilesTestCase(SimpleRequestResponseTestCase):
+    """Test the ListPublicFiles class."""
+
+    response_class = ListPublicFiles
+
+    @defer.inlineCallbacks
+    def test_process_set_values(self):
+        """Set length attribute and operation data while processing."""
+        mocker = Mocker()
+
+        user = mocker.mock()
+        self.response.protocol.user = user
+
+        nodes = [FakeNode(), FakeNode()]
+        expect(user.list_public_files()).result(nodes)
+
+        with mocker:
+            yield self.response._process()
+
+        self.assertEqual(self.response.length, 2)
+        self.assertEqual(self.response.operation_data, "public_files=2")
+
+
 class UnlinkTestCase(SimpleRequestResponseTestCase):
     """Test the Unlink class."""
 

=== modified file 'magicicada/settings/__init__.py'
--- magicicada/settings/__init__.py	2016-09-15 11:46:39 +0000
+++ magicicada/settings/__init__.py	2016-12-27 22:00:10 +0000
@@ -147,6 +147,7 @@
         if self.isEnabledFor(TRACE):
             self._log(TRACE, msg, args, **kwargs)
 
+
 logging.setLoggerClass(MagicicadaLogger)
 
 

=== modified file 'test'
--- test	2016-09-15 11:46:39 +0000
+++ test	2016-12-27 22:00:10 +0000
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 # Copyright 2008-2015 Canonical
-# Copyright 2015 Chicharreros (https://launchpad.net/~chicharreros)
+# Copyright 2015-2016 Chicharreros (https://launchpad.net/~chicharreros)
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@@ -44,6 +44,11 @@
     os.environ.setdefault(
         'XDG_CACHE_HOME', os.path.join(ROOTDIR, 'tmp', 'xdg_cache'))
 
+    # repeated setting from makefile, as some tests check this, to work 
+    # ok when running them directly from ./test
+    os.environ.setdefault('PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION', 'cpp')
+    os.environ.setdefault('PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION', '2')
+
     dbus_address_file = os.path.join(ROOTDIR, 'tmp', 'dbus.address')
     if os.path.exists(dbus_address_file):
         with open(dbus_address_file) as fh: