Merge branch '0.2.6.1'

Author: kouk

features/upload_resume.feature

@@ -0,0 +1,33 @@
+Feature: resume upload feature
+
+    Background: setup the command configuration
+        Given the home directory is "/tmp/test"
+        And the Longaccess directory exists in HOME
+        And the mock API "longaccessmock"
+        And the environment variable "LA_API_URL" is "{api_url}path/to/api"
+        And the username "test" 
+        And the password "test"
+        And I have 2 capsules
+        And I store my credentials in "{homedir}/.netrc"
+
+    @dev
+    Scenario: I pause an archive
+        Given the command line arguments "archive create -t foobar lacli"
+        And an S3 bucket named "foobucket"
+        When I run console script "lacli"
+        Then I wait 10 seconds to see "archive prepared"
+        Given the command line arguments "archive upload"
+        When I run console script "lacli"
+        Then I see "ETA:"
+        When I send control-c
+        And I wait until I don't see "ETA:" anymore
+        Then I see "paused"
+
+    Scenario: I resume an archive
+        Given I have 1 pending uploads
+        And an S3 bucket named "foobucket"
+        Given the command line arguments "-d 4 archive upload"
+        When I run console script "lacli"
+        Then I see "ETA:"
+        When the upload status is "completed"
+        Then I wait 5 seconds to see "done."

lacli/__init__.py

@@ -1,17 +1,15 @@
 from __future__ import unicode_literals
-import platform
 
 try:
     from lacli.version import __version__
 except ImportError:
-    __version__ = "0.2.6"
+    __version__ = "0.2.6.1"
 
 
 def get_client_info(terse=False):
+    from lacore import get_client_info as lacore_info
     el = ["Longaccess client"]
     el.append(__version__)
-    el.append(platform.platform(True, terse))
-    el.append("py"+platform.python_version())
-    el.append(platform.machine())
+    el.append(lacore_info(terse))
     return " ".join(el)
 # vim: et:sw=4:ts=4

lacli/main.py

@@ -79,7 +79,8 @@ def settings(options):
             'pass': options.get('--password'),
             'url': os.getenv('LA_API_URL'),
             'verify': verify,
-            'factory': RequestsFactory
+            'factory': RequestsFactory,
+            'user_agent': get_client_info(terse=True)
         },
         'command': {
             'debug': debug,

lacli/server/__init__.py

@@ -78,6 +78,9 @@ def do_run(self, port=9090):
             self.logincmd.username = self.prefs['gui']['username']
             self.logincmd.password = self.prefs['gui']['password']
             self.logincmd.email = self.prefs['gui']['email']
+        ua = os.getenv("LA_API_AGENT_INFO")
+        if ua is not None:
+            self.registry.session.prefs['user_agent'] += " (" + ua + ")"
         reactor.run()
         self.batch = False
 

lacli/t/__init__.py

@@ -5,6 +5,7 @@
 from contextlib import contextmanager
 from tempfile import mkdtemp
 from shutil import rmtree
+from logging import Handler as LogHandler
 
 
 def setup():
@@ -71,3 +72,36 @@ def _temp_home():
     d = mkdtemp()
     yield d
     rmtree(d)
+
+
+class MockLoggingHandler(LogHandler):
+    """Mock logging handler to check for expected logs.
+
+    Messages are available from an instance's ``messages`` dict,
+    in order, indexed by a lowercase log level string (e.g.,
+    'debug', 'info', etc.).
+
+    Adapted from: http://stackoverflow.com/questions/899067/
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.messages = {'debug': [], 'info': [], 'warning': [], 'error': [],
+                         'critical': []}
+        super(MockLoggingHandler, self).__init__(*args, **kwargs)
+
+    def emit(self, record):
+        "Store a message from ``record`` in the instance's ``messages`` dict."
+        self.acquire()
+        try:
+            self.messages[record.levelname.lower()].append(
+                (record.getMessage(), record.exc_info))
+        finally:
+            self.release()
+
+    def reset(self):
+        self.acquire()
+        try:
+            for message_list in self.messages.values():
+                del message_list[:]
+        finally:
+            self.release()

lacli/t/test_main.py

@@ -59,3 +59,12 @@ def test_make_home(self, stdin):
         finally:
             if (tmpdir and os.path.isdir(tmphome)):
                 shutil.rmtree(tmpdir)
+
+    @patch('lacli.main.get_client_info')
+    def test_user_agent(self, info):
+        settings = self._makeit()
+        info.return_value = self.getUniqueString()
+        prefs, _ = settings({'--home': self.home})
+        self.assertIn('api', prefs)
+        self.assertIn('user_agent', prefs['api'])
+        self.assertEqual(info.return_value, prefs['api']['user_agent'])

lacli/t/test_registry.py

@@ -1,15 +1,24 @@
 import os
 
 from testtools import TestCase
-from . import makeprefs
-from mock import Mock
+from . import makeprefs, MockLoggingHandler
+from mock import Mock, patch
 
 
 class RegistryTest(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super(RegistryTest, cls).setUpClass()
+        cls._lacli_log_handler = MockLoggingHandler(level='DEBUG')
+        cls.lacli_log_messages = cls._lacli_log_handler.messages
+
     def setUp(self):
         super(RegistryTest, self).setUp()
         self.prefs = makeprefs(lambda x: None)
         self.home = os.path.join('t', 'data', 'home')
+        self._lacli_log_handler.reset()
+        from lacli.log import getLogger
+        getLogger().addHandler(self._lacli_log_handler)
 
     def tearDown(self):
         super(RegistryTest, self).tearDown()
@@ -20,3 +29,43 @@ def _makeit(self, *args, **kwargs):
 
     def test_registry(self):
         assert self._makeit(Mock(), self.prefs, Mock())
+
+    def test_new_session(self):
+        s = self.getUniqueString()
+        f = Mock(return_value=s)
+        prefs = makeprefs(f)
+        r = self._makeit(Mock(), prefs, Mock())
+        self.assertEqual(s, r.session)
+        self.assertEqual(prefs['api'], f.call_args[0][0])
+
+    @patch('lacli.registry.API_URL', new='http://wtf')
+    def test_new_session_default_url(self):
+        f = Mock()
+        prefs = makeprefs(f)
+        del prefs['api']['url']
+        self._makeit(Mock(), prefs, Mock())
+        self.assertEqual('http://wtf', f.call_args[0][0]['url'])
+
+    def test_new_session_prefs(self):
+        s = self.getUniqueString()
+        f = Mock(return_value=s)
+        myprefs = {self.getUniqueString(): self.getUniqueString()}
+        r = self._makeit(Mock(), makeprefs(f), Mock())
+        self.assertEqual(s, r.new_session(myprefs))
+        self.assertEqual(myprefs, f.call_args[0][0])
+
+    @patch('lacli.registry.netrc')
+    def test_saved_session_error(self, netrc):
+        f = Mock()
+        prefs = makeprefs(f)
+        prefs['api']['user'] = False
+        exc = Exception(self.getUniqueString())
+        netrc.side_effect = exc
+        self._makeit(Mock(home='foo'), prefs, Mock())
+        self.assertEqual(None, f.call_args[0][0]['pass'])
+        self.assertEqual(os.path.expanduser('~/.netrc'),
+                         netrc.call_args[0][0])
+        for debug_msg, debug_exc in self.lacli_log_messages['debug']:
+            self.assertIn("Couldn't read from netrc", debug_msg)
+            self.assertTrue(debug_exc is not None)
+            self.assertEqual(exc, debug_exc[1])

lacli/t/test_server.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import os
+import crochet
 
 from testtools import TestCase
 from twisted.internet import defer
@@ -8,6 +9,11 @@
 
 
 class ServerTest(TestCase):
+
+    @classmethod
+    def setup_class(cls):
+        crochet.setup()
+
     def setUp(self):
         super(ServerTest, self).setUp()
         self.prefs = makeprefs()
@@ -24,6 +30,7 @@ def ttypes(self):
         from lacli.server.interface.ClientInterface import ttypes
         return ttypes
 
+    @crochet.wait_for(2.0)
     @defer.inlineCallbacks
     def test_get_latest_version(self):
         registry = Mock()
@@ -45,6 +52,7 @@ def test_get_latest_version(self):
                     self.assertEqual(
                         v, self.ttypes().VersionInfo('1.2.3'))
 
+    @crochet.wait_for(2.0)
     @defer.inlineCallbacks
     def test_get_latest_version_from_api(self):
         registry = Mock()

lacli/t/test_upload_state.py

@@ -0,0 +1,60 @@
+from testtools import TestCase
+from mock import Mock
+
+
+class UploadStateTest(TestCase):
+    def setUp(self):
+        from lacli.upload import UploadState
+        UploadState.states = None
+        super(UploadStateTest, self).setUp()
+
+    def tearDown(self):
+        super(UploadStateTest, self).tearDown()
+
+    def _mockcache(self, uploads={}, archives={}):
+        return Mock(_get_uploads=Mock(return_value=uploads),
+                    _for_adf=Mock(return_value=archives))
+
+    def test_no_uploads(self):
+        from lacli.upload import UploadState
+        UploadState.init(self._mockcache())
+        archive = self.getUniqueString()
+        self.assertEqual(archive, UploadState.get(archive).archive)
+        self.assertTrue(archive in UploadState.states)
+
+    def test_no_change_upload_size(self):
+        from lacli.upload import UploadState
+        UploadState.init(self._mockcache())
+        archive = self.getUniqueString()
+        size = 123
+        self.assertEqual(size, UploadState.get(archive, size=size).size)
+        e = self.assertRaises(AssertionError,
+                              UploadState.get, archive, size=size+1)
+        self.assertEqual("Can't change size for upload", str(e))
+
+    def test_no_change_sandbox_status(self):
+        from lacli.upload import UploadState
+        UploadState.init(self._mockcache())
+        archive = self.getUniqueString()
+        self.assertFalse(UploadState.get(archive).sandbox)
+        e = self.assertRaises(AssertionError,
+                              UploadState.get, archive, sandbox=True)
+        self.assertEqual("Can't change sandbox status for upload", str(e))
+
+    def test_no_change_capsule(self):
+        from lacli.upload import UploadState
+        UploadState.init(self._mockcache())
+        archive = self.getUniqueString()
+        self.assertEqual(
+            1, UploadState.get(archive, capsule={'id': 1}).capsule['id'])
+        e = self.assertRaises(
+            AssertionError, UploadState.get, archive, capsule={'id': 2})
+        self.assertEqual("Can't change capsule for upload", str(e))
+
+    def test_change_capsule(self):
+        from lacli.upload import UploadState
+        UploadState.init(self._mockcache())
+        archive = self.getUniqueString()
+        self.assertIs(None, UploadState.get(archive).capsule)
+        self.assertEqual(
+            2, UploadState.get(archive, capsule={'id': 2}).capsule['id'])

lacli/upload.py

@@ -60,7 +60,11 @@ def get(cls, fname, size=None, capsule=None, sandbox=False):
                 assert state.size == size, msg.format('size')
                 cls.states[fname].size = size
             if capsule is not None:
-                assert state.capsule.id == capsule.id, msg.format('capsule')
+                # might be helpful if you want to change the capsule
+                if state.capsule is None:
+                    state.capsule = capsule
+                cid = state.capsule.get('id', None)
+                assert cid == capsule['id'], msg.format('capsule')
                 cls.states[fname].capsule = capsule
             if sandbox is True:
                 assert state.sandbox == sandbox, msg.format('sandbox status')