def test_do_put_error(self):
from lacli.cache import Cache
with _temp_home() as home:
registry = Mock()
registry.cache = Cache(home)
registry.prefs = self.prefs
cli = self._makeit(registry, self.prefs)
with patch('sys.stdout', new_callable=StringIO) as out:
cli.onecmd('upload')
self.assertThat(out.getvalue(),
Contains('no such archive'))
registry = Mock()
registry.cache = Cache(self.home)
registry.prefs = self.prefs
registry.session.capsule_ids.return_value = {'1': dummycapsule}
cli = self._makeit(registry, self.prefs)
with patch('sys.stdout', new_callable=StringIO) as out:
cli.onecmd('upload foobar')
self.assertThat(out.getvalue(),
Contains('error: invalid value'))
with patch('sys.stdout', new_callable=StringIO) as out:
archives = cli.cache._for_adf('archives')
for seq, archive in enumerate(archives.itervalues()):
if archive['archive'].title == 'My 2013 vacation':
cli.onecmd('upload {}'.format(seq+1))
self.assertThat(out.getvalue(),
Contains('upload is already completed'))
def test_do_restore_none(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
cli = self._makeit(registry)
cli.onecmd('extract filedoesnotexist')
self.assertThat(out.getvalue(), Contains('does not exist'))
def test_do_archive_list_none(self, out):
registry = Mock()
registry.cache._for_adf.return_value = {}
registry.prefs = self.prefs
cli = self._makeit(registry, self.prefs)
cli.onecmd('list')
self.assertEqual('No available archives.\n', out.getvalue())
def test_do_archive_exception(self, mock_stdout):
registry = Mock()
registry.cache.prepare.side_effect = Exception("foo")
registry.prefs = self.prefs
cli = self._makeit(registry)
cli.onecmd('create {} baz'.format(self.home))
self.assertThat(mock_stdout.getvalue(),
Contains('error: foo'))
def test_do_logout(self):
registry = Mock()
registry.prefs = self.prefs
registry.session = "foobar"
cli = self._makeit(registry)
cli.onecmd('logout')
self.assertEqual(None, cli.registry.session)
def test_do_list_exception(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
registry.session.capsules.side_effect = Exception("foo")
cli = self._makeit(registry)
cli.onecmd('list')
self.assertEqual("error: foo\n", out.getvalue())
def test_show_archives(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
registry.session.archives.return_value = ()
cli = self._makeit(registry)
cli.onecmd('archives')
self.assertEqual("No available archives.\n", out.getvalue())
def test_fetch_archive_nonexistent(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
registry.session.archives.return_value = ()
cli = self._makeit(registry)
cli.onecmd('fetch baz')
self.assertEqual("Archive not found\n", out.getvalue())
def test_do_login(self, stdout):
registry = Mock()
registry.prefs = self.prefs
registry.new_session.return_value.account = {'email': 'foo'}
cli = self._makeit(registry)
cli.onecmd('login')
self.assertThat(stdout.getvalue(),
Contains('authentication succesfull'))
def test_do_login_session_fail(self, stdout):
registry = Mock()
registry.prefs = self.prefs
registry.new_session.side_effect = Exception()
cli = self._makeit(registry)
cli.onecmd('login')
self.assertThat(stdout.getvalue(),
Contains('authentication failed'))
def test_do_status(self):
from lacli.cache import Cache
registry = Mock()
registry.cache = Cache(self.home)
registry.prefs = self.prefs
with patch('sys.stdout', new_callable=StringIO) as out:
cli = self._makeit(registry, self.prefs)
cli.onecmd('status')
self.assertThat(out.getvalue(),
Contains('Usage:'))
def test_do_login_auth_fail(self, stdout):
registry = Mock()
registry.prefs = self.prefs
registry.new_session.return_value.async_account = defer.fail(
Exception())
cli = self._makeit(registry)
cli.onecmd('login')
self.assertThat(stdout.getvalue(),
Contains('authentication failed'))
def test_do_archive_with_title(self, mock_stdout):
registry = Mock()
registry.cache.prepare.return_value = True
registry.prefs = self.prefs
cli = self._makeit(registry)
cli.onecmd('create {} baz'.format(self.home))
args, _ = registry.cache.prepare.call_args
self.assertTrue(self.home in args)
self.assertTrue(u'baz' in args)
self.assertThat(mock_stdout.getvalue(),
Contains('archive prepared'))
def test_show_archives_nonexistent(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
registry.session.capsules.return_value = ()
registry.session.capsule_ids.return_value = {}
registry.session.archives.return_value = (dummyarchive,)
cli = self._makeit(registry)
cli.onecmd('archives 1')
self.assertThat(out.getvalue(),
Contains('No such capsule'))
def test_do_archive_list_some(self, out):
from lacore.adf.elements import Archive, Meta
meta = Meta(format='', size=None, cipher='')
archive = Archive(title="foo", description='',
tags=[], meta=meta)
registry = Mock()
registry.cache._for_adf.return_value = {'foo': {'archive': archive}}
registry.prefs = self.prefs
cli = self._makeit(registry)
cli.onecmd('list')
self.assertThat(out.getvalue(),
Contains('foo'))
def test_do_login_user(self, stdout):
registry = Mock()
registry.prefs = self.prefs
registry.new_session.return_value.async_account = defer.succeed(
{'email': 'foo'})
cli = self._makeit(registry)
cli.onecmd('login user pass')
self.assertThat(stdout.getvalue(),
Contains('authentication succesfull as foo'))
self.assertEqual('user', cli.username)
self.assertEqual('pass', cli.password)
self.assertEqual('foo', cli.email)
def test_show_archives_wrong_capsule(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
othercapsule = dummycapsule
othercapsule['resource_uri'] = 'blabla'
registry.session.capsules.return_value = (othercapsule,)
registry.session.capsule_ids.return_value = {1: othercapsule}
registry.session.archives.return_value = (dummyarchive,)
cli = self._makeit(registry)
cli.onecmd('archives 1')
self.assertThat(out.getvalue(),
Contains('No available archives'))
def test_list_capsules_some(self):
with patch('sys.stdout', new_callable=StringIO) as out:
registry = Mock()
registry.prefs = self.prefs
registry.session.capsules.return_value = (dummycapsule,)
cli = self._makeit(registry)
cli.onecmd('list')
self.assertThat(out.getvalue(),
Contains('foo'))
self.assertThat(out.getvalue(),
Contains('bar'))
self.assertThat(out.getvalue(),
Contains('1 MB'))
self.assertThat(out.getvalue(),
Contains('1970-01-01'))
def test_do_archive_list_more(self):
with patch('sys.stdout', new_callable=StringIO) as out:
for size in [(25, '25 B'), (1024, '1 KB'), (2000000, '1 MB')]:
from lacore.adf.elements import Archive, Meta
meta = Meta(format='', size=size[0], cipher='')
archive = Archive(title="foo", description='',
tags=[], meta=meta)
registry = Mock()
registry.cache._for_adf.return_value = {
'foo': {'archive': archive}}
registry.prefs = self.prefs
cli = self._makeit(registry)
cli.onecmd('list')
self.assertThat(out.getvalue(),
Contains('foo'))
self.assertThat(out.getvalue(),
Contains(size[1]))
def test_fetch_archive(self):
with patch('sys.stdout', new_callable=StringIO) as out:
with patch('lacli.command.ask_key') as ask_key:
ask_key.return_value = 'DEADBEEF' * 8
registry = Mock()
registry.prefs = self.prefs
registry.cache.save_cert.return_value = ('LALA', None)
registry.session.archives.return_value = (dummyarchive,)
cli = self._makeit(registry)
cli.onecmd('fetch baz')
self.assertThat(out.getvalue(),
Contains('Fetched certificate LALA'))
docs = registry.cache.save_cert.call_args[0][0]
self.assertTrue('cert' in docs)
self.assertTrue('archive' in docs)
self.assertTrue('signature' in docs)
self.assertEqual(docs['archive'].title, 'faz')
def test_do_archive_list_capsule(self, out):
from lacore.adf.elements import Archive, Meta, Links
meta = Meta(format='', size=None, cipher='')
archive = Archive(title="foo", description='',
tags=[], meta=meta)
links = Links(upload='http://foo.bar.com/123#C:Photos:')
registry = Mock()
registry.cache._for_adf.return_value = {
'foo': {
'archive': archive,
'links': links
}
}
registry.prefs = self.prefs
cli = self._makeit(registry)
cli.onecmd('list')
self.assertThat(out.getvalue(),
Contains('foo'))
self.assertThat(out.getvalue(),
Contains('Photos'))
