Merge lp:~gary/charms/precise/juju-gui/update into lp:charms/juju-gui

[Gary Poster]

Merge work from ~juju-gui. This adds support for a number of GUI options, license file changes, and new test infrastructure.

Merge work from ~juju-gui. This adds support for a number of GUI options, license file changes, and new test infrastructure.

[Gary Poster (gary)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2013-05-02 09:49:51 +0000
+++ .bzrignore	2013-07-17 21:35:43 +0000
@@ -2,3 +2,4 @@
 tags
 exec.d/*
 npm-cache.tgz
+tests/.venv

=== added file '.lbox'
--- .lbox	1970-01-01 00:00:00 +0000
+++ .lbox	2013-07-17 21:35:43 +0000
@@ -0,0 +1,1 @@
+propose -cr -for lp:~juju-gui/charms/precise/juju-gui/trunk

=== added file '.lbox.check'
--- .lbox.check	1970-01-01 00:00:00 +0000
+++ .lbox.check	2013-07-17 21:35:43 +0000
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+make lint unittest

=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2013-07-17 21:35:43 +0000
@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<http://www.gnu.org/licenses/>.

=== modified file 'Dependencies.md'
--- Dependencies.md	2013-06-03 14:27:05 +0000
+++ Dependencies.md	2013-07-17 21:35:43 +0000
@@ -1,3 +1,12 @@
+<!--
+Dependencies.md
+Copyright 2013 Canonical Ltd.
+This work is licensed under the Creative Commons Attribution-Share Alike 3.0
+Unported License. To view a copy of this license, visit
+http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
+Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.
+-->
+
 # Juju GUI Charm external dependencies #
 
 The Juju GUI has a number of external dependencies including packages that are
@@ -42,5 +51,3 @@
 single starting place to obtain QA'd software.  Dev ops can grab the subset of
 packages they need, audit, test, and then serve them locally.  The
 `repository-location` config variable can be used to point to the local repo.
-
-

=== modified file 'HACKING.md'
--- HACKING.md	2013-06-27 18:25:15 +0000
+++ HACKING.md	2013-07-17 21:35:43 +0000
@@ -1,3 +1,12 @@
+<!--
+HACKING.md
+Copyright 2013 Canonical Ltd.
+This work is licensed under the Creative Commons Attribution-Share Alike 3.0
+Unported License. To view a copy of this license, visit
+http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
+Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.
+-->
+
 # Juju GUI Charm Development #
 
 ## Contacting the Developers ##
@@ -16,8 +25,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 +34,45 @@
 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".
+
+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 +80,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 +96,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-07-17 21:35:43 +0000
@@ -0,0 +1,63 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+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
+	@$(VENV)/bin/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 'README.md'
--- README.md	2013-06-26 20:37:57 +0000
+++ README.md	2013-07-17 21:35:43 +0000
@@ -1,3 +1,12 @@
+<!--
+README.md
+Copyright 2013 Canonical Ltd.
+This work is licensed under the Creative Commons Attribution-Share Alike 3.0
+Unported License. To view a copy of this license, visit
+http://creativecommons.org/licenses/by-sa/3.0/ or send a letter to Creative
+Commons, 171 Second Street, Suite 300, San Francisco, California, 94105, USA.
+-->
+
 # Juju GUI Charm #
 
 This charm makes it easy to deploy a Juju GUI into an existing environment.
@@ -23,7 +32,7 @@
 Next, you simply need to deploy the charm and expose it.  (See also "Deploying
 with Jitsu" below, for another option.)
 
-    juju deploy cs:precise/juju-gui
+    juju deploy juju-gui
     juju expose juju-gui
 
 Finally, you need to identify the GUI's URL. It can take a few minutes for the

=== modified file 'config.yaml'
--- config.yaml	2013-05-31 19:54:41 +0000
+++ config.yaml	2013-07-17 21:35:43 +0000
@@ -1,3 +1,19 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 options:
   juju-gui-source:
     description: |
@@ -111,7 +127,7 @@
       The URL of the charm catalog site ("charmworld") from which charm
       catalog data will be drawn.
     type: string
-    default: https://manage.jujucharms.com
+    default: https://manage.jujucharms.com/
   repository-location:
     description: |
       The charm depends on several software packages that are not packaged in
@@ -124,3 +140,30 @@
       'add-apt-repository'.
     type: string
     default: ppa:juju-gui-charmers/stable
+  use-analytics:
+    description: |
+      The team developing the Juju GUI benefits from understanding how
+      different deployments use the tool.  By enabling this setting,
+      anonymized usage data is reported back using Google Analytics.  The type
+      of data collected includes the charms that are deployed and the number
+      of units per service.  Use of analytics is optional but we hope you will
+      allow us to improve our tool based on your experience.
+    type: boolean
+    default: true
+  default-viewmode:
+    description: |
+      What the charmbrowser's default viewmode should be. Possible options are:
+      - 'sidebar' (default): the charmwbrowser will appear as a sidebar. This
+        is also known as build mode.
+      - 'fullscreen': the charmbrowser will appear in full screen, hiding the
+        canvas. This is also known as browse mode.
+      - 'minimized': the charmbrowser will be minimized by default, and hidden.
+    type: string
+    default: sidebar 
+  show-get-juju-button:
+    description: |
+      There are deployment modes for Juju GUI which are not intended as regular
+      use mode. In these cases, login/logout are disabled and instead there is a
+      link to juju.ubuntu.com
+    type: boolean
+    default: false

=== modified file 'config/config.js.template'
--- config/config.js.template	2013-04-26 21:05:03 +0000
+++ config/config.js.template	2013-07-17 21:35:43 +0000
@@ -22,5 +22,8 @@
   apiBackend: {{api_backend}}, // Value can be 'python' or 'go'.
   readOnly: {{readonly}},
   sandbox: {{sandbox}},
-  login_help: {{login_help}}
+  useAnalytics: {{use_analytics}},
+  login_help: {{login_help}},
+  defaultViewmode: {{default_viewmode}},
+  showGetJujuButton: {{show_get_juju_button}}
 };

=== modified file 'copyright'
--- copyright	2013-01-21 16:56:10 +0000
+++ copyright	2013-07-17 21:35:43 +0000
@@ -2,10 +2,10 @@
 
 Files: *
 Copyright: Copyright 2013, Canonical Ltd., All Rights Reserved.
-License: GPL-3
+License: Affero GPL-3
  This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
+ it under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
  .
  This program is distributed in the hope that it will be useful,

=== modified file 'hooks/backend.py'
--- hooks/backend.py	2013-07-11 21:02:07 +0000
+++ hooks/backend.py	2013-07-17 21:35:43 +0000
@@ -1,3 +1,19 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 """
 A composition system for creating backend objects.
 
@@ -84,7 +100,11 @@
             config['juju-gui-console-enabled'], config['login-help'],
             config['read-only'], config['staging'], config['ssl-cert-path'],
             config['charmworld-url'], config['serve-tests'],
-            secure=config['secure'], sandbox=config['sandbox'])
+            secure=config['secure'], sandbox=config['sandbox'],
+            use_analytics=config['use-analytics'],
+            default_viewmode=config['default-viewmode'],
+            show_get_juju_button=config['show-get-juju-button'])
+
         charmhelpers.open_port(80)
         charmhelpers.open_port(443)
 

=== modified file 'hooks/bootstrap_utils.py'
--- hooks/bootstrap_utils.py	2013-04-24 10:46:20 +0000
+++ hooks/bootstrap_utils.py	2013-07-17 21:35:43 +0000
@@ -1,3 +1,19 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 """
 These are actually maintained in python-shelltoolbox.  Precise does not have
 that package, so we need to bootstrap the process by copying the functions

=== modified file 'hooks/config-changed'
--- hooks/config-changed	2013-05-03 09:13:45 +0000
+++ hooks/config-changed	2013-07-17 21:35:43 +0000
@@ -1,8 +1,21 @@
 #!/usr/bin/env python2
 # -*- python -*-
 
-# Copyright 2012 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import sys
 

=== modified file 'hooks/install'
--- hooks/install	2013-05-31 19:54:41 +0000
+++ hooks/install	2013-07-17 21:35:43 +0000
@@ -1,6 +1,22 @@
 #!/usr/bin/env python2
 # -*- python -*-
 
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 import errno
 import json
 import os

=== modified file 'hooks/start'
--- hooks/start	2013-05-03 09:13:45 +0000
+++ hooks/start	2013-07-17 21:35:43 +0000
@@ -1,6 +1,22 @@
 #!/usr/bin/env python2
 #-*- python -*-
 
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 from charmhelpers import get_config
 
 from backend import Backend

=== modified file 'hooks/stop'
--- hooks/stop	2013-05-03 10:37:06 +0000
+++ hooks/stop	2013-07-17 21:35:43 +0000
@@ -1,6 +1,22 @@
 #!/usr/bin/env python2
 #-*- python -*-
 
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 from backend import Backend
 from utils import log_hook
 

=== modified file 'hooks/utils.py'
--- hooks/utils.py	2013-07-11 19:10:30 +0000
+++ hooks/utils.py	2013-07-17 21:35:43 +0000
@@ -1,3 +1,19 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 """Juju GUI charm utilities."""
 
 __all__ = [
@@ -112,13 +128,24 @@
     cmd_log(apt_get_install(*DEB_BUILD_DEPENDENCIES))
 
 
-def get_api_address(unit_dir):
-    """Return the Juju API address stored in the uniter agent.conf file."""
+def get_api_address(unit_dir=None):
+    """Return the Juju API address.
+
+    If not present in the hook context as an environment variable, try to
+    retrieve the address parsing the machiner agent.conf file.
+    """
+    api_addresses = os.getenv("JUJU_API_ADDRESSES")
+    if api_addresses is not None:
+        return api_addresses.split()[0]
+    # The JUJU_API_ADDRESSES environment variable is not included in the hooks
+    # context in older releases of juju-core.  Retrieve it from the machiner
+    # agent file instead.
     import yaml  # python-yaml is only installed if juju-core is used.
-    # XXX 2013-03-27 frankban bug=1161443:
-        # currently the uniter agent.conf file does not include the API
-        # address. For now retrieve it from the machine agent file.
-    base_dir = os.path.abspath(os.path.join(unit_dir, '..'))
+    if unit_dir is None:
+        base_dir = os.path.join(CURRENT_DIR, '..', '..')
+    else:
+        base_dir = os.path.join(unit_dir, '..')
+    base_dir = os.path.abspath(base_dir)
     for dirname in os.listdir(base_dir):
         if dirname.startswith('machine-'):
             agent_conf = os.path.join(base_dir, dirname, 'agent.conf')
@@ -333,11 +360,12 @@
 def start_gui(
         console_enabled, login_help, readonly, in_staging, ssl_cert_path,
         charmworld_url, serve_tests, haproxy_path='/etc/haproxy/haproxy.cfg',
-        config_js_path=None, secure=True, sandbox=False):
+        config_js_path=None, secure=True, sandbox=False, use_analytics=False,
+        default_viewmode='sidebar', show_get_juju_button=False):
     """Set up and start the Juju GUI server."""
     with su('root'):
         run('chown', '-R', 'ubuntu:', JUJU_GUI_DIR)
-    # XXX 2013-02-05 frankban bug=1116320:
+        # XXX 2013-02-05 frankban bug=1116320:
         # External insecure resources are still loaded when testing in the
         # debug environment. For now, switch to the production environment if
         # the charm is configured to serve tests.
@@ -373,6 +401,9 @@
         'protocol': json.dumps(protocol),
         'sandbox': json.dumps(sandbox),
         'charmworld_url': json.dumps(charmworld_url),
+        'use_analytics': json.dumps(use_analytics),
+        'default_viewmode': json.dumps(default_viewmode),
+        'show_get_juju_button': json.dumps(show_get_juju_button),
     }
     if config_js_path is None:
         config_js_path = os.path.join(
@@ -387,7 +418,7 @@
         api_address = '127.0.0.1:{0}'.format(API_PORT)
     else:
         # Retrieve the juju-core API server address.
-        api_address = get_api_address(os.path.join(CURRENT_DIR, '..'))
+        api_address = get_api_address()
     context = {
         'api_address': api_address,
         'api_pem': JUJU_PEM,

=== modified file 'hooks/web-relation-joined'
--- hooks/web-relation-joined	2013-05-03 09:13:45 +0000
+++ hooks/web-relation-joined	2013-07-17 21:35:43 +0000
@@ -1,6 +1,22 @@
 #!/usr/bin/env python2
 #-*- python -*-
 
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 import socket
 
 from charmhelpers import (

=== modified file 'metadata.yaml'
--- metadata.yaml	2013-04-23 07:32:46 +0000
+++ metadata.yaml	2013-07-17 21:35:43 +0000
@@ -1,3 +1,19 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 name: juju-gui
 summary: User interface for Juju (development)
 maintainer: Juju GUI Team <[e-mail]>

=== modified file 'revision'
--- revision	2013-07-12 18:37:59 +0000
+++ revision	2013-07-17 21:35:43 +0000
@@ -1,1 +1,1 @@
-52
+53
\ No newline at end of file

=== added file 'tests/00-setup'
--- tests/00-setup	1970-01-01 00:00:00 +0000
+++ tests/00-setup	2013-07-17 21:35:43 +0000
@@ -0,0 +1,36 @@
+#!/bin/sh
+
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+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-07-17 21:35:43 +0000
@@ -1,5 +1,22 @@
-#!/usr/bin/env python2
-# -*- python -*-
+#!tests/.venv/bin/python
+
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Unit test suite."""
 
 import os
 import sys
@@ -8,4 +25,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-07-17 21:35:43 +0000
@@ -1,30 +1,47 @@
-#!/usr/bin/env python2
-#-*- python -*-
-
-import os
+#!tests/.venv/bin/python
+
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 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,
+    juju_version,
+    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 = juju_version().major == 0
 
 
 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,29 +51,14 @@
         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."""
         self.wait_for_script(
-            'return app.env.get("connected");',
+            'return app && app.env && 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(
@@ -85,7 +87,7 @@
             return driver.title == 'Juju Admin'
         self.wait_for(page_ready, error='Juju GUI not found.')
 
-    def wait_for(self, condition, error=None, timeout=20):
+    def wait_for(self, condition, error=None, timeout=30):
         """Wait for condition to be True.
 
         The argument condition is a callable accepting a driver object.
@@ -95,7 +97,7 @@
         wait = ui.WebDriverWait(self.selenium, timeout)
         return wait.until(condition, error)
 
-    def wait_for_css_selector(self, selector, error=None, timeout=20):
+    def wait_for_css_selector(self, selector, error=None, timeout=30):
         """Wait until the provided CSS selector is found.
 
         Fail printing the provided error if timeout is exceeded.
@@ -106,7 +108,7 @@
         elements = self.wait_for(condition, error=error, timeout=timeout)
         return elements[0]
 
-    def wait_for_script(self, script, error=None, timeout=20):
+    def wait_for_script(self, script, error=None, timeout=30):
         """Wait for the given JavaScript snippet to return a True value.
 
         Fail printing the provided error if timeout is exceeded.
@@ -115,14 +117,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 +129,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 +138,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 +168,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-07-17 21:35:43 +0000
@@ -0,0 +1,80 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""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(name, source, series='precise'):
+    """Create a temporary Juju repository to use for charm deployment.
+
+    Copy the charm files in source in the precise repository section, using the
+    provided charm name and excluding the virtualenv and Bazaar directories.
+
+    Return the repository path.
+    """
+    source = os.path.abspath(source) + os.path.sep
+    repo = tempfile.mkdtemp()
+    destination = os.path.join(repo, series, name)
+    os.makedirs(destination)
+    rsync(source, destination)
+    return repo
+
+
+def juju_deploy(
+        charm, options=None, force_machine=None, charm_source=None,
+        series='precise'):
+    """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, charm_source, series=series)
+    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:{}/{}'.format(series, 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-07-17 21:35:43 +0000
@@ -0,0 +1,185 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Juju GUI test helpers."""
+
+from collections import namedtuple
+from functools import wraps
+import json
+import os
+import re
+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')
+Version = namedtuple('Version', 'major minor patch')
+
+
+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)
+
+
+_juju_version_expression = re.compile(r"""
+    ^  # Beginning of line.
+    (?:juju\s+)?  # Optional juju prefix.
+    (\d+)\.(\d+)  # Major and minor versions.
+    (?:\.(\d+))?  # Optional patch version.
+    .*  # Optional suffix.
+    $  # End of line.
+""", re.VERBOSE)
+
+
+def juju_version():
+    """Return the currently used Juju version.
+
+    The version is returned as a named tuple (major, minor, patch).
+    If the patch number is missing, it is set to zero.
+    """
+    try:
+        # In pyJuju, version info is printed to stderr.
+        output = subprocess.check_output(
+            ['juju', '--version'], stderr=subprocess.STDOUT)
+    except subprocess.CalledProcessError:
+        # Current juju-core exposes a version subcommand.
+        output = subprocess.check_output(['juju', 'version'])
+    match = _juju_version_expression.match(output)
+    if match is None:
+        raise ValueError('invalid juju version: {!r}'.format(output))
+    to_int = lambda num: 0 if num is None else int(num)
+    return Version._make(map(to_int, match.groups()))
+
+
+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-07-17 21:35:43 +0000
@@ -0,0 +1,28 @@
+# Juju GUI test requirements.
+
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+-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-05-02 16:51:14 +0000
+++ tests/test_backends.py	2013-07-17 21:35:43 +0000
@@ -1,3 +1,19 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 from collections import defaultdict
 from contextlib import contextmanager
 import os
@@ -34,7 +50,7 @@
             frozenset(('apache2', 'curl', 'haproxy', 'openssl', 'zookeeper')),
             test_backend.debs)
         self.assertEqual(
-            frozenset(('ppa:juju-gui/ppa',)),
+            frozenset(()),
             test_backend.repositories)
         self.assertEqual(
             frozenset(('haproxy.conf',)),
@@ -51,7 +67,7 @@
             frozenset(('apache2', 'curl', 'haproxy', 'openssl')),
             test_backend.debs)
         self.assertEqual(
-            frozenset(('ppa:juju-gui/ppa',)),
+            frozenset(()),
             test_backend.repositories)
         self.assertEqual(
             frozenset(('haproxy.conf',)),
@@ -68,7 +84,7 @@
             frozenset(('apache2', 'curl', 'haproxy', 'openssl')),
             test_backend.debs)
         self.assertEqual(
-            frozenset(('ppa:juju-gui/ppa',)),
+            frozenset(()),
             test_backend.repositories)
         self.assertEqual(
             frozenset(('haproxy.conf',)),
@@ -97,7 +113,7 @@
                 ('apache2', 'curl', 'haproxy', 'openssl', 'python-yaml')),
             test_backend.debs)
         self.assertEqual(
-            frozenset(('ppa:juju-gui/ppa',)),
+            frozenset(()),
             test_backend.repositories)
         self.assertEqual(
             frozenset(('haproxy.conf',)),
@@ -192,14 +208,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-07-17 21:35:43 +0000
@@ -0,0 +1,196 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""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):
+
+    name = 'test-charm'
+
+    def setUp(self):
+        # Create a directory structure for the charm source.
+        self.source = tempfile.mkdtemp()
+        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.name], os.listdir(series_dir))
+        self.assert_dir_exists(os.path.join(series_dir, self.name))
+
+    def test_repository(self):
+        # The charm repository is correctly created with the default series.
+        repo = setup_repository(self.name, self.source)
+        self.check_repository(repo, 'precise')
+
+    def test_series(self):
+        # The charm repository is created with the given series.
+        repo = setup_repository(self.name, 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.name, self.source)
+        charm_dir = os.path.join(repo, 'precise', self.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:precise/{}'.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,
+            options=None, force_machine=None, charm_source=None,
+            series='precise'):
+        mock_setup_repository.return_value = self.repo
+        mock_wait_for_unit.return_value = self.unit_info
+        if charm_source is None:
+            expected_source = os.path.join(os.path.dirname(__file__), '..')
+        else:
+            expected_source = charm_source
+        unit_info = juju_deploy(
+            self.charm, options=options, force_machine=force_machine,
+            charm_source=charm_source, series=series)
+        mock_setup_repository.assert_called_once_with(
+            self.charm, expected_source, series=series)
+        # 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)
+
+    def test_series(self):
+        # The function can deploy a charm from a specific series.
+        expected_deploy_call = mock.call(
+            'deploy',
+            '--repository', self.repo,
+            'local:raring/{}'.format(self.charm)
+        )
+        deploy_call = self.call_deploy(series='raring')
+        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-07-17 21:35:43 +0000
@@ -0,0 +1,397 @@
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Juju GUI helpers tests."""
+
+import json
+import subprocess
+import unittest
+
+import mock
+
+from helpers import (
+    command,
+    juju,
+    juju_destroy_service,
+    juju_env,
+    juju_status,
+    juju_version,
+    ProcessError,
+    retry,
+    Version,
+    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]('subprocess.check_output')
+class TestJujuVersion(unittest.TestCase):
+
+    error = subprocess.CalledProcessError(2, 'invalid flag', 'output')
+
+    def test_pyjuju(self, mock_check_output):
+        # The pyJuju version is correctly retrieved.
+        mock_check_output.return_value = '0.7.2'
+        version = juju_version()
+        self.assertEqual(Version(0, 7, 2), version)
+        mock_check_output.assert_called_once_with(
+            ['juju', '--version'], stderr=subprocess.STDOUT,
+        )
+
+    def test_juju_core(self, mock_check_output):
+        # The juju-core version is correctly retrieved.
+        mock_check_output.side_effect = (self.error, '1.12.3')
+        version = juju_version()
+        self.assertEqual(Version(1, 12, 3), version)
+        self.assertEqual(2, mock_check_output.call_count)
+        first_call, second_call = mock_check_output.call_args_list
+        self.assertEqual(
+            mock.call(['juju', '--version'], stderr=subprocess.STDOUT),
+            first_call,
+        )
+        self.assertEqual(mock.call(['juju', 'version']), second_call)
+
+    def test_not_semantic_versioning(self, mock_check_output):
+        # If the patch number is missing, it is set to zero.
+        mock_check_output.return_value = '0.7'
+        version = juju_version()
+        self.assertEqual(Version(0, 7, 0), version)
+
+    def test_prefix(self, mock_check_output):
+        # The function handles versions returned as "juju x.y.z".
+        mock_check_output.return_value = 'juju 0.8.3'
+        version = juju_version()
+        self.assertEqual(Version(0, 8, 3), version)
+
+    def test_suffix(self, mock_check_output):
+        # The function handles versions returned as "x.y.z-series-arch".
+        mock_check_output.return_value = '1.10.3-raring-amd64'
+        version = juju_version()
+        self.assertEqual(Version(1, 10, 3), version)
+
+    def test_all(self, mock_check_output):
+        # Additional information is correctly handled.
+        mock_check_output.side_effect = (self.error, 'juju 1.234-precise-i386')
+        version = juju_version()
+        self.assertEqual(Version(1, 234, 0), version)
+        self.assertEqual(2, mock_check_output.call_count)
+
+    def test_invalid_version(self, mock_check_output):
+        # A ValueError is raised if the returned version is not valid.
+        mock_check_output.return_value = '42'
+        with self.assertRaises(ValueError) as info:
+            juju_version()
+        self.assertEqual("invalid juju version: '42'", str(info.exception))
+
+    def test_failure(self, mock_check_output):
+        # A CalledProcessError is raised if the Juju version cannot be found.
+        mock_check_output.side_effect = (self.error, self.error)
+        with self.assertRaises(subprocess.CalledProcessError) as info:
+            juju_version()
+        self.assertIs(self.error, info.exception)
+        self.assertEqual(2, mock_check_output.call_count)
+
+
+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-07-11 19:10:30 +0000
+++ tests/test_utils.py	2013-07-17 21:35:43 +0000
@@ -1,14 +1,31 @@
-#!/usr/bin/env python2
+# This file is part of the Juju GUI, which lets users view and manage Juju
+# environments within a graphical interface (https://launchpad.net/juju-gui).
+# Copyright (C) 2012-2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""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
 
 import charmhelpers
+from shelltoolbox import environ
 import tempita
 import yaml
 
@@ -86,28 +103,70 @@
 
 class TestGetApiAddress(unittest.TestCase):
 
-    def setUp(self):
-        self.base_dir = tempfile.mkdtemp()
-        self.addCleanup(shutil.rmtree, self.base_dir)
-        self.unit_dir = tempfile.mkdtemp(dir=self.base_dir)
-        self.machine_dir = os.path.join(self.base_dir, 'machine-1')
-
-    def test_retrieving_address(self):
-        # The API address is correctly returned.
-        address = 'example.com:17070'
-        os.mkdir(self.machine_dir)
-        with open(os.path.join(self.machine_dir, 'agent.conf'), 'w') as conf:
-            yaml.dump({'apiinfo': {'addrs': [address]}}, conf)
-        self.assertEqual(address, get_api_address(self.unit_dir))
-
-    def test_missing_file(self):
+    env_address = 'env.example.com:17070'
+    agent_address = 'agent.example.com:17070'
+
+    @contextmanager
+    def agent_file(self, addresses=None):
+        """Set up a directory structure similar to the one created by juju.
+
+        If addresses are provided, also create a machiner directory and an
+        agent file containing the addresses.
+        Remove the directory structure when exiting from the context manager.
+        """
+        base_dir = tempfile.mkdtemp()
+        unit_dir = tempfile.mkdtemp(dir=base_dir)
+        machine_dir = os.path.join(base_dir, 'machine-1')
+        if addresses is not None:
+            os.mkdir(machine_dir)
+            with open(os.path.join(machine_dir, 'agent.conf'), 'w') as conf:
+                yaml.dump({'apiinfo': {'addrs': addresses}}, conf)
+        try:
+            yield unit_dir, machine_dir
+        finally:
+            shutil.rmtree(base_dir)
+
+    def test_retrieving_address_from_env(self):
+        # The API address is correctly retrieved from the environment.
+        with environ(JUJU_API_ADDRESSES=self.env_address):
+            self.assertEqual(self.env_address, get_api_address())
+
+    def test_multiple_addresses_in_env(self):
+        # If multiple API addresses are listed in the environment variable,
+        # the first one is returned.
+        addresses = '{} foo.example.com:42'.format(self.env_address)
+        with environ(JUJU_API_ADDRESSES=addresses):
+            self.assertEqual(self.env_address, get_api_address())
+
+    def test_both_env_and_agent_file(self):
+        # If the API address is included in both the environment and the
+        # agent.conf file, the environment variable takes precedence.
+        with environ(JUJU_API_ADDRESSES=self.env_address):
+            with self.agent_file([self.agent_address]) as (unit_dir, _):
+                self.assertEqual(self.env_address, get_api_address(unit_dir))
+
+    def test_retrieving_address_from_agent_file(self):
+        # The API address is correctly retrieved from the machiner agent file.
+        with self.agent_file([self.agent_address]) as (unit_dir, _):
+            self.assertEqual(self.agent_address, get_api_address(unit_dir))
+
+    def test_multiple_addresses_in_agent_file(self):
+        # If multiple API addresses are listed in the agent file, the first
+        # one is returned.
+        addresses = [self.agent_address, 'foo.example.com:42']
+        with self.agent_file(addresses) as (unit_dir, _):
+            self.assertEqual(self.agent_address, get_api_address(unit_dir))
+
+    def test_missing_env_and_agent_file(self):
         # An IOError is raised if the agent configuration file is not found.
-        os.mkdir(self.machine_dir)
-        self.assertRaises(IOError, get_api_address, self.unit_dir)
+        with self.agent_file() as (unit_dir, machine_dir):
+            os.mkdir(machine_dir)
+            self.assertRaises(IOError, get_api_address, unit_dir)
 
-    def test_missing_directory(self):
+    def test_missing_env_and_agent_directory(self):
         # An IOError is raised if the machine directory is not found.
-        self.assertRaises(IOError, get_api_address, self.unit_dir)
+        with self.agent_file() as (unit_dir, _):
+            self.assertRaises(IOError, get_api_address, unit_dir)
 
 
 class TestLegacyJuju(unittest.TestCase):
@@ -484,7 +543,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
@@ -578,7 +637,7 @@
         start_gui(
             False, 'This is login help.', True, True, ssl_cert_path,
             charmworld_url, True, haproxy_path='haproxy',
-            config_js_path='config')
+            config_js_path='config', use_analytics=True)
         haproxy_conf = self.files['haproxy']
         self.assertIn('ca-base {0}'.format(ssl_cert_path), haproxy_conf)
         self.assertIn('crt-base {0}'.format(ssl_cert_path), haproxy_conf)
@@ -596,6 +655,7 @@
         self.assertIn("socket_url: 'wss://", js_conf)
         self.assertIn('socket_protocol: "wss"', js_conf)
         self.assertIn('charmworldURL: "http://charmworld.example"', js_conf)
+        self.assertIn('useAnalytics: true', js_conf)
         apache_conf = self.files['juju-gui']
         self.assertIn('juju-gui/build-', apache_conf)
         self.assertIn('VirtualHost *:{0}'.format(WEB_PORT), apache_conf)
@@ -628,6 +688,38 @@
         self.assertIn('user: "admin"', js_conf)
         self.assertIn('password: "admin"', js_conf)
 
+    def test_start_gui_no_analytics(self):
+        ssl_cert_path = '/tmp/certificates/'
+        charmworld_url = 'http://charmworld.example'
+        start_gui(
+            False, 'This is login help.', False, False, ssl_cert_path,
+            charmworld_url, True, haproxy_path='haproxy',
+            config_js_path='config', use_analytics=False)
+        js_conf = self.files['config']
+        self.assertIn('useAnalytics: false', js_conf)
+
+    def test_start_gui_fullscreen(self):
+        ssl_cert_path = '/tmp/certificates/'
+        charmworld_url = 'http://charmworld.example'
+        start_gui(
+            False, 'This is login help.', False, False, ssl_cert_path,
+            charmworld_url, True, haproxy_path='haproxy',
+            config_js_path='config', sandbox=True,
+            default_viewmode='fullscreen')
+        js_conf = self.files['config']
+        self.assertIn('defaultViewmode: "fullscreen"', js_conf)
+
+    def test_start_gui_with_button(self):
+        ssl_cert_path = '/tmp/certificates/'
+        charmworld_url = 'http://charmworld.example'
+        start_gui(
+            False, 'This is login help.', False, False, ssl_cert_path,
+            charmworld_url, True, haproxy_path='haproxy',
+            config_js_path='config', sandbox=True,
+            show_get_juju_button=True)
+        js_conf = self.files['config']
+        self.assertIn('showGetJujuButton: true', js_conf)
+
 
 class TestNpmCache(unittest.TestCase):
     """To speed building from a branch we prepopulate the NPM cache."""