Validation Errors

This is an exploration of the flatten_errors function given to check validation errors.

from configobj import ConfigObj, flatten_errors
from validate import Validator

Literal String

One of the things that I want to check is to see if the plugin was given the correct configuration.

configspec="""
[TEST]
value = LiteralString
""".splitlines()

config = """
[TEST]
value = NonLiteralString
""".splitlines()

config_spec = ConfigObj(configspec,
                        list_values=False,
                        _inspec=True)
configuration = ConfigObj(config, configspec=configspec)

validator = Validator()

outcome = configuration.validate(validator, preserve_errors=True)
print outcome

{'TEST': {'value': VdtUnknownCheckError('the check "LiteralString" is unknown.',)}}

So, it appears that you can’t just make up names in the configspec. What if we give it a single option? .. ‘

configspec="""
[TEST]
value = option('LiteralString')
""".splitlines()

config_spec = ConfigObj(configspec,
                        list_values=False,
                        _inspec=True)

configuration = ConfigObj(config, configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
print outcome

{'TEST': {'value': VdtValueError('the value "NonLiteralString" is unacceptable.',)}}

This seems to be what we want. But now how do you use flatten_errors? First, let’s see what outcome is when the value is correct. .. ‘

config = """
[TEST]
value = LiteralString
""".splitlines()

configuration = ConfigObj(config,
                          configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
print outcome

True

So, instead of a dictionary it returns True. Now let’s try and flatten the errors. .. ‘

def process_errors(config, outcome):
    """
    Uses `flatten_errors` to find bad values

    :param:

      - `config`: ConfigObj that created the outcome
      - `outcome`: returned value from config.validate
    """
    if outcome:
        for section_list, key, error in flatten_errors(config, outcome):
            if key is not None:
                print "The '{0}' key in section '{1}' failed validation (error='{2}')".format(key,
                                                                                ','.join(section_list),
                                                                                error)
            else:
                print "The '{0}' section was missing".format(','.join(section_list))
    return

config = """
[TEST]
value = BadValue
""".splitlines()

configuration = ConfigObj(config,
                          configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
process_errors(configuration, outcome)

The 'value' key in section 'TEST' failed validation (error='the value "BadValue" is unacceptable.')

Missing Value

Okay, so that was the bad-value. What about a missing value?

config_spec = """
[TEST]
option_1 = option('LiteralStringValue')
option_2 = integer
""".splitlines()
configspec = ConfigObj(config_spec,
                       list_values=False,
                       _inspec=True)

Now the configuration.

config = """
[TEST]
option_1 = LiteralStringValue
""".splitlines()

configuration = ConfigObj(config, configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
process_errors(configuration, outcome)

The 'option_2' key in section 'TEST' failed validation (error='False')

That didn’t work the way I thought it would. It looks like setting preserve_errors changes the behavior... I need to change process_errors. .. ‘

Process Errors 2

def process_errors_2(config, outcome):
    """
    Uses `flatten_errors` to find bad values

    :param:

      - `config`: ConfigObj that created the outcome
      - `outcome`: returned value from config.validate
    """
    if outcome:
        for sections, option, error in flatten_errors(config, outcome):
            section = ','.join(sections)
            if option is not None:

                if error:
                    print "Option '{0}' in section '{1}' failed validation (error='{2}')".format(option,
                                                                                                section,
                                                                                                error)
                else:
                    print "Option '{0}' in section '{1}' was missing.".format(option,
                                                                                section)
            else:
                print "The '{0}' section was missing".format(section)
    return

Now check again.

outcome = configuration.validate(validator, preserve_errors=True)
process_errors_2(configuration, outcome)

Option 'option_2' in section 'TEST' was missing.

All Bad Values

Now that we have a working process_errors_2 function, let’s see what happens if both the values are bad. .. ‘

config = """
[TEST]
option_1 = BadValue
option_2 = apple
""".splitlines()

configuration = ConfigObj(config,
                          configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
process_errors_2(configuration, outcome)

Option 'option_1' in section 'TEST' failed validation (error='the value "BadValue" is unacceptable.')
Option 'option_2' in section 'TEST' failed validation (error='the value "apple" is of the wrong type.')

Missing Section

Just for completeness, we’ll make sure that the process_errors_2 function handles missing sections correctly. .. ‘

config_spec = """
[TEST]
option_1 = integer

[[SUBTEST]]
option_2 = float
""".splitlines()

configspec = ConfigObj(config_spec,
                       list_values=False,
                       _inspec=True)
config = """
[TEST]
option_1 = 1
option_2 = 2
""".splitlines()

configuration = ConfigObj(config,
                          configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
process_errors_2(configuration, outcome)

The 'TEST,SUBTEST' section was missing

The output isn’t as intuitive as I would like, but I’m not sure it’s worth the effort to build up the brackets. .. ‘

Extras

Just to be safe, I’ll check to make sure that extra options don’t create errors.

config = """
[TEST]
option_1 = 2

[[SUBTEST]]
option_2 = 3.5
option_4 = 5
""".splitlines()
configuration = ConfigObj(config,
                          configspec=configspec)
outcome = configuration.validate(validator, preserve_errors=True)
process_errors_2(configuration, outcome)