Merge lp:~billy-olsen/charms/trusty/mongodb/sample-unittest into lp:~mariosplivalo/charms/trusty/mongodb/replsets-fix-try

[Billy Olsen]

Sample test case for testing one branch of the replicaset-relation-joined hook.

Includes comments for clarity (hopefully).

[Mario Splivalo (mariosplivalo)]

review: Approve

=== added file 'setup.cfg'
--- setup.cfg	1970-01-01 00:00:00 +0000
+++ setup.cfg	2014-12-13 00:22:04 +0000
@@ -0,0 +1,6 @@
+[nosetests]
+verbosity=2
+with-coverage=1
+cover-erase=1
+cover-package=hooks
+

=== added file 'unit_tests/__init__.py'
--- unit_tests/__init__.py	1970-01-01 00:00:00 +0000
+++ unit_tests/__init__.py	2014-12-13 00:22:04 +0000
@@ -0,0 +1,2 @@
+import sys
+sys.path.append('hooks')

=== added file 'unit_tests/test_hooks.py'
--- unit_tests/test_hooks.py	1970-01-01 00:00:00 +0000
+++ unit_tests/test_hooks.py	2014-12-13 00:22:04 +0000
@@ -0,0 +1,69 @@
+from mock import patch
+
+import hooks
+
+from test_utils import CharmTestCase
+
+# Defines a set of functions to patch on the hooks object. Any of these
+# methods will be patched by default on the default invocations of the
+# hooks.some_func(). Invoking the the interface change relations will cause
+# the hooks context to be created outside of the normal mockery.
+TO_PATCH = [
+    'relation_id',
+    'relation_get',
+    'relation_set',
+    'unit_get',
+    'juju_log',
+    'config',
+]
+
+
+class MongoHooksTest(CharmTestCase):
+
+    def setUp(self):
+        super(MongoHooksTest, self).setUp(hooks, TO_PATCH)
+
+        # The self.config object can be used for direct invocations of the
+        # hooks methods. The side_effect of invoking the config object within
+        # the hooks object will return the value that is set in the test case's
+        # test_config dictionary
+        self.config.side_effect = self.test_config.get
+
+    # Note: if we need to mock a specific class of an object, we need to
+    # invoke the patch.object rather than simply mocking the module itself.
+    # This is typically recommended for patching any object which belongs
+    # to the object under test (lookup partial-mocks for more information).
+    @patch.object(hooks, 'restart_mongod')
+    @patch.object(hooks, 'enable_replset')
+    # Note: patching the os.environ dictionary in-line here so there's no
+    # additional parameter sent into the function
+    @patch.dict('os.environ', JUJU_UNIT_NAME='fake-unit/0')
+    def test_replica_set_relation_joined(self, mock_enable, mock_restart):
+        # only have 1 invocation of the unit_get, so we'll just tell it what
+        # to return. Can change to be more sophisticated when necessary.
+        self.unit_get.return_value = 'private.address'
+        self.test_config.set('port', '1234')
+        self.test_config.set('replicaset', 'fake-replicaset')
+        self.relation_id.return_value = 'fake-relation-id'
+
+        # Partial mock to control the flow around the if check for the enable
+        # restart.
+        mock_enable.return_value = False
+
+        # This tests the trigger of firing the relation-joined as the python
+        # invocation works. However, it doesn't seem to accept all the mocking
+        # in this case, so I'll just invoke the function directly.
+        # hooks.hooks.execute(['hooks/replicaset-relation-joined'])
+        hooks.replica_set_relation_joined()
+
+        # Verify that mongodb was NOT restarted since the replicaset we claimed
+        # was not enabled.
+        self.assertFalse(mock_restart.called)
+
+        exp_rel_vals = {'hostname': 'private.address',
+                        'port': '1234',
+                        'replset': 'fake-replicaset',
+                        'install-order': '0',
+                        'type': 'replset'}
+        # Check that the relation data was set as we expect it to be set.
+        self.relation_set.assert_called_with('fake-relation-id', exp_rel_vals)

=== added file 'unit_tests/test_utils.py'
--- unit_tests/test_utils.py	1970-01-01 00:00:00 +0000
+++ unit_tests/test_utils.py	2014-12-13 00:22:04 +0000
@@ -0,0 +1,111 @@
+import logging
+import unittest
+import os
+import yaml
+import io
+
+from contextlib import contextmanager
+from mock import patch
+
+
+@contextmanager
+def mock_open(filename, contents=None):
+    ''' Slightly simpler mock of open to return contents for filename '''
+    def mock_file(*args):
+        if args[0] == filename:
+            return io.StringIO(contents)
+        else:
+            return open(*args)
+    with patch('__builtin__.open', mock_file):
+        yield
+
+
+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):
+        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