Merge pull request #13 from lmr/settings-unittest

Settings unittest

avocado/settings.py

@@ -18,15 +18,27 @@ config_path_intree = os.path.join(_config_path_intree, config_filename)
 
 
 class SettingsError(Exception):
+
+    """
+    Base settings error.
+    """
     pass
 
 
 class SettingsValueError(SettingsError):
+
+    """
+    Error thrown when we could not convert successfully a key to a value.
+    """
     pass
 
 
 class ConfigFileNotFound(SettingsError):
 
+    """
+    Error thrown when the main settings file could not be found.
+    """
+
     def __init__(self, path_list):
         super(ConfigFileNotFound, self).__init__()
         self.path_list = path_list
@@ -79,32 +91,52 @@ def convert_value_type(key, section, value, value_type):
 
 class Settings(object):
 
+    """
+    Simple wrapper around ConfigParser, with a key type conversion available.
+    """
+
     no_default = object()
 
-    def __init__(self):
+    def __init__(self, config_path=None):
+        """
+        Constructor. Tries to find the main settings file and load it.
+
+        :param config_path: Path to a config file. Useful for unittesting.
+        """
         self.config = ConfigParser.ConfigParser()
-        config_system = os.path.exists(config_path_system)
-        config_local = os.path.exists(config_path_local)
-        config_intree = os.path.exists(config_path_intree)
         self.intree = False
-        if not config_local and not config_system:
-            if not config_intree:
-                raise ConfigFileNotFound([config_path_system,
-                                          config_path_local,
-                                          config_path_intree])
-            self.config_path = config_path_intree
-            self.intree = True
-        else:
-            if config_local:
-                self.config_path = config_path_local
+        if config_path is None:
+            config_system = os.path.exists(config_path_system)
+            config_local = os.path.exists(config_path_local)
+            config_intree = os.path.exists(config_path_intree)
+            if not config_local and not config_system:
+                if not config_intree:
+                    raise ConfigFileNotFound([config_path_system,
+                                              config_path_local,
+                                              config_path_intree])
+                self.config_path = config_path_intree
+                self.intree = True
             else:
-                self.config_path = config_path_system
-        self.parse_file()
-
-    def parse_file(self):
+                if config_local:
+                    self.config_path = config_path_local
+                else:
+                    self.config_path = config_path_system
+        else:
+            self.config_path = config_path
         self.config.read(self.config_path)
 
     def _handle_no_value(self, section, key, default):
+        """
+        What to do if key in section has no value.
+
+        :param section: Config file section.
+        :param key: Config file key, relative to section.
+        :param default: Default value for key, in case it does not exist.
+
+        :returns: Default value, if a default value was provided.
+
+        :raises: SettingsError, in case no default was provided.
+        """
         if default is self.no_default:
             msg = ("Value '%s' not found in section '%s'" %
                    (key, section))
@@ -114,6 +146,21 @@ class Settings(object):
 
     def get_value(self, section, key, key_type=str, default=no_default,
                   allow_blank=False):
+        """
+        Get value from key in a given config file section.
+
+        :param section: Config file section.
+        :param key: Config file key, relative to section.
+        :param key_type: Type of key.
+                It can be either of: str, int, float, bool, list
+        :param default: Default value for the key, if none found.
+        :param allow_blank: Whether an empty value for the key is allowed.
+
+        :returns: value, if one available in the config.
+                default value, if one provided.
+
+        :raises: SettingsError, in case no default was provided.
+        """
         try:
             val = self.config.get(section, key)
         except ConfigParser.Error:

unittests/avocado/settings_unittest.py

+#!/usr/bin/env python
+
+import unittest
+import os
+import sys
+import tempfile
+
+# simple magic for using scripts within a source tree
+basedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+basedir = os.path.dirname(basedir)
+if os.path.isdir(os.path.join(basedir, 'avocado')):
+    sys.path.append(basedir)
+
+from avocado import settings
+
+example_1 = """[foo]
+str_key = frobnicate
+int_key = 1
+float_key = 1.25
+bool_key = True
+list_key = I, love, settings
+empty_key =
+"""
+
+
+class SettingsTest(unittest.TestCase):
+
+    def setUp(self):
+        self.config_file = tempfile.NamedTemporaryFile(delete=False)
+        self.config_file.write(example_1)
+        self.config_file.close()
+        self.settings = settings.Settings(self.config_file.name)
+
+    def testStringConversion(self):
+        self.assertEqual(self.settings.get_value('foo', 'str_key', str),
+                         'frobnicate')
+
+    def testIntConversion(self):
+        self.assertEqual(self.settings.get_value('foo', 'int_key', int), 1)
+
+    def testFloatConversion(self):
+        self.assertEqual(self.settings.get_value('foo', 'float_key', float),
+                         1.25)
+
+    def testBoolConversion(self):
+        self.assertTrue(self.settings.get_value('foo', 'bool_key', bool))
+
+    def testListConversion(self):
+        self.assertEqual(self.settings.get_value('foo', 'list_key', list),
+                         ['I', 'love', 'settings'])
+
+    def testDefault(self):
+        self.assertEqual(self.settings.get_value('foo', 'non_existing',
+                                                 str, "ohnoes"), "ohnoes")
+
+    def testNonExistingKey(self):
+        with self.assertRaises(settings.SettingsError):
+            self.settings.get_value('foo', 'non_existing', str)
+
+    def testAllowBlankTrueStr(self):
+        self.assertEqual(self.settings.get_value('foo', 'empty_key', str,
+                                                 allow_blank=True), "")
+
+    def testAllowBlankTrueInt(self):
+        self.assertEqual(self.settings.get_value('foo', 'empty_key', int,
+                                                 allow_blank=True), 0)
+
+    def testAllowBlankTrueFloat(self):
+        self.assertEqual(self.settings.get_value('foo', 'empty_key', float,
+                                                 allow_blank=True), 0.0)
+
+    def testAllowBlankTrueList(self):
+        self.assertEqual(self.settings.get_value('foo', 'empty_key', list,
+                                                 allow_blank=True), [])
+
+    def testAllowBlankTrueBool(self):
+        self.assertEqual(self.settings.get_value('foo', 'empty_key', bool,
+                                                 allow_blank=True), False)
+
+    def testAllowBlankTrueOther(self):
+        self.assertEqual(self.settings.get_value('foo', 'empty_key', 'baz',
+                                                 allow_blank=True), None)
+
+    def testAllowBlankFalse(self):
+        with self.assertRaises(settings.SettingsError):
+            self.settings.get_value('foo', 'empty_key', str)
+
+    def tearDown(self):
+        os.unlink(self.config_file.name)
+
+if __name__ == '__main__':
+    unittest.main()