Re-writing unit tests

Author: BrunoSilvaAndrade

README.md

@@ -21,7 +21,8 @@ SCHEMA_CONFIG = {
     "core":{
         "logging":{
             "format": And(Use(str), lambda string: len(string) > 0),
-            "datefmt": And(Use(str), lambda string: len(string) > 0)
+            "datefmt": And(Use(str), lambda string: len(string) > 0),
+            "level": str
         },
         "allowed_clients":[
             {
@@ -40,6 +41,7 @@ core:
   logging:
     format: "[%(asctime)s][%(levelname)s]: %(message)s"
     datefmt: "%d-%b-%y %H:%M:%S"
+    level: ${LEVEL_ENV_VARIABLE}
   allowed_clients:
   - ip: 192.168.0.10
     timeout: 60

config/bad_content.json

@@ -0,0 +1 @@
+{""

config/bad_content.yaml

@@ -0,0 +1 @@
+{'''}

config/config.json

@@ -2,8 +2,9 @@
     "core":{
         "logging":{
             "format": "format",
-            "datefmt": "datefmt"
+            "datefmt": "${DATE_FORMAT_TEST}",
+            "level": "$LOG_LEVEL_TEST"
         },
-        "obj_list":[{"name":"bruno", "age":24}]
+        "obj_list":[{"name":"Mike", "age":24}]
     }
 }

config/config.yaml

@@ -0,0 +1,8 @@
+core:
+  logging:
+    format: format
+    datefmt: datefmt
+    level: level
+  obj_list:
+  - name: ${TEST_PYCONFIGPARSER}
+    age: 24

config/schema_config_test.py config/schemas.pyconfig/schema_config_test.py renamed to config/schemas.py

@@ -2,8 +2,13 @@
     'core': {
         'logging': {
             'format': str,
-            'datefmt': str
+            'datefmt': str,
+            'level': str
         },
         'obj_list': [{'name': str, 'age': int}]
     }
 }
+
+UNSUPPORTED_OBJECT_KEYS_SCHEMA = {
+    'testeWith-': int
+}

config/unsupported_object_key.json

@@ -0,0 +1 @@
+{"testeWith-": 1}

pyconfigparser.py

@@ -11,18 +11,20 @@ def json_parser(file_buff):
     try:
         return json.loads(file_buff)
     except json.JSONDecodeError as e:
-        raise ConfigFileDecodeError(e)
+        raise ConfigFileDecodeError(f'Unable to decode config file using json', e)
 
 
 def yaml_parser(file_buff):
     try:
-        return yaml.load(file_buff, yaml.FullLoader)
+        return yaml.safe_load(file_buff)
     except yaml.YAMLError as e:
-        raise ConfigFileDecodeError(e)
+        raise ConfigFileDecodeError(f'Unable to decode config file using yaml', e)
 
 
+LINUX_KEY_VARIABLE_PATTERN = r'\$([a-zA-Z][\w]+|\{[a-zA-Z][\w]+\})$'
 DEFAULT_CONFIG_FILES = ('config.json', 'config.yaml', 'config.yml')
-ENTITY_NAME_PATTERN = '^[\w\d_]+$'
+ENTITY_NAME_PATTERN = r'^[a-zA-Z][\w]+$'
+
 SUPPORTED_EXTENSIONS = {
     'json': json_parser,
     'yaml': yaml_parser,
@@ -41,15 +43,30 @@ def __iter__(self):
 
 class Config:
     __instance = None
+    __hold_an_instance = True
+
+    @classmethod
+    def hold_an_instance(cls):
+        return cls.__hold_an_instance
+
+    @classmethod
+    def set_hold_an_instance(cls, value):
+        if type(value) is not bool:
+            raise ValueError('value must be a bool')
+        cls.__hold_an_instance = value
 
     def __new__(cls, *args, **kwargs):
         raise RuntimeError('A instance of config is not allowed, use Config.get_config() instead')
 
     @classmethod
     def get_config(cls, schema: dict = None, config_dir: str = 'config', file_name: Any = DEFAULT_CONFIG_FILES):
 
-        if cls.__instance is None or schema is not None:
-            cls.__create_new_instance(schema, config_dir, file_name)
+        if cls.__instance is None:
+            instance = cls.__create_new_instance(schema, config_dir, file_name)
+            if cls.__hold_an_instance:
+                cls.__instance = instance
+            else:
+                return instance
         return cls.__instance
 
     @classmethod
@@ -61,17 +78,17 @@ def __create_new_instance(cls, schema, config_dir, file_name):
 
         try:
             config = Schema(schema).validate(parser(file_buff))
-            cls.__instance = cls.__dict_2_obj(config)
+            return cls.__dict_2_obj(config)
         except SchemaError as e:
-            raise ConfigFileModelError(str(e))
+            raise ConfigError('Schema validation error', e)
 
     @classmethod
     def __get_file_parser(cls, file_path):
         try:
             extension = file_path.split('.')[-1]
             return SUPPORTED_EXTENSIONS[extension]
         except KeyError:
-            raise ConfigFileExtensionNotSupportedError(f'Supported extensions: {list(SUPPORTED_EXTENSIONS.keys())}')
+            raise ConfigError(f'Supported extensions: {list(SUPPORTED_EXTENSIONS.keys())}')
 
     @classmethod
     def __get_file_path(cls, config_dir, file_name):
@@ -94,11 +111,8 @@ def __check_schema(cls, schema):
 
     @classmethod
     def __get_file_buff(cls, path_file: str):
-        try:
-            with open(path_file, 'r') as f:
-                return f.read()
-        except Exception as e:
-            raise ConfigFileOpenReadError(str(e))
+        with open(path_file, 'r') as f:
+            return f.read()
 
     @classmethod
     def __dict_2_obj(cls, data: Any):
@@ -108,43 +122,39 @@ def __dict_2_obj(cls, data: Any):
             obj = ConfigValue()
             for key, value in data.items():
                 if re.search(ENTITY_NAME_PATTERN, key) is None:
-                    raise ConfigEntitiesWithWrongNameError(
+                    raise ConfigError(
                         f'The key {key} is invalid. The entity keys only may have words, number and underscores.')
                 setattr(obj, key, cls.__dict_2_obj(value))
             return obj
         if _type in (list, set, tuple):
             return list(map(lambda v: cls.__dict_2_obj(v), data))
         else:
+            if type(data) is str and re.search(LINUX_KEY_VARIABLE_PATTERN, data) is not None:
+                return cls.interpol_variable(data)
             return data
 
+    @classmethod
+    def interpol_variable(cls, data):
+        try:
+            return os.environ[cls.extract_env_variable_key(data)]
+        except KeyError:
+            raise ConfigError(f'Environment variable {data} was not found')
 
-class ConfigError(Exception):
-    pass
+    @classmethod
+    def extract_env_variable_key(cls, variable):
+        variable = variable[1:]
+        if variable[0] == '{':
+            return variable[1:-1]
+        return variable
 
 
-class ConfigFileModelError(ConfigError):
+class ConfigError(Exception):
     pass
 
 
 class ConfigFileDecodeError(ConfigError):
     pass
 
 
-class ConfigSchemaModelError(ConfigError):
-    pass
-
-
-class ConfigFileOpenReadError(ConfigError):
-    pass
-
-
 class ConfigFileNotFoundError(ConfigError):
     pass
-
-
-class ConfigFileExtensionNotSupportedError(ConfigError):
-    pass
-
-
-class ConfigEntitiesWithWrongNameError(ConfigError):
-    pass

setup.py

@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name='python-config-parser',
-    version='2.0.3',
+    version='2.0.4',
     author='Bruno Silva de Andrade',
     author_email='brunojf.andrade@gmail.com',
     description='Project created to given the possibility of create dynamics config files',

test_configparser.py

@@ -1,30 +1,65 @@
+import os
 import unittest
-from pyconfigparser import *
-from config.schema_config_test import SIMPLE_SCHEMA_CONFIG
+from config.schemas import SIMPLE_SCHEMA_CONFIG, UNSUPPORTED_OBJECT_KEYS_SCHEMA
+from pyconfigparser import Config, ConfigError, ConfigFileNotFoundError, ConfigFileDecodeError
+
+DT_FMT_TEST = '%Y-%m-%dT%H:%M:%SZ'
+VAR_LOG_LEVEL_INFO = 'INFO'
 
 
 class ConfigTestCase(unittest.TestCase):
+    def setUp(self) -> None:
+        Config.set_hold_an_instance(False)
+        os.environ['DATE_FORMAT_TEST'] = DT_FMT_TEST
+        os.environ['LOG_LEVEL_TEST'] = VAR_LOG_LEVEL_INFO
 
-    def test_config_without_file(self):
-        self.assertRaises(ConfigFileNotFoundError, Config.get_config, SIMPLE_SCHEMA_CONFIG, 'config', 'some_non_exists_file.json')
+    def test_new(self):
+        self.assertRaises(RuntimeError, Config)
 
-    def test_config_with_wrong_json_model(self):
-        self.assertRaises(ConfigFileModelError, Config.get_config, SIMPLE_SCHEMA_CONFIG, 'config', 'wrong_model.json')
+    def test_schema_checking(self):
+        self.assertRaises(ConfigError, Config.get_config)
+        self.assertRaises(ConfigError, Config.get_config, [])
 
-    def test_config_file_with_unsupported_extension(self):
-        self.assertRaises(ConfigFileExtensionNotSupportedError, Config.get_config, SIMPLE_SCHEMA_CONFIG, 'config', 'config.bad_extension')
+    def test_config_without_file(self):
+        self.assertRaises(ConfigFileNotFoundError, Config.get_config, SIMPLE_SCHEMA_CONFIG,
+                          'config',
+                          'some_non_exists_file.json')
+
+    def test_undefined_env_var(self):
+        try:
+            Config.get_config(SIMPLE_SCHEMA_CONFIG, file_name='config.yaml')
+        except Exception as e:
+            self.assertIn('Environment', str(e))
 
     def test_to_access_attr_from_config(self):
         config = Config.get_config(SIMPLE_SCHEMA_CONFIG)
-        self.assertEqual(config.core.logging.format, 'format')
-        self.assertEqual(config.core.logging.datefmt, 'datefmt')
-        self.assertEqual(config.core.obj_list[0].name, 'bruno')
-        self.assertEqual(config.core.obj_list[0].age, 24)
+        self.assertEqual(VAR_LOG_LEVEL_INFO, config.core.logging.level)
+        self.assertEqual(DT_FMT_TEST, config.core.logging.datefmt)
+        self.assertEqual('format', config.core.logging.format)
+        self.assertEqual(24, config.core.obj_list[0].age)
+        self.assertEqual('Mike', config.core.obj_list[0]['name'])  # <- using subscriptable access
 
     def test_access_fake_attr(self):
         config = Config.get_config(SIMPLE_SCHEMA_CONFIG)
         self.assertRaises(AttributeError, lambda: config.fake_attr)
 
+    def test_unsupported_object_key(self):
+        self.assertRaises(ConfigError, Config.get_config, UNSUPPORTED_OBJECT_KEYS_SCHEMA,
+                          file_name='unsupported_object_key.json')
+
+    def test_set_hold_an_invalid_instance(self):
+        self.assertRaises(ValueError, Config.set_hold_an_instance, [])
+
+    def test_config_with_wrong_json_model(self):
+        self.assertRaises(ConfigError, Config.get_config, SIMPLE_SCHEMA_CONFIG, file_name='wrong_model.json')
+
+    def test_config_file_with_unsupported_extension(self):
+        self.assertRaises(ConfigError, Config.get_config, SIMPLE_SCHEMA_CONFIG, file_name='config.bad_extension')
+
+    def test_bad_decoder_error(self):
+        self.assertRaises(ConfigFileDecodeError, Config.get_config, SIMPLE_SCHEMA_CONFIG, file_name='bad_content.json')
+        self.assertRaises(ConfigFileDecodeError, Config.get_config, SIMPLE_SCHEMA_CONFIG, file_name='bad_content.yaml')
+
 
 if __name__ == '__main__':
     unittest.main()