Merge lp:~mikemc/ubuntuone-client/add-downloads-to-menudata into lp:ubuntuone-client

[Mike McCracken]

- Add current downloads to data for sync menu, and add downloads to recent transfers. (LP: #1067806)

- Add current downloads to data for sync menu, and add downloads to recent transfers. (LP: #1067806)

Also adds tests for downloads. Tests changed are in tests/status/

No real way to test IRL, as menu clients don't use this yet.

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

[dobey (dobey)]

review: Approve

=== modified file 'tests/status/test_aggregator.py'
--- tests/status/test_aggregator.py	2012-10-11 14:37:35 +0000
+++ tests/status/test_aggregator.py	2012-10-24 16:06:50 +0000
@@ -47,6 +47,7 @@
     status_listener,
     RECENT_TRANSFERS,
     UPLOADING,
+    DOWNLOADING
 )
 from ubuntuone.syncdaemon.volume_manager import Share, UDF, Root
 
@@ -240,7 +241,7 @@
 
     def build_discovery_message(self):
         """Build the file discovery message."""
-        return "a lot of files found (%d).""" % self.discovered
+        return "a lot of files found (%d)." % self.discovered
 
     def get_progress_message(self):
         """Return the progress message."""
@@ -250,11 +251,11 @@
     def build_progress_message(self):
         """Build the progress message."""
         params = (self.discovered, self.completed)
-        return "a lot of files transferring (%d/%d).""" % params
+        return "a lot of files transferring (%d/%d)." % params
 
     def get_final_status_message(self):
         """Return the final status message."""
-        return "a lot of files completed."""
+        return "a lot of files completed."
 
     def get_notification(self):
         """Create a new toggleable notification object."""
@@ -713,9 +714,22 @@
         self.node_id = path
         self.deflated_size = 10000
         self.size = 0
+
+
+class FakeUploadCommand(FakeCommand):
+    """A fake upload."""
+    def __init__(self, path=''):
+        super(FakeUploadCommand, self).__init__(path)
         self.n_bytes_written = 0
 
 
+class FakeDownloadCommand(FakeCommand):
+    """A fake upload."""
+    def __init__(self, path=''):
+        super(FakeDownloadCommand, self).__init__(path)
+        self.n_bytes_read = 0
+
+
 class FakeVolumeManager(object):
     """A fake vm."""
 
@@ -760,6 +774,7 @@
         """A download just finished."""
         if command in self.files_downloading:
             self.files_downloading.remove(command)
+        self.recent_transfers.append(command.path)
         self.queued_commands.discard(command)
 
     def upload_started(self, command):
@@ -808,14 +823,17 @@
 
     def test_recent_transfers(self):
         """Check that it generates a tuple with the recent transfers."""
-        self.patch(status_listener.action_queue, "Upload", FakeCommand)
-        fake_command = FakeCommand('path1')
-        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
-        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
-        fake_command = FakeCommand('path2')
-        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
-        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
-        fake_command = FakeCommand('path3')
+        self.patch(status_listener.action_queue, "Upload", FakeUploadCommand)
+        self.patch(status_listener.action_queue, "Download",
+                   FakeDownloadCommand)
+
+        fake_command = FakeUploadCommand('path1')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+        fake_command = FakeUploadCommand('path2')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+        fake_command = FakeDownloadCommand('path3')
         self.listener.handle_SYS_QUEUE_ADDED(fake_command)
         self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
         transfers = self.status_frontend.recent_transfers()
@@ -824,11 +842,13 @@
 
         menu_data = self.listener.menu_data()
         self.assertEqual(menu_data,
-            {UPLOADING: [], RECENT_TRANSFERS: expected})
+            {UPLOADING: [],
+             DOWNLOADING: [],
+             RECENT_TRANSFERS: expected})
 
-    def test_file_uploading(self):
+    def test_files_uploading(self):
         """Check that it returns a list with the path, size, and progress."""
-        fc = FakeCommand(path='testfile.txt')
+        fc = FakeUploadCommand(path='testfile.txt')
         fc.deflated_size = 200
         self.status_frontend.upload_started(fc)
         uploading = self.status_frontend.files_uploading()
@@ -836,11 +856,13 @@
         self.assertEqual(uploading, expected)
         menu_data = self.listener.menu_data()
         self.assertEqual(menu_data,
-            {UPLOADING: expected, RECENT_TRANSFERS: []})
+            {UPLOADING: expected,
+             DOWNLOADING: [],
+             RECENT_TRANSFERS: []})
 
         fc.deflated_size = 1000
         fc.n_bytes_written = 200
-        fc2 = FakeCommand(path='testfile2.txt')
+        fc2 = FakeUploadCommand(path='testfile2.txt')
         fc2.deflated_size = 2000
         fc2.n_bytes_written = 450
         self.status_frontend.upload_started(fc2)
@@ -850,38 +872,100 @@
 
         menu_data = self.listener.menu_data()
         self.assertEqual(menu_data,
-            {UPLOADING: expected, RECENT_TRANSFERS: []})
+            {UPLOADING: expected,
+             DOWNLOADING: [],
+             RECENT_TRANSFERS: []})
+
+    def test_files_downloading(self):
+        """Check that it returns a list with the path, size, and progress."""
+        fc = FakeDownloadCommand(path='testfile.txt')
+        fc.deflated_size = 200
+        self.status_frontend.download_started(fc)
+        downloading = self.status_frontend.files_downloading()
+        expected = [('testfile.txt', 200, 0)]
+        self.assertEqual(downloading, expected)
+        menu_data = self.listener.menu_data()
+        self.assertEqual(menu_data,
+            {DOWNLOADING: expected,
+             UPLOADING: [],
+             RECENT_TRANSFERS: []})
+
+        fc.deflated_size = 1000
+        fc.n_bytes_read = 200
+        fc2 = FakeDownloadCommand(path='testfile2.txt')
+        fc2.deflated_size = 2000
+        fc2.n_bytes_read = 450
+        self.status_frontend.download_started(fc2)
+        downloading = self.status_frontend.files_downloading()
+        expected = [('testfile.txt', 1000, 200), ('testfile2.txt', 2000, 450)]
+        self.assertEqual(downloading, expected)
+
+        menu_data = self.listener.menu_data()
+        self.assertEqual(menu_data,
+            {DOWNLOADING: expected,
+             UPLOADING: [],
+             RECENT_TRANSFERS: []})
 
     def test_files_uploading_empty(self):
         """Check that empty files are ignored."""
-        fc = FakeCommand(path='testfile.txt')
+        fc = FakeUploadCommand(path='testfile.txt')
         fc.deflated_size = None
         self.status_frontend.upload_started(fc)
 
-        fc2 = FakeCommand(path='testfile2.txt')
+        fc2 = FakeUploadCommand(path='testfile2.txt')
         fc2.deflated_size = 0
         fc2.n_bytes_written = 450
         self.status_frontend.upload_started(fc2)
         uploading = self.status_frontend.files_uploading()
         self.assertEqual(uploading, [])
 
+    def test_files_downloading_empty(self):
+        """Check that empty files are ignored."""
+        fc = FakeDownloadCommand(path='testfile.txt')
+        fc.deflated_size = None
+        self.status_frontend.download_started(fc)
+
+        fc2 = FakeDownloadCommand(path='testfile2.txt')
+        fc2.deflated_size = 0
+        fc2.n_bytes_written = 450
+        self.status_frontend.download_started(fc2)
+        downloading = self.status_frontend.files_downloading()
+        self.assertEqual(downloading, [])
+
     def test_menu_data_full_response(self):
-        """Check that listener.menu_data returns both uploading and recent."""
-        self.patch(status_listener.action_queue, "Upload", FakeCommand)
-        fake_command = FakeCommand('path1')
-        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
-        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
-        fc = FakeCommand(path='testfile.txt')
+        """listener.menu_data returns uploading, downloading, and recent."""
+        self.patch(status_listener.action_queue, "Upload", FakeUploadCommand)
+        fake_command = FakeUploadCommand('path1')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+
+        self.patch(status_listener.action_queue, "Download",
+                   FakeDownloadCommand)
+        fake_command = FakeDownloadCommand('path2')
+        self.listener.handle_SYS_QUEUE_ADDED(fake_command)
+        self.listener.handle_SYS_QUEUE_REMOVED(fake_command)
+
+        fc = FakeUploadCommand(path='testfile.txt')
         fc.deflated_size = 1000
         fc.n_bytes_written = 200
         self.status_frontend.upload_started(fc)
+
+        fc = FakeDownloadCommand(path='download.pdf')
+        fc.deflated_size = 10
+        fc.n_bytes_read = 1
+        self.status_frontend.download_started(fc)
+
         uploading = self.status_frontend.files_uploading()
+        downloading = self.status_frontend.files_downloading()
         transfers = self.status_frontend.recent_transfers()
         expected = {UPLOADING: [('testfile.txt', 1000, 200)],
-            RECENT_TRANSFERS: ['path1']}
+                    DOWNLOADING: [('download.pdf', 10, 1)],
+                    RECENT_TRANSFERS: ['path1', 'path2']}
 
-        self.assertEqual(
-            {UPLOADING: uploading, RECENT_TRANSFERS: transfers}, expected)
+        self.assertEqual({UPLOADING: uploading,
+                          DOWNLOADING: downloading,
+                          RECENT_TRANSFERS: transfers},
+                         expected)
 
     def test_file_published(self):
         """A file published event is processed."""
@@ -1415,6 +1499,7 @@
         self.assertEqual(
             {(fc.share_id, fc.node_id): (fc.deflated_size)},
             self.aggregator.progress)
+        self.assertEqual(len(self.aggregator.recent_transfers), 1)
 
     def test_file_upload_started(self):
         """Test that a file has started upload."""
@@ -1443,10 +1528,14 @@
 
     def test_max_recent_files(self):
         """Check that the queue doesn't exceed the 5 items."""
-        for i in range(15):
-            fc = FakeCommand()
+        for i in range(10):
+            fc = FakeUploadCommand()
             self.status_frontend.upload_started(fc)
             self.status_frontend.upload_finished(fc)
+        for i in range(10):
+            fc = FakeDownloadCommand()
+            self.status_frontend.download_started(fc)
+            self.status_frontend.download_finished(fc)
         self.assertEqual(len(self.aggregator.recent_transfers), 5)
 
     def test_progress_made(self):

=== modified file 'ubuntuone/status/aggregator.py'
--- ubuntuone/status/aggregator.py	2012-10-15 21:20:54 +0000
+++ ubuntuone/status/aggregator.py	2012-10-24 16:06:50 +0000
@@ -754,6 +754,7 @@
         if command.deflated_size is not None:
             self.progress[
                 (command.share_id, command.node_id)] = command.deflated_size
+        self.recent_transfers.append(command.path)
         logger.debug("unqueueing command: %s", command.__class__.__name__)
         self.update_progressbar()
 
@@ -836,11 +837,11 @@
                 self.sync_menu.update_transfers)
 
     def recent_transfers(self):
-        """Return a tuple with the recent transfers paths."""
+        """Return a list of paths of recently transferred files."""
         return list(self.aggregator.recent_transfers)
 
     def files_uploading(self):
-        """Return a list with the files being uploading."""
+        """Return list with (path, size, written) per current upload."""
         uploading = []
         for upload in self.aggregator.files_uploading:
             if upload.deflated_size not in (0, None):
@@ -848,6 +849,15 @@
                     upload.n_bytes_written))
         return uploading
 
+    def files_downloading(self):
+        """Returns list with (path, size, read) per current download."""
+        downloading = []
+        for download in self.aggregator.files_downloading:
+            if download.deflated_size not in (0, None):
+                downloading.append((download.path, download.deflated_size,
+                                    download.n_bytes_read))
+        return downloading
+
     def file_published(self, public_url):
         """A file was published."""
         status_event = FilePublishingStatus(new_public_url=public_url)

=== modified file 'ubuntuone/syncdaemon/__init__.py'
--- ubuntuone/syncdaemon/__init__.py	2012-08-10 12:49:46 +0000
+++ ubuntuone/syncdaemon/__init__.py	2012-10-24 16:06:50 +0000
@@ -41,3 +41,4 @@
 #Sync Menu data constants
 RECENT_TRANSFERS = 'recent-transfers'
 UPLOADING = 'uploading'
+DOWNLOADING = 'downloading'

=== modified file 'ubuntuone/syncdaemon/status_listener.py'
--- ubuntuone/syncdaemon/status_listener.py	2012-09-20 12:56:32 +0000
+++ ubuntuone/syncdaemon/status_listener.py	2012-10-24 16:06:50 +0000
@@ -36,6 +36,7 @@
     config,
     RECENT_TRANSFERS,
     UPLOADING,
+    DOWNLOADING
 )
 from ubuntuone.syncdaemon.interaction_interfaces import (
     get_share_dict, get_udf_dict)
@@ -74,8 +75,11 @@
     def menu_data(self):
         """Return the info necessary to construct the sync menu."""
         uploading = self.status_frontend.files_uploading()
+        downloading = self.status_frontend.files_downloading()
         transfers = self.status_frontend.recent_transfers()
-        data = {RECENT_TRANSFERS: transfers, UPLOADING: uploading}
+        data = {RECENT_TRANSFERS: transfers,
+                UPLOADING: uploading,
+                DOWNLOADING: downloading}
         return data
 
     def get_show_all_notifications(self):