:fix: parser UTs

b3j0f/conf/parser/core.py

@@ -173,7 +173,7 @@
 REGEX_REF = re_compile(EVAL_REF)
 
 #: programmatic language expression.
-EVAL_FORMAT = r'\%((?P<lang>\w+):)?(?P<expr>([^%]|\\%)+[^\\])\%'
+EVAL_FORMAT = r'\%((?P<lang>\w+):)?(?P<expr>([^%]|(\\%))*[^\\]?)\%'
 
 REGEX_FORMAT = re_compile(EVAL_FORMAT)
 
@@ -197,7 +197,7 @@ def serialize(expr):
         result = expr
 
     elif expr is not None:
-        result = '={0}'.format(expr)
+        result = '=py:{0}'.format(expr)
 
     return result
 

b3j0f/conf/parser/test/core.py

@@ -222,7 +222,7 @@ def test_path_cname_pname(self):
 
     def test_both(self):
 
-        test = '@a%b%@c%js:d%@e'
+        test = u'@a%b%@c%js:d%@e'
 
         matches = REGEX_STR.finditer(test)
 
@@ -236,7 +236,6 @@ def test_both(self):
 
         for index, match in enumerate(matches):
             groupdict = match.groupdict()
-            print(groupdict, index, match)
             value = values[index]
             self.assertEqual(groupdict[value[0]], value[1])
 
@@ -378,52 +377,6 @@ def test_format_expr(self):
         self.assertEqual(val, 'test')
 
 
-class SimpleParserTest(UTCase):
-    """Test the function _simpleparser."""
-
-    def test_bool_empty(self):
-        """Test bool type with an empty string."""
-
-        value = _simpleparser(svalue='', _type=bool)
-
-        self.assertFalse(value)
-
-    def test_bool_1(self):
-        """Test bool type with 1."""
-
-        value = _simpleparser(svalue='1', _type=bool)
-
-        self.assertTrue(value)
-
-    def test_bool_true(self):
-        """Test bool type with true."""
-
-        value = _simpleparser(svalue='true', _type=bool)
-
-        self.assertTrue(value)
-
-    def test_bool_ptrue(self):
-        """Test bool type with True value."""
-
-        value = _simpleparser(svalue='True', _type=bool)
-
-        self.assertTrue(value)
-
-    def test_bool_wrong(self):
-        """Test bool type with false value."""
-
-        value = _simpleparser(svalue='TrUe', _type=bool)
-
-        self.assertFalse(value)
-
-    def test_string(self):
-        """Test default with string type."""
-
-        value = _simpleparser(svalue='test')
-
-        self.assertEqual(value, 'test')
-
-
 class ConfigurationTest(UTCase):
     """Base class of test which uses a local configuration."""
 
@@ -447,40 +400,7 @@ def setUp(self):
             self.conf += category
 
 
-class Resolve(ConfigurationTest):
-
-    def test_default(self):
-        """Test default params."""
-
-        value = _resolve(conf=self.conf, pname=self.pname)
-
-        self.assertEqual(value, self.pvalues[-1])
-
-    def test_cname(self):
-        """Test with cname."""
-
-        for i in range(self.count):
-
-            value = _resolve(
-                conf=self.conf, cname=self.cnames[i], pname=self.pname
-            )
-
-            self.assertEqual(value, self.pvalues[i])
-
-    def test_nocname(self):
-        """Test when category name does not exist."""
-
-        self.assertRaises(
-            KeyError, _resolve, cname='test', pname=self.pname, conf=self.conf
-        )
-
-    def test_nopname(self):
-        """Test when parameter name does not exist."""
-
-        self.assertRaises(KeyError, _resolve, pname='test', conf=self.conf)
-
-
-class Serializer(ConfigurationTest):
+class SerializerTest(ConfigurationTest):
     """Test the function serializer."""
 
     def test_str(self):
@@ -509,73 +429,39 @@ def test_other(self):
 
             serialized = serialize(value)
 
-            self.assertEqual(serialized, '={0}'.format(value))
-
-
-class ExprParser(ConfigurationTest):
-    """Test the function _exprparser."""
-
-    def setUp(self):
-
-        super(ExprParser, self).setUp()
-
-        self.configurable = Configurable(
-            drivers=[TestConfDriver()]
-        )
-
-    def test_empty(self):
-        """Test default value."""
+            self.assertEqual(serialized, '=py:{0}'.format(value))
 
-        value = _exprparser(svalue='')
 
-        self.assertIsNone(value, '')
+class ParseTest(ConfigurationTest):
+    """Test the parse function."""
 
-    def test_pname(self):
-        """Test parameter value."""
+    def test_default(self):
+        """Test default params."""
 
-        value = _exprparser(svalue='@{0}'.format(self.pname), conf=self.conf)
+        value = parse(svalue='=2')
 
-        self.assertEqual(value, self.pvalues[-1])
+        self.assertEqual(value, 2)
 
     def test_cname(self):
-        """Test with a resolve argument."""
-
-        svalue = ''
-        for i in range(self.count):
-            svalue += '@{0}.{1} +'.format(self.cnames[i], self.pname)
-
-        svalue = svalue[:-2]  # remove the last '+'
-        value = _exprparser(svalue=svalue, conf=self.conf)
-
-        self.assertEqual(value, sum(self.pvalues))
-
-    def test_confpath(self):
-        """Test with a conf path."""
-
-        svalue = '@://test/param'
-
-        value = _exprparser(
-            svalue=svalue, conf=self.conf, configurable=self.configurable
-        )
+        """Test with cname."""
 
-    def test_confpath_cname(self):
-        """Test with a conf path and a cname."""
+        value = parse(svalue='2')
 
-    def test_lookup(self):
-        """Test lookup parameter."""
+        self.assertEqual(value, '2')
 
-        svalue = '#{0}'.format(getpath(getpath))
+    def test_nocname(self):
+        """Test when category name does not exist."""
 
-        value = _exprparser(svalue=svalue, _globals={'getpath': getpath})
+        value = parse(svalue='t%"es"%t')
 
-        self.assertIs(value, getpath)
+        self.assertEqual(value, 'test')
 
-    def test_error_lookup(self):
-        """Test a lookup parameter without referencing the python object."""
+    def test_nopname(self):
+        """Test when parameter name does not exist."""
 
-        svalue = '#{0}'.format(getpath(getpath))
+        value = parse(svalue='="test"')
 
-        self.assertRaises(ImportError, _exprparser, svalue=svalue)
+        self.assertEqual(value, 'test')
 
 
 if __name__ == '__main__':