configglue team mailing list archive

[Ricardo Kirkner <ricardo.kirkner@xxxxxxxxxxxxx>]

Ricardo Kirkner has proposed merging lp:~ricardokirkner/configglue/simplified into lp:configglue.

Requested reviews:
  Configglue developers (configglue)


Included lp:~chipaca/configglue/simplified branch and added some tests
-- 
https://code.launchpad.net/~ricardokirkner/configglue/simplified/+merge/44148
Your team Configglue developers is requested to review the proposed merge of lp:~ricardokirkner/configglue/simplified into lp:configglue.

=== modified file 'configglue/pyschema/__init__.py'
--- configglue/pyschema/__init__.py	2010-08-10 15:23:25 +0000
+++ configglue/pyschema/__init__.py	2010-12-18 21:57:00 +0000
@@ -17,10 +17,14 @@
 
 import __builtin__
 from optparse import OptionParser
+from collections import namedtuple
 import sys
 
 # XXX: more imports at bottom (we probably want to fix this)
 
+SchemaGlue = namedtuple("SchemaGlue", "schema_parser option_parser options args")
+IniGlue = namedtuple("IniGlue", " option_parser options args")
+
 def ini2schema(fd, p=None):
     """
     Turn a fd that refers to a INI-style schema definition into a
@@ -120,7 +124,7 @@
                 # update it.
                 parser.set(section.name, option.name, value)
 
-    return op, options, args
+    return IniGlue(op, options, args)
 
 def super_vars(obj):
     """An extended version of vars() that walks all base classes."""
@@ -260,5 +264,18 @@
 from parser import SchemaConfigParser
 from schema import Schema
 
+def configglue(schema_class, configs, usage=None):
+    scp = SchemaConfigParser(schema_class())
+    scp.read(configs)
+    if usage is not None:
+        op = OptionParser(usage=usage)
+    else:
+        op = None
+    parser, opts, args = schemaconfigglue(scp, op=op)
+    is_valid, reasons = scp.is_valid(report=True)
+    if not is_valid:
+        parser.error(reasons[0])
+    return SchemaGlue(scp, parser, opts, args)
+
 # circular import avoidance
 from configglue.inischema import AttributedConfigParser, parsers

=== modified file 'setup.py'
--- setup.py	2010-08-11 20:21:57 +0000
+++ setup.py	2010-12-18 21:57:00 +0000
@@ -35,12 +35,13 @@
         'Topic :: Software Development :: Libraries :: Python Modules',
         'Programming Language :: Python',
         ],
-      author='John R. Lenton',
-      author_email='john.lenton@xxxxxxxxxxxxx',
+      author='John R. Lenton, Ricardo Kirkner',
+      author_email='john.lenton@xxxxxxxxxxxxx, ricardo.kirkner@xxxxxxxxxxxxx',
       url='https://launchpad.net/configglue',
       license='BSD License',
       packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
       include_package_data=True,
       zip_safe=True,
       test_suite='tests',
+      tests_require=['mock'],
       )

=== modified file 'tests/pyschema/test_schemaconfig.py'
--- tests/pyschema/test_schemaconfig.py	2010-08-04 12:42:29 +0000
+++ tests/pyschema/test_schemaconfig.py	2010-12-18 21:57:00 +0000
@@ -19,7 +19,9 @@
 import sys
 from StringIO import StringIO
 
-from configglue.pyschema import ConfigOption, ConfigSection, schemaconfigglue
+from mock import patch, Mock
+
+from configglue.pyschema import ConfigOption, ConfigSection, schemaconfigglue, configglue
 from configglue.pyschema.options import IntConfigOption
 from configglue.pyschema.parser import SchemaConfigParser
 from configglue.pyschema.schema import Schema
@@ -179,3 +181,109 @@
         output = stdout.read()
         self.assertTrue(output.startswith('Usage:'))
 
+
+class ConfigglueTestCase(unittest.TestCase):
+    @patch('configglue.pyschema.SchemaConfigParser')
+    @patch('configglue.pyschema.schemaconfigglue')
+    def test_configglue(self, mock_schemaconfigglue, mock_schema_parser):
+        # prepare mocks
+        expected_schema_parser = Mock()
+        expected_schema_parser.is_valid.return_value = (True, None)
+        expected_option_parser = Mock()
+        expected_options = Mock()
+        expected_args = Mock()
+        mock_schemaconfigglue.return_value = (expected_option_parser,
+            expected_options, expected_args)
+        mock_schema_parser.return_value = expected_schema_parser
+
+        # define the inputs
+        class MySchema(Schema):
+            foo = IntConfigOption()
+
+        configs = ['config.ini']
+
+        # call the function under test
+        glue = configglue(MySchema, configs)
+
+        # schema_parse is a SchemaConfigParser, initialized with MySchema
+        # and fed with the configs file list
+        self.assertEqual(glue.schema_parser, expected_schema_parser)
+        mock_schema_parser.assert_called_with(MySchema())
+        mock_schema_parser.return_value.read.assert_called_with(configs)
+        # the other attributes are the result of calling schemaconfigglue
+        mock_schemaconfigglue.assert_called_with(expected_schema_parser, op=None)
+        self.assertEqual(glue.option_parser, expected_option_parser)
+        self.assertEqual(glue.options, expected_options)
+        self.assertEqual(glue.args, expected_args)
+
+    @patch('configglue.pyschema.SchemaConfigParser')
+    @patch('configglue.pyschema.schemaconfigglue')
+    def test_configglue(self, mock_schemaconfigglue, mock_schema_parser):
+        # prepare mocks
+        expected_schema_parser = Mock()
+        expected_schema_parser.is_valid.return_value = (False, ['some error'])
+        expected_option_parser = Mock()
+        expected_options = Mock()
+        expected_args = Mock()
+        mock_schemaconfigglue.return_value = (expected_option_parser,
+            expected_options, expected_args)
+        mock_schema_parser.return_value = expected_schema_parser
+
+        # define the inputs
+        class MySchema(Schema):
+            foo = IntConfigOption()
+
+        configs = ['config.ini']
+
+        # call the function under test
+        glue = configglue(MySchema, configs)
+
+        # schema_parse is a SchemaConfigParser, initialized with MySchema
+        # and fed with the configs file list
+        self.assertEqual(glue.schema_parser, expected_schema_parser)
+        mock_schema_parser.assert_called_with(MySchema())
+        mock_schema_parser.return_value.read.assert_called_with(configs)
+        # the other attributes are the result of calling schemaconfigglue
+        mock_schemaconfigglue.assert_called_with(expected_schema_parser, op=None)
+        self.assertEqual(glue.option_parser, expected_option_parser)
+        expected_option_parser.error.assert_called_with('some error')
+        self.assertEqual(glue.options, expected_options)
+        self.assertEqual(glue.args, expected_args)
+
+    @patch('configglue.pyschema.OptionParser')
+    @patch('configglue.pyschema.SchemaConfigParser')
+    @patch('configglue.pyschema.schemaconfigglue')
+    def test_configglue_with_usage(self, mock_schemaconfigglue,
+        mock_schema_parser, mock_option_parser):
+        # prepare mocks
+        expected_schema_parser = Mock()
+        expected_schema_parser.is_valid.return_value = (True, None)
+        expected_option_parser = mock_option_parser.return_value
+        expected_options = Mock()
+        expected_args = Mock()
+        mock_schemaconfigglue.return_value = (expected_option_parser, expected_options,
+            expected_args)
+        mock_schema_parser.return_value = expected_schema_parser
+
+        # define the inputs
+        class MySchema(Schema):
+            foo = IntConfigOption()
+
+        configs = ['config.ini']
+
+        # call the function under test
+        glue = configglue(MySchema, configs, usage='foo')
+
+        # schema_parse is a SchemaConfigParser, initialized with MySchema
+        # and fed with the configs file list
+        self.assertEqual(glue.schema_parser, expected_schema_parser)
+        mock_schema_parser.assert_called_with(MySchema())
+        mock_schema_parser.return_value.read.assert_called_with(configs)
+        # the other attributes are the result of calling schemaconfigglue
+        mock_schemaconfigglue.assert_called_with(expected_schema_parser,
+            op=expected_option_parser)
+        mock_option_parser.assert_called_with(usage='foo')
+        self.assertEqual(glue.option_parser, expected_option_parser)
+        self.assertEqual(glue.options, expected_options)
+        self.assertEqual(glue.args, expected_args)
+