Merge lp:~jason-hobbs/charms/trusty/odl-controller/add-unit-tests into lp:~sdn-charmers/charms/trusty/odl-controller/trunk

[Jason Hobbs]

Add unit tests for the maven settings template generator.

Just a start on unit tests for odl controller, along with a minor refactor on one of the methods being tested. I copied test_utils.py from the nova-compute charm.

Unmerged revisions

9. By Jason Hobbs on 2015-07-02

Add some docstrings.

8. By Jason Hobbs on 2015-07-02

One more unit test for no_proxy.

7. By Jason Hobbs on 2015-07-02

Finish adding unit tests for odl_controller_utils.

6. By Jason Hobbs on 2015-06-30

Continue adding unit tests.

5. By Jason Hobbs on 2015-06-30

Add first unit test for ODL utils.

4. By Jason Hobbs on 2015-06-30

Use early return from mvn_proxy_ctx().

=== modified file 'hooks/odl_controller_utils.py'
--- hooks/odl_controller_utils.py	2015-02-19 22:08:13 +0000
+++ hooks/odl_controller_utils.py	2015-07-02 21:50:28 +0000
@@ -9,29 +9,37 @@
     ctx.update(mvn_proxy_ctx("https"))
     return ctx
 
+
 def mvn_proxy_ctx(protocol):
     ctx = {}
     key = protocol + "_proxy"
-    if key in environ:
-        url = urlparse.urlparse(environ[key])
-        hostname = url.hostname
-        if hostname:
-            ctx[key] = True
-            ctx[protocol + "_proxy_host"] = hostname
-            port = url.port
-            ctx[protocol + "_proxy_port"] = port if port else 80
-            username = url.username
-            if username:
-                ctx[protocol + "_proxy_username"] = username
-                ctx[protocol + "_proxy_password"] = url.password
-            no_proxy = []
-            if "no_proxy" in environ:
-                np = environ["no_proxy"]
-                if np:
-                    no_proxy = np.split(",")
-            ctx[protocol + "_noproxy"] = no_proxy
+    if key not in environ:
+        return ctx
+
+    url = urlparse.urlparse(environ[key])
+    hostname = url.hostname
+
+    if not hostname:
+        return ctx
+
+    ctx[key] = True
+    ctx[protocol + "_proxy_host"] = hostname
+    port = url.port
+    ctx[protocol + "_proxy_port"] = port if port else 80
+    username = url.username
+    if username:
+        ctx[protocol + "_proxy_username"] = username
+        ctx[protocol + "_proxy_password"] = url.password
+    no_proxy = []
+    if "no_proxy" in environ:
+        np = environ["no_proxy"]
+        if np:
+            no_proxy = np.split(",")
+    ctx[protocol + "_noproxy"] = no_proxy
+
     return ctx
 
+
 def write_mvn_config():
     ctx = mvn_ctx()
     render("settings.xml", "/home/opendaylight/.m2/settings.xml", ctx,
 
=== added directory 'unit_tests'
=== added file 'unit_tests/__init__.py'
--- unit_tests/__init__.py	1970-01-01 00:00:00 +0000
+++ unit_tests/__init__.py	2015-07-02 21:50:28 +0000
@@ -0,0 +1,3 @@
+import sys
+
+sys.path.append('hooks/')
 
=== added file 'unit_tests/test_odl_controller_utils.py'
--- unit_tests/test_odl_controller_utils.py	1970-01-01 00:00:00 +0000
+++ unit_tests/test_odl_controller_utils.py	2015-07-02 21:50:28 +0000
@@ -0,0 +1,125 @@
+import odl_controller_utils as utils
+import xml.etree.ElementTree as ET
+
+from mock import patch
+
+from test_utils import (
+    CharmTestCase,
+    patch_open,
+    )
+
+
+class TestWriteMvnConfig(CharmTestCase):
+    """Unit tests for utils.write_mvn_config().
+    
+    These tests all follow the pattern of mocking environ
+    to manipulate the http_proxy variables write_mvn_config()
+    uses to determine what variables will be supplied when
+    rendering the settings.xml template.
+    """
+
+    def setUp(self):
+        super(TestMvnProxyCtx, self).setUp(utils, [])
+
+    @patch('charmhelpers.core.host.mkdir')
+    @patch('charmhelpers.core.host.write_file')
+    @patch('charmhelpers.core.hookenv.charm_dir')
+    def get_rendered_settings(self, charm_dir, write_file, mkdir):
+        """Call write_mvn_config() to generate XML settings.
+
+        Uses mocks in the right places to prevent interaction with the
+        filesystem and to intercept the write to settings.xml.
+
+        This returns the root element of the XML as a lxml.etree.Element.
+        """
+        charm_dir.return_value = '.'
+        result = utils.write_mvn_config()
+        first_call = write_file.call_args[0]
+        path = first_call[0]
+        self.assertEqual(
+            '/home/opendaylight/.m2/settings.xml',
+            path)
+        contents = first_call[1]
+        root = ET.fromstring(contents)
+        return root
+
+    @patch.dict(utils.environ, {})
+    def test_proxies_empty_if_proxy_not_provided(self):
+        root = self.get_rendered_settings()
+        self.assertEqual([], root.findall('./proxies//*'))
+
+    @patch.dict(utils.environ, {'http_proxy': '-'})
+    def test_proxies_empty_if_hostname_not_in_url(self):
+        root = self.get_rendered_settings()
+        self.assertEqual([], root.findall('./proxies//*'))
+
+    def assertExpectedProxySettings(self, proxy, protocol, overrides=None):
+        """Assert that a 'proxy' element contains the expected settings.
+        
+        protocol -- settings vary based on protocol, which can be either 'http'
+        or 'https'.
+
+        overrides -- a dictionary providing additional settings to verify,
+        or overriding the default settings (see below for default settings).
+        """
+        self.assertIsNotNone(proxy)
+
+        expected_values = {
+            'id': "%s_proxy" % protocol,
+            'active': 'true',
+            'protocol': protocol,
+            'host': 'url.com',
+            'port': '80',
+            'nonProxyHosts': None,
+        }
+
+        if overrides is not None:
+            for key, value in overrides.iteritems():
+                expected_values[key] = value
+
+        for key, value in expected_values.iteritems():
+            element = proxy.find(key)
+            self.assertIsNotNone(element)
+            self.assertEqual(value, element.text)
+
+    @patch.dict(utils.environ, {'http_proxy': 'http://url.com/'})
+    def test_http_proxy_specified(self):
+        root = self.get_rendered_settings()
+        proxy = root.find('.//proxies/proxy')
+        self.assertExpectedProxySettings(proxy, 'http')
+
+    @patch.dict(utils.environ, {'https_proxy': 'http://url.com/'})
+    def test_https_proxy_specified(self):
+        root = self.get_rendered_settings()
+        proxy = root.find('.//proxies/proxy')
+        self.assertExpectedProxySettings(proxy, 'https')
+
+    @patch.dict(utils.environ,
+        {'http_proxy': 'http://url.com/', 'https_proxy': 'http://url.com/'})
+    def test_http_and_https_proxy_specified(self):
+        root = self.get_rendered_settings()
+        http_proxy, https_proxy = root.findall('.//proxies/proxy')
+        self.assertExpectedProxySettings(http_proxy, 'http')
+        self.assertExpectedProxySettings(https_proxy, 'https')
+
+    @patch.dict(utils.environ, {'http_proxy': 'http://url.com:8491/'})
+    def test_uses_provided_port(self):
+        root = self.get_rendered_settings()
+        proxy = root.find('.//proxies/proxy')
+        self.assertExpectedProxySettings(proxy, 'http', {'port': '8491'})
+
+    @patch.dict(utils.environ, {'http_proxy': 'http://u:[e-mail]/'})
+    def test_uses_username_and_password(self):
+        root = self.get_rendered_settings()
+        proxy = root.find('.//proxies/proxy')
+        overrides = {'username': 'u', 'password': 'p'}
+        self.assertExpectedProxySettings(proxy, 'http', overrides)
+
+    @patch.dict(
+        utils.environ,
+        {'http_proxy': 'http://url.com/', 'no_proxy': 'host1,host2'})
+    def test_uses_no_proxy(self):
+        root = self.get_rendered_settings()
+        proxy = root.find('.//proxies/proxy')
+        self.assertExpectedProxySettings(
+            proxy, 'http', {'nonProxyHosts': 'host1|host2'})
 
=== added file 'unit_tests/test_utils.py'
--- unit_tests/test_utils.py	1970-01-01 00:00:00 +0000
+++ unit_tests/test_utils.py	2015-07-02 21:50:28 +0000
@@ -0,0 +1,121 @@
+import logging
+import unittest
+import os
+import yaml
+
+from contextlib import contextmanager
+from mock import patch, MagicMock
+
+
+def load_config():
+    '''
+    Walk backwords from __file__ looking for config.yaml, load and return the
+    'options' section'
+    '''
+    config = None
+    f = __file__
+    while config is None:
+        d = os.path.dirname(f)
+        if os.path.isfile(os.path.join(d, 'config.yaml')):
+            config = os.path.join(d, 'config.yaml')
+            break
+        f = d
+
+    if not config:
+        logging.error('Could not find config.yaml in any parent directory '
+                      'of %s. ' % file)
+        raise Exception
+
+    return yaml.safe_load(open(config).read())['options']
+
+
+def get_default_config():
+    '''
+    Load default charm config from config.yaml return as a dict.
+    If no default is set in config.yaml, its value is None.
+    '''
+    default_config = {}
+    config = load_config()
+    for k, v in config.iteritems():
+        if 'default' in v:
+            default_config[k] = v['default']
+        else:
+            default_config[k] = None
+    return default_config
+
+
+class CharmTestCase(unittest.TestCase):
+
+    def setUp(self, obj, patches):
+        super(CharmTestCase, self).setUp()
+        self.patches = patches
+        self.obj = obj
+        self.test_config = TestConfig()
+        self.test_relation = TestRelation()
+        self.patch_all()
+
+    def patch(self, method):
+        _m = patch.object(self.obj, method)
+        mock = _m.start()
+        self.addCleanup(_m.stop)
+        return mock
+
+    def patch_all(self):
+        for method in self.patches:
+            setattr(self, method, self.patch(method))
+
+
+class TestConfig(object):
+
+    def __init__(self):
+        self.config = get_default_config()
+
+    def get(self, attr=None):
+        if not attr:
+            return self.get_all()
+        try:
+            return self.config[attr]
+        except KeyError:
+            return None
+
+    def get_all(self):
+        return self.config
+
+    def set(self, attr, value):
+            if attr not in self.config:
+                raise KeyError
+            self.config[attr] = value
+
+
+class TestRelation(object):
+
+    def __init__(self, relation_data={}):
+        self.relation_data = relation_data
+
+    def set(self, relation_data):
+        self.relation_data = relation_data
+
+    def get(self, attr=None, unit=None, rid=None):
+        if attr is None:
+            return self.relation_data
+        elif attr in self.relation_data:
+            return self.relation_data[attr]
+        return None
+
+
+@contextmanager
+def patch_open():
+    '''Patch open() to allow mocking both open() itself and the file that is
+    yielded.
+
+    Yields the mock for "open" and "file", respectively.'''
+    mock_open = MagicMock(spec=open)
+    mock_file = MagicMock(spec=file)
+
+    @contextmanager
+    def stub_open(*args, **kwargs):
+        mock_open(*args, **kwargs)
+        yield mock_file
+
+    with patch('__builtin__.open', stub_open):
+        yield mock_open, mock_file