Merge lp:~nskaggs/juju-ci-tools/add-assess-terms into lp:juju-ci-tools

[Nicholas Skaggs]

This implements a basic test for various charm types that contain metrics, terms and plans

Unmerged revisions

1934. By Nicholas Skaggs on 2017-03-22

working PoC

1933. By Nicholas Skaggs on 2017-03-22

update deploy

1932. By Nicholas Skaggs on 2017-03-10

fix repo

1931. By Nicholas Skaggs on 2017-03-10

fix location

1930. By Nicholas Skaggs on 2017-03-10

Create assess terms

=== added file 'assess_terms.py'
--- assess_terms.py	1970-01-01 00:00:00 +0000
+++ assess_terms.py	2017-03-29 15:30:53 +0000
@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+"""
+This test will test a suite of charms that require combinations of terms,
+metrics, and commerical features.
+
+"""
+from __future__ import print_function
+
+import argparse
+from collections import namedtuple
+import logging
+import subprocess
+import sys
+
+from deploy_stack import BootstrapManager
+from jujucharm import (
+    local_charm_path,
+)
+from utility import (
+    add_basic_testing_arguments,
+    configure_logging,
+    JujuAssertionError,
+)
+
+__metaclass__ = type
+
+log = logging.getLogger("assess_terms")
+
+
+Test = namedtuple("Test", ["charm_name", "series", "success"])
+
+
+def assess_terms(client):
+    """Assess charm combinations
+
+    :param client: Juju client.
+    :type client: jujupy.ModelClient
+    :return: None
+    """
+    tests = [
+        Test(charm_name="canonical-terms-example",
+             series="xenial", success=False),
+    ]
+    for test in tests:
+        test_charm = local_charm_path(
+            charm=test.charm_name, juju_ver=client.version, series=test.series)
+        log.info(
+            "Assessing charm: test: {} charm_dir:{}".format(
+                test, charm_path))
+        assert_deploy(client, test, test_charm)
+
+
+def assert_deploy(client, test, test_charm):
+    """Deploy a charm and assert a success or fail.
+
+    :param client: Juju client
+    :type client: jujupy.ModelClient
+    :param test: Deploy test data.
+    :type  test: Test
+    :param charm_dir:
+    :type charm_dir: str
+    :return: None
+    """
+    if test.success:
+        client.deploy(charm=test_charm, series=test.series)
+        client.wait_for_started()
+    else:
+        try:
+            client.deploy(charm=test_charm, series=test.series)
+        except subprocess.CalledProcessError:
+            return
+        raise JujuAssertionError('Assert deploy failed for {}'.format(test))
+
+
+def parse_args(argv):
+    """Parse all arguments."""
+    parser = argparse.ArgumentParser(
+        description=("Test charms with combinations of terms, "
+                     "plans and commercial support"))
+    add_basic_testing_arguments(parser)
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+    configure_logging(args.verbose)
+    bs_manager = BootstrapManager.from_args(args)
+    with bs_manager.booted_context(args.upload_tools):
+        assess_terms(bs_manager.client)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'tests/test_assess_terms.py'
--- tests/test_assess_terms.py	1970-01-01 00:00:00 +0000
+++ tests/test_assess_terms.py	2017-03-29 15:30:53 +0000
@@ -0,0 +1,79 @@
+"""Tests for assess_terms module."""
+
+import logging
+import StringIO
+
+from mock import (
+    Mock,
+    patch,
+    )
+
+from assess_terms import (
+    assess_terms,
+    parse_args,
+    main,
+    )
+from fakejuju import fake_juju_client
+from tests import (
+    parse_error,
+    TestCase,
+    )
+
+
+class TestParseArgs(TestCase):
+
+    def test_common_args(self):
+        args = parse_args(["an-env", "/bin/juju", "/tmp/logs", "an-env-mod"])
+        self.assertEqual("an-env", args.env)
+        self.assertEqual("/bin/juju", args.juju_bin)
+        self.assertEqual("/tmp/logs", args.logs)
+        self.assertEqual("an-env-mod", args.temp_env_name)
+        self.assertEqual(False, args.debug)
+
+    def test_help(self):
+        fake_stdout = StringIO.StringIO()
+        with parse_error(self) as fake_stderr:
+            with patch("sys.stdout", fake_stdout):
+                parse_args(["--help"])
+        self.assertEqual("", fake_stderr.getvalue())
+        self.assertNotIn("TODO", fake_stdout.getvalue())
+
+
+class TestMain(TestCase):
+
+    def test_main(self):
+        argv = ["an-env", "/bin/juju", "/tmp/logs", "an-env-mod", "--verbose"]
+        env = object()
+        client = Mock(spec=["is_jes_enabled"])
+        with patch("assess_terms.configure_logging",
+                   autospec=True) as mock_cl:
+            with patch("assess_terms.BootstrapManager.booted_context",
+                       autospec=True) as mock_bc:
+                with patch('deploy_stack.client_from_config',
+                           return_value=client) as mock_cfc:
+                    with patch("assess_terms.assess_terms",
+                               autospec=True) as mock_assess:
+                        main(argv)
+        mock_cl.assert_called_once_with(logging.DEBUG)
+        mock_cfc.assert_called_once_with('an-env', "/bin/juju", debug=False,
+                                         soft_deadline=None)
+        self.assertEqual(mock_bc.call_count, 1)
+        mock_assess.assert_called_once_with(client)
+
+
+class TestAssess(TestCase):
+
+    def test_terms(self):
+        # Using fake_client means that deploy and get_status have plausible
+        # results.  Wrapping it in a Mock causes every call to be recorded, and
+        # allows assertions to be made about calls.  Mocks and the fake client
+        # can also be used separately.
+        fake_client = Mock(wraps=fake_juju_client())
+        fake_client.bootstrap()
+        assess_terms(fake_client)
+        fake_client.deploy.assert_called_once_with(
+            'local:trusty/my-charm')
+        fake_client.wait_for_started.assert_called_once_with()
+        self.assertEqual(
+            1, fake_client.get_status().get_service_unit_count('my-charm'))
+        self.assertNotIn("TODO", self.log_stream.getvalue())