Merge lp:~frankban/juju-quickstart/sudo-fixes into lp:juju-quickstart

[Francesco Banconi]

Install missing packages for add-apt-repository.

Also use absolute paths to commands executed
with sudo privileges.

Tests: `make check`

QA:

1) Create a saucy LXC sharing your home directory,
    e.g. `sudo lxc-create -t ubuntu -n quickstart -f <MY-TEMPLATE> \
          -- -r saucy -a amd64 -b $USER`
    where "quickstart" is the name of the container,
    "-r" is used to specify the release to use,
    "-b" binds the home directory of the specified user,
    and <MY-TEMPLATE> is a file with the following contents:
        lxc.network.type=veth
        lxc.network.link=lxcbr0
        lxc.network.flags=up
    I assume you already have:
      - a juju home containing the environments.yaml file
        configured with an "ec2" ec2 environment;
      - your ssh keys properly set up;
      - run the tests with `make check` as described above.
    So at this point the container does not have juju
    installed, but the juju home and ssh keys are
    available, and so the branch with a configured testing
    virtualenv. We already have cards for environment
    creation and ssh keys handling.
2) Start the LXC instance (`sudo lxc-start -n quickstart`).
3) Open a console inside the LXC with
    `sudo lxc-console -n quickstart`, log in using your user
    credentials, and cd into the directory where you checked
    out this branch.
4) Run `.venv/bin/python juju-quickstart -e ec2 --no-browser`.
    You should be asked the sudo password in order to add
    the missing PPA and install juju-core and lxc.
    Note that installing the packages can take some minutes.
    The process will then proceed as usual.
5) Run `.venv/bin/python juju-quickstart -e ec2 --no-browser`
    again: this time no packages installation should be required,
    and quickstart just reuses the existing environment.
6) From the host, stop and destroy the LXC container:
    `sudo lxc-stop -n quickstart` and `sudo lxc-destroy -n quickstart`.
7) Destroy your ec2 environment.

Thank you!

https://codereview.appspot.com/32760043/

[Francesco Banconi (frankban)]

Reviewers: mp+196692_code.launchpad.net,

Message:
Please take a look.

Description:
Install missing packages for add-apt-repository.

Also use absolute paths to commands executed
with sudo privileges.

Tests: `make check`

QA:

1) Create a saucy LXC sharing your home directory,
     e.g. `sudo lxc-create -t ubuntu -n quickstart -f <MY-TEMPLATE> \
           -- -r saucy -a amd64 -b $USER`
     where "quickstart" is the name of the container,
     "-r" is used to specify the release to use,
     "-b" binds the home directory of the specified user,
     and <MY-TEMPLATE> is a file with the following contents:
         lxc.network.type=veth
         lxc.network.link=lxcbr0
         lxc.network.flags=up
     I assume you already have:
       - a juju home containing the environments.yaml file
         configured with an "ec2" ec2 environment;
       - your ssh keys properly set up;
       - run the tests with `make check` as described above.
     So at this point the container does not have juju
     installed, but the juju home and ssh keys are
     available, and so the branch with a configured testing
     virtualenv. We already have cards for environment
     creation and ssh keys handling.
2) Start the LXC instance (`sudo lxc-start -n quickstart`).
3) Open a console inside the LXC with
     `sudo lxc-console -n quickstart`, log in using your user
     credentials, and cd into the directory where you checked
     out this branch.
4) Run `.venv/bin/python juju-quickstart -e ec2 --no-browser`.
     You should be asked the sudo password in order to add
     the missing PPA and install juju-core and lxc.
     Note that installing the packages can take some minutes.
     The process will then proceed as usual.
5) Run `.venv/bin/python juju-quickstart -e ec2 --no-browser`
     again: this time no packages installation should be required,
     and quickstart just reuses the existing environment.
6) From the host, stop and destroy the LXC container:
     `sudo lxc-stop -n quickstart` and `sudo lxc-destroy -n quickstart`.
7) Destroy your ec2 environment.

Thank you!

https://code.launchpad.net/~frankban/juju-quickstart/sudo-fixes/+merge/196692

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/32760043/

Affected files (+255, -94 lines):
   A [revision details]
   M quickstart/__init__.py
   M quickstart/app.py
   M quickstart/tests/helpers.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_manage.py
   M quickstart/tests/test_utils.py
   M quickstart/utils.py

[lp:~frankban/juju-quickstart/sudo-fixes]

26. By Francesco Banconi on 2013-11-26

Fixes as per review.

[Francesco Banconi (frankban)]

Please take a look.

https://codereview.appspot.com/32760043/

[Brad Crittenden (bac)]

Code LGTM. QA had one problem, which you've already fixed. QA on patch
was successful.

https://codereview.appspot.com/32760043/

[Richard Harding (rharding)]

LGTM with a question and suggestion.

https://codereview.appspot.com/32760043/diff/20001/quickstart/app.py
File quickstart/app.py (right):

https://codereview.appspot.com/32760043/diff/20001/quickstart/app.py#newcode63
quickstart/app.py:63: # The lxc package is required to create the LXC
containers used by
shouldn't this dep be based on if your env is lxc vs just if the lxc-ls
command is available? Will this try to install lxc if I'm using
quickstart on non-local provider installs?

https://codereview.appspot.com/32760043/diff/20001/quickstart/app.py#newcode166
quickstart/app.py:166: '/usr/bin/juju', 'api-endpoints', '-e', env_name,
'--format', 'json')
maybe providing a COMMANDS or something list where this is hard coded
will be easier to maintain and less finding of paths through the code.

https://codereview.appspot.com/32760043/

[Francesco Banconi (frankban)]

On 2013/11/26 14:36:25, rharding wrote:
> LGTM with a question and suggestion.

> https://codereview.appspot.com/32760043/diff/20001/quickstart/app.py
> File quickstart/app.py (right):

https://codereview.appspot.com/32760043/diff/20001/quickstart/app.py#newcode63
> quickstart/app.py:63: # The lxc package is required to create the LXC
containers
> used by
> shouldn't this dep be based on if your env is lxc vs just if the
lxc-ls command
> is available? Will this try to install lxc if I'm using quickstart on
non-local
> provider installs?

https://codereview.appspot.com/32760043/diff/20001/quickstart/app.py#newcode166
> quickstart/app.py:166: '/usr/bin/juju', 'api-endpoints', '-e',
env_name,
> '--format', 'json')
> maybe providing a COMMANDS or something list where this is hard coded
will be
> easier to maintain and less finding of paths through the code.

Both good points, thank you.
We agreed they are out of scope for this branch, so I'll create cards.

https://codereview.appspot.com/32760043/

[Francesco Banconi (frankban)]

*** Submitted:

Install missing packages for add-apt-repository.

Also use absolute paths to commands executed
with sudo privileges.

Tests: `make check`

QA:

1) Create a saucy LXC sharing your home directory,
     e.g. `sudo lxc-create -t ubuntu -n quickstart -f <MY-TEMPLATE> \
           -- -r saucy -a amd64 -b $USER`
     where "quickstart" is the name of the container,
     "-r" is used to specify the release to use,
     "-b" binds the home directory of the specified user,
     and <MY-TEMPLATE> is a file with the following contents:
         lxc.network.type=veth
         lxc.network.link=lxcbr0
         lxc.network.flags=up
     I assume you already have:
       - a juju home containing the environments.yaml file
         configured with an "ec2" ec2 environment;
       - your ssh keys properly set up;
       - run the tests with `make check` as described above.
     So at this point the container does not have juju
     installed, but the juju home and ssh keys are
     available, and so the branch with a configured testing
     virtualenv. We already have cards for environment
     creation and ssh keys handling.
2) Start the LXC instance (`sudo lxc-start -n quickstart`).
3) Open a console inside the LXC with
     `sudo lxc-console -n quickstart`, log in using your user
     credentials, and cd into the directory where you checked
     out this branch.
4) Run `.venv/bin/python juju-quickstart -e ec2 --no-browser`.
     You should be asked the sudo password in order to add
     the missing PPA and install juju-core and lxc.
     Note that installing the packages can take some minutes.
     The process will then proceed as usual.
5) Run `.venv/bin/python juju-quickstart -e ec2 --no-browser`
     again: this time no packages installation should be required,
     and quickstart just reuses the existing environment.
6) From the host, stop and destroy the LXC container:
     `sudo lxc-stop -n quickstart` and `sudo lxc-destroy -n quickstart`.
7) Destroy your ec2 environment.

Thank you!

R=bac, rharding
CC=
https://codereview.appspot.com/32760043

https://codereview.appspot.com/32760043/

=== modified file 'quickstart/__init__.py'
--- quickstart/__init__.py	2013-11-22 08:30:42 +0000
+++ quickstart/__init__.py	2013-11-26 14:39:39 +0000
@@ -19,7 +19,7 @@
 that it can be managed using a Web interface (the Juju GUI).
 """
 
-VERSION = (0, 4, 2)
+VERSION = (0, 4, 3)
 
 
 def get_version():

=== modified file 'quickstart/app.py'
--- quickstart/app.py	2013-11-22 08:32:44 +0000
+++ quickstart/app.py	2013-11-26 14:39:39 +0000
@@ -55,31 +55,28 @@
     Raise a ProgramExit if an error occurs installing.
     """
     required_packages = []
-    retcode = utils.call('juju', 'version')[0]
+    retcode = utils.call('/usr/bin/juju', 'version')[0]
     if retcode > 0:
         required_packages.append('juju-core')
-    retcode = utils.call('lxc-ls')[0]
+    retcode = utils.call('/usr/bin/lxc-ls')[0]
     if retcode > 0:
-        required_packages.append('lxc')
+        # The lxc package is required to create the LXC containers used by
+        # the local provider. When the local provider is enabled, the host
+        # itself is used as bootstrap node. For this reason, the mongodb-server
+        # package from the Juju stable PPA is also required.
+        required_packages.extend(['lxc', 'mongodb-server'])
     if required_packages:
-        if len(required_packages) == 1:
-            plural_parts = 'package needs'
-        else:
-            plural_parts = 'packages need'
-
-        print('The following {} to be installed: {}'.format(
-            plural_parts, ', '.join(required_packages)))
-        print('sudo privileges are required for package installation.')
-
-        cmds = (
-            ('apt-add-repository', '-y', 'ppa:juju/stable'),
-            ('apt-get', 'update'),
-            ['apt-get', 'install', '-y'] + required_packages,
-        )
-        for cmd in cmds:
-            retcode, _, error = utils.call('sudo', *cmd)
-            if retcode:
-                raise ProgramExit(error)
+        try:
+            utils.add_apt_repository('ppa:juju/stable')
+        except OSError as err:
+            raise ProgramExit(str(err))
+        print('installing the following packages: {} '
+              '(this can take a while)'.format(', '.join(required_packages)))
+        print('sudo privileges will be used for package installation')
+        retcode, _, error = utils.call(
+            'sudo', '/usr/bin/apt-get', 'install', '-y', *required_packages)
+        if retcode:
+            raise ProgramExit(error)
 
 
 def bootstrap(env_name, is_local=False, debug=False):
@@ -100,7 +97,7 @@
     Raise a ProgramExit if any error occurs in the bootstrap process.
     """
     already_bootstrapped = False
-    cmd = ['juju', 'bootstrap', '-e', env_name]
+    cmd = ['/usr/bin/juju', 'bootstrap', '-e', env_name]
     # XXX frankban 2013-11-20: avoid using sudo once this is no longer required
     # in juju-core.
     if is_local:
@@ -140,7 +137,7 @@
     timeout = time.time() + (60*10)
     while time.time() < timeout:
         retcode, output, error = utils.call(
-            'juju', 'status', '-e', env_name, '--format', 'yaml')
+            '/usr/bin/juju', 'status', '-e', env_name, '--format', 'yaml')
         if retcode:
             continue
         # Ensure the state server is up and the agent is started.
@@ -166,7 +163,7 @@
     Raise a ProgramExit if any error occurs.
     """
     retcode, output, error = utils.call(
-        'juju', 'api-endpoints', '-e', env_name, '--format', 'json')
+        '/usr/bin/juju', 'api-endpoints', '-e', env_name, '--format', 'json')
     if retcode:
         raise ProgramExit(error)
     # Assuming there is always at least one API address, grab the first one

=== modified file 'quickstart/tests/helpers.py'
--- quickstart/tests/helpers.py	2013-11-22 08:32:44 +0000
+++ quickstart/tests/helpers.py	2013-11-26 14:39:39 +0000
@@ -121,6 +121,10 @@
         return env_file.name
 
 
+# Mock the builtin print function.
+mock_print = mock.patch('__builtin__.print')
+
+
 class UrlReadTestsMixin(object):
     """Expose a method to mock the quickstart.utils.urlread helper function."""
 

=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2013-11-22 09:55:35 +0000
+++ quickstart/tests/test_app.py	2013-11-26 14:39:39 +0000
@@ -31,9 +31,6 @@
 from quickstart.tests import helpers
 
 
-mock_print = mock.patch('__builtin__.print')
-
-
 class TestProgramExit(unittest.TestCase):
 
     def test_string_representation(self):
@@ -61,94 +58,128 @@
         return jujuclient.EnvError({'Error': message})
 
 
-@mock_print
[e-mail]_print
 class TestEnsureDependencies(
         helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
 
+    add_repository = '/usr/bin/add-apt-repository'
+    apt_get = '/usr/bin/apt-get'
+
     def call_ensure_dependencies(self, call_effects):
         with self.patch_multiple_calls(call_effects) as mock_call:
             app.ensure_dependencies()
         return mock_call
 
     def test_success_install(self, mock_print):
-        call = self.call_ensure_dependencies(
-            (
-                (127, '', 'no juju'),
-                (127, '', 'no lxc'),
-                (0, 'add repo', ''),
-                (0, 'update', ''),
-                (0, 'install', ''),
-            )
+        # All the missing packages are installed from the PPA.
+        side_effects = (
+            (127, '', 'no juju'),  # Check the juju command.
+            (127, '', 'no lxc'),  # Check the lxc-ls command.
+            (0, 'saucy', ''),  # Retrieve the Ubuntu release codename.
+            (0, 'install add repo', ''),  # Install add-apt-repository.
+            (0, 'add repo', ''),  # Add the juju stable repository.
+            (0, 'update', ''),  # Update the repository with new sources.
+            (0, 'install', ''),  # Install missing packages.
         )
-        self.assertEqual(call.call_count, 5)
-        call.assert_has_calls([
-            mock.call('juju', 'version'),
-            mock.call('lxc-ls'),
-            mock.call('sudo', 'apt-add-repository', '-y', 'ppa:juju/stable'),
-            mock.call('sudo', 'apt-get', 'update'),
-            mock.call('sudo', 'apt-get', 'install', '-y', 'juju-core', 'lxc'),
+        mock_call = self.call_ensure_dependencies(side_effects)
+        self.assertEqual(len(side_effects), mock_call.call_count)
+        mock_call.assert_has_calls([
+            mock.call('/usr/bin/juju', 'version'),
+            mock.call('/usr/bin/lxc-ls'),
+            mock.call('lsb_release', '-cs'),
+            mock.call('sudo', self.apt_get, 'install', '-y',
+                      'software-properties-common'),
+            mock.call('sudo', self.add_repository, '-y', 'ppa:juju/stable'),
+            mock.call('sudo', self.apt_get, 'update'),
+            mock.call('sudo', self.apt_get, 'install', '-y',
+                      'juju-core', 'lxc', 'mongodb-server'),
         ])
         mock_print.assert_has_calls([
-            mock.call(
-                'The following packages need to be installed: juju-core, lxc'),
-            mock.call(
-                'sudo privileges are required for package installation.'),
+            mock.call('sudo privileges are required for PPA installation'),
+            mock.call('installing the following packages: juju-core, '
+                      'lxc, mongodb-server (this can take a while)'),
+            mock.call('sudo privileges will be used for package installation'),
         ])
 
     def test_success_no_install(self, mock_print):
-        call = self.call_ensure_dependencies(
-            [
-                (0, '1.16', ''),
-                (0, '', ''),
-                (0, 'add repo', ''),
-                (0, 'update', ''),
-                (0, 'install', ''),
-            ]
+        # There is no need to install packages/PPAs if everything is already
+        # set up.
+        side_effects = (
+            (0, '1.16', ''),  # Check the juju command.
+            (0, '', ''),  # Check the lxc-ls command.
+            # The remaining call should be ignored.
+            (1, '', 'not ignored'),
         )
-        self.assertEqual(call.call_count, 2)
+        mock_call = self.call_ensure_dependencies(side_effects)
+        self.assertEqual(2, mock_call.call_count)
+        self.assertFalse(mock_print.called)
 
-    def test_success_one_install(self, mock_print):
+    def test_success_partial_install(self, mock_print):
         # One missing installation is correctly handled.
-        call = self.call_ensure_dependencies([
-            (0, '1.16', ''),
-            (127, '', 'no lxc'),
-            (0, 'add repo', ''),
-            (0, 'update', ''),
-            (0, 'install', ''),
-        ])
-        self.assertEqual(call.call_count, 5)
-        call.assert_has_calls([
-            mock.call('juju', 'version'),
-            mock.call('lxc-ls'),
-            mock.call('sudo', 'apt-add-repository', '-y', 'ppa:juju/stable'),
-            mock.call('sudo', 'apt-get', 'update'),
-            mock.call('sudo', 'apt-get', 'install', '-y', 'lxc'),
+        side_effects = (
+            (0, '1.16', ''),  # Check the juju command.
+            (127, '', 'no lxc'),  # Check the lxc-ls command.
+            (0, 'saucy', ''),  # Retrieve the Ubuntu release codename.
+            (0, 'install add repo', ''),  # Install add-apt-repository.
+            (0, 'add repo', ''),  # Add the juju stable repository.
+            (0, 'update', ''),  # Update the repository with new sources.
+            (0, 'install', ''),  # Install missing packages.
+        )
+        mock_call = self.call_ensure_dependencies(side_effects)
+        self.assertEqual(len(side_effects), mock_call.call_count)
+        mock_call.assert_has_calls([
+            mock.call('/usr/bin/juju', 'version'),
+            mock.call('/usr/bin/lxc-ls'),
+            mock.call('lsb_release', '-cs'),
+            mock.call('sudo', self.apt_get, 'install', '-y',
+                      'software-properties-common'),
+            mock.call('sudo', self.add_repository, '-y', 'ppa:juju/stable'),
+            mock.call('sudo', self.apt_get, 'update'),
+            mock.call('sudo', self.apt_get, 'install', '-y',
+                      'lxc', 'mongodb-server'),
         ])
         mock_print.assert_has_calls([
-            mock.call('The following package needs to be installed: lxc'),
-            mock.call(
-                'sudo privileges are required for package installation.'),
+            mock.call('sudo privileges are required for PPA installation'),
+            mock.call('installing the following packages: '
+                      'lxc, mongodb-server (this can take a while)'),
+            mock.call('sudo privileges will be used for package installation'),
         ])
 
-    def test_failure(self, mock_print):
-        with self.assert_program_exit('install failure'):
-            call = self.call_ensure_dependencies(
-                [
-                    (127, '', ''),
-                    (127, '', ''),
-                    (1, 'add repo', 'install failure'),
-                    (1, 'update', 'uh-oh'),
-                    (1, 'install', 'oh no'),
-                ]
-            )
-            self.assertEqual(call.call_count, 3)
-
-
-@mock_print
+    def test_add_repository_failure(self, mock_print):
+        # A ProgramExit is raised if the PPA is not successfully installed.
+        side_effects = (
+            (127, '', 'no juju'),  # Check the juju command.
+            (127, '', 'no lxc'),  # Check the lxc-ls command.
+            (0, 'saucy', ''),  # Retrieve the Ubuntu release codename.
+            (0, 'install add repo', ''),  # Install add-apt-repository.
+            (1, '', 'add repo error'),  # Add the juju stable repository.
+        )
+        with self.assert_program_exit('add repo error'):
+            mock_call = self.call_ensure_dependencies(side_effects)
+            self.assertEqual(3, mock_call.call_count)
+
+    def test_install_failure(self, mock_print):
+        # A ProgramExit is raised if the packages installation fails.
+        side_effects = (
+            (127, '', 'no juju'),  # Check the juju command.
+            (127, '', 'no lxc'),  # Check the lxc-ls command.
+            (0, 'saucy', ''),  # Retrieve the Ubuntu release codename.
+            (0, 'install add repo', ''),  # Install add-apt-repository.
+            (0, 'add repo', ''),  # Add the juju stable repository.
+            (0, 'update', ''),  # Update the repository with new sources.
+            (1, '', 'install error'),  # Install missing packages.
+        )
+        with self.assert_program_exit('install error'):
+            mock_call = self.call_ensure_dependencies(side_effects)
+            self.assertEqual(3, mock_call.call_count)
+
+
[e-mail]_print
 class TestBootstrap(
         helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
 
     env_name = 'my-juju-env'
+    juju = '/usr/bin/juju'
     status_message = 'retrieving the environment status'
 
     def make_status_output(self, agent_state):
@@ -160,7 +191,7 @@
     def make_status_calls(self, number):
         """Return a list containing the given number of status calls."""
         call = mock.call(
-            'juju', 'status', '-e', self.env_name, '--format', 'yaml')
+            self.juju, 'status', '-e', self.env_name, '--format', 'yaml')
         return [call for _ in range(number)]
 
     def make_side_effects(self):
@@ -178,7 +209,7 @@
         with self.patch_multiple_calls(side_effects) as mock_call:
             app.bootstrap(self.env_name)
         mock_call.assert_has_calls([
-            mock.call('juju', 'bootstrap', '-e', self.env_name),
+            mock.call(self.juju, 'bootstrap', '-e', self.env_name),
         ] + self.make_status_calls(5))
 
     def test_success(self, mock_print):
@@ -187,7 +218,7 @@
             already_bootstrapped = app.bootstrap(self.env_name)
         self.assertFalse(already_bootstrapped)
         mock_call.assert_has_calls([
-            mock.call('juju', 'bootstrap', '-e', self.env_name),
+            mock.call(self.juju, 'bootstrap', '-e', self.env_name),
         ] + self.make_status_calls(1))
         mock_print.assert_called_once_with(self.status_message)
 
@@ -197,7 +228,7 @@
             already_bootstrapped = app.bootstrap(self.env_name, is_local=True)
         self.assertFalse(already_bootstrapped)
         mock_call.assert_has_calls([
-            mock.call('sudo', 'juju', 'bootstrap', '-e', self.env_name),
+            mock.call('sudo', self.juju, 'bootstrap', '-e', self.env_name),
         ] + self.make_status_calls(1))
         mock_print.assert_has_calls([
             mock.call('sudo privileges required to bootstrap the environment'),
@@ -210,7 +241,7 @@
             already_bootstrapped = app.bootstrap(self.env_name, debug=True)
         self.assertFalse(already_bootstrapped)
         mock_call.assert_has_calls([
-            mock.call('juju', 'bootstrap', '-e', self.env_name, '--debug'),
+            mock.call(self.juju, 'bootstrap', '-e', self.env_name, '--debug'),
         ] + self.make_status_calls(1))
 
     def test_already_bootstrapped(self, mock_print):
@@ -224,7 +255,7 @@
             already_bootstrapped = app.bootstrap(self.env_name)
         self.assertTrue(already_bootstrapped)
         mock_call.assert_has_calls([
-            mock.call('juju', 'bootstrap', '-e', self.env_name),
+            mock.call(self.juju, 'bootstrap', '-e', self.env_name),
         ] + self.make_status_calls(1))
         existing_message = 'reusing the already bootstrapped {} environment'
         mock_print.assert_has_calls([
@@ -238,7 +269,7 @@
             with self.assert_program_exit('bad wolf'):
                 app.bootstrap(self.env_name)
         mock_call.assert_called_once_with(
-            'juju', 'bootstrap', '-e', self.env_name)
+            self.juju, 'bootstrap', '-e', self.env_name)
 
     def test_status_retry_error(self, mock_print):
         # Before raising a ProgramExit, the functions tries to call
@@ -299,7 +330,7 @@
             with self.assert_program_exit(expected):
                 app.bootstrap(self.env_name)
         mock_call.assert_has_calls([
-            mock.call('juju', 'bootstrap', '-e', self.env_name),
+            mock.call(self.juju, 'bootstrap', '-e', self.env_name),
         ] + self.make_status_calls(1))
 
     def test_status_failure(self, mock_print):
@@ -325,7 +356,7 @@
                 with self.assert_program_exit(expected):
                     app.bootstrap(self.env_name)
         mock_call.assert_has_calls([
-            mock.call('juju', 'bootstrap', '-e', self.env_name),
+            mock.call(self.juju, 'bootstrap', '-e', self.env_name),
         ] + self.make_status_calls(2))
 
 
@@ -341,7 +372,8 @@
             api_url = app.get_api_url(self.env_name)
         self.assertEqual('wss://api.example.com:17070', api_url)
         mock_call.assert_called_once_with(
-            'juju', 'api-endpoints', '-e', self.env_name, '--format', 'json')
+            '/usr/bin/juju', 'api-endpoints', '-e', self.env_name,
+            '--format', 'json')
 
     def test_failure(self):
         # A ProgramExit is raised if an error occurs retrieving the API URL.
@@ -349,7 +381,8 @@
             with self.assert_program_exit('bad wolf'):
                 app.get_api_url(self.env_name)
         mock_call.assert_called_once_with(
-            'juju', 'api-endpoints', '-e', self.env_name, '--format', 'json')
+            '/usr/bin/juju', 'api-endpoints', '-e', self.env_name,
+            '--format', 'json')
 
 
 class TestConnect(ProgramExitTestsMixin, unittest.TestCase):
@@ -397,7 +430,7 @@
         self.assertIs(error, context_manager.exception)
 
 
-@mock_print
[e-mail]_print
 class TestDeployGui(
         ProgramExitTestsMixin, helpers.WatcherDataTestsMixin,
         unittest.TestCase):
@@ -706,7 +739,7 @@
         self.assertIs(error, context_manager.exception)
 
 
-@mock_print
[e-mail]_print
 class TestWatch(ProgramExitTestsMixin, unittest.TestCase):
 
     address = 'unit.example.com'

=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2013-11-22 15:07:02 +0000
+++ quickstart/tests/test_manage.py	2013-11-26 14:39:39 +0000
@@ -42,7 +42,7 @@
             '--test', action=manage._DescriptionAction, nargs=0)
 
     @mock.patch('sys.exit')
-    @mock.patch('__builtin__.print')
+    @helpers.mock_print
     def test_action(self, mock_print, mock_exit):
         # The action just prints the description and exits.
         args = self.parser.parse_args(['--test'])
@@ -359,7 +359,7 @@
 
     def test_description(self):
         # The program description is properly printed out as required by juju.
-        with mock.patch('__builtin__.print') as mock_print:
+        with helpers.mock_print as mock_print:
             self.call_setup(['--description'])
         mock_print.assert_called_once_with(settings.DESCRIPTION)
 

=== modified file 'quickstart/tests/test_utils.py'
--- quickstart/tests/test_utils.py	2013-11-22 09:55:35 +0000
+++ quickstart/tests/test_utils.py	2013-11-26 14:39:39 +0000
@@ -32,6 +32,78 @@
 from quickstart.tests import helpers
 
 
[e-mail]_print
+class TestAddAptRepository(helpers.CallTestsMixin, unittest.TestCase):
+
+    apt_add_repository = '/usr/bin/add-apt-repository'
+    apt_get = '/usr/bin/apt-get'
+    repository = 'ppa:good/stuff'
+    side_effects = (
+        (0, 'apt-get install', ''),  # Install add-apt-repository.
+        (0, 'add-apt-repository', ''),  # Add the repository.
+        (0, 'update', ''),  # Update the global repository
+    )
+
+    def patch_codename(self, codename):
+        """Patch the Ubuntu codename returned by get_ubuntu_codename."""
+        return mock.patch(
+            'quickstart.utils.get_ubuntu_codename',
+            mock.Mock(return_value=codename))
+
+    def test_precise(self, mock_print):
+        # The repository is properly added in precise.
+        with self.patch_codename('precise') as mock_get_ubuntu_codename:
+            with self.patch_multiple_calls(self.side_effects) as mock_call:
+                utils.add_apt_repository(self.repository)
+        mock_get_ubuntu_codename.assert_called_once_with()
+        self.assertEqual(len(self.side_effects), mock_call.call_count)
+        mock_call.assert_has_calls([
+            mock.call('sudo', self.apt_get, 'install', '-y',
+                      'python-software-properties'),
+            mock.call('sudo', self.apt_add_repository, '-y', self.repository),
+            mock.call('sudo', self.apt_get, 'update'),
+        ])
+
+    def test_after_precise(self, mock_print):
+        # The repository is correctly added in newer releases.
+        with self.patch_codename('trusty') as mock_get_ubuntu_codename:
+            with self.patch_multiple_calls(self.side_effects) as mock_call:
+                utils.add_apt_repository(self.repository)
+        mock_get_ubuntu_codename.assert_called_once_with()
+        self.assertEqual(len(self.side_effects), mock_call.call_count)
+        mock_call.assert_has_calls([
+            mock.call('sudo', self.apt_get, 'install', '-y',
+                      'software-properties-common'),
+            mock.call('sudo', self.apt_add_repository, '-y', self.repository),
+            mock.call('sudo', self.apt_get, 'update'),
+        ])
+
+    def test_output(self, mock_print):
+        # The user is properly informed about the process.
+        with self.patch_codename('raring'):
+            with self.patch_multiple_calls(self.side_effects):
+                utils.add_apt_repository(self.repository)
+        self.assertEqual(2, mock_print.call_count)
+        mock_print.assert_has_calls([
+            mock.call('adding the {} PPA repository'.format(self.repository)),
+            mock.call('sudo privileges are required for PPA installation'),
+        ])
+
+    def test_command_error(self, mock_print):
+        # An OSError is raised if a command error occurs.
+        side_effects = [(1, '', 'apt-get install error')]
+        with self.patch_codename('quantal') as mock_get_ubuntu_codename:
+            with self.patch_multiple_calls(side_effects) as mock_call:
+                with self.assertRaises(OSError) as context_manager:
+                    utils.add_apt_repository(self.repository)
+        mock_get_ubuntu_codename.assert_called_once_with()
+        mock_call.assert_called_once_with(
+            'sudo', self.apt_get, 'install', '-y',
+            'software-properties-common')
+        self.assertEqual(
+            'apt-get install error', str(context_manager.exception))
+
+
 class TestCall(unittest.TestCase):
 
     def test_success(self):
@@ -285,6 +357,24 @@
         self.assertEqual(expected, utils.get_service_info([], 'my-gui'))
 
 
+class TestGetUbuntuCodename(helpers.CallTestsMixin, unittest.TestCase):
+
+    def test_codename(self):
+        # The distribution codename is correctly returned.
+        with self.patch_call(0, output='trusty\n') as mock_call:
+            codename = utils.get_ubuntu_codename()
+        self.assertEqual('trusty', codename)
+        mock_call.assert_called_once_with('lsb_release', '-cs')
+
+    def test_error_retrieving_codename(self):
+        # An OSError is returned if the codename cannot be retrieved.
+        with self.patch_call(1, error='bad wolf') as mock_call:
+            with self.assertRaises(OSError) as context_manager:
+                utils.get_ubuntu_codename()
+        self.assertEqual('bad wolf', str(context_manager.exception))
+        mock_call.assert_called_once_with('lsb_release', '-cs')
+
+
 class TestParseBundle(
         helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
         unittest.TestCase):

=== modified file 'quickstart/utils.py'
--- quickstart/utils.py	2013-11-22 08:32:44 +0000
+++ quickstart/utils.py	2013-11-26 14:39:39 +0000
@@ -39,6 +39,32 @@
 _juju_switch_expression = re.compile(r'Current environment: "([\w-]+)"\n')
 
 
+def add_apt_repository(repository):
+    """Add the given APT repository to the current list of APT sources.
+
+    Also take care of installing the add-apt-repository script and of updating
+    the list of APT packages after the repository installation.
+
+    Raise an OSError if any error occur in the process.
+    """
+    print('adding the {} PPA repository'.format(repository))
+    print('sudo privileges are required for PPA installation')
+    # The package including add-apt-repository is python-software-properties
+    # in precise and software-properties-common after precise.
+    add_repository_package = 'software-properties-common'
+    if get_ubuntu_codename() == 'precise':
+        add_repository_package = 'python-software-properties'
+    commands = (
+        ('/usr/bin/apt-get', 'install', '-y', add_repository_package),
+        ('/usr/bin/add-apt-repository', '-y', repository),
+        ('/usr/bin/apt-get', 'update'),
+    )
+    for command in commands:
+        retcode, _, error = call('sudo', *command)
+        if retcode:
+            raise OSError(error)
+
+
 def call(command, *args):
     """Call a subprocess passing the given arguments.
 
@@ -162,6 +188,17 @@
     return services[0], units[0] if units else None
 
 
+def get_ubuntu_codename():
+    """Return the codename of the current Ubuntu release (e.g. "trusty").
+
+    Raise an OSError if an error occurs retrieving the codename.
+    """
+    retcode, output, error = call('lsb_release', '-cs')
+    if retcode:
+        raise OSError(error)
+    return output.strip()
+
+
 def parse_bundle(bundle_yaml, bundle_name=None):
     """Parse the provided bundle YAML encoded contents.