Merge lp:~sseman/juju-ci-tools/multi-series-charm-2 into lp:juju-ci-tools

[Seman]

This branch adds tests for multi series charm.

Charms have the capability to declare that they support more than
one series. Previously a separate copy of the charm was required for
each series. Supported series are added to charm metadata as follows:

    name: mycharm
    summary: "Great software"
    description: It works
    series:
       - trusty
       - precise
       - wily

The default series is the first in the list:

    juju deploy mycharm

should deploy a mycharm service running on trusty.

A different, non-default series may be specified:

    juju deploy mycharm --series precise

It is possible to force the charm to deploy using an unsupported series
(so long as the underlying OS is compatible):

    juju deploy mycharm --series xenial --force

[Aaron Bentley (abentley)]

Very nice.

review: Approve

[lp:~sseman/juju-ci-tools/multi-series-charm-2]

1360. By Seman on 2016-04-15

Minor reformatting.

=== modified file 'assess_heterogeneous_control.py'
--- assess_heterogeneous_control.py	2016-04-09 06:17:50 +0000
+++ assess_heterogeneous_control.py	2016-04-15 17:05:32 +0000
@@ -203,13 +203,16 @@
         raise AssertionError('Machine not destroyed: {}.'.format(agent_id))
 
 
-def check_series(client):
+def check_series(client,  machine='0', series=None):
     """Use 'juju ssh' to check that the deployed series meets expectations."""
-    result = client.get_juju_output('ssh', '0', 'lsb_release', '-c')
+    result = client.get_juju_output('ssh', machine, 'lsb_release', '-c')
     label, codename = result.rstrip().split('\t')
     if label != 'Codename:':
         raise AssertionError()
-    expected_codename = client.env.config['default-series']
+    if series:
+        expected_codename = series
+    else:
+        expected_codename = client.env.config['default-series']
     if codename != expected_codename:
         raise AssertionError(
             'Series is {}, not {}'.format(codename, expected_codename))

=== added file 'assess_multi_series_charms.py'
--- assess_multi_series_charms.py	1970-01-01 00:00:00 +0000
+++ assess_multi_series_charms.py	2016-04-15 17:05:32 +0000
@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+"""
+Charms have the capability to declare that they support more than
+one series. Previously a separate copy of the charm was required for
+each series. An important constraint here is that for a given charm,
+all of the  listed series must be for the same distro/OS; it is not
+allowed to offer a  single charm for Ubuntu and CentOS for example.
+Supported series are added to charm metadata as follows:
+
+    name: mycharm
+    summary: "Great software"
+    description: It works
+    series:
+       - trusty
+       - precise
+       - wily
+
+The default series is the first in the list:
+
+    juju deploy mycharm
+
+should deploy a mycharm service running on trusty.
+
+A different, non-default series may be specified:
+
+    juju deploy mycharm --series precise
+
+It is possible to force the charm to deploy using an unsupported series
+(so long as the underlying OS is compatible):
+
+    juju deploy mycharm --series xenial --force
+
+"""
+from __future__ import print_function
+
+import argparse
+from collections import namedtuple
+import logging
+import subprocess
+import sys
+
+from deploy_stack import BootstrapManager
+from utility import (
+    add_basic_testing_arguments,
+    configure_logging,
+    make_charm,
+    temp_dir,
+)
+from assess_heterogeneous_control import check_series
+from assess_min_version import JujuAssertionError
+
+
+__metaclass__ = type
+
+log = logging.getLogger("assess_multi_series_charms")
+
+
+Test = namedtuple("Test", ["series", "service", "force", "success", "machine"])
+
+
+def assess_multi_series_charms(client):
+    """Assess multi series charms.
+
+    :param client: Juju client.
+    :type client: jujupy.EnvJujuClient
+    :return: None
+    """
+    tests = [
+        Test(series="precise", service='test0', force=False, success=False,
+             machine=None),
+        Test(series=None, service='test1', force=False, success=True,
+             machine='0'),
+        Test(series="trusty", service='test2', force=False, success=True,
+             machine='1'),
+        Test(series="xenial", service='test3', force=False, success=True,
+             machine='2'),
+        Test(series="precise", service='test4', force=True, success=True,
+             machine='3'),
+    ]
+    with temp_dir() as charm_dir:
+        make_charm(charm_dir, series=['trusty', 'xenial'])
+        for test in tests:
+            log.info(
+                "Assessing multi series charms: test: {} charm_dir:{}".format(
+                    test, charm_dir))
+            assert_deploy(client, test, charm_dir)
+            if test.machine:
+                check_series(client, machine=test.machine, series=test.series)
+
+
+def assert_deploy(client, test, charm_dir):
+    """Deploy a charm and assert a success or fail.
+
+    :param client: Juju client
+    :type client: jujupy.EnvJujuClient
+    :param test: Deploy test data.
+    :type  test: Test
+    :param charm_dir:
+    :type charm_dir: str
+    :return: None
+    """
+    if test.success:
+        client.deploy(charm=charm_dir, series=test.series,
+                      service=test.service, force=test.force)
+        client.wait_for_started()
+    else:
+        try:
+            client.deploy(charm=charm_dir, series=test.series,
+                          service=test.service, force=test.force)
+        except subprocess.CalledProcessError:
+            return
+        raise JujuAssertionError('Assert deploy failed for {}'.format(test))
+
+
+def parse_args(argv):
+    """Parse all arguments."""
+    parser = argparse.ArgumentParser(
+        description="Test multi series charm feature")
+    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_multi_series_charms(bs_manager.client)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

=== modified file 'tests/test_assess_heterogeneous_control.py'
--- tests/test_assess_heterogeneous_control.py	2016-04-09 06:17:50 +0000
+++ tests/test_assess_heterogeneous_control.py	2016-04-15 17:05:32 +0000
@@ -9,6 +9,7 @@
 
 from assess_heterogeneous_control import (
     assess_heterogeneous,
+    check_series,
     get_clients,
     parse_args,
     test_control_heterogeneous,
@@ -149,3 +150,28 @@
         test_control_heterogeneous(bs_manager, other_client, True)
         self.assertEqual(initial_client.env.juju_home,
                          other_client.env.juju_home)
+
+
+class TestCheckSeries(TestCase):
+
+    def test_check_series(self):
+        client = FakeJujuClient()
+        check_series(client)
+
+    def test_check_series_xenial(self):
+        client = MagicMock(spec=["get_juju_output"])
+        client.get_juju_output.return_value = "Codename:	xenial"
+        check_series(client, 1, 'xenial')
+
+    def test_check_series_calls(self):
+        client = MagicMock(spec=["get_juju_output"])
+        with patch.object(client, 'get_juju_output',
+                          return_value="Codename:	xenial") as gjo_mock:
+            check_series(client, 2, 'xenial')
+        gjo_mock.assert_called_once_with('ssh', 2, 'lsb_release', '-c')
+
+    def test_check_series_exceptionl(self):
+        client = FakeJujuClient()
+        with self.assertRaisesRegexp(
+                AssertionError, 'Series is angsty, not xenial'):
+            check_series(client, '0', 'xenial')

=== added file 'tests/test_assess_multi_series_charms.py'
--- tests/test_assess_multi_series_charms.py	1970-01-01 00:00:00 +0000
+++ tests/test_assess_multi_series_charms.py	2016-04-15 17:05:32 +0000
@@ -0,0 +1,140 @@
+"""Tests for assess_multi_series_charms module."""
+
+import logging
+from mock import (
+    call,
+    Mock,
+    patch,
+)
+import StringIO
+import subprocess
+
+from assess_min_version import JujuAssertionError
+from assess_multi_series_charms import (
+    assert_deploy,
+    assess_multi_series_charms,
+    parse_args,
+    main,
+    Test,
+)
+from tests import (
+    parse_error,
+    TestCase,
+)
+from utility import temp_dir
+
+
+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_multi_series_charms.configure_logging",
+                   autospec=True) as mock_cl:
+            with patch("assess_multi_series_charms.BootstrapManager."
+                       "booted_context",
+                       autospec=True) as mock_bc:
+                with patch("jujupy.SimpleEnvironment.from_config",
+                           return_value=env) as mock_e:
+                    with patch("jujupy.EnvJujuClient.by_version",
+                               return_value=client) as mock_c:
+                        with patch("assess_multi_series_charms."
+                                   "assess_multi_series_charms",
+                                   autospec=True) as mock_assess:
+                            main(argv)
+        mock_cl.assert_called_once_with(logging.DEBUG)
+        mock_e.assert_called_once_with("an-env")
+        mock_c.assert_called_once_with(env, "/bin/juju", debug=False)
+        self.assertEqual(mock_bc.call_count, 1)
+        mock_assess.assert_called_once_with(client)
+
+
+class TestAssess(TestCase):
+
+    def test_assess_multi_series_charms(self):
+        mock_client = Mock(
+            spec=["deploy", "get_juju_output", "wait_for_started"])
+        mock_client.get_juju_output.return_value = "Codename:	trusty"
+        mock_client.deploy.side_effect = [
+            subprocess.CalledProcessError(None, None),
+            None,
+            None,
+            None,
+            None
+        ]
+        with temp_dir() as charm_dir:
+            with patch('assess_multi_series_charms.temp_dir',
+                       autospec=True) as td_mock:
+                td_mock.return_value.__enter__.return_value = charm_dir
+                with patch('assess_multi_series_charms.check_series',
+                           autospec=True) as cs_mock:
+                    assess_multi_series_charms(mock_client)
+        self.assertEqual(mock_client.wait_for_started.call_count, 4)
+        calls = [
+            call(charm=charm_dir, force=False, series='precise',
+                 service='test0'),
+            call(charm=charm_dir, force=False, series=None, service='test1'),
+            call(charm=charm_dir, force=False, series='trusty',
+                 service='test2'),
+            call(charm=charm_dir, force=False, series='xenial',
+                 service='test3'),
+            call(charm=charm_dir, force=True, series='precise',
+                 service='test4')
+        ]
+        self.assertEqual(mock_client.deploy.mock_calls, calls)
+        td_mock.assert_called_once_with()
+        cs_calls = [
+            call(mock_client, machine='0', series=None),
+            call(mock_client, machine='1', series='trusty'),
+            call(mock_client, machine='2', series='xenial'),
+            call(mock_client, machine='3', series='precise')]
+        self.assertEqual(cs_mock.mock_calls, cs_calls)
+
+    def test_assert_deploy(self):
+        test = Test(series='trusty', service='test1', force=False,
+                    success=True, machine='0')
+        mock_client = Mock(
+            spec=["deploy", "get_juju_output", "wait_for_started"])
+        assert_deploy(mock_client, test, '/tmp/foo')
+        mock_client.deploy.assert_called_once_with(
+            charm='/tmp/foo', force=False, series='trusty', service='test1')
+
+    def test_assert_deploy_success_false(self):
+        test = Test(series='trusty', service='test1', force=False,
+                    success=False, machine='0')
+        mock_client = Mock(
+            spec=["deploy", "get_juju_output", "wait_for_started"])
+        mock_client.deploy.side_effect = subprocess.CalledProcessError(
+            None, None)
+        assert_deploy(mock_client, test, '/tmp/foo')
+        mock_client.deploy.assert_called_once_with(
+            charm='/tmp/foo', force=False, series='trusty', service='test1')
+
+    def test_assert_deploy_success_false_raises_exception(self):
+        test = Test(series='trusty', service='test1', force=False,
+                    success=False, machine='0')
+        mock_client = Mock(
+            spec=["deploy", "get_juju_output", "wait_for_started"])
+        with self.assertRaisesRegexp(
+                JujuAssertionError, 'Assert deploy failed for'):
+            assert_deploy(mock_client, test, '/tmp/foo')
+        mock_client.deploy.assert_called_once_with(
+            charm='/tmp/foo', force=False, series='trusty', service='test1')

=== modified file 'utility.py'
--- utility.py	2016-04-13 22:22:47 +0000
+++ utility.py	2016-04-15 17:05:32 +0000
@@ -476,6 +476,7 @@
     content['min-juju-version'] = min_ver
     content['summary'] = summary
     content['description'] = description
-    content['series'] = [series] if isinstance(series, str) else series
+    if series is not None:
+        content['series'] = [series] if isinstance(series, str) else series
     with open(metadata, 'w') as f:
         yaml.safe_dump(content, f, default_flow_style=False)