Merge lp:~veebers/juju-ci-tools/initial-persistent-storage-skel into lp:juju-ci-tools

[Christopher Lee]

Initial skeleton for persistent storage testing.

Initial skeleton for persistent storage testing.

First in an upcoming series of branches adding persistent storage testing.
This MP introduces some of the fundamental methods used in testing i.e. asserting token values stored on file.

As this feature hasn't fully landed the test isn't expected to pass.

This work will continue to be done by Burton with some hand-off work in the process (e.g. peer-ing initially then leading to fully handed off).

[Curtis Hovey (sinzui)]

Thank you.

review: Approve (code)

=== added file 'assess_persistent_storage.py'
--- assess_persistent_storage.py	1970-01-01 00:00:00 +0000
+++ assess_persistent_storage.py	2017-03-15 08:41:57 +0000
@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+"""Testing persistent storage function of Juju."""
+
+from __future__ import print_function
+
+import argparse
+import yaml
+import logging
+from subprocess import CalledProcessError
+import sys
+
+from deploy_stack import (
+    BootstrapManager,
+    get_random_string,
+    )
+from utility import (
+    JujuAssertionError,
+    add_basic_testing_arguments,
+    configure_logging,
+    )
+from jujucharm import local_charm_path
+
+__metaclass__ = type
+
+
+log = logging.getLogger("assess_persistent_storage")
+
+
+def assess_persistent_storage(client):
+    ensure_storage_remains_after_application_removal()
+
+
+def ensure_storage_remains_after_application_removal(client):
+    """Storage created during a deploy must persist after application removal.
+
+    Steps taken to test:
+      - Deploy the dummy storage charm
+      - Set config and ensure data is stored on storage.
+      - Remove application, taking note of the remaining storage name
+      - Re-deploy new charm using persisted storage
+      - Ensure data has remained.
+
+    :param client: ModelClient object to deploy the charm on.
+    """
+    random_token = get_random_string()
+    expected_token_values = {'single-fs-token': random_token}
+    charm_path = local_charm_path(
+        charm='dummy-storage', juju_ver=client.version)
+    client.deploy(charm_path, storage='single-fs=rootfs')
+    client.wait_for_started()
+    client.set_config('dummy-storage', {'single-fs-token': random_token})
+    client.wait_for_workloads()
+
+    assert_storage_is_intact(client, expected_results=expected_token_values)
+
+    try:
+        single_filesystem_name = get_storage_filesystems(
+            client, 'single-fs')[0]
+    except IndexError:
+        raise JujuAssertionError('Storage was not found.')
+
+    client.remove_service('dummy-storage')
+
+    # Wait for application to be removed then re-deploy with existing storage.
+
+    storage_command = '--attach-storage single-fs={}'.format(
+        single_filesystem_name)
+    client.deploy(charm_path, alias=storage_command)
+    client.wait_for_started()
+    client.wait_for_workloads()
+
+    assert_storage_is_intact(client, expected_token_values)
+
+
+def get_storage_filesystems(client, storage_name):
+    """Return storage unit names for a named storage.
+
+    :param client: ModelClient object to query.
+    :param storage_name: Name of storage unit to get filesystem names for.
+    :return: List of filesystem names
+    """
+    all_storage = yaml.safe_load(client.list_storage())['filesystems']
+    return [
+        details['storage'] for unit, details in all_storage.items()
+        if details['storage'].startswith(storage_name)]
+
+
+def assert_storage_is_intact(client, expected_results):
+    """Ensure stored tokens match the expected values in `expected_results`.
+
+    Checks the token values stored on the storage assigned to the deployed
+    dummy-storage charm.
+
+    Only matches the provided expected token values and ignores any that have
+    no values provided for them.
+
+    :param client: ModelClient object where dummy-storage application is
+      deployed
+    :param expected_results: Dict containing 'token name' -> 'expected value'
+      look up values.
+    :raises JujuAssertionError: If expected token values are not present in the
+      stored token details.
+    """
+    stored_content = get_stored_token_content(client)
+
+    for expected_name, expected_value in expected_results.iteritems():
+        try:
+            stored_value = stored_content[expected_name]
+        except KeyError:
+            raise JujuAssertionError(
+                'Expected token "{}" not found in stored results.'.format(
+                    expected_name))
+        if stored_value != expected_value:
+            raise JujuAssertionError(
+                'Token values do not match. Expected: {} got: {}'.format(
+                    expected_value, stored_value))
+
+
+def get_stored_token_content(client):
+    """Retrieve token values from file stored on the unit.
+
+    Token values are retrieved from the storage units and logged into a file on
+    the application unit.
+
+    :param client: ModelClient object to query.
+    :return: Dict containing 'token name' -> 'token value'.
+    """
+    try:
+        # TODO: Need to pass in application/unit
+        contents = client.get_juju_output(
+            'ssh', ('dummy-storage/0', 'cat', '/tmp/status'))
+    except CalledProcessError as e:
+        raise JujuAssertionError('Failed to read token file: {}'.format(e))
+
+    return {token_name: token_value for token_name, token_value in (
+        line.split(':', 1) for line in contents.splitlines() if line != '')}
+
+
+def parse_args(argv):
+    """Parse all arguments."""
+    parser = argparse.ArgumentParser(
+        description="Test for Persistent Storage 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_persistent_storage(bs_manager.client)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'tests/test_assess_persistent_storage.py'
--- tests/test_assess_persistent_storage.py	1970-01-01 00:00:00 +0000
+++ tests/test_assess_persistent_storage.py	2017-03-15 08:41:57 +0000
@@ -0,0 +1,228 @@
+"""Tests for assess_persistent_storage module."""
+
+import StringIO
+from subprocess import CalledProcessError
+from textwrap import dedent
+
+from mock import (
+    Mock,
+    patch,
+    )
+
+import assess_persistent_storage as aps
+from tests import (
+    parse_error,
+    TestCase,
+    )
+from utility import JujuAssertionError
+
+
+class TestParseArgs(TestCase):
+
+    def test_common_args(self):
+        args = aps.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):
+                aps.parse_args(["--help"])
+        self.assertEqual("", fake_stderr.getvalue())
+        self.assertNotIn("TODO", fake_stdout.getvalue())
+
+
+class TestGetStorageSystems(TestCase):
+    def test_returns_single_known_filesystem(self):
+        storage_json = dedent("""\
+        filesystems:
+            0/0:
+                provider-id: 0/1
+                storage: single-fs/1
+                attachments:
+                machines:
+                    "0":
+                    mount-point: /srv/single-fs
+                    read-only: false
+                    life: alive
+                units:
+                    dummy-storage/0:
+                    machine: "0"
+                    location: /srv/single-fs
+                    life: alive
+                pool: rootfs
+                size: 28775
+                life: alive
+                status:
+                current: attached
+                since: 14 Mar 2017 17:01:15+13:00
+        """)
+        client = Mock()
+        client.list_storage.return_value = storage_json
+
+        self.assertEqual(
+            aps.get_storage_filesystems(client, 'single-fs'),
+            ['single-fs/1'])
+
+    def test_returns_empty_list_when_none_found(self):
+        storage_json = dedent("""\
+        filesystems:
+            0/0:
+                provider-id: 0/1
+                storage: single-fs/1
+                attachments:
+                machines:
+                    "0":
+                    mount-point: /srv/single-fs
+                    read-only: false
+                    life: alive
+                units:
+                    dummy-storage/0:
+                    machine: "0"
+                    location: /srv/single-fs
+                    life: alive
+                pool: rootfs
+                size: 28775
+                life: alive
+                status:
+                current: attached
+                since: 14 Mar 2017 17:01:15+13:00
+        """)
+        client = Mock()
+        client.list_storage.return_value = storage_json
+
+        self.assertEqual(
+            aps.get_storage_filesystems(client, 'not-found'),
+            [])
+
+    def test_returns_many_for_multiple_finds(self):
+        storage_json = dedent("""\
+        filesystems:
+            "0/0":
+                provider-id: 0/1
+                storage: multi-fs/1
+                attachments:
+                machines:
+                    "0":
+                    mount-point: /srv/multi-fs
+                    read-only: false
+                    life: alive
+                units:
+                    dummy-storage/0:
+                    machine: "0"
+                    location: /srv/multi-fs
+                    life: alive
+                pool: rootfs
+                size: 28775
+                life: alive
+                status:
+                current: attached
+                since: 14 Mar 2017 17:01:15+13:00
+            0/1:
+                provider-id: 0/2
+                storage: multi-fs/2
+                attachments:
+                machines:
+                    "0":
+                    mount-point: /srv/multi-fs
+                    read-only: false
+                    life: alive
+                units:
+                    dummy-storage/0:
+                    machine: "0"
+                    location: /srv/multi-fs
+                    life: alive
+                pool: rootfs
+                size: 28775
+                life: alive
+                status:
+                current: attached
+                since: 14 Mar 2017 17:01:15+13:00
+        """)
+        client = Mock()
+        client.list_storage.return_value = storage_json
+
+        self.assertEqual(
+            aps.get_storage_filesystems(client, 'multi-fs'),
+            ['multi-fs/1', 'multi-fs/2'])
+
+
+class TestAssertStorageIsIntact(TestCase):
+
+    def test_passes_when_token_values_match(self):
+        client = Mock()
+        stored_values = {'single-fs-token': 'abc123'}
+        expected_results = {'single-fs-token': 'abc123'}
+        with patch.object(
+                aps, 'get_stored_token_content',
+                autospec=True,
+                return_value=stored_values) as m_gstc:
+            aps.assert_storage_is_intact(client, expected_results)
+            m_gstc.assert_called_once_with(client)
+
+    def test_ignores_token_values_not_supplied(self):
+        client = Mock()
+        stored_values = {
+            'single-fs-token': 'abc123',
+            'multi-fs-token/1': '00000'
+        }
+        expected_results = {'single-fs-token': 'abc123'}
+        with patch.object(
+                aps, 'get_stored_token_content',
+                autospec=True,
+                return_value=stored_values) as m_gstc:
+            aps.assert_storage_is_intact(client, expected_results)
+            m_gstc.assert_called_once_with(client)
+
+    def test_raises_when_token_values_do_not_match(self):
+        client = Mock()
+        stored_values = {'single-fs-token': 'abc123x'}
+        expected_results = {'single-fs-token': 'abc123'}
+        with patch.object(
+                aps, 'get_stored_token_content',
+                autospec=True,
+                return_value=stored_values):
+            with self.assertRaises(JujuAssertionError):
+                aps.assert_storage_is_intact(client, expected_results)
+
+
+class TestGetStoredTokenContent(TestCase):
+
+    def test_raises_if_token_file_not_present(self):
+        client = Mock()
+        client.get_juju_output.side_effect = CalledProcessError(-1, None, '')
+        with self.assertRaises(JujuAssertionError):
+            aps.get_stored_token_content(client)
+
+    def test_returns_dict_containing_all_values_when_single_value(self):
+        token_file_contents = dedent("""\
+
+        single-fs-token:Blocked: not set
+        """)
+        client = Mock()
+        client.get_juju_output.return_value = token_file_contents
+
+        self.assertEqual(
+            aps.get_stored_token_content(client),
+            {'single-fs-token': 'Blocked: not set'})
+
+    def test_returns_dict_containing_all_values_when_many_values(self):
+        token_file_contents = dedent("""\
+
+        single-fs-token:Blocked: not set
+        multi-fs-token/2:abc123
+        """)
+        client = Mock()
+        client.get_juju_output.return_value = token_file_contents
+
+        self.assertEqual(
+            aps.get_stored_token_content(client),
+            {
+                'single-fs-token': 'Blocked: not set',
+                'multi-fs-token/2': 'abc123'
+            })