Merge lp:~veebers/juju-ci-tools/adding_model_destory_test into lp:juju-ci-tools

[Christopher Lee]

Add functional test for bug: https://bugs.launchpad.net/juju-core/+bug/1582021

Add functional test for bug: https://bugs.launchpad.net/juju-core/+bug/1582021
This test was request by core devs in case of regression.

It does a couple of things against the grain of normal usage of jujupy, namely using the 'switch' command. This is due to the nature of the bug and test.

It also has a gross workaround where it uses a sleep around the creation and deletion of a model due to bug https://bugs.launchpad.net/juju-core/+bug/1613960. Perhaps there is a better way to do this?

Tests that deleting the in-focus model removes the current model and the ability to switch to a new model to set it.

[Curtis Hovey (sinzui)]

Thank you.

review: Approve (code)

Unmerged revisions

1561. By Christopher Lee on 2016-08-19

Actually use unit tests and with a fix.

1560. By Christopher Lee on 2016-08-18

Add gross workaround for bug (1613960)

1559. By Christopher Lee on 2016-08-18

Add reference to bug this test is to cover

1558. By Christopher Lee on 2016-08-18

Fix status command check

1557. By Christopher Lee on 2016-08-17

Fixed call to 'switch'.

1556. By Christopher Lee on 2016-08-17

Initial pass of simple test

=== added file 'assess_destroy_model.py'
--- assess_destroy_model.py	1970-01-01 00:00:00 +0000
+++ assess_destroy_model.py	2016-08-19 00:10:42 +0000
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+"""Test destroy model functionality.
+
+Ensures that juju is able to destroy a hosted model and that systems run as
+expected during and after a model destroy.
+
+"""
+
+from __future__ import print_function
+
+import argparse
+import logging
+import subprocess
+import sys
+import time
+
+from deploy_stack import (
+    BootstrapManager,
+)
+from utility import (
+    JujuAssertionError,
+    add_basic_testing_arguments,
+    configure_logging,
+)
+
+
+__metaclass__ = type
+
+
+log = logging.getLogger("assess_destroy_model")
+
+
+def assess_destroy_model(client):
+    """Ensure current model is stored when expected.
+
+    When deleting a model it must be unset (and thus will cause an error if
+    status without '-m' is used).
+    When unset list-models must still work.
+    'switch-ing' to another model must set current model.
+
+    Covers this bug: https://bugs.launchpad.net/juju-core/+bug/1582021
+
+    """
+    ensure_only_expected_models_exist(
+        client, ['controller', client.env.environment])
+
+    new_model = client.add_model(client.env.clone('new-model'))
+
+    ensure_only_expected_models_exist(
+        client,
+        ['controller', client.env.environment, new_model.env.environment])
+
+    # Creating and deleting a model quickly can leave that model in list-models
+    # output.
+    # as per: https://bugs.launchpad.net/juju-core/+bug/1613960
+    time.sleep(10)
+    new_model.destroy_model()
+    time.sleep(10)
+
+    ensure_only_expected_models_exist(
+        client, ['controller', client.env.environment])
+
+    ensure_no_current_model(client)
+
+    ensure_switching_models_sets_current_model(client)
+
+
+def ensure_switching_models_sets_current_model(client):
+    full_model_name = '{}:{}'.format(
+        client.env.controller.name, client.env.environment)
+    client.juju('switch', (full_model_name), include_e=False)
+    try:
+        client.juju('status', (), include_e=False)
+    except subprocess.CalledProcessError as e:
+        raise JujuAssertionError('Call to status failed: {}'.format(str(e)))
+
+
+def ensure_only_expected_models_exist(client, model_names):
+    models = client.get_models()
+    existing_models = [m['name'] for m in models['models']]
+
+    if set(existing_models).difference(set(model_names)) != set():
+        raise JujuAssertionError(
+            'Unexpected models encountered.\n'
+            'Expected: {}\nGot: {}'.format(model_names, existing_models))
+
+
+def ensure_no_current_model(client):
+    """Raise exception if there is any current model set anywhere."""
+    if '*' in client.get_juju_output('list-models', include_e=False):
+        raise JujuAssertionError('list-models shows current model set.')
+
+    current_model = client.get_models().get('current-model', None)
+    if current_model is not None:
+        raise JujuAssertionError(
+            'Current model is still set: {}'.format(current_model))
+
+    try:
+        client.juju('status', (), include_e=False, check=True)
+    except subprocess.CalledProcessError:
+        log.info('Status call failed as expected.')
+        return
+    raise JujuAssertionError('Status call did not fail as expected.')
+
+
+def parse_args(argv):
+    parser = argparse.ArgumentParser(description="Test Destroy Model.")
+    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_destroy_model(bs_manager.client)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'tests/test_assess_destroy_model.py'
--- tests/test_assess_destroy_model.py	1970-01-01 00:00:00 +0000
+++ tests/test_assess_destroy_model.py	2016-08-19 00:10:42 +0000
@@ -0,0 +1,135 @@
+"""Tests for assess_destroy_model module."""
+
+import argparse
+from mock import Mock, patch
+import StringIO
+import subprocess
+
+import assess_destroy_model as adm
+from tests import (
+    parse_error,
+    TestCase,
+)
+from utility import JujuAssertionError
+
+
+class TestParseArgs(TestCase):
+
+    def test_default_args(self):
+        args = adm.parse_args(
+            ["an-env", "/bin/juju", "/tmp/logs", "an-env-mod"])
+        self.assertEqual(
+            args,
+            argparse.Namespace(
+                env="an-env",
+                juju_bin='/bin/juju',
+                logs='/tmp/logs',
+                temp_env_name='an-env-mod',
+                debug=False,
+                agent_stream=None,
+                agent_url=None,
+                bootstrap_host=None,
+                keep_env=False,
+                machine=[],
+                region=None,
+                series=None,
+                upload_tools=False,
+                verbose=20))
+
+    def test_help(self):
+        fake_stdout = StringIO.StringIO()
+        with parse_error(self) as fake_stderr:
+            with patch("sys.stdout", fake_stdout):
+                adm.parse_args(["--help"])
+        self.assertEqual("", fake_stderr.getvalue())
+        self.assertIn("Test Destroy Model.", fake_stdout.getvalue())
+
+
+class TestEnsureSwithingModelsSetsCurrentModel(TestCase):
+
+    def test_raises_exception_on_status_failure(self):
+        client = Mock()
+        client.juju.side_effect = [
+            None,
+            subprocess.CalledProcessError(-1, None, None),
+        ]
+        with self.assertRaises(JujuAssertionError):
+            adm.ensure_switching_models_sets_current_model(client)
+
+    def test_no_exceptions_raised_on_successful_switch(self):
+        client = Mock()
+        adm.ensure_switching_models_sets_current_model(client)
+
+
+class TestEnsureNoCurrentModel(TestCase):
+
+    def test_raises_on_current_set_in_listmodels(self):
+        client = Mock()
+        client.get_juju_output.return_value = '*some-model'
+        client.get_models.return_value = {}
+
+        with self.assertRaises(JujuAssertionError) as ex:
+            adm.ensure_no_current_model(client)
+        exception_message = str(ex.exception)
+        self.assertEqual(
+            exception_message, 'list-models shows current model set.')
+
+    def test_raises_on_current_model_in_models_list(self):
+        client = Mock()
+        client.get_juju_output.return_value = ''
+        client.get_models.return_value = {'current-model': 'foo'}
+
+        with self.assertRaises(JujuAssertionError) as ex:
+            adm.ensure_no_current_model(client)
+        exception_message = str(ex.exception)
+        self.assertEqual(
+            exception_message, 'Current model is still set: foo')
+
+    def test_raises_exception_if_unexpectedly_passes(self):
+        client = Mock()
+        client.get_juju_output.return_value = ''
+        client.get_models.return_value = {}
+
+        with self.assertRaises(JujuAssertionError) as ex:
+            adm.ensure_no_current_model(client)
+        exception_message = str(ex.exception)
+        self.assertEqual(
+            exception_message, 'Status call did not fail as expected.')
+
+    def test_passes_when_status_fails(self):
+        client = Mock()
+        client.get_juju_output.return_value = ''
+        client.get_models.return_value = {}
+        client.juju.side_effect = subprocess.CalledProcessError(-1, None, None)
+
+        adm.ensure_no_current_model(client)
+
+
+class TestEnsureOnlyExpectedModelsExist(TestCase):
+
+    def test_not_raised_on_all_expected(self):
+        to_check = ['a', 'b', 'c']
+        actual_models = {
+            'models': [
+                {'name': 'a'},
+                {'name': 'b'},
+                {'name': 'c'}
+            ]}
+
+        mock_client = Mock()
+        mock_client.get_models.return_value = actual_models
+        adm.ensure_only_expected_models_exist(mock_client, to_check)
+
+    def test_raises_on_more_than_expected(self):
+        to_check = ['a', 'b']
+        actual_models = {
+            'models': [
+                {'name': 'a'},
+                {'name': 'b'},
+                {'name': 'c'}
+            ]}
+
+        mock_client = Mock()
+        mock_client.get_models.return_value = actual_models
+        with self.assertRaises(JujuAssertionError):
+            adm.ensure_only_expected_models_exist(mock_client, to_check)