示例#1
0
    def test_settings_export(self):
        node1 = config.SchemaNode(
                colander.Str(),
                name = 'node1',
                default = 'test')

        node2 = config.SchemaNode(
                colander.Str(),
                name = 'node2',
                default = 'test')

        group = config.registerSettings('group4', node1, node2)

        self._init_memphis()

        # changed settings
        self.assertEqual(config.Settings.export(), {})

        # default settings
        self.assertEqual(config.Settings.export(default=True),
                         {'group4.node1': 'test', 'group4.node2': 'test'})

        # changed settings
        group['node2'] = 'changed'
        data = dict(config.Settings.export())
        self.assertEqual(data, {'group4.node2': 'changed'})
示例#2
0
    def test_settings_group_multiple_validation(self):
        def validator1(node, appstruct):
            raise colander.Invalid(node['node1'], 'Error1')
        def validator2(node, appstruct):
            raise colander.Invalid(node, 'Error2')

        node1 = config.SchemaNode(
                colander.Str(),
                name = 'node1',
                default = 'test')

        node2 = config.SchemaNode(
                colander.Str(),
                name = 'node2',
                default = 'test')

        group = config.registerSettings(
            'group3', node1, node2, validator=(validator1, validator2))

        self._init_memphis()

        try:
            group.schema.deserialize({
                    'group3.node1': 'value',
                    'group3.node2': 'value'})
        except colander.Invalid, err:
            pass
示例#3
0
    def test_settings_register_multiple(self):
        node = config.SchemaNode(
            colander.Str(),
            name = 'node',
            default = 'test')

        group = config.registerSettings(
            'group1', node,
            title = 'Section title',
            description = 'Section description',
            )

        node2 = config.SchemaNode(
            colander.Str(),
            name = 'node2',
            default = 'test2')

        group2 = config.registerSettings(
            'group1', node2,
            title = 'Section title',
            description = 'Section description',
            )

        self.assertTrue(group is group2)
示例#4
0
    def _create_default_group(self):
        node1 = config.SchemaNode(
                colander.Str(),
                name = 'node1',
                default = 'default1')

        node2 = config.SchemaNode(
                colander.Int(),
                name = 'node2',
                default = 10)

        group = config.registerSettings('group', node1, node2)
        self._init_memphis()

        group.clear()
        return group
示例#5
0
    def test_settings_group_validation(self):
        def validator(node, appstruct):
            raise colander.Invalid(node['node'], 'Error')

        node = config.SchemaNode(
                colander.Str(),
                name = 'node',
                default = 'test')

        group = config.registerSettings(
            'group2', node, validator=validator)

        self._init_memphis()

        try:
            group.schema.deserialize({'group2.node': 'value'})
        except colander.Invalid, err:
            pass
示例#6
0
    def test_settings_initialize_load_default(self):
        node1 = config.SchemaNode(
                colander.Str(),
                name = 'node1',
                default = 'default1')

        node2 = config.SchemaNode(
                colander.Int(),
                name = 'node2',
                default = 10)

        group = config.registerSettings('group', node1, node2)
        self._init_memphis()

        config.initializeSettings({'group.node1': 'setting from ini'})

        self.assertEqual(group['node1'], 'setting from ini')
        self.assertEqual(group['node2'], 10)
示例#7
0
    def test_settings_register_simple(self):
        node = config.SchemaNode(
                colander.Str(),
                name = 'node',
                default = 'test')

        group = config.registerSettings(
            'group1', node,
            title = 'Section title',
            description = 'Section description',
            )

        self.assertEqual(group.name, 'group1')
        self.assertEqual(group.title, 'Section title')
        self.assertEqual(group.description, 'Section description')
        self.assertEqual(len(group.schema.children), 0)
        self.assertTrue(isinstance(group.category, InterfaceClass))

        self._init_memphis()

        self.assertEqual(len(group.schema.children), 1)
        self.assertTrue(group.schema.children[0] is node)
        self.assertEqual(group.node, 'test')
        self.assertEqual(group['node'], 'test')
        self.assertRaises(
            AttributeError,
            group.__getattr__, 'unknown')
        self.assertRaises(
            KeyError,
            group.__getitem__, 'unknown')

        self.assertEqual(config.Settings._changed, None)

        group.node = 'test2'
        self.assertFalse(group.node == group['node'])

        group['node'] =  'test2'
        self.assertTrue('group1' in config.Settings._changed)
        self.assertTrue('node' in config.Settings._changed['group1'])
示例#8
0
    def test_settings_initialize_load_settings_include(self):
        path = os.path.join(self.dir, 'settings.cfg')
        f = open(path, 'wb')
        f.write('[DEFAULT]\ngroup.node1 = value\n\n')
        f.close()

        node1 = config.SchemaNode(
                colander.Str(),
                name = 'node1',
                default = 'default1')

        node2 = config.SchemaNode(
                colander.Int(),
                name = 'node2',
                default = 10)

        group = config.registerSettings('group', node1, node2)
        self._init_memphis()

        config.initializeSettings({'include': path})

        self.assertEqual(group['node1'], 'value')
        self.assertEqual(group['node2'], 10)
示例#9
0
    def test_settings_fs_watcher(self):
        path = os.path.join(self.dir, 'settings.cfg')
        f = open(path, 'wb')
        f.write('[DEFAULT]\ngroup.node1 = value\n\n')
        f.close()

        node1 = config.SchemaNode(
                colander.Str(),
                name = 'node1',
                default = 'default1')

        group = config.registerSettings('group', node1)
        self._init_memphis()

        class Config(object):
            def begin(self):
                pass
            def end(self):
                pass

        config.initializeSettings({'settings': path}, config=Config())

        self.assertTrue(
            isinstance(config.Settings.loader.watcher, iNotifyWatcher))
        self.assertEqual(group['node1'], 'value')

        f = open(path, 'wb')
        f.write('[DEFAULT]\ngroup.node1 = new_value\n\n')
        f.close()
        time.sleep(0.2)

        self.assertEqual(group['node1'], 'new_value')
        self.assertTrue(config.Settings.loader.watcher.started)

        shutdown()
        self.assertFalse(config.Settings.loader.watcher.started)