Merge lp:~frankban/charms/precise/juju-gui/use-juju-test into lp:~juju-gui/charms/precise/juju-gui/trunk

[Francesco Banconi]

Replace jitsu test with juju-test.

This branch makes juju-test the default test runner
for both the unit tests and the charm functional tests.

The charm test suite now supports both pyJuju and juju-core.

The tests dependencies are now installed in a virtualenv that
is automatically created and updated by the first test
executable (00-setup). This way we don't require the user
to install all the packages, and, moreover, we make the tests
ready to be run in the charm testing infrastructure.

When the charm is deployed during tests, a temporary repository
is created where the charm is copied and then deployed.
This way we achieve two important goals:
- the developer is not forced to manually set up a local
Juju repository where to branch the Juju GUI;
- the charm can be deployed even if it contains a virtualenv, i.e.
a directory with absolute symlinks (that's because the .venv dir
is not copied in the temp repo).

The tests/helpers.py and tests/deploy.py files will be eventually
replaced by similar tools provided by the juju testing harness.

Updated the documentation where required.

Fixed unit tests exit code.

Common commands (test/lint/clean etc.) can now be easily run
using make.

Nice to have, not included in this branch:
  - collect deployment test logs;
  - reintroduce a way to test the charm specifying a
    different juju-gui-source;
  - do not require the branch to be named "juju-gui".

PS: sorry for the diff, well over 1k loc :-/

https://codereview.appspot.com/9874050/

[Francesco Banconi (frankban)]

Reviewers: mp+168079_code.launchpad.net,

Message:
Please take a look.

Description:
Replace jitsu test with juju-test.

This branch makes juju-test the default test runner
for both the unit tests and the charm functional tests.

The charm test suite now supports both pyJuju and juju-core.

The tests dependencies are now installed in a virtualenv that
is automatically created and updated by the first test
executable (00-setup). This way we don't require the user
to install all the packages, and, moreover, we make the tests
ready to be run in the charm testing infrastructure.

When the charm is deployed during tests, a temporary repository
is created where the charm is copied and then deployed.
This way we achieve two important goals:
- the developer is not forced to manually set up a local
Juju repository where to branch the Juju GUI;
- the charm can be deployed even if it contains a virtualenv, i.e.
a directory with absolute symlinks (that's because the .venv dir
is not copied in the temp repo).

The tests/helpers.py and tests/deploy.py files will be eventually
replaced by similar tools provided by the juju testing harness.

Updated the documentation where required.

Fixed unit tests exit code.

Common commands (test/lint/clean etc.) can now be easily run
using make.

Nice to have, not included in this branch:
   - collect deployment test logs;
   - reintroduce a way to test the charm specifying a
     different juju-gui-source;
   - do not require the branch to be named "juju-gui".

PS: sorry for the diff, well over 1k loc :-/

https://code.launchpad.net/~frankban/charms/precise/juju-gui/use-juju-test/+merge/168079

(do not edit description out of merge proposal)

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

Affected files:
   M .bzrignore
   M HACKING.md
   A Makefile
   A [revision details]
   M revision
   A tests/00-setup
   M tests/10-unit.test
   M tests/20-functional.test
   A tests/deploy.py
   A tests/helpers.py
   A tests/requirements.pip
   M tests/test_backends.py
   A tests/test_deploy.py
   A tests/test_helpers.py
   M tests/test_utils.py

[Gary Poster (gary)]

Wow, this looks great. I'll give it a LGTM conditional on at least one
other person doing qa along with a review.

https://codereview.appspot.com/9874050/diff/1/HACKING.md
File HACKING.md (right):

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode19
HACKING.md:19: sudo apt-get install build-essential bzr libapt-pkg-dev
That's better :-)

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode28
HACKING.md:28: time of this writing it is not yet released. To run it
you must first install
lol that this part didn't have to change. Hopefully it won't stay that
way.

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode36
HACKING.md:36: The current incarnation of our testing infrastructure
requires that the current
Suggest simplifying old stuff:

Our testing infrastructure requires the current directory name to match
the charm name, so you...

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode38
HACKING.md:38: directory named "juju-gui":
Agreed that removing this requirement would be nice to have for later.
Seems like it would be pretty easy given the new approach, yeah?

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode42
HACKING.md:42: Before being able to run the suite, tests requirements
need to be installed
s/tests/test/

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode96
HACKING.md:96: If you have set up your environment to run you local
development charm,
s/run you/run your/

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode117
HACKING.md:117: created, the testing virtualenv.
Nice

https://codereview.appspot.com/9874050/diff/1/Makefile
File Makefile (right):

https://codereview.appspot.com/9874050/diff/1/Makefile#newcode1
Makefile:1: # Juju GUI Makefile.
I was going to ask you to add a copyright notice, but I see that we need
to do that for the whole charm. I'll make a card.

https://codereview.appspot.com/9874050/

[Nicola Larosa (teknico)]

LGTM, very nice work, a couple trivials. Did not QA yet, will do on
Monday.

https://codereview.appspot.com/9874050/diff/1/tests/20-functional.test
File tests/20-functional.test (right):

https://codereview.appspot.com/9874050/diff/1/tests/20-functional.test#newcode14
tests/20-functional.test:14: ssh,
Swap the two lines above?

https://codereview.appspot.com/9874050/diff/1/tests/helpers.py
File tests/helpers.py (right):

https://codereview.appspot.com/9874050/diff/1/tests/helpers.py#newcode30
tests/helpers.py:30: be appeneded to the "baked in" arguments.
s/appeneded/appended/

https://codereview.appspot.com/9874050/diff/1/tests/helpers.py#newcode40
tests/helpers.py:40: """
Nice docstring. :-)

https://codereview.appspot.com/9874050/

[Brad Crittenden (bac)]

LGTM but I cannot get the tests to run cleanly and I have some
documentation suggestions.

Trying to run with pyjuju I get the following failures

http://paste.ubuntu.com/5742947/

I figure it is landable if these failures can be addressed.

https://codereview.appspot.com/9874050/diff/1/HACKING.md
File HACKING.md (right):

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode67
HACKING.md:67: make unittest
Excellent

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode81
HACKING.md:81: In the command above, "myenv" is the juju environment, as
it is specified in
myenv was first introduced on line 60 but not explained until here,
which is confusing.

Also, it is not totally obvious which environment you should pick.
After some investigation I see that it depends on the version of juju in
your path. Since environment.yaml stanzas are different for pyjuju and
juju-core you have to carefully pick an environment that matches the
juju in your path. That should be stated explicitly in this document.

For some makefile targets the environment is optional and the default is
used. Can this not be applied to them all?

https://codereview.appspot.com/9874050/diff/1/tests/helpers.py
File tests/helpers.py (right):

https://codereview.appspot.com/9874050/diff/1/tests/helpers.py#newcode66
tests/helpers.py:66: return True
This check seems very fragile. If juju-core ever grows a '--version'
option this breaks.

https://codereview.appspot.com/9874050/

[lp:~frankban/charms/precise/juju-gui/use-juju-test]

77. By Francesco Banconi on 2013-06-10

Changes as per review.

78. By Francesco Banconi on 2013-06-10

s/lp/http/ in requirements.

[Francesco Banconi (frankban)]

Please take a look.

https://codereview.appspot.com/9874050/diff/1/HACKING.md
File HACKING.md (right):

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode19
HACKING.md:19: sudo apt-get install build-essential bzr libapt-pkg-dev
On 2013/06/07 16:33:34, gary.poster wrote:
> That's better :-)

Indeed! However, I forgot two important
dependencies here: pip and virtualenv.
Fixed.

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode36
HACKING.md:36: The current incarnation of our testing infrastructure
requires that the current
On 2013/06/07 16:33:34, gary.poster wrote:
> Suggest simplifying old stuff:

> Our testing infrastructure requires the current directory name to
match the
> charm name, so you...

Done.

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode38
HACKING.md:38: directory named "juju-gui":
On 2013/06/07 16:33:35, gary.poster wrote:
> Agreed that removing this requirement would be nice to have for later.
  Seems
> like it would be pretty easy given the new approach, yeah?

Correct, it should not be a problem.

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode42
HACKING.md:42: Before being able to run the suite, tests requirements
need to be installed
On 2013/06/07 16:33:35, gary.poster wrote:
> s/tests/test/

Done.

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode81
HACKING.md:81: In the command above, "myenv" is the juju environment, as
it is specified in
On 2013/06/07 20:05:58, bac wrote:
> myenv was first introduced on line 60 but not explained until here,
which is
> confusing.

Fixed.

> Also, it is not totally obvious which environment you should pick.
After some
> investigation I see that it depends on the version of juju in your
path. Since
> environment.yaml stanzas are different for pyjuju and juju-core you
have to
> carefully pick an environment that matches the juju in your path.

Not necessarily. Or are there problems preventing you to use
the same environment? There are some cases where one env is not
compatible with different juju implementations (e.g. the local provider
is used, or juju-origin is specified). Other than that, AFAIK, it is
absolutely licit to boostrap, for example, the same ec2 environment from

both pyJuju and juju-core. Am I missing something?

> That should
> be stated explicitly in this document.

The documentation already includes a link to the relevant part of
the Juju doc explaining what is and how to set up an environment.yaml.

> For some makefile targets the environment is optional and the default
is used.
> Can this not be applied to them all?

This depends on juju-test explicitly requiring an environment name to
be passed. For this reason the make targets wrapping juju-test have the
same requirement. We could parse the environment.yaml and find ourself
the
name of the default env, but I believe that's out of scope for this
branch,
and maybe also in general for the charm tests. I guess the ability to
use the default env if not specified otherwise could quite easily
be added to juju-test in the future.

https://codereview.appspot.com/9874050/diff/1/HACKING.md#newcode96
HACKING.md:96: If you have set up your environment to...

[Francesco Banconi (frankban)]

On 2013/06/07 20:05:58, bac wrote:

> Trying to run with pyjuju I get the following failures

> http://paste.ubuntu.com/5742947/

This is weird. When you are available, if you agree,
I'd like to investigate this issue with you.

https://codereview.appspot.com/9874050/

[Nicola Larosa (teknico)]

teknico wrote:
> Did not QA yet, will do on Monday.

QA completed successfully, on both pyjuju and juju-core. It took some
more tweaking to the juju-test command, thanks for the collaboration.

https://codereview.appspot.com/9874050/

[lp:~frankban/charms/precise/juju-gui/use-juju-test]

79. By Francesco Banconi on 2013-06-10

Add xvfb to the list of requirements.

[Francesco Banconi (frankban)]

*** Submitted:

Replace jitsu test with juju-test.

This branch makes juju-test the default test runner
for both the unit tests and the charm functional tests.

The charm test suite now supports both pyJuju and juju-core.

The tests dependencies are now installed in a virtualenv that
is automatically created and updated by the first test
executable (00-setup). This way we don't require the user
to install all the packages, and, moreover, we make the tests
ready to be run in the charm testing infrastructure.

When the charm is deployed during tests, a temporary repository
is created where the charm is copied and then deployed.
This way we achieve two important goals:
- the developer is not forced to manually set up a local
Juju repository where to branch the Juju GUI;
- the charm can be deployed even if it contains a virtualenv, i.e.
a directory with absolute symlinks (that's because the .venv dir
is not copied in the temp repo).

The tests/helpers.py and tests/deploy.py files will be eventually
replaced by similar tools provided by the juju testing harness.

Updated the documentation where required.

Fixed unit tests exit code.

Common commands (test/lint/clean etc.) can now be easily run
using make.

Nice to have, not included in this branch:
   - collect deployment test logs;
   - reintroduce a way to test the charm specifying a
     different juju-gui-source;
   - do not require the branch to be named "juju-gui".

PS: sorry for the diff, well over 1k loc :-/

R=
CC=
https://codereview.appspot.com/9874050

https://codereview.appspot.com/9874050/

[Francesco Banconi (frankban)]

Hi Gary, Nicola and Brad,
thanks for reviewing and QAing this branch!

https://codereview.appspot.com/9874050/

=== modified file '.bzrignore'
--- .bzrignore	2013-05-02 09:49:51 +0000
+++ .bzrignore	2013-06-10 14:12:23 +0000
@@ -2,3 +2,4 @@
 tags
 exec.d/*
 npm-cache.tgz
+tests/.venv

=== modified file 'HACKING.md'
--- HACKING.md	2013-05-22 13:19:26 +0000
+++ HACKING.md	2013-06-10 14:12:23 +0000
@@ -16,8 +16,8 @@
 
 You'll also need some dependencies and developer basics.
 
-    sudo apt-get install bzr autoconf libtool python-charmhelpers python-yaml \
-        xvfb
+    sudo apt-get install build-essential bzr libapt-pkg-dev python-pip \
+        python-virtualenv xvfb
 
 Next, you need the bzr branch.  We work from
 [lp:~juju-gui/charms/precise/juju-gui/trunk](https://code.launchpad.net/~juju-gui/charms/precise/juju-gui/trunk).
@@ -25,49 +25,50 @@
 You could start hacking now, but there's a bit more to do to prepare for
 running and writing tests.
 
-We use the Jitsu test command to run our functional tests.  At the time of
-this writing it is not yet released.  To run it you must first install it
-locally.  The files may be installed globally, or into your home directory (as
-here):
-
-    sudo apt-get install autoconf libtool python-charmhelpers python-tempita
-    bzr branch lp:juju-jitsu juju-jitsu
-    cd juju-jitsu
-    autoreconf
-    ./configure --prefix=$HOME
+We use the juju-test test command to run our functional and unit tests.  At the
+time of this writing it is not yet released.  To run it you must first install
+it locally, e.g.:
+
+    bzr checkout --lightweight lp:juju-plugins
+
+At this point, link "juju-plugins/plugins/juju_test.py" as "juju-test"
+somewhere in your PATH, so that it is possible to execute "juju-test".
+
+Our testing infrastructure requires the current directory name to match the
+charm name, so you must check out the charm into a directory named "juju-gui":
+
+    bzr branch lp:~juju-gui/charms/precise/juju-gui/trunk juju-gui
+
+Before being able to run the suite, test requirements need to be installed
+running the command:
+
     make
-    make install
-
-Functional tests make use of Selenium and xvfbwrapper. To install the latest
-version of these packages, as required by the test suite, you can use pip or
-easy_install, e.g.:
-
-    sudo pip install selenium xvfbwrapper
-
-The current incarnation of the Jitsu test command requires that the current
-directory name match the charm name, so you must check out the charm into a
-directory named "juju-gui":
-
-    bzr branch lp:~juju-gui/charms/precise/juju-gui/trunk juju-gui
-
-The branch directory must be placed (or linked from) within a local charm
-repository. It consists of a directory, itself containing a number of
-directories, one for each distribution codename, e.g. `precise`. In turn, the
-codename directories will contain the charm directories. Therefore, you
-should put your charm in a path like this: `[REPO]/precise/juju-gui`.
-
-Now you are ready to run the functional tests (see the next section).
+
+The command above will create a ".venv" directory inside "juju-gui/tests/",
+ignored by DVCSes, containing the development virtual environment with all the
+testing dependencies.  Run "make help" to see all the available make targets.
+
+Now you are ready to run the functional and unit tests (see the next section).
 
 ## Testing ##
 
 There are two types of tests for the charm: unit tests and functional tests.
+Long story short, to run all the tests:
+
+    make test JUJU_ENV="myenv"
+
+In the command above, "myenv" is the juju environment, as it is specified in
+your `~/.juju/environments.yaml`, that will be bootstrapped before running the
+tests and destroyed at the end of the test run.
+
+Please read further for additional details.
 
 ### Unit Tests ###
 
 The unit tests do not require a functional Juju environment, and can be run
 with this command::
 
-    python tests/unit.test
+    make unittest
 
 Unit tests should be created in the "tests" subdirectory and be named in the
 customary way (i.e., "test_*.py").
@@ -75,33 +76,15 @@
 ### Functional Tests ###
 
 Running the functional tests requires a Juju testing environment as provided
-by the Jitsu test command (see "Getting Started", above).  All files in the
-tests directory which end with ".test" will be run in a Juju Jitsu test
-environment.
-
-Jitsu requires the charm directory to be named the same as the charm and to be
-the current working directory when the tests are run:
-
-    JUJU_REPOSITORY=/path/to/charm/repo ~/bin/jitsu test juju-gui \
-        --logdir /tmp --timeout 40m
-
-This command will bootstrap the default Juju environment specified in your
-`~/.juju/environments.yaml`.
-
-Functional tests deploy, by default, the latest stable release of Juju GUI.
-However, it is possible to provide a different Juju GUI source by setting the
-environment variable `JUJU_GUI_SOURCE` while running tests, e.g.:
-
-    JUJU_GUI_SOURCE=lp:mybranch JUJU_REPOSITORY=/path/to/charm/repo \
-        ~/bin/jitsu test juju-gui ...
-
-To test a new trunk release:
-
-    JUJU_GUI_SOURCE=trunk JUJU_REPOSITORY=/path/to/charm/repo \
-        ~/bin/jitsu test juju-gui ...
-
-This can be useful to verify that a given branch works with the charm, which is
-one of the tasks that release QA should include.
+by the juju-test command (see "Getting Started", above).
+
+To run only the functional tests:
+
+    make ftest JUJU_ENV="myenv"
+
+As seen before, "myenv" is the juju environment, as it is specified in your
+`~/.juju/environments.yaml`, that will be bootstrapped before running the
+tests and destroyed at the end of the test run.
 
 #### LXC ####
 
@@ -109,33 +92,34 @@
 for these tests.  At this time, we recommend using other environments, such as
 OpenStack; but we will periodically check the tests in LXC environments
 because it would be great to be able to use it.  If you do want to use LXC,
-you will need to install the `apt-cacher-ng` and `lxc` packages.
-
-Currently running tests on a local environment is quite slow (with quantal
-host and precise container at least), so you may want to further increase the
-`jitsu test` command timeout.
-
-If Jitsu generates errors about not being able to bootstrap:
-
-    CalledProcessError: Command '['juju', 'bootstrap']'...
-
-or if it hangs, then you may need to bootstrap the environment yourself and
-pass the --no-bootstrap switch to Jitsu.
+you will need to install the `apt-cacher-ng` and `lxc` packages.  Also note
+that at this time juju-core does not support the local provider.
 
 ## Running the Charm From Development ##
 
-If you have set up your environment to run functional tests, you also have set
-it up to run your local development charm.  Developing and debugging with this
-is much easier than trying to develop and debug with the tests, unfortunately.
-
-To get started, first, simply do a `juju bootstrap`.  Using a non-LXC
-environment probably will reduce frustrations.  Then, deploy your charm like
-this (again, assuming you have set up your repo the way the functional tests
-need them, as described above).
-
+If you have set up your environment to run your local development charm,
+deploying the charm fails if attempted after the testing virtualenv has been
+created: juju deploy exits with an error due to ".venv" directory containing
+an absolute symbolic link.  There are two ways to work around this problem.
+
+The first one is running "make clean" before deploying the charm:
+
+    make clean
+    juju bootstrap
     juju deploy --repository=/path/to/charm/repo local:precise/juju-gui
     juju expose juju-gui
 
+The second one is just running "make deploy":
+
+    juju bootstrap
+    make deploy
+
+The "make deploy" command creates a temporary Juju repository (excluding
+the ".venv" directory), deploys the Juju GUI charm from that repository and
+exposes the juju-gui service.  Also note that "make deploy" does not require
+you to manually set up a local Juju environment, and preserves, if already
+created, the testing virtualenv.
+
 Now you are working with a test run, as described in
 <https://juju.ubuntu.com/docs/write-charm.html#test-run>.  The
 `juju debug-hooks` command, described in the same web page, is your most

=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2013-06-10 14:12:23 +0000
@@ -0,0 +1,49 @@
+# Juju GUI Makefile.
+
+JUJUTEST = juju-test --timeout=30m -v -e "$(JUJU_ENV)" --upload-tools
+VENV = ./tests/.venv
+
+all: setup
+
+setup:
+	@./tests/00-setup
+
+unittest: setup
+	./tests/10-unit.test
+
+ftest: setup
+	$(JUJUTEST) 20-functional.test
+
+# This will be eventually removed when we have juju-test --clean-state.
+test: unittest ftest
+
+# This will be eventually renamed as test when we have juju-test --clean-state.
+jujutest:
+	$(JUJUTEST)
+
+lint: setup
+	@flake8 --show-source --exclude=.venv  ./hooks/ ./tests/
+
+clean:
+	find . -name '*.pyc' -delete
+	rm -rf $(VENV)
+
+deploy: setup
+	$(VENV)/bin/python ./tests/deploy.py
+
+help:
+	@echo -e 'Juju GUI charm - list of make targets:\n'
+	@echo -e 'make - Set up development and testing environment.\n'
+	@echo 'make test JUJU_ENV="my-juju-env" - Run functional and unit tests.'
+	@echo -e '  JUJU_ENV is the Juju environment that will be bootstrapped.\n'
+	@echo -e 'make unittest - Run unit tests.\n'
+	@echo 'make ftest JUJU_ENV="my-juju-env" - Run functional tests.'
+	@echo -e '  JUJU_ENV is the Juju environment that will be bootstrapped.\n'
+	@echo -e 'make lint - Run linter and pep8.\n'
+	@echo -e 'make clean - Remove bytecode files and virtualenvs.\n'
+	@echo 'make deploy [JUJU_ENV="my-juju-env]" - Deploy and expose the Juju'
+	@echo '  GUI charm setting up a temporary Juju repository. Wait for the'
+	@echo '  service to be started.  If JUJU_ENV is not passed, the charm will'
+	@echo '  be deployed in the default Juju environment.'
+
+.PHONY: all clean deploy ftest help jujutest lint setup test unittest

=== modified file 'revision'
--- revision	2013-06-06 13:51:45 +0000
+++ revision	2013-06-10 14:12:23 +0000
@@ -1,1 +1,1 @@
-49
+50

=== added file 'tests/00-setup'
--- tests/00-setup	1970-01-01 00:00:00 +0000
+++ tests/00-setup	2013-06-10 14:12:23 +0000
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+TESTDIR=`dirname $0`
+VENV="$TESTDIR/.venv"
+ACTIVATE="$VENV/bin/activate"
+REQUIREMENTS="$TESTDIR/requirements.pip"
+
+
+createvenv() {
+    # Create a virtualenv if it does not exist, or it is older than requirements.
+    if [ ! -f "$ACTIVATE" -o "$REQUIREMENTS" -nt "$ACTIVATE" ]; then
+        virtualenv --distribute $VENV
+        . $VENV/bin/activate && \
+            yes w | pip install --use-mirrors -r $REQUIREMENTS
+        touch $VENV/bin/activate
+    fi
+}
+
+
+createvenv

=== renamed file 'tests/unit.test' => 'tests/10-unit.test'
--- tests/unit.test	2012-12-07 21:16:55 +0000
+++ tests/10-unit.test	2013-06-10 14:12:23 +0000
@@ -1,5 +1,6 @@
-#!/usr/bin/env python2
-# -*- python -*-
+#!tests/.venv/bin/python
+
+"""Unit test suite."""
 
 import os
 import sys
@@ -8,4 +9,5 @@
 
 runner = unittest.TextTestRunner(verbosity=2)
 suite = unittest.TestLoader().discover(os.path.dirname(__file__))
-sys.exit(runner.run(suite))
+result = runner.run(suite)
+sys.exit(not result.wasSuccessful())

=== renamed file 'tests/deploy.test' => 'tests/20-functional.test'
--- tests/deploy.test	2013-04-27 18:57:12 +0000
+++ tests/20-functional.test	2013-06-10 14:12:23 +0000
@@ -1,30 +1,31 @@
-#!/usr/bin/env python2
-#-*- python -*-
+#!tests/.venv/bin/python
 
-import os
 import unittest
 import urlparse
 
-from charmhelpers import make_charm_config_file
 from selenium.webdriver import Firefox
 from selenium.webdriver.support import ui
-from shelltoolbox import command
 from xvfbwrapper import Xvfb
 
-
-JUJU_GUI_SOURCE = os.getenv('JUJU_GUI_SOURCE')
+from deploy import juju_deploy
+from helpers import (
+    juju_destroy_service,
+    legacy_juju,
+    ssh,
+)
+
+
 JUJU_GUI_TEST_BRANCH = 'lp:~juju-gui/juju-gui/charm-tests-branch'
 STAGING_SERVICES = ('haproxy', 'mediawiki', 'memcached', 'mysql', 'wordpress')
-jitsu = command('jitsu')
-juju = command('juju')
-ssh = command('ssh')
+is_legacy_juju = legacy_juju()
 
 
 class DeployTestMixin(object):
 
+    charm = 'juju-gui'
+    port = '443'
+
     def setUp(self):
-        self.charm = 'juju-gui'
-        self.port = '443'
         # Perform all graphical operations in memory.
         vdisplay = Xvfb(width=1280, height=720)
         vdisplay.start()
@@ -34,7 +35,7 @@
         self.addCleanup(selenium.quit)
 
     def tearDown(self):
-        juju('destroy-service', self.charm)
+        juju_destroy_service(self.charm)
 
     def assertEnvironmentIsConnected(self):
         """Assert the GUI environment is connected to the Juju API agent."""
@@ -42,21 +43,6 @@
             'return app.env.get("connected");',
             error='Environment not connected.')
 
-    def make_config_file(self, options=None):
-        """Create a charm config file adding, if required, the Juju GUI source.
-
-        Return the created config file object.
-
-        The Juju GUI source can be provided by setting the environment variable
-        *JUJU_GUI_SOURCE*. This is just a simple wrapper around
-        ``charmhelpers.make_charm_config_file``.
-        """
-        if options is None:
-            options = {}
-        if JUJU_GUI_SOURCE is not None:
-            options.setdefault('juju-gui-source', JUJU_GUI_SOURCE)
-        return make_charm_config_file({self.charm: options})
-
     def handle_browser_warning(self):
         """Overstep the browser warning dialog if required."""
         self.wait_for_script(
@@ -115,14 +101,6 @@
         condition = lambda driver: driver.execute_script(script)
         return self.wait_for(condition, error=error, timeout=timeout)
 
-    def login(self, password):
-        """Log in to access the Juju GUI using the provided *password*."""
-        form = self.wait_for_css_selector('form', 'Login form not found.')
-        passwd = form.find_element_by_css_selector('input[type=password]')
-        passwd.send_keys(password)
-        submit = form.find_element_by_css_selector('input[type=submit]')
-        submit.click()
-
     def get_service_names(self):
         """Return the set of services' names displayed in the current page."""
         def services_found(driver):
@@ -135,8 +113,8 @@
             # Just invoking ``juju destroy-service juju-gui`` in tearDown
             # should execute the ``stop`` hook, stopping all the services
             # started by the charm in the machine. Right now this does not
-            # work, so the same behavior is accomplished keeping track of
-            # started services and manually stopping them here.
+            # work in pyJuju, so the same behavior is accomplished keeping
+            # track of started services and manually stopping them here.
         target = 'ubuntu@{0}'.format(hostname)
         for service in services:
             ssh(target, 'sudo', 'service', service, 'stop')
@@ -144,36 +122,24 @@
 
 class DeployTest(DeployTestMixin, unittest.TestCase):
 
-    def deploy(self, config=None):
-        """Deploy and expose the Juju GUI charm. Return the service host name.
-
-        Also wait until the service is started.
-        If *config_path* is provided, it will be used when deploying the charm.
-        """
-        config_file = self.make_config_file(config)
-        juju('deploy', 'local:{0}'.format(self.charm),
-             '--config', config_file.name)
-        juju('expose', self.charm)
-        jitsu(
-            'watch', '--failfast', self.charm,
-            '--state', 'started', '--open-port', self.port)
-        address = jitsu('get-service-info', self.charm, 'public-address')
-        return address.strip().split(':')[1]
-
     def test_api_agent(self):
         # Ensure the Juju GUI and API agent services are correctly set up.
-        hostname = self.deploy()
-        # XXX 2012-11-29 frankban bug=872264: see *stop_services* above.
-        self.addCleanup(
-            self.stop_services,
-            hostname, ['haproxy', 'apache2', 'juju-api-agent'])
+        unit_info = juju_deploy(self.charm)
+        hostname = unit_info['public-address']
+        if is_legacy_juju:
+            # XXX 2012-11-29 frankban bug=872264: see *stop_services* above.
+            self.addCleanup(
+                self.stop_services,
+                hostname, ['haproxy', 'apache2', 'juju-api-agent'])
         self.navigate_to(hostname)
         self.handle_browser_warning()
         self.assertEnvironmentIsConnected()
 
+    @unittest.skipUnless(is_legacy_juju, 'staging only works in pyJuju')
     def test_staging(self):
         # Ensure the Juju GUI and improv services are correctly set up.
-        hostname = self.deploy({'staging': 'true'})
+        unit_info = juju_deploy(self.charm, options={'staging': 'true'})
+        hostname = unit_info['public-address']
         # XXX 2012-11-29 frankban bug=872264: see *stop_services* above.
         self.addCleanup(
             self.stop_services,
@@ -186,44 +152,24 @@
 
     def test_branch_source(self):
         # Ensure the Juju GUI is correctly deployed from a Bazaar branch.
-        hostname = self.deploy({'juju-gui-source': JUJU_GUI_TEST_BRANCH})
-        # XXX 2012-11-29 frankban bug=872264: see *stop_services* above.
-        self.addCleanup(
-            self.stop_services,
-            hostname, ['haproxy', 'apache2', 'juju-api-agent'])
+        unit_info = juju_deploy(
+            self.charm, options={'juju-gui-source': JUJU_GUI_TEST_BRANCH})
+        hostname = unit_info['public-address']
+        if is_legacy_juju:
+            # XXX 2012-11-29 frankban bug=872264: see *stop_services* above.
+            self.addCleanup(
+                self.stop_services,
+                hostname, ['haproxy', 'apache2', 'juju-api-agent'])
         self.navigate_to(hostname)
         self.handle_browser_warning()
         self.assertEnvironmentIsConnected()
 
-
-class DeployToTest(DeployTestMixin, unittest.TestCase):
-
-    def deploy_to(self):
-        """Deploy the Juju GUI charm in the Juju bootstrap node.
-
-        Expose it and return the service host name.
-        Also wait until the service is started.
-        """
-        config_file = self.make_config_file()
-        # The id of the bootstrap node is 0 (the first node started by Juju).
-        jitsu('deploy-to', '0', 'local:{0}'.format(self.charm),
-              '--config', config_file.name)
-        juju('expose', self.charm)
-        jitsu(
-            'watch', '--failfast', self.charm,
-            '--state', 'started', '--open-port', self.port)
-        address = jitsu('get-service-info', self.charm, 'public-address')
-        return address.strip().split(':')[1]
-
-    def test_api_agent(self):
-        # Ensure the Juju GUI and API agent services are correctly set up in
-        # the Juju bootstrap node.
-        hostname = self.deploy_to()
-        # XXX 2012-11-29 frankban bug=872264: see *stop_services* above.
-        self.addCleanup(
-            self.stop_services,
-            hostname, ['haproxy', 'apache2', 'juju-api-agent'])
-        self.navigate_to(hostname)
+    @unittest.skipIf(is_legacy_juju, 'force-machine only works in juju-core')
+    def test_force_machine(self):
+        # Ensure the Juju GUI is correctly set up in the Juju bootstrap node.
+        unit_info = juju_deploy(self.charm, force_machine=0)
+        self.assertEqual('0', unit_info['machine'])
+        self.navigate_to(unit_info['public-address'])
         self.handle_browser_warning()
         self.assertEnvironmentIsConnected()
 

=== added file 'tests/deploy.py'
--- tests/deploy.py	1970-01-01 00:00:00 +0000
+++ tests/deploy.py	2013-06-10 14:12:23 +0000
@@ -0,0 +1,62 @@
+"""Juju GUI deploy helper."""
+
+from __future__ import print_function
+import json
+import os
+import tempfile
+
+from charmhelpers import make_charm_config_file
+
+from helpers import (
+    command,
+    juju,
+    wait_for_unit,
+)
+
+
+rsync = command('rsync', '-a', '--exclude', '.bzr', '--exclude', '.venv')
+
+
+def setup_repository(source, series='precise'):
+    """Create a temporary Juju repository to use for charm deployment.
+
+    Copy the charm files in source in the precise repository section, excluding
+    the virtualenv and Bazaar directories.
+
+    Return the repository path.
+    """
+    source = os.path.abspath(source)
+    repo = tempfile.mkdtemp()
+    destination = os.path.join(repo, series)
+    os.makedirs(destination)
+    rsync(source, destination)
+    return repo
+
+
+def juju_deploy(charm, options=None, force_machine=None, charm_source=None):
+    """Deploy and expose the charm. Return the first unit's public address.
+
+    Also wait until the service is exposed and the first unit started.
+    If options are provided, they will be used when deploying the charm.
+    If force_machine is not None, create the unit in the specified machine.
+    If charm_source is None, dynamically retrieve the charm source directory.
+    """
+    if charm_source is None:
+        # Dynamically retrieve the charm source based on the path of this file.
+        charm_source = os.path.join(os.path.dirname(__file__), '..')
+    repo = setup_repository(charm_source)
+    args = ['deploy', '--repository', repo]
+    if options is not None:
+        config_file = make_charm_config_file({charm: options})
+        args.extend(['--config', config_file.name])
+    if force_machine is not None:
+        args.extend(['--force-machine', str(force_machine)])
+    args.append('local:{0}'.format(charm))
+    juju(*args)
+    juju('expose', charm)
+    return wait_for_unit(charm)
+
+
+if __name__ == '__main__':
+    unit = juju_deploy('juju-gui')
+    print(json.dumps(unit, indent=2))

=== added file 'tests/helpers.py'
--- tests/helpers.py	1970-01-01 00:00:00 +0000
+++ tests/helpers.py	2013-06-10 14:12:23 +0000
@@ -0,0 +1,145 @@
+"""Juju GUI test helpers."""
+
+from functools import wraps
+import json
+import os
+import subprocess
+import time
+
+
+class ProcessError(subprocess.CalledProcessError):
+    """Error running a shell command."""
+
+    def __init__(self, retcode, cmd, output, error):
+        super(ProcessError, self).__init__(retcode, cmd, output)
+        self.error = error
+
+    def __str__(self):
+        msg = super(ProcessError, self).__str__()
+        return '{}. Output: {!r}. Error: {!r}.'.format(
+            msg, self.output, self.error)
+
+
+def command(*base_args):
+    """Return a callable that will run the given command with any arguments.
+
+    The first argument is the path to the command to run, subsequent arguments
+    are command-line arguments to "bake into" the returned callable.
+
+    The callable runs the given executable and also takes arguments that will
+    be appended to the "baked in" arguments.
+
+    For example, this code will list a file named "foo" (if it exists):
+
+        ls_foo = command('/bin/ls', 'foo')
+        ls_foo()
+
+    While this invocation will list "foo" and "bar" (assuming they exist):
+
+        ls_foo('bar')
+    """
+    PIPE = subprocess.PIPE
+
+    def runner(*args, **kwargs):
+        cmd = base_args + args
+        process = subprocess.Popen(cmd, stdout=PIPE, stderr=PIPE, **kwargs)
+        output, error = process.communicate()
+        retcode = process.poll()
+        if retcode:
+            raise ProcessError(retcode, cmd, output, error)
+        return output
+
+    return runner
+
+
+juju_command = command('juju')
+juju_env = lambda: os.getenv('JUJU_ENV')  # This is propagated by juju-test.
+ssh = command('ssh')
+
+
+def legacy_juju():
+    """Return True if pyJuju is being used, False otherwise."""
+    try:
+        juju_command('--version')
+    except ProcessError:
+        return False
+    return True
+
+
+def retry(exception, tries=10, delay=1):
+    """If the decorated function raises the exception, wait and try it again.
+
+    Raise the exception raised by the last call if the function does not
+    exit normally after the specified number of tries.
+
+    Original from http://wiki.python.org/moin/PythonDecoratorLibrary#Retry.
+    """
+    def decorator(func):
+        @wraps(func)
+        def decorated(*args, **kwargs):
+            mtries = tries
+            while mtries:
+                try:
+                    return func(*args, **kwargs)
+                except exception as err:
+                    time.sleep(delay)
+                    mtries -= 1
+            raise err
+        return decorated
+    return decorator
+
+
+@retry(ProcessError)
+def juju(command, *args):
+    """Call the juju command, passing the environment parameters if required.
+
+    The environment value can be provided in args, or can be found in the
+    context as JUJU_ENV.
+    """
+    arguments = [command]
+    if ('-e' not in args) and ('--environment' not in args):
+        env = juju_env()
+        if env is not None:
+            arguments.extend(['-e', env])
+    arguments.extend(args)
+    return juju_command(*arguments)
+
+
+def juju_destroy_service(service):
+    """Destroy the given service and wait for the service to be removed."""
+    juju('destroy-service', service)
+    while True:
+        services = juju_status().get('services', {})
+        if service not in services:
+            return
+
+
+def juju_status():
+    """Return the Juju status as a dictionary."""
+    status = juju('status', '--format', 'json')
+    return json.loads(status)
+
+
+def wait_for_unit(sevice):
+    """Wait for the first unit of the given service to be started.
+
+    Also wait for the service to be exposed.
+    Raise a RuntimeError if the unit is found in an error state.
+    Return info about the first unit as a dict containing at least the
+    following keys: agent-state, machine, and public-address.
+    """
+    while True:
+        status = juju_status()
+        service = status.get('services', {}).get(sevice)
+        if service is None or not service.get('exposed'):
+            continue
+        units = service.get('units', {})
+        if not len(units):
+            continue
+        unit = units.values()[0]
+        state = unit['agent-state']
+        if 'error' in state:
+            raise RuntimeError(
+                'the service unit is in an error state: {}'.format(state))
+        if state == 'started':
+            return unit

=== added file 'tests/requirements.pip'
--- tests/requirements.pip	1970-01-01 00:00:00 +0000
+++ tests/requirements.pip	2013-06-10 14:12:23 +0000
@@ -0,0 +1,10 @@
+-e bzr+http://launchpad.net/charm-tools#egg=charm-tools
+flake8==2.0
+launchpadlib==1.10.2
+mock==1.0.1
+python-apt==0.8.5
+-e bzr+http://launchpad.net/python-shelltoolbox#egg=python-shelltoolbox
+PyYAML==3.10
+selenium==2.33.0
+Tempita==0.5.1
+xvfbwrapper==0.2.2

=== modified file 'tests/test_backends.py'
--- tests/test_backends.py	2013-06-06 13:51:45 +0000
+++ tests/test_backends.py	2013-06-10 14:12:23 +0000
@@ -192,14 +192,16 @@
     def test_start_agent(self):
         test_backend = backend.Backend(config=self.alwaysFalse)
         test_backend.start()
-        for mocked in ('service_control', 'start_agent', 'start_gui',
+        for mocked in (
+                'service_control', 'start_agent', 'start_gui',
                 'open_port', 'su'):
             self.assertTrue(mocked, '{} was not called'.format(mocked))
 
     def test_start_improv(self):
         test_backend = backend.Backend(config=self.alwaysTrue)
         test_backend.start()
-        for mocked in ('service_control', 'start_improv', 'start_gui',
+        for mocked in (
+                'service_control', 'start_improv', 'start_gui',
                 'open_port', 'su'):
             self.assertTrue(mocked, '{} was not called'.format(mocked))
 

=== added file 'tests/test_deploy.py'
--- tests/test_deploy.py	1970-01-01 00:00:00 +0000
+++ tests/test_deploy.py	2013-06-10 14:12:23 +0000
@@ -0,0 +1,163 @@
+"""Juju GUI deploy module tests."""
+
+import os
+import shutil
+import tempfile
+import unittest
+
+import mock
+
+from deploy import (
+    juju_deploy,
+    setup_repository,
+)
+
+
+class TestSetupRepository(unittest.TestCase):
+
+    def setUp(self):
+        # Create a directory structure for the charm source.
+        self.source = tempfile.mkdtemp()
+        self.charm_name = os.path.basename(self.source)
+        self.addCleanup(shutil.rmtree, self.source)
+        # Create a file in the source dir.
+        _, self.root_file = tempfile.mkstemp(dir=self.source)
+        # Create a Bazaar repository directory with a file in it.
+        bzr_dir = os.path.join(self.source, '.bzr')
+        os.mkdir(bzr_dir)
+        tempfile.mkstemp(dir=bzr_dir)
+        # Create a tests directory including a .venv directory and a file.
+        self.tests_dir = os.path.join(self.source, 'tests')
+        venv_dir = os.path.join(self.tests_dir, '.venv')
+        os.makedirs(venv_dir)
+        tempfile.mkstemp(dir=venv_dir)
+        # Create a test file.
+        _, self.tests_file = tempfile.mkstemp(dir=self.tests_dir)
+
+    def assert_dir_exists(self, path):
+        self.assertTrue(
+            os.path.isdir(path),
+            'the directory {!r} does not exist'.format(path))
+
+    def assert_files_equal(self, expected, path):
+        fileset = set()
+        for dirpath, _, filenames in os.walk(path):
+            relpath = os.path.relpath(dirpath, path)
+            if relpath == '.':
+                relpath = ''
+            else:
+                fileset.add(relpath + os.path.sep)
+            fileset.update(os.path.join(relpath, name) for name in filenames)
+        self.assertEqual(expected, fileset)
+
+    def check_repository(self, repo, series):
+        # The repository has been created in the temp directory.
+        self.assertEqual(tempfile.tempdir, os.path.split(repo)[0])
+        self.assert_dir_exists(repo)
+        # The repository only contains the series directory.
+        self.assertEqual([series], os.listdir(repo))
+        series_dir = os.path.join(repo, series)
+        self.assert_dir_exists(series_dir)
+        # The series directory only contains our charm.
+        self.assertEqual([self.charm_name], os.listdir(series_dir))
+        self.assert_dir_exists(os.path.join(series_dir, self.charm_name))
+
+    def test_repository(self):
+        # The charm repository is correctly created with the default series.
+        repo = setup_repository(self.source)
+        self.check_repository(repo, 'precise')
+
+    def test_series(self):
+        # The charm repository is created with the given series.
+        repo = setup_repository(self.source, series='raring')
+        self.check_repository(repo, 'raring')
+
+    def test_charm_files(self):
+        # The charm files are correctly copied inside the repository, excluding
+        # unwanted directories.
+        repo = setup_repository(self.source)
+        charm_dir = os.path.join(repo, 'precise', self.charm_name)
+        test_dir_name = os.path.basename(self.tests_dir)
+        expected = set([
+            os.path.basename(self.root_file),
+            test_dir_name + os.path.sep,
+            os.path.join(test_dir_name, os.path.basename(self.tests_file))
+        ])
+        self.assert_files_equal(expected, charm_dir)
+
+
+class TestJujuDeploy(unittest.TestCase):
+
+    unit_info = {'public-address': 'unit.example.com'}
+    charm = 'test-charm'
+    expose_call = mock.call('expose', charm)
+    local_charm = 'local:{}'.format(charm)
+    repo = '/tmp/repo/'
+
+    @mock.patch('deploy.juju')
+    @mock.patch('deploy.wait_for_unit')
+    @mock.patch('deploy.setup_repository')
+    def call_deploy(
+            self, mock_setup_repository, mock_wait_for_unit, mock_juju,
+            **kwargs):
+        mock_setup_repository.return_value = self.repo
+        mock_wait_for_unit.return_value = self.unit_info
+        charm_source = kwargs.setdefault(
+            'charm_source', os.path.join(os.path.dirname(__file__), '..'))
+        unit_info = juju_deploy(self.charm, **kwargs)
+        mock_setup_repository.assert_called_once_with(charm_source)
+        # The unit address is correctly returned.
+        self.assertEqual(self.unit_info, unit_info)
+        self.assertEqual(1, mock_wait_for_unit.call_count)
+        # Juju is called two times: deploy and expose.
+        juju_calls = mock_juju.call_args_list
+        self.assertEqual(2, len(juju_calls))
+        deploy_call, expose_call = juju_calls
+        self.assertEqual(self.expose_call, expose_call)
+        return deploy_call
+
+    def test_deployment(self):
+        # The function deploys and exposes the given charm.
+        expected_deploy_call = mock.call(
+            'deploy',
+            '--repository', self.repo,
+            self.local_charm,
+        )
+        deploy_call = self.call_deploy()
+        self.assertEqual(expected_deploy_call, deploy_call)
+
+    def test_options(self):
+        # The function handles charm options.
+        mock_config_file = mock.Mock()
+        mock_config_file.name = '/tmp/config.yaml'
+        expected_deploy_call = mock.call(
+            'deploy',
+            '--repository', self.repo,
+            '--config', mock_config_file.name,
+            self.local_charm,
+        )
+        with mock.patch('deploy.make_charm_config_file') as mock_callable:
+            mock_callable.return_value = mock_config_file
+            deploy_call = self.call_deploy(options={'foo': 'bar'})
+        self.assertEqual(expected_deploy_call, deploy_call)
+
+    def test_force_machine(self):
+        # The function can deploy charms in a specified machine.
+        expected_deploy_call = mock.call(
+            'deploy',
+            '--repository', self.repo,
+            '--force-machine', '42',
+            self.local_charm,
+        )
+        deploy_call = self.call_deploy(force_machine=42)
+        self.assertEqual(expected_deploy_call, deploy_call)
+
+    def test_charm_source(self):
+        # The function can deploy a charm from a specific source.
+        expected_deploy_call = mock.call(
+            'deploy',
+            '--repository', self.repo,
+            self.local_charm,
+        )
+        deploy_call = self.call_deploy(charm_source='/tmp/source/')
+        self.assertEqual(expected_deploy_call, deploy_call)

=== added file 'tests/test_helpers.py'
--- tests/test_helpers.py	1970-01-01 00:00:00 +0000
+++ tests/test_helpers.py	2013-06-10 14:12:23 +0000
@@ -0,0 +1,327 @@
+"""Juju GUI helpers tests."""
+
+import json
+import unittest
+
+import mock
+
+from helpers import (
+    command,
+    juju,
+    juju_destroy_service,
+    juju_env,
+    juju_status,
+    legacy_juju,
+    ProcessError,
+    retry,
+    wait_for_unit,
+)
+
+
+class TestCommand(unittest.TestCase):
+
+    def test_simple_command(self):
+        # Creating a simple command (ls) works and running the command
+        # produces a string.
+        ls = command('/bin/ls')
+        self.assertIsInstance(ls(), str)
+
+    def test_arguments(self):
+        # Arguments can be passed to commands.
+        ls = command('/bin/ls')
+        self.assertIn('Usage:', ls('--help'))
+
+    def test_missing(self):
+        # If the command does not exist, an OSError (No such file or
+        # directory) is raised.
+        bad = command('this command does not exist')
+        with self.assertRaises(OSError) as info:
+            bad()
+        self.assertEqual(2, info.exception.errno)
+
+    def test_error(self):
+        # If the command returns a non-zero exit code, an exception is raised.
+        bad = command('/bin/ls', '--not a valid switch')
+        self.assertRaises(ProcessError, bad)
+
+    def test_baked_in_arguments(self):
+        # Arguments can be passed when creating the command as well as when
+        # executing it.
+        ll = command('/bin/ls', '-al')
+        self.assertIn('rw', ll())  # Assumes a file is r/w in the pwd.
+        self.assertIn('Usage:', ll('--help'))
+
+    def test_quoting(self):
+        # There is no need to quote special shell characters in commands.
+        ls = command('/bin/ls')
+        ls('--help', '>')
+
+
[e-mail]('helpers.juju_command')
+class TestJuju(unittest.TestCase):
+
+    env = 'test-env'
+    patch_environ = mock.patch('os.environ', {'JUJU_ENV': env})
+    process_error = ProcessError(1, 'an error occurred', 'output', 'error')
+
+    def test_e_in_args(self, mock_juju_command):
+        # The command includes the environment if provided with -e.
+        with self.patch_environ:
+            juju('deploy', '-e', 'another-env', 'test-charm')
+        mock_juju_command.assert_called_once_with(
+            'deploy', '-e', 'another-env', 'test-charm')
+
+    def test_environment_in_args(self, mock_juju_command):
+        # The command includes the environment if provided with --environment.
+        with self.patch_environ:
+            juju('deploy', '--environment', 'another-env', 'test-charm')
+        mock_juju_command.assert_called_once_with(
+            'deploy', '--environment', 'another-env', 'test-charm')
+
+    def test_environment_in_context(self, mock_juju_command):
+        # The command includes the environment if found in the context as
+        # the environment variable JUJU_ENV.
+        with self.patch_environ:
+            juju('deploy', 'test-charm')
+        mock_juju_command.assert_called_once_with(
+            'deploy', '-e', self.env, 'test-charm')
+
+    def test_environment_not_in_context(self, mock_juju_command):
+        # The command does not include the environment if not found in the
+        # context as the environment variable JUJU_ENV.
+        with mock.patch('os.environ', {}):
+            juju('deploy', 'test-charm')
+        mock_juju_command.assert_called_once_with('deploy', 'test-charm')
+
+    def test_handle_process_errors(self, mock_juju_command):
+        # The command retries several times before failing if a ProcessError is
+        # raised.
+        mock_juju_command.side_effect = ([self.process_error] * 9) + ['value']
+        with mock.patch('time.sleep') as mock_sleep:
+            with mock.patch('os.environ', {}):
+                result = juju('deploy', 'test-charm')
+        self.assertEqual('value', result)
+        self.assertEqual(10, mock_juju_command.call_count)
+        mock_juju_command.assert_called_with('deploy', 'test-charm')
+        self.assertEqual(9, mock_sleep.call_count)
+        mock_sleep.assert_called_with(1)
+
+    def test_raise_process_errors(self, mock_juju_command):
+        # The command raises the last ProcessError after a number of retries.
+        mock_juju_command.side_effect = [self.process_error] * 10
+        with mock.patch('time.sleep') as mock_sleep:
+            with mock.patch('os.environ', {}):
+                with self.assertRaises(ProcessError) as info:
+                    juju('deploy', 'test-charm')
+        self.assertIs(self.process_error, info.exception)
+        self.assertEqual(10, mock_juju_command.call_count)
+        mock_juju_command.assert_called_with('deploy', 'test-charm')
+        self.assertEqual(10, mock_sleep.call_count)
+        mock_sleep.assert_called_with(1)
+
+
[e-mail]('helpers.juju')
[e-mail]('helpers.juju_status')
+class TestJujuDestroyService(unittest.TestCase):
+
+    service = 'test-service'
+
+    def test_service_destroyed(self, mock_juju_status, mock_juju):
+        # The juju destroy-service command is correctly called.
+        mock_juju_status.return_value = {}
+        juju_destroy_service(self.service)
+        self.assertEqual(1, mock_juju_status.call_count)
+        mock_juju.assert_called_once_with('destroy-service', self.service)
+
+    def test_wait_until_removed(self, mock_juju_status, mock_juju):
+        # The function waits for the service to be removed.
+        mock_juju_status.side_effect = (
+            {'services': {self.service: {}, 'another-service': {}}},
+            {'services': {'another-service': {}}},
+        )
+        juju_destroy_service(self.service)
+        self.assertEqual(2, mock_juju_status.call_count)
+        mock_juju.assert_called_once_with('destroy-service', self.service)
+
+
+class TestJujuEnv(unittest.TestCase):
+
+    def test_env_in_context(self):
+        # The function returns the juju env if found in the execution context.
+        with mock.patch('os.environ', {'JUJU_ENV': 'test-env'}):
+            self.assertEqual('test-env', juju_env())
+
+    def test_env_not_in_context(self):
+        # The function returns None if JUJU_ENV is not included in the context.
+        with mock.patch('os.environ', {}):
+            self.assertIsNone(juju_env())
+
+
+class TestJujuStatus(unittest.TestCase):
+
+    status = {
+        'machines': {
+            '0': {'agent-state': 'running', 'dns-name': 'ec2.example.com'},
+        },
+        'services': {
+            'juju-gui': {'charm': 'cs:precise/juju-gui-48', 'exposed': True},
+        },
+    }
+
+    @mock.patch('helpers.juju')
+    def test_status(self, mock_juju):
+        # The function returns the unserialized juju status.
+        mock_juju.return_value = json.dumps(self.status)
+        status = juju_status()
+        self.assertEqual(self.status, status)
+        mock_juju.assert_called_once_with('status', '--format', 'json')
+
+
[e-mail]('helpers.juju_command')
+class TestLegacyJuju(unittest.TestCase):
+
+    def test_pyjuju(self, mock_juju_command):
+        # Legacy Juju is correctly recognized.
+        mock_juju_command.return_value = '0.7.0'
+        self.assertTrue(legacy_juju())
+        mock_juju_command.assert_called_once_with('--version')
+
+    def test_juju_core(self, mock_juju_command):
+        # juju-core is correctly recognized.
+        mock_juju_command.side_effect = ProcessError(1, 'failed', '', '')
+        self.assertFalse(legacy_juju())
+        mock_juju_command.assert_called_once_with('--version')
+
+
+class TestProcessError(unittest.TestCase):
+
+    def test_str(self):
+        # The string representation of the error includes required info.
+        err = ProcessError(1, 'mycommand', 'myoutput', 'myerror')
+        expected = (
+            "Command 'mycommand' returned non-zero exit status 1. "
+            "Output: 'myoutput'. Error: 'myerror'."
+        )
+        self.assertEqual(expected, str(err))
+
+
[e-mail]('time.sleep')
+class TestRetry(unittest.TestCase):
+
+    retry_type_error = retry(TypeError, tries=10, delay=1)
+    result = 'my value'
+
+    def make_callable(self, side_effect):
+        mock_callable = mock.Mock()
+        mock_callable.side_effect = side_effect
+        mock_callable.__name__ = 'mock_callable'  # Required by wraps.
+        decorated = retry(TypeError, tries=5, delay=1)(mock_callable)
+        return mock_callable, decorated
+
+    def test_immediate_success(self, mock_sleep):
+        # The decorated function returns without retrying if no errors occur.
+        mock_callable, decorated = self.make_callable([self.result])
+        result = decorated()
+        self.assertEqual(self.result, result)
+        self.assertEqual(1, mock_callable.call_count)
+        self.assertFalse(mock_sleep.called)
+
+    def test_success(self, mock_sleep):
+        # The decorated function returns without errors after several tries.
+        side_effect = ([TypeError] * 4) + [self.result]
+        mock_callable, decorated = self.make_callable(side_effect)
+        result = decorated()
+        self.assertEqual(self.result, result)
+        self.assertEqual(5, mock_callable.call_count)
+        self.assertEqual(4, mock_sleep.call_count)
+        mock_sleep.assert_called_with(1)
+
+    def test_failure(self, mock_sleep):
+        # The decorated function raises the last error.
+        mock_callable, decorated = self.make_callable([TypeError] * 5)
+        self.assertRaises(TypeError, decorated)
+        self.assertEqual(5, mock_callable.call_count)
+        self.assertEqual(5, mock_sleep.call_count)
+        mock_sleep.assert_called_with(1)
+
+
[e-mail]('helpers.juju_status')
+class TestWaitForService(unittest.TestCase):
+
+    address = 'unit.example.com'
+    service = 'test-service'
+
+    def get_status(self, state='started', exposed=True, unit=0):
+        """Return a dict-like Juju status."""
+        unit_name = '{}/{}'.format(self.service, unit)
+        return {
+            'services': {
+                self.service: {
+                    'exposed': exposed,
+                    'units': {
+                        unit_name: {
+                            'agent-state': state,
+                            'public-address': self.address,
+                        }
+                    },
+                },
+            },
+        }
+
+    def test_service_not_deployed(self, mock_juju_status):
+        # The function waits until the service is deployed.
+        mock_juju_status.side_effect = (
+            {}, {'services': {}}, self.get_status(),
+        )
+        unit_info = wait_for_unit(self.service)
+        self.assertEqual(self.address, unit_info['public-address'])
+        self.assertEqual(3, mock_juju_status.call_count)
+
+    def test_service_not_exposed(self, mock_juju_status):
+        # The function waits until the service is exposed.
+        mock_juju_status.side_effect = (
+            self.get_status(exposed=False), self.get_status(),
+        )
+        unit_info = wait_for_unit(self.service)
+        self.assertEqual(self.address, unit_info['public-address'])
+        self.assertEqual(2, mock_juju_status.call_count)
+
+    def test_unit_not_ready(self, mock_juju_status):
+        # The function waits until the unit is created.
+        mock_juju_status.side_effect = (
+            {'services': {'juju-gui': {}}},
+            {'services': {'juju-gui': {'units': {}}}},
+            self.get_status(),
+        )
+        unit_info = wait_for_unit(self.service)
+        self.assertEqual(self.address, unit_info['public-address'])
+        self.assertEqual(3, mock_juju_status.call_count)
+
+    def test_state_error(self, mock_juju_status):
+        # An error is raised if the unit is in an error state.
+        mock_juju_status.return_value = self.get_status(state='install-error')
+        self.assertRaises(RuntimeError, wait_for_unit, self.service)
+        self.assertEqual(1, mock_juju_status.call_count)
+
+    def test_not_started(self, mock_juju_status):
+        # The function waits until the unit is in a started state.
+        mock_juju_status.side_effect = (
+            self.get_status(state='pending'), self.get_status(),
+        )
+        unit_info = wait_for_unit(self.service)
+        self.assertEqual(self.address, unit_info['public-address'])
+        self.assertEqual(2, mock_juju_status.call_count)
+
+    def test_unit_number(self, mock_juju_status):
+        # Different unit names are correctly handled.
+        mock_juju_status.return_value = self.get_status(unit=42)
+        unit_info = wait_for_unit(self.service)
+        self.assertEqual(self.address, unit_info['public-address'])
+        self.assertEqual(1, mock_juju_status.call_count)
+
+    def test_public_address(self, mock_juju_status):
+        # The public address is returned when the service is ready.
+        mock_juju_status.return_value = self.get_status()
+        unit_info = wait_for_unit(self.service)
+        self.assertEqual(self.address, unit_info['public-address'])
+        self.assertEqual(1, mock_juju_status.call_count)

=== modified file 'tests/test_utils.py'
--- tests/test_utils.py	2013-05-31 12:53:58 +0000
+++ tests/test_utils.py	2013-06-10 14:12:23 +0000
@@ -1,9 +1,9 @@
-#!/usr/bin/env python2
+"""Juju GUI utils tests."""
 
 from contextlib import contextmanager
+import json
 import os
 import shutil
-from simplejson import dumps
 from subprocess import CalledProcessError
 import tempfile
 import unittest
@@ -527,7 +527,7 @@
         fd, self.log_file_name = tempfile.mkstemp()
         os.close(fd)
         mock_config = {'command-log-file': self.log_file_name}
-        charmhelpers.command = lambda *args: lambda: dumps(mock_config)
+        charmhelpers.command = lambda *args: lambda: json.dumps(mock_config)
 
     def tearDown(self):
         charmhelpers.command = self.command