Esempio n. 1
0
    def test_configuration(self):

        # test to get from no file
        configurable = Configurable()

        conf = configurable.get_configuration()

        self.assertEqual(len(conf), len(self.conf))

        # test to get from files which do not exist
        configurable.conf_paths = self.conf_paths

        for conf_path in self.conf_paths:
            try:
                remove(conf_path)
            except OSError:
                pass

        conf = configurable.get_configuration()

        self.assertEqual(len(conf), len(self.conf))

        # get parameters from empty files
        for conf_path in self.conf_paths:
            with open(conf_path, 'w') as _file:
                _file.write('\n')

        conf = configurable.get_configuration()

        self.assertEqual(len(conf), len(self.conf))

        # get parameters from empty files and empty parsing_rules
        conf = Configuration()
        configurable.get_configuration(conf=conf)

        self.assertEqual(len(conf), 0)

        # fill files
        configurable = Configurable(
            conf_paths=self.conf_paths)

        # add first category in conf file[0]
        configurable.set_configuration(
            conf_path=self.conf_paths[0],
            conf=Configuration(self.conf['A']),
            driver=configurable._drivers.split(',')[0])

        # add second category in conf file[1]
        configurable.set_configuration(
            conf_path=self.conf_paths[1],
            conf=Configuration(self.conf['B']),
            driver=configurable._drivers.split(',')[1])

        conf = configurable.get_configuration(conf=self.conf)

        unified_configuration = conf.unify()
        parameters = unified_configuration[Configuration.VALUES]
        errors = unified_configuration[Configuration.ERRORS]

        self.assertTrue('a' in parameters and 'a' not in errors)
        self.assertEqual(parameters['a'].value, 'b')
        self.assertTrue('2' in parameters and '2' not in errors)
        self.assertEqual(parameters['2'].value, 2)
        self.assertTrue('b' in parameters and 'b' not in errors)
        self.assertEqual(parameters['b'].value, 'b')
        self.assertTrue('error' in errors and 'error' not in parameters)
Esempio n. 2
0
    def get_configuration(
        self, conf_path, logger, conf=None, override=True
    ):
        """
        Parse a configuration_files with input conf and returns
        parameters and errors by param name.

        :param str conf_path: conf file to parse and from get parameters
        :param Configuration conf: conf to fill with conf_path values and
            conf param names.
        :param Logger logger: logger to use in order to trace information/error
        :param bool override: if True (by default), override self configuration
        """

        conf_resource = None

        result = None

        # ensure conf_path exists and is not empty.
        if self.exists(conf_path):
            try:
                # first, read conf file
                conf_resource = self._get_conf_resource(
                    conf_path=conf_path,
                    logger=logger
                )

            except Exception as e:
                # if an error occured, log it
                logger.error(
                    'Impossible to parse conf_path {0} with {1}: {2}'.format(
                        conf_path,
                        type(self),
                        e
                    )
                )

            else:  # else process conf file
                if conf_resource is None:
                    return result

                result = Configuration() if conf is None else conf

                categories = self._get_categories(
                    conf_resource=conf_resource,
                    logger=logger
                )

                for category_name in categories:
                    # do something only for referenced categories
                    if category_name in result:
                        category = result.setdefault(
                            category_name,
                            Category(category_name)
                        )

                        if isinstance(category, Category):
                            parameters = self._get_parameters(
                                conf_resource=conf_resource,
                                category=category,
                                logger=logger
                            )

                            for name in parameters:
                                # if param name exists in conf
                                if name in category:
                                    # copy parameter
                                    param = category[name].copy()

                                # else create not local parameter
                                else:
                                    param = Parameter(name, local=False)

                                param = category.setdefault(name, param)

                                value = self._get_value(
                                    conf_resource=conf_resource,
                                    category=category,
                                    param=param,
                                    logger=logger
                                )

                                if value not in (None, ''):
                                    if override or param.value in (None, ''):
                                        param.value = value

                        elif isinstance(category, ParamList):
                            paramlist = category
                            category = Category(category_name)
                            result.categories[category_name] = category

                            parameters = self._get_parameters(
                                conf_resource=conf_resource,
                                category=category,
                                logger=logger
                            )

                            for name in parameters:
                                param = Parameter(
                                    name,
                                    local=False,
                                    parser=paramlist.parser,
                                    asitem=category
                                )

                                param = category.setdefault(name, param)

                                value = self._get_value(
                                    conf_resource=conf_resource,
                                    category=category,
                                    param=param,
                                    logger=logger
                                )

                                if value not in (None, ''):
                                    if override or param.value in (None, ''):
                                        param.value = value

        return result
Esempio n. 3
0
    def test_configuration(self):

        # try to get conf from not existing file
        self._remove()

        conf = self.manager.get_configuration(
            conf_path=self.conf_path,
            logger=self.logger)

        self.assertEqual(conf, None)

        # get conf from an empty media
        self._open()

        conf = self.manager.get_configuration(
            conf_path=self.conf_path,
            logger=self.logger)

        self.assertTrue(conf is None)

        # get full conf
        self.manager.set_configuration(
            conf_path=self.conf_path,
            conf=self.conf,
            logger=self.logger)

        conf = self.manager.get_configuration(
            conf_path=self.conf_path,
            conf=self.conf,
            logger=self.logger)

        self.assertFalse(conf is None)
        self.assertEqual(len(conf), 2)

        unified_conf = conf.unify()

        parameters = unified_conf[Configuration.VALUES]
        errors = unified_conf[Configuration.ERRORS]

        self.assertTrue('a' in parameters and 'a' not in errors)
        self.assertEqual(parameters['a'].value, 0)
        self.assertTrue('b' in parameters and 'b' not in errors)
        self.assertEqual(parameters['b'].value, 1)
        self.assertTrue('c' in errors and 'c' not in parameters)

        # get some conf
        conf = Configuration(self.conf['B'])

        conf = self.manager.get_configuration(
            conf_path=self.conf_path,
            conf=conf,
            logger=self.logger)

        unified_conf = conf.unify()

        parameters = unified_conf[Configuration.VALUES]
        errors = unified_conf[Configuration.ERRORS]

        self.assertTrue('a' not in parameters and 'a' not in errors)
        self.assertTrue('b' in parameters and 'b' not in errors)
        self.assertEqual(parameters['b'].value, 1)
        self.assertTrue('c' in errors and 'c' not in parameters)