Merge lp:~mskalka/juju-ci-tools/assess_add_credentials into lp:juju-ci-tools

[Michael Skalka]

Adds assess_add_credentials.

This test pulls in credential information from cloud-city then manually adds those credentials to a new temporary JUJU_HOME, verifies they were written properly, and attempts to bootstrap using those those credentials from the temp directory.

The test will fail if the credentials inputted do not match the supplied credentials, or if the client cannot bootstrap with the credentials.

Currently this test will always fail on GCE as reported by bug #1682562.

[Curtis Hovey (sinzui)]

Thank you. I have some suggestions inline to make the script run on all hosts.

review: Approve (code)

[lp:~mskalka/juju-ci-tools/assess_add_credentials]

2000. By Michael Skalka on 2017-04-17

changes as per MP comments

[Michael Skalka (mskalka)]

Made the suggested changes.

=== added file 'assess_add_credentials.py'
--- assess_add_credentials.py	1970-01-01 00:00:00 +0000
+++ assess_add_credentials.py	2017-04-17 14:06:57 +0000
@@ -0,0 +1,307 @@
+#!/usr/bin/env python
+"""Assess proper functionality of juju add-credential."""
+
+from __future__ import print_function
+
+import argparse
+import logging
+import sys
+import os
+import yaml
+import pexpect
+import shutil
+
+from deploy_stack import (
+    BootstrapManager,
+    )
+from utility import (
+    configure_logging,
+    add_basic_testing_arguments,
+    JujuAssertionError,
+    temp_dir,
+    )
+
+__metaclass__ = type
+
+
+log = logging.getLogger("assess_add_credentials")
+
+script_dir = os.path.dirname(__file__)
+cloud_city = os.path.join(script_dir, 'cloud-city')
+
+
+def assess_add_credentials(args):
+    """Tests if juju's add-credentials command works as expected.
+
+    Adds credentials from our real source to our juju client and tests if
+    that client can bootstrap.
+
+    :param client: Client object used in bootstrap check
+    :param args: Test arguments
+    """
+
+    if 'vmaas' in args.env:
+        env = 'maas'
+    elif 'gce' in args.env:
+        env = 'google'
+    else:
+        env = args.env.split('parallel-')[1]
+
+    # Grab the credentials from cloud-city
+    cred = get_credentials(env)
+
+    # Fix the keypath to reflect local username
+    key_path = cred['credentials'].get('private-key-path')
+    if key_path:
+        cred['credentials']['private-key-path'] = os.path.join(
+            cloud_city, '{}-key'.format(env))
+
+    verify_add_credentials(args, env, cred)
+    verify_credentials_match(env, cred)
+    verify_bootstrap(args)
+
+    log.info('SUCCESS')
+
+
+def verify_add_credentials(args, env, cred):
+    """Adds the supplied credential to juju with 'juju add-credential'.
+
+    :param args: Testing arguments
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    testing_variations = {
+        'aws': add_aws,
+        'google': add_gce,
+        'rackspace': add_rackspace,
+        'maas': add_maas,
+        'joyent': add_joyent,
+        'azure': add_azure
+        }
+
+    log.info("Adding {} credential from /cloud-city/credentials.yaml "
+             "into testing instance".format(args.env))
+    with pexpect.spawn('juju add-credential {}'.format(env)) as child:
+        try:
+            testing_variations[env](child, env, cred)
+        except pexpect.TIMEOUT:
+            log.error('Buffer: {}'.format(child.buffer))
+            log.error('Before: {}'.format(child.before))
+            raise Exception(
+                'Registering user failed: pexpect session timed out')
+
+
+def get_credentials(env):
+    """Gets the stored test credentials.
+
+    :return: Dict of credential information
+    """
+    with open(os.path.join(cloud_city, 'credentials.yaml')) as f:
+        creds_dict = yaml.load(f)
+    cred = creds_dict['credentials'][env]
+    return cred
+
+
+def verify_bootstrap(args):
+    """Verify the client can bootstrap with the newly added credentials
+
+    :param args: Testing arguments
+    """
+    env_file = os.path.join(
+        os.environ['HOME'], 'cloud-city', 'environments.yaml')
+    shutil.copy(env_file, os.environ['JUJU_DATA'])
+    bs_manager = BootstrapManager.from_args(args)
+    with bs_manager.booted_context(args.upload_tools):
+        log.info('Bootstrap successfull, tearing down client')
+
+
+def verify_credentials_match(env, cred):
+    """Verify the credentials entered match the stored credentials.
+
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    with open(os.path.join(os.environ['JUJU_DATA'], 'credentials.yaml')) as f:
+        test_creds = yaml.load(f)
+        test_creds = test_creds['credentials'][env][env]
+    if not test_creds == cred['credentials']:
+        error = 'Credential miss-match after manual add'
+        raise JujuAssertionError(error)
+
+
+def end_session(session):
+    """Convenience function to check a pexpect session has properly closed.
+    """
+    session.expect(pexpect.EOF)
+    session.close()
+    if session.exitstatus != 0:
+        log.error('Buffer: {}'.format(session.buffer))
+        log.error('Before: {}'.format(session.before))
+        raise Exception('pexpect process exited with {}'.format(
+                session.exitstatus))
+
+
+def add_aws(child, env, cred):
+    """Adds credentials for AWS to test client using real credentials.
+
+    :param child: pexpect.spawn object of the juju add-credential command
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    access_key = cred['credentials']['access-key']
+    secret_key = cred['credentials']['secret-key']
+
+    child.expect('Enter credential name:')
+    child.sendline(env)
+    child.expect('Enter access-key:')
+    child.sendline(access_key)
+    child.expect('Enter secret-key:')
+    child.sendline(secret_key)
+    end_session(child)
+    log.info('Added AWS credential')
+
+
+def add_gce(child, env, cred):
+    """Adds credentials for GCE to test client using real credentials.
+
+    :param child: pexpect.spawn object of the juju add-credential command
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    auth_type = cred['credentials']['auth-type']
+    project_id = cred['credentials']['project-id']
+    private_key = cred['credentials']['private-key']
+    client_email = cred['credentials']['client-email']
+    client_id = cred['credentials']['client-id']
+
+    child.expect('Enter credential name:')
+    child.sendline(env)
+    child.expect('Select auth-type:')
+    child.sendline(auth_type)
+    child.expect('Enter client-id:')
+    child.sendline(client_id)
+    child.expect('Enter client-email:')
+    child.sendline(client_email)
+    child.expect('Enter private-key:')
+    child.send(private_key)
+    child.sendline('')
+    child.expect('Enter project-id:')
+    child.sendline(project_id)
+    end_session(child)
+    log.info('Added GCE credential')
+
+
+def add_rackspace(child, env, cred):
+    """Adds credentials for Rackspace to test client using real credentials.
+
+    :param child: pexpect.spawn object of the juju add-credential command
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    username = cred['credentials']['username']
+    password = cred['credentials']['password']
+    tenant_name = cred['credentials']['tenant-name']
+
+    child.expect('Enter credential name:')
+    child.sendline(env)
+    child.expect('Enter username:')
+    child.sendline(username)
+    child.expect('Enter password:')
+    child.sendline(password)
+    child.expect('Enter tenant-name:')
+    child.sendline(tenant_name)
+    end_session(child)
+    log.info('Added Rackspace credential')
+
+
+def add_maas(child, env, cred):
+    """Adds credentials for MaaS to test client using real credentials.
+
+    :param child: pexpect.spawn object of the juju add-credential command
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    maas_oauth = cred['credentials']['maas-oauth']
+
+    child.expect('Enter credential name:')
+    child.sendline(env)
+    child.expect('Enter maas-oauth:')
+    child.sendline(maas_oauth)
+    end_session(child)
+    log.info('Added MaaS credential')
+
+
+def add_joyent(child, env, cred):
+    """Adds credentials for Joyent to test client using real credentials.
+
+    :param child: pexpect.spawn object of the juju add-credential command
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    algorithm = cred['credentials']['algorithm']
+    sdc_user = cred['credentials']['sdc-user']
+    sdc_key_id = cred['credentials']['sdc-key-id']
+    private_key_path = os.path.join(
+        os.environ['HOME'], 'cloud-city', 'joyent-key')
+
+    child.expect('Enter credential name:')
+    child.sendline(env)
+    child.expect('Enter sdc-user:')
+    child.sendline(sdc_user)
+    child.expect('Enter sdc-key-id:')
+    child.sendline(sdc_key_id)
+    child.expect('Enter private-key-path:')
+    child.sendline(private_key_path)
+    child.expect(',rsa-sha512]:')
+    child.sendline(algorithm)
+    end_session(child)
+    log.info('Added Joyent credential')
+
+
+def add_azure(child, env, cred):
+    """Adds credentials for Azure to test client using real credentials.
+
+    :param child: pexpect.spawn object of the juju add-credential command
+    :param env: String environment name
+    :param cred: Dict of credential information
+    """
+    auth_type = cred['credentials']['auth-type']
+    application_id = cred['credentials']['application-id']
+    subscription_id = cred['credentials']['subscription-id']
+    application_password = cred['credentials']['application-password']
+
+    child.expect('Enter credential name:')
+    child.sendline(env)
+    child.expect('Select auth-type:')
+    child.sendline(auth_type)
+    child.expect('Enter application-id:')
+    child.sendline(application_id)
+    child.expect('Enter subscription-id:')
+    child.sendline(subscription_id)
+    child.expect('Enter application-password:')
+    child.sendline(application_password)
+    end_session(child)
+    log.info('Added Azure credential')
+
+
+def parse_args(argv):
+    """Parse all arguments."""
+    parser = argparse.ArgumentParser(
+        description='Test if juju properly adds credentials with the '
+        'add-credential command.')
+    add_basic_testing_arguments(parser)
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+    configure_logging(args.verbose)
+    with temp_dir() as temp:
+        os.environ['JUJU_HOME'] = temp
+        os.environ['JUJU_DATA'] = temp
+        assess_add_credentials(args)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'tests/test_assess_add_credentials.py'
--- tests/test_assess_add_credentials.py	1970-01-01 00:00:00 +0000
+++ tests/test_assess_add_credentials.py	2017-04-17 14:06:57 +0000
@@ -0,0 +1,310 @@
+"""Tests for assess_destroy_model module."""
+
+import logging
+import StringIO
+import yaml
+import os
+import io
+
+from mock import (
+    Mock,
+    call,
+    patch,
+    mock_open
+    )
+from assess_add_credentials import (
+    verify_add_credentials,
+    get_credentials,
+    verify_bootstrap,
+    verify_credentials_match,
+    add_aws,
+    add_gce,
+    add_maas,
+    add_azure,
+    add_joyent,
+    add_rackspace,
+    parse_args,
+    main,
+    )
+from tests import (
+    parse_error,
+    TestCase,
+    )
+from utility import (
+    JujuAssertionError,
+    )
+
+
+dummy_test_pass = u"""
+  credentials:
+    aws:
+      aws:
+        auth-type: access-key
+        access-key: foo
+        secret-key: verysecret-key"""
+
+dummy_test_fail = u"""
+  credentials:
+    aws:
+      aws:
+        auth-type: access-key
+        access-key: bar
+        secret-key: verysecret-key"""
+
+dummy_creds = u"""
+    credentials:
+      aws:
+        credentials:
+          auth-type: access-key
+          access-key: foo
+          secret-key: verysecret-key
+      azure:
+        credentials:
+          auth-type: service-principal-secret
+          application-id: foo-bar-baz
+          application-password: somepass
+          subscription-id: someid
+      google:
+        credentials:
+          auth-type: oauth2
+          client-email: [e-mail]
+          client-id: foo.apps.googleusercontent.com
+          private-key: |
+            -----BEGIN PRIVATE KEY-----
+            somekeyfoo
+            -----END PRIVATE KEY-----
+          project-id: gothic-list-89514
+      joyent:
+        credentials:
+          auth-type: userpass
+          algorithm: rsa-sha256
+          private-key: |
+            -----BEGIN RSA PRIVATE KEY-----
+            somekeybar
+            -----END RSA PRIVATE KEY-----
+          sdc-key-id: AA:AA
+          sdc-user: dummyuser
+      maas:
+        credentials:
+          auth-type: oauth1
+          maas-oauth: EXAMPLE:DUMMY:OAUTH
+      rackspace:
+        credentials:
+          auth-type: userpass
+          password: somepass
+          tenant-name: "123456789"
+          username: userfoo
+    """
+
+dummy_loaded = yaml.load(dummy_creds)
+
+
+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"]
+        args = parse_args(argv)
+        with patch("assess_add_credentials.configure_logging",
+                   autospec=True) as mock_cl:
+            with patch("assess_add_credentials.assess_add_credentials",
+                       autospec=True) as mock_assess:
+                main(argv)
+        mock_cl.assert_called_once_with(logging.DEBUG)
+        mock_assess.assert_called_once_with(args)
+
+
+class TestAssess(TestCase):
+
+    def test_verify_add_credentials(self):
+        argv = ["an-env", "/bin/juju", "/tmp/logs", "an-env-mod", "--verbose"]
+        args = parse_args(argv)
+        cred = dummy_loaded['credentials']['aws']
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                verify_add_credentials(args, 'aws', cred)
+        self.assertEqual(
+            [call('juju add-credential aws'),
+             call().__enter__(),
+             call().__enter__().expect('Enter credential name:'),
+             call().__enter__().sendline('aws'),
+             call().__enter__().expect('Enter access-key:'),
+             call().__enter__().sendline('foo'),
+             call().__enter__().expect('Enter secret-key:'),
+             call().__enter__().sendline('verysecret-key'),
+             call().__exit__(None, None, None)],
+            mock_assess.mock_calls)
+
+    def test_get_credentials(self):
+        m = mock_open()
+        with patch('assess_add_credentials.open', m, create=True) as o:
+            o.return_value = io.StringIO(dummy_creds)
+            with patch.dict(os.environ, {'HOME': '/'}):
+                out = get_credentials('aws')
+        self.assertEqual(out, dummy_loaded['credentials']['aws'])
+
+    def test_verify_bootstrap(self):
+        argv = ["an-env", "/bin/juju", "/tmp/logs", "an-env-mod", "--verbose"]
+        client = Mock(spec=["is_jes_enabled"])
+        args = parse_args(argv)
+        with patch.dict(os.environ, {'JUJU_DATA': '/', 'HOME': '/'}):
+            with patch('shutil.copy', autospec=True, return_value=None):
+                with patch(
+                    "assess_destroy_model.BootstrapManager.booted_context",
+                        autospec=True) as mock_bc:
+                    with patch('deploy_stack.client_from_config',
+                               return_value=client) as mock_cfc:
+                        verify_bootstrap(args)
+        mock_cfc.assert_called_once_with('an-env', "/bin/juju", debug=False,
+                                         soft_deadline=None)
+        self.assertEqual(mock_bc.call_count, 1)
+
+    def test_verify_credentials_match_pass(self):
+        m = mock_open()
+        with patch('assess_add_credentials.open', m, create=True) as o:
+            o.return_value = io.StringIO(dummy_test_pass)
+            with patch.dict(os.environ, {'JUJU_DATA': '/'}):
+                verify_credentials_match(
+                    'aws', dummy_loaded['credentials']['aws'])
+
+    def test_verify_credentials_match_fail(self):
+        m = mock_open()
+        creds = dummy_loaded['credentials']['aws']
+        with patch('assess_add_credentials.open', m, create=True) as o:
+            o.return_value = io.StringIO(dummy_test_fail)
+            with patch.dict(os.environ, {'JUJU_DATA': '/'}):
+                pattern = 'Credential miss-match after manual add'
+                with self.assertRaisesRegexp(JujuAssertionError, pattern):
+                    verify_credentials_match('aws', creds)
+
+    def test_add_aws(self):
+        env = 'aws'
+        creds = dummy_loaded['credentials'][env]
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                add_aws(mock_assess, env, creds)
+        self.assertEqual(
+            [call.expect('Enter credential name:'),
+             call.sendline('aws'),
+             call.expect('Enter access-key:'),
+             call.sendline('foo'),
+             call.expect('Enter secret-key:'),
+             call.sendline('verysecret-key')],
+            mock_assess.mock_calls)
+
+    def test_add_gce(self):
+        env = 'google'
+        creds = dummy_loaded['credentials'][env]
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                add_gce(mock_assess, env, creds)
+        self.assertEqual(
+            [call.expect('Enter credential name:'),
+             call.sendline('google'),
+             call.expect('Select auth-type:'),
+             call.sendline('oauth2'),
+             call.expect('Enter client-id:'),
+             call.sendline('foo.apps.googleusercontent.com'),
+             call.expect('Enter client-email:'),
+             call.sendline('[e-mail]'),
+             call.expect('Enter private-key:'),
+             call.send('-----BEGIN PRIVATE KEY-----\n'
+                       'somekeyfoo\n-----END PRIVATE KEY-----\n'),
+             call.sendline(''),
+             call.expect('Enter project-id:'),
+             call.sendline('gothic-list-89514')],
+            mock_assess.mock_calls)
+
+    def test_add_maas(self):
+        env = 'maas'
+        creds = dummy_loaded['credentials'][env]
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                add_maas(mock_assess, env, creds)
+        self.assertEqual(
+            [call.expect('Enter credential name:'),
+             call.sendline('maas'),
+             call.expect('Enter maas-oauth:'),
+             call.sendline('EXAMPLE:DUMMY:OAUTH')],
+            mock_assess.mock_calls)
+
+    def test_add_azure(self):
+        env = 'azure'
+        creds = dummy_loaded['credentials'][env]
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                add_azure(mock_assess, env, creds)
+        self.assertEqual(
+            [call.expect('Enter credential name:'),
+             call.sendline('azure'),
+             call.expect('Select auth-type:'),
+             call.sendline('service-principal-secret'),
+             call.expect('Enter application-id:'),
+             call.sendline('foo-bar-baz'),
+             call.expect('Enter subscription-id:'),
+             call.sendline('someid'),
+             call.expect('Enter application-password:'),
+             call.sendline('somepass')],
+            mock_assess.mock_calls)
+
+    def test_add_joyent(self):
+        env = 'joyent'
+        creds = dummy_loaded['credentials'][env]
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                with patch.dict(os.environ, {'HOME': '/'}):
+                    add_joyent(mock_assess, env, creds)
+        self.assertEqual(
+            [call.expect('Enter credential name:'),
+             call.sendline('joyent'),
+             call.expect('Enter sdc-user:'),
+             call.sendline('dummyuser'),
+             call.expect('Enter sdc-key-id:'),
+             call.sendline('AA:AA'),
+             call.expect('Enter private-key-path:'),
+             call.sendline('/cloud-city/joyent-key'),
+             call.expect(',rsa-sha512]:'),
+             call.sendline('rsa-sha256')],
+            mock_assess.mock_calls)
+
+    def test_add_rackspace(self):
+        env = 'rackspace'
+        creds = dummy_loaded['credentials'][env]
+        with patch('pexpect.spawn', autospec=True) as mock_assess:
+            with patch('assess_add_credentials.end_session',
+                       return_value=None):
+                add_rackspace(mock_assess, env, creds)
+        self.assertEqual(
+            [call.expect('Enter credential name:'),
+             call.sendline('rackspace'),
+             call.expect('Enter username:'),
+             call.sendline('userfoo'),
+             call.expect('Enter password:'),
+             call.sendline('somepass'),
+             call.expect('Enter tenant-name:'),
+             call.sendline('123456789')],
+            mock_assess.mock_calls)