Merge lp:~ericsnowcurrently/fake-juju/python-lib-testing into lp:~landscape/fake-juju/trunk-old

[Eric Snow]

Add the fakejuju.testing module.

This is essentially fake-juju part of txjuju.testing.

Unmerged revisions

=== added directory 'python'
=== added file 'python/LICENSE'
--- python/LICENSE	1970-01-01 00:00:00 +0000
+++ python/LICENSE	2016-10-06 22:53:21 +0000
@@ -0,0 +1,191 @@
+All files in this repository are licensed as follows. If you contribute
+to this repository, it is assumed that you license your contribution
+under the same license unless you state otherwise.
+
+All files Copyright (C) 2012-2016 Canonical Ltd. unless otherwise specified in the file.
+
+This software is licensed under the LGPLv3, included below.
+
+As a special exception to the GNU Lesser General Public License version 3
+("LGPL3"), the copyright holders of this Library give you permission to
+convey to a third party a Combined Work that links statically or dynamically
+to this Library without providing any Minimal Corresponding Source or
+Minimal Application Code as set out in 4d or providing the installation
+information set out in section 4e, provided that you comply with the other
+provisions of LGPL3 and provided that you meet, for the Application the
+terms and conditions of the license(s) which apply to the Application.
+
+Except as stated in this special exception, the provisions of LGPL3 will
+continue to comply in full to this Library. If you modify this Library, you
+may apply this exception to your version of this Library, but you are not
+obliged to do so. If you do not wish to do so, delete this exception
+statement from your version. This exception does not (and cannot) modify any
+license terms which apply to the Application, with which you must still
+comply.
+
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 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.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser 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
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

=== added file 'python/Makefile'
--- python/Makefile	1970-01-01 00:00:00 +0000
+++ python/Makefile	2016-10-06 22:53:21 +0000
@@ -0,0 +1,9 @@
+PYTHON = python
+
+.PHONY: test
+test:
+	$(PYTHON) -m unittest discover -t $(shell pwd) -s $(shell pwd)/fakejuju
+
+.PHONY: install-dev
+install-dev:
+	ln -s $(shell pwd)/fakejuju /usr/local/lib/python2.7/dist-packages/fakejuju

=== added file 'python/README.md'
--- python/README.md	1970-01-01 00:00:00 +0000
+++ python/README.md	2016-10-06 22:53:21 +0000
@@ -0,0 +1,1 @@
+# fakejuju

=== added directory 'python/fakejuju'
=== added file 'python/fakejuju/__init__.py'
--- python/fakejuju/__init__.py	1970-01-01 00:00:00 +0000
+++ python/fakejuju/__init__.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,57 @@
+# Copyright 2016 Canonical Limited.  All rights reserved.
+
+"""Support for interaction with fake-juju.
+
+"fake-juju" is a combination of the juju and jujud commands that is
+suitable for use in integration tests.  It exposes a limited subset
+of the standard juju subcommands (see FakeJuju in this module for
+specifics).  When called without any arguments it runs jujud (using
+the dummy provider) with extra logging and testing hooks available to
+control failures.  See https://launchpad.net/fake-juju for the project.
+
+The binary is named with the Juju version for which it was built.
+For example, for version 1.25.6 the file is named "fake-juju-1.25.6".
+
+fake-juju uses the normal Juju local config directory.  This defaults
+to ~/.local/shared/juju and may be set using the JUJU_DATA environment
+variable (in 2.x, for 1.x it is JUJU_HOME).
+
+In addition to all the normal Juju environment variables (e.g.
+JUJU_DATA), fake-juju uses the following:
+
+  FAKE_JUJU_FAILURES - the path to the failures file
+      The Failures class below sets this to $JUJU_DATA/juju-failures.
+  FAKE_JUJU_LOGS_DIR - the path to the logs directory
+      This defaults to $JUJU_DATA.
+
+fake-juju also creates several extra files:
+
+  $FAKE_JUJU_LOGS_DIR/fake-juju.log - where fake-juju logs are written
+  $JUJU_DATA/fakejuju - fake-juju's data cache
+  $JUJU_DATA/fifo - a FIFO file that triggers jujud shutdown
+  $JUJU_DATA/cert.ca - the API's CA certificate
+
+Normal Juju logging for is written to $JUJU_DATA/fake-juju.log.
+
+Failures may be injected into a running fake-juju (or set before
+running).  They may be injected by adding them to the file identified
+by $FAKE_JUJU_FAILURES.  The format is a single failure definition per
+line.  The syntax of the failure definition depends on the failure.
+The currently supported failures (with their definition syntax) are
+listed here:
+
+  * when adding a unit with a specific ID
+    format: "unit-<ID>"  (e.g. unit-mysql/0)
+
+"""
+
+from .fakejuju import get_bootstrap_spec, get_filename, set_envvars, FakeJuju
+
+
+__all__ = [
+    "__version__",
+    "get_bootstrap_spec", "get_filename", "set_envvars",
+    "FakeJuju",
+    ]
+
+__version__ = "0.9.0b1"

=== added file 'python/fakejuju/failures.py'
--- python/fakejuju/failures.py	1970-01-01 00:00:00 +0000
+++ python/fakejuju/failures.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,65 @@
+# Copyright 2016 Canonical Limited.  All rights reserved.
+
+import errno
+import os
+import os.path
+
+
+class Failures(object):
+    """The collection of injected failures to use with a fake-juju.
+
+    The failures are tracked here as well as injected into any
+    fake-juju using the initial config dir (aka "juju home").
+
+    Note that fake-juju provides only limited capability for
+    failure injection.
+    """
+
+    def __init__(self, cfgdir, entities=None):
+        """
+        @param cfgdir: The "juju home" directory into which the
+            failures will be registered for injection.
+        @param entities: The entity names to start with, if any.
+        """
+        filename = os.path.join(cfgdir, "juju-failures")
+        entities = set(unicode(tag) for tag in entities or ())
+
+        self._filename = unicode(filename)
+        self._entities = entities
+
+    @property
+    def filename(self):
+        """The path to the failures file the fake-juju reads."""
+        return self._filename
+
+    @property
+    def entities(self):
+        """The IDs of the failing entities."""
+        return set(self._entities)
+
+    def _flush(self):
+        """Write the failures to disk."""
+        data = "\n".join(self._entities) + "\n"
+        try:
+            file = open(self._filename, "w")
+        except IOError:
+            dirname = os.path.dirname(self._filename)
+            if not os.path.exists(dirname):
+                os.makedirs(dirname)
+            file = open(self._filename, "w")
+        with file:
+            file.write(data)
+
+    def fail_entity(self, tag):
+        """Inject a global failure for the identified Juju entity."""
+        self._entities.add(tag)
+        self._flush()
+
+    def clear(self):
+        """Remove all injected failures."""
+        try:
+            os.remove(self._filename)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+        self._entities.clear()

=== added file 'python/fakejuju/fakejuju.py'
--- python/fakejuju/fakejuju.py	1970-01-01 00:00:00 +0000
+++ python/fakejuju/fakejuju.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,145 @@
+# Copyright 2016 Canonical Limited.  All rights reserved.
+
+from collections import namedtuple
+import os.path
+
+import txjuju.cli
+
+from .failures import Failures
+
+
+def get_bootstrap_spec(name, admin_secret=None):
+    """Return the BootstrapSpec instance for the given controller.
+
+    @param name: The controller name to set up.
+    @param admin_secret: The admin user password to use.
+    """
+    type = "dummy"
+    default_series = None  # Use the default.
+    return txjuju.cli.BootstrapSpec(name, type, default_series, admin_secret)
+
+
+def get_filename(version, bindir=None):
+    """Return the full path to the fake-juju binary for the given version.
+
+    @param version: The Juju version to use.
+    @param bindir: The directory containing the fake-juju binary.
+        This defaults to /usr/bin.
+    """
+    if not version:
+        raise ValueError("version not provided")
+    filename = "fake-juju-{}".format(version)
+    if bindir is None:
+        # XXX Search $PATH.
+        bindir = "/usr/bin"
+    return os.path.join(bindir, filename)
+
+
+def set_envvars(envvars, failures_filename=None, logsdir=None):
+    """Return the environment variables with which to run fake-juju.
+
+    @param envvars: The env dict to update.
+    @param failures_filename: The path to the failures file that
+        fake-juju will use.
+    @params logsdir: The path to the directory where fake-juju will
+        write its log files.
+    """
+    envvars["FAKE_JUJU_FAILURES"] = failures_filename or ""
+    envvars["FAKE_JUJU_LOGS_DIR"] = logsdir or ""
+
+
+class FakeJuju(
+        namedtuple("FakeJuju", "filename version cfgdir logsdir failures")):
+    """The fundamental details for fake-juju."""
+
+    @classmethod
+    def from_version(cls, version, cfgdir,
+                     logsdir=None, failuresdir=None, bindir=None):
+        """Return a new instance given the provided information.
+
+        @param version: The Juju version to fake.
+        @param cfgdir: The "juju home" directory to use.
+        @param logsdir: The directory where logs will be written.
+            This defaults to cfgdir.
+        @params failuresdir: The directory where failure injection
+            is managed.
+        @param bindir: The directory containing the fake-juju binary.
+            This defaults to /usr/bin.
+        """
+        if logsdir is None:
+            logsdir = cfgdir
+        if failuresdir is None:
+            failuresdir = cfgdir
+        filename = get_filename(version, bindir=bindir)
+        failures = Failures(failuresdir)
+        return cls(filename, version, cfgdir, logsdir, failures)
+
+    def __new__(cls, filename, version, cfgdir, logsdir=None, failures=None):
+        """
+        @param filename: The path to the fake-juju binary.
+        @param version: The Juju version to fake.
+        @param cfgdir: The "juju home" directory to use.
+        @param logsdir: The directory where logs will be written.
+            This defaults to cfgdir.
+        @param failures: The set of fake-juju failures to use.
+        """
+        filename = unicode(filename) if filename else None
+        version = unicode(version) if version else None
+        cfgdir = unicode(cfgdir) if cfgdir else None
+        logsdir = unicode(logsdir) if logsdir is not None else cfgdir
+        if failures is None and cfgdir:
+            failures = Failures(cfgdir)
+        return super(FakeJuju, cls).__new__(
+            cls, filename, version, cfgdir, logsdir, failures)
+
+    def __init__(self, *args, **kwargs):
+        if not self.filename:
+            raise ValueError("missing filename")
+        if not self.version:
+            raise ValueError("missing version")
+        if not self.cfgdir:
+            raise ValueError("missing cfgdir")
+        if not self.logsdir:
+            raise ValueError("missing logsdir")
+        if self.failures is None:
+            raise ValueError("missing failures")
+
+    @property
+    def logfile(self):
+        """The path to fake-juju's log file."""
+        return os.path.join(self.logsdir, "fake-juju.log")
+
+    @property
+    def infofile(self):
+        """The path to fake-juju's data cache."""
+        return os.path.join(self.cfgdir, "fakejuju")
+
+    @property
+    def fifo(self):
+        """The path to the fifo file that triggers shutdown."""
+        return os.path.join(self.cfgdir, "fifo")
+
+    @property
+    def cacertfile(self):
+        """The path to the API server's certificate."""
+        return os.path.join(self.cfgdir, "cert.ca")
+
+    def cli(self, envvars=None):
+        """
+
+        Currently only the following juju subcommands are supported:
+
+        * bootstrap
+          Not that this only supports the dummy provider and the local
+          system is only minimally impacted.
+        * api-info
+          Note that passwords are always omited, even if requested.
+        * api-endpoints
+        * destroy-environment
+        """
+        if envvars is None:
+            envvars = os.environ
+        envvars = dict(envvars)
+        set_envvars(envvars, self.failures._filename, self.logsdir)
+        return txjuju.cli.CLI.from_version(
+            self.filename, self.version, self.cfgdir, envvars)

=== added file 'python/fakejuju/testing.py'
--- python/fakejuju/testing.py	1970-01-01 00:00:00 +0000
+++ python/fakejuju/testing.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,68 @@
+# Copyright 2016 Canonical Limited.  All rights reserved.
+
+import txjuju
+from fixtures import Fixture, TempDir
+from testtools.content import content_from_file
+
+from . import fakejuju
+
+
+JUJU1_VER = "1.25.6"
+JUJU2_VER = "2.0-beta17"
+JUJU_VER = JUJU1_VER
+
+
+class FakeJujuFixture(Fixture):
+    """Manages a fake-juju process."""
+
+    CONTROLLER = "test"
+    ADMIN_SECRET = "sekret"
+    VERSION = JUJU_VER
+
+    def __init__(self, controller=None, password=None, logs_dir=None,
+                 version=None):
+        """
+        @param logs_dir: If given, copy logs to this directory upon cleanup,
+            otherwise, print it as test plain text detail upon failure.
+        """
+        if controller is None:
+            controller = self.CONTROLLER
+        if password is None:
+            password = self.ADMIN_SECRET
+        if version is None:
+            version = self.VERSION
+
+        self._controller = controller
+        self._password = password
+        self._logs_dir = logs_dir
+        self._version = version
+
+    def setUp(self):
+        super(FakeJujuFixture, self).setUp()
+        self._juju_home = self.useFixture(TempDir())
+        self._juju = fakejuju.FakeJuju.make(
+            self._juju_home.path, self._version, self._logs_dir)
+
+        if not self._logs_dir:
+            # Attach logs as testtools details.
+            self.addDetail("log-file", content_from_file(self._juju.logfile))
+
+        spec = fakejuju.get_bootstrap_spec(self._controller, self._password)
+        cfgfile = txjuju.prepare_for_bootstrap(
+            spec, self._version, self._juju_home)
+        cli = self._juju.cli()
+        cli.bootstrap(spec, cfgfile=cfgfile)
+        api_info = cli.api_info(spec.name)
+        if self._version.startswith("1."):
+            # fake-juju doesn't give us the password, so we have to
+            # set it here.
+            api_info = api_info._replace(password=self._password)
+        self.api_info = api_info
+
+    def cleanUp(self):
+        self._juju.destroy_controller(self._controller)
+        super(FakeJujuFixture, self).cleanUp()
+
+    def add_failure(self, entity):
+        """Make the given entity fail with an error status."""
+        self._juju.failures.fail_entity(entity)

=== added directory 'python/fakejuju/tests'
=== added file 'python/fakejuju/tests/__init__.py'
=== added file 'python/fakejuju/tests/test_failures.py'
--- python/fakejuju/tests/test_failures.py	1970-01-01 00:00:00 +0000
+++ python/fakejuju/tests/test_failures.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,98 @@
+# Copyright 2016 Canonical Limited.  All rights reserved.
+
+import os
+import os.path
+import shutil
+import tempfile
+import unittest
+
+from fakejuju.failures import Failures
+
+
+class FailuresTests(unittest.TestCase):
+
+    def setUp(self):
+        super(FailuresTests, self).setUp()
+        self.dirname = tempfile.mkdtemp(prefix="fakejuju-test-")
+
+    def tearDown(self):
+        shutil.rmtree(self.dirname)
+        super(FailuresTests, self).tearDown()
+
+    def test_full(self):
+        """Failures() works correctly when given all args."""
+        entities = [u"x", u"y", u"z"]
+        failures = Failures(u"/some/dir", entities)
+
+        self.assertEqual(failures.filename, u"/some/dir/juju-failures")
+        self.assertEqual(failures.entities, set(entities))
+
+    def test_minimal(self):
+        """Failures() works correctly when given minimal args."""
+        failures = Failures(u"/some/dir")
+
+        self.assertEqual(failures.filename, u"/some/dir/juju-failures")
+        self.assertEqual(failures.entities, set())
+
+    def test_conversion(self):
+        """Failures() converts str to unicode."""
+        entities = ["x", "y", "z"]
+        failures = Failures("/some/dir", entities)
+
+        self.assertIsInstance(failures.filename, unicode)
+        for id in failures.entities:
+            self.assertIsInstance(id, unicode)
+
+    def test_file_not_created_initially(self):
+        """Failures() doesn't create a missing cfgdir until necessary."""
+        failures = Failures(self.dirname)
+
+        self.assertFalse(os.path.exists(failures.filename))
+
+    def test_cfgdir_created(self):
+        """Failures() creates a missing cfgdir as soon as it's needed."""
+        dirname = os.path.join(self.dirname, "subdir")
+        self.assertFalse(os.path.exists(dirname))
+        failures = Failures(dirname)
+        failures.fail_entity("unit-xyz")
+
+        self.assertTrue(os.path.exists(dirname))
+
+    def test_fail_entity_one(self):
+        """Failures,fail_entity() writes an initial entry to disk."""
+        failures = Failures(self.dirname)
+        failures.fail_entity("unit-abc")
+        with open(failures.filename) as file:
+            data = file.read()
+
+        self.assertEqual(data, "unit-abc\n")
+
+    def test_fail_entity_multiple(self):
+        """Failures.fail_entity() correctly writes multiple entries to disk."""
+        failures = Failures(self.dirname)
+        failures.fail_entity("unit-abc")
+        failures.fail_entity("unit-xyz")
+
+        with open(failures.filename) as file:
+            data = file.read()
+        entities = set(tag for tag in data.splitlines() if tag)
+        self.assertEqual(entities, failures.entities)
+        self.assertTrue(data.endswith("\n"))
+
+    def test_clear_exists(self):
+        """Failures.clear() deletes the failures file if it exists."""
+        failures = Failures(self.dirname)
+        failures.fail_entity("unit-abc")
+        self.assertTrue(os.path.exists(failures.filename))
+        failures.clear()
+
+        self.assertFalse(os.path.exists(failures.filename))
+        self.assertEqual(failures.entities, set())
+
+    def test_clear_not_exists(self):
+        """Failures.clear() does nothing if the failures file is missing."""
+        failures = Failures(self.dirname)
+        self.assertFalse(os.path.exists(failures.filename))
+        failures.clear()
+
+        self.assertFalse(os.path.exists(failures.filename))

=== added file 'python/fakejuju/tests/test_fakejuju.py'
--- python/fakejuju/tests/test_fakejuju.py	1970-01-01 00:00:00 +0000
+++ python/fakejuju/tests/test_fakejuju.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,280 @@
+# Copyright 2016 Canonical Limited.  All rights reserved.
+
+import os
+import unittest
+
+from txjuju import _juju1, _juju2
+from txjuju._utils import Executable
+import txjuju.cli
+
+from fakejuju.failures import Failures
+from fakejuju.fakejuju import (
+    get_bootstrap_spec, get_filename, set_envvars, FakeJuju)
+
+
+class HelperTests(unittest.TestCase):
+
+    def test_get_bootstrap_spec_full(self):
+        """get_bootstrap_spec() works correctly when given all args."""
+        spec = get_bootstrap_spec("my-env", "pw")
+
+        self.assertEqual(
+            spec,
+            txjuju.cli.BootstrapSpec("my-env", "dummy", admin_secret="pw"))
+
+    def test_get_bootstrap_spec_minimal(self):
+        """get_bootstrap_spec() works correctly when given minimal args."""
+        spec = get_bootstrap_spec("my-env")
+
+        self.assertEqual(spec, txjuju.cli.BootstrapSpec("my-env", "dummy"))
+
+    def test_get_filename_full(self):
+        """get_filename() works correctly when given all args."""
+        filename = get_filename("1.25.6", "/spam")
+
+        self.assertEqual(filename, "/spam/fake-juju-1.25.6")
+
+    def test_get_filename_minimal(self):
+        """get_filename() works correctly when given minimal args."""
+        filename = get_filename("1.25.6")
+
+        self.assertEqual(filename, "/usr/bin/fake-juju-1.25.6")
+
+    def test_get_filename_empty_bindir(self):
+        """get_filename() works correctly when given an empty string
+        for bindir."""
+        filename = get_filename("1.25.6", "")
+
+        self.assertEqual(filename, "fake-juju-1.25.6")
+
+    def test_get_filename_missing_version(self):
+        """get_filename() fails if version is None or empty."""
+        with self.assertRaises(ValueError):
+            get_filename(None)
+        with self.assertRaises(ValueError):
+            get_filename("")
+
+    def test_set_envvars_full(self):
+        """set_envvars() works correctly when given all args."""
+        envvars = {}
+        set_envvars(envvars, "/spam/failures", "/eggs/logsdir")
+
+        self.assertEqual(envvars, {
+            "FAKE_JUJU_FAILURES": "/spam/failures",
+            "FAKE_JUJU_LOGS_DIR": "/eggs/logsdir",
+            })
+
+    def test_set_envvars_minimal(self):
+        """set_envvars() works correctly when given minimal args."""
+        envvars = {}
+        set_envvars(envvars)
+
+        self.assertEqual(envvars, {
+            "FAKE_JUJU_FAILURES": "",
+            "FAKE_JUJU_LOGS_DIR": "",
+            })
+
+    def test_set_envvars_start_empty(self):
+        """set_envvars() sets all values on an empty dict."""
+        envvars = {}
+        set_envvars(envvars, "x", "y")
+
+        self.assertEqual(envvars, {
+            "FAKE_JUJU_FAILURES": "x",
+            "FAKE_JUJU_LOGS_DIR": "y",
+            })
+
+    def test_set_envvars_no_collisions(self):
+        """set_envvars() sets all values when none are set yet."""
+        envvars = {"SPAM": "eggs"}
+        set_envvars(envvars, "x", "y")
+
+        self.assertEqual(envvars, {
+            "SPAM": "eggs",
+            "FAKE_JUJU_FAILURES": "x",
+            "FAKE_JUJU_LOGS_DIR": "y",
+            })
+
+    def test_set_envvars_empty_to_nonempty(self):
+        """set_envvars() updates empty values."""
+        envvars = {
+            "FAKE_JUJU_FAILURES": "",
+            "FAKE_JUJU_LOGS_DIR": "",
+            }
+        set_envvars(envvars, "x", "y")
+
+        self.assertEqual(envvars, {
+            "FAKE_JUJU_FAILURES": "x",
+            "FAKE_JUJU_LOGS_DIR": "y",
+            })
+
+    def test_set_envvars_nonempty_to_nonempty(self):
+        """set_envvars() overwrites existing values."""
+        envvars = {
+            "FAKE_JUJU_FAILURES": "spam",
+            "FAKE_JUJU_LOGS_DIR": "ham",
+            }
+        set_envvars(envvars, "x", "y")
+
+        self.assertEqual(envvars, {
+            "FAKE_JUJU_FAILURES": "x",
+            "FAKE_JUJU_LOGS_DIR": "y",
+            })
+
+    def test_set_envvars_nonempty_to_empty(self):
+        """set_envvars() with no args "unsets" existing values."""
+        envvars = {
+            "FAKE_JUJU_FAILURES": "x",
+            "FAKE_JUJU_LOGS_DIR": "y",
+            }
+        set_envvars(envvars)
+
+        self.assertEqual(envvars, {
+            "FAKE_JUJU_FAILURES": "",
+            "FAKE_JUJU_LOGS_DIR": "",
+            })
+
+
+class FakeJujuTests(unittest.TestCase):
+
+    def test_from_version_full(self):
+        """FakeJuju.from_version() works correctly when given all args."""
+        juju = FakeJuju.from_version(
+            "1.25.6", "/a/juju/home", "/logs/dir", "/failures/dir", "/bin/dir")
+
+        self.assertEqual(juju.filename, "/bin/dir/fake-juju-1.25.6")
+        self.assertEqual(juju.version, "1.25.6")
+        self.assertEqual(juju.cfgdir, "/a/juju/home")
+        self.assertEqual(juju.logsdir, "/logs/dir")
+        self.assertEqual(juju.failures.filename, "/failures/dir/juju-failures")
+
+    def test_from_version_minimal(self):
+        """FakeJuju.from_version() works correctly when given minimal args."""
+        juju = FakeJuju.from_version("1.25.6", "/my/juju/home")
+
+        self.assertEqual(juju.filename, "/usr/bin/fake-juju-1.25.6")
+        self.assertEqual(juju.version, "1.25.6")
+        self.assertEqual(juju.cfgdir, "/my/juju/home")
+        self.assertEqual(juju.logsdir, "/my/juju/home")
+        self.assertEqual(juju.failures.filename, "/my/juju/home/juju-failures")
+
+    def test_full(self):
+        """FakeJuju() works correctly when given all args."""
+        cfgdir = "/my/juju/home"
+        failures = Failures(cfgdir)
+        juju = FakeJuju("/fake-juju", "1.25.6", cfgdir, "/some/logs", failures)
+
+        self.assertEqual(juju.filename, "/fake-juju")
+        self.assertEqual(juju.version, "1.25.6")
+        self.assertEqual(juju.cfgdir, cfgdir)
+        self.assertEqual(juju.logsdir, "/some/logs")
+        self.assertIs(juju.failures, failures)
+
+    def test_minimal(self):
+        """FakeJuju() works correctly when given minimal args."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/my/juju/home")
+
+        self.assertEqual(juju.filename, "/fake-juju")
+        self.assertEqual(juju.version, "1.25.6")
+        self.assertEqual(juju.cfgdir, "/my/juju/home")
+        self.assertEqual(juju.logsdir, "/my/juju/home")
+        self.assertEqual(juju.failures.filename, "/my/juju/home/juju-failures")
+
+    def test_conversions(self):
+        """FakeJuju() converts str to unicode."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x", "/y", Failures("/..."))
+
+        self.assertIsInstance(juju.filename, unicode)
+        self.assertIsInstance(juju.version, unicode)
+        self.assertIsInstance(juju.cfgdir, unicode)
+        self.assertIsInstance(juju.logsdir, unicode)
+
+    def test_missing_filename(self):
+        """FakeJuju() fails if filename is None or empty."""
+        with self.assertRaises(ValueError):
+            FakeJuju(None, "1.25.6", "/my/juju/home")
+        with self.assertRaises(ValueError):
+            FakeJuju("", "1.25.6", "/my/juju/home")
+
+    def test_missing_version(self):
+        """FakeJuju() fails if version is None or empty."""
+        with self.assertRaises(ValueError):
+            FakeJuju("/fake-juju", None, "/my/juju/home")
+        with self.assertRaises(ValueError):
+            FakeJuju("/fake-juju", "", "/my/juju/home")
+
+    def test_missing_cfgdir(self):
+        """FakeJuju() fails if cfgdir is None or empty."""
+        with self.assertRaises(ValueError):
+            FakeJuju("/fake-juju", "1.25.6", None)
+        with self.assertRaises(ValueError):
+            FakeJuju("/fake-juju", "1.25.6", "")
+
+    def test_logfile(self):
+        """FakeJuju.logfile returns the path to the fake-juju log file."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x", "/some/logs")
+
+        self.assertEqual(juju.logfile, "/some/logs/fake-juju.log")
+
+    def test_infofile(self):
+        """FakeJuju.logfile returns the path to the fake-juju info file."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x")
+
+        self.assertEqual(juju.infofile, "/x/fakejuju")
+
+    def test_fifo(self):
+        """FakeJuju.logfile returns the path to the fake-juju fifo."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x")
+
+        self.assertEqual(juju.fifo, "/x/fifo")
+
+    def test_cacertfile(self):
+        """FakeJuju.cacertfile returns the path to the Juju API cert."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x")
+
+        self.assertEqual(juju.cacertfile, "/x/cert.ca")
+
+    def test_cli_full(self):
+        """FakeJuju.cli() works correctly when given all args."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x")
+        cli = juju.cli({"SPAM": "eggs"})
+
+        self.assertEqual(
+            cli._exe,
+            Executable("/fake-juju", {
+                "SPAM": "eggs",
+                "FAKE_JUJU_FAILURES": "/x/juju-failures",
+                "FAKE_JUJU_LOGS_DIR": "/x",
+                "JUJU_HOME": "/x",
+                }),
+            )
+
+    def test_cli_minimal(self):
+        """FakeJuju.cli() works correctly when given minimal args."""
+        juju = FakeJuju("/fake-juju", "1.25.6", "/x")
+        cli = juju.cli()
+
+        self.assertEqual(
+            cli._exe,
+            Executable("/fake-juju", dict(os.environ, **{
+                "FAKE_JUJU_FAILURES": "/x/juju-failures",
+                "FAKE_JUJU_LOGS_DIR": "/x",
+                "JUJU_HOME": "/x",
+                })),
+            )
+
+    def test_cli_juju1(self):
+        """FakeJuju.cli() works correctly for Juju 1.x."""
+        juju = FakeJuju.from_version("1.25.6", "/x")
+        cli = juju.cli()
+
+        self.assertEqual(cli._exe.envvars["JUJU_HOME"], "/x")
+        self.assertIsInstance(cli._juju, _juju1.CLIHooks)
+
+    def test_cli_juju2(self):
+        """FakeJuju.cli() works correctly for Juju 2.x."""
+        juju = FakeJuju.from_version("2.0.0", "/x")
+        cli = juju.cli()
+
+        self.assertEqual(cli._exe.envvars["JUJU_DATA"], "/x")
+        self.assertIsInstance(cli._juju, _juju2.CLIHooks)

=== added file 'python/setup.py'
--- python/setup.py	1970-01-01 00:00:00 +0000
+++ python/setup.py	2016-10-06 22:53:21 +0000
@@ -0,0 +1,69 @@
+import os
+from importlib import import_module
+try:
+    from setuptools import setup
+except ImportError:
+    from distutils.core import setup
+
+
+basedir = os.path.abspath(os.path.dirname(__file__) or '.')
+
+# required data
+
+package_name = 'fakejuju'
+NAME = package_name
+SUMMARY = 'A limited adaptation of Juju\'s client, with testing hooks.'
+AUTHOR = 'Canonical Landscape team'
+EMAIL = '[e-mail]'
+PROJECT_URL = 'https://launchpad.net/fake-juju'
+LICENSE = 'LGPLv3'
+
+with open(os.path.join(basedir, 'README.md')) as readme_file:
+    DESCRIPTION = readme_file.read()
+
+# dymanically generated data
+
+VERSION = import_module(package_name).__version__
+
+# set up packages
+
+exclude_dirs = [
+        'tests',
+        ]
+
+PACKAGES = []
+for path, dirs, files in os.walk(package_name):
+    if "__init__.py" not in files:
+        continue
+    path = path.split(os.sep)
+    if path[-1] in exclude_dirs:
+        continue
+    PACKAGES.append(".".join(path))
+
+# dependencies
+
+DEPS = ['yaml',
+        # for testing
+        'txjuju',
+        'fixtures',
+        'testtools',
+        ]
+
+
+if __name__ == "__main__":
+    setup(name=NAME,
+          version=VERSION,
+          author=AUTHOR,
+          author_email=EMAIL,
+          url=PROJECT_URL,
+          license=LICENSE,
+          description=SUMMARY,
+          long_description=DESCRIPTION,
+          packages=PACKAGES,
+
+          # for distutils
+          requires=DEPS,
+
+          # for setuptools
+          install_requires=DEPS,
+          )