def test_serialize_yaml(self):
        data = {"foo": "bar"}
        serialized = yaml.serialize(data)
        assert serialized == '{foo: bar}', serialized

        deserialized = yaml.deserialize(serialized)
        assert deserialized == data, deserialized
Пример #2
0
    def test_compare_sls_vs_yaml_with_jinja(self):
        tpl = '{{ data }}'
        env = jinja2.Environment()
        src = '{foo: 1, bar: 2, baz: {qux: true}}'

        sls_src = env.from_string(tpl).render(data=sls.deserialize(src))
        yml_src = env.from_string(tpl).render(data=yaml.deserialize(src))

        sls_data = sls.deserialize(sls_src)
        yml_data = yaml.deserialize(yml_src)

        # ensure that sls & yaml have the same base
        assert isinstance(sls_data, dict)
        assert isinstance(yml_data, dict)
        assert sls_data == yml_data

        # ensure that sls is ordered, while yaml not
        assert isinstance(sls_data, OrderedDict)
        assert not isinstance(yml_data, OrderedDict)

        # prove that yaml does not handle well with OrderedDict
        # while sls is jinja friendly.
        obj = OrderedDict([
            ('foo', 1),
            ('bar', 2),
            ('baz', {'qux': True})
        ])

        sls_obj = sls.deserialize(sls.serialize(obj))
        try:
            yml_obj = yaml.deserialize(yaml.serialize(obj))
        except SerializationError:
            # BLAAM! yaml was unable to serialize OrderedDict,
            # but it's not the purpose of the current test.
            yml_obj = obj.copy()

        sls_src = env.from_string(tpl).render(data=sls_obj)
        yml_src = env.from_string(tpl).render(data=yml_obj)

        final_obj = yaml.deserialize(sls_src)
        assert obj == final_obj

        # BLAAM! yml_src is not valid !
        final_obj = yaml.deserialize(yml_src)
        assert obj != final_obj
Пример #3
0
    def test_serialize_yaml(self):
        data = {
            "foo": "bar"
        }
        serialized = yaml.serialize(data)
        assert serialized == '{foo: bar}', serialized

        deserialized = yaml.deserialize(serialized)
        assert deserialized == data, deserialized
    def test_compare_sls_vs_yaml_with_jinja(self):
        tpl = '{{ data }}'
        env = jinja2.Environment()
        src = '{foo: 1, bar: 2, baz: {qux: true}}'

        sls_src = env.from_string(tpl).render(data=yamlex.deserialize(src))
        yml_src = env.from_string(tpl).render(data=yaml.deserialize(src))

        sls_data = yamlex.deserialize(sls_src)
        yml_data = yaml.deserialize(yml_src)

        # ensure that sls & yaml have the same base
        assert isinstance(sls_data, dict)
        assert isinstance(yml_data, dict)
        assert sls_data == yml_data

        # ensure that sls is ordered, while yaml not
        assert isinstance(sls_data, OrderedDict)
        assert not isinstance(yml_data, OrderedDict)

        # prove that yaml does not handle well with OrderedDict
        # while sls is jinja friendly.
        obj = OrderedDict([('foo', 1), ('bar', 2), ('baz', {'qux': True})])

        sls_obj = yamlex.deserialize(yamlex.serialize(obj))
        try:
            yml_obj = yaml.deserialize(yaml.serialize(obj))
        except SerializationError:
            # BLAAM! yaml was unable to serialize OrderedDict,
            # but it's not the purpose of the current test.
            yml_obj = obj.copy()

        sls_src = env.from_string(tpl).render(data=sls_obj)
        yml_src = env.from_string(tpl).render(data=yml_obj)

        final_obj = yaml.deserialize(sls_src)
        assert obj == final_obj

        # BLAAM! yml_src is not valid !
        final_obj = yaml.deserialize(yml_src)
        assert obj != final_obj
    def test_compare_sls_vs_yaml(self):
        src = '{foo: 1, bar: 2, baz: {qux: true}}'
        sls_data = yamlex.deserialize(src)
        yml_data = yaml.deserialize(src)

        # ensure that sls & yaml have the same base
        assert isinstance(sls_data, dict)
        assert isinstance(yml_data, dict)
        assert sls_data == yml_data

        # ensure that sls is ordered, while yaml not
        assert isinstance(sls_data, OrderedDict)
        assert not isinstance(yml_data, OrderedDict)
Пример #6
0
    def test_compare_sls_vs_yaml(self):
        src = '{foo: 1, bar: 2, baz: {qux: true}}'
        sls_data = sls.deserialize(src)
        yml_data = yaml.deserialize(src)

        # ensure that sls & yaml have the same base
        assert isinstance(sls_data, dict)
        assert isinstance(yml_data, dict)
        assert sls_data == yml_data

        # ensure that sls is ordered, while yaml not
        assert isinstance(sls_data, OrderedDict)
        assert not isinstance(yml_data, OrderedDict)
 def deserialize_salt_file(self, template):
     return yaml_serializer.deserialize(self.get_salt_file(template))
 def deserialize_yamlscript_file(template):
     template.seek(0)
     return yaml_serializer.deserialize(template.read(), **{'Loader': YamlScriptSafeLoader})
def test(salt_data, test_data, sls=''):
    '''
    Runs a test to confirm state values provided in test file matched the
    generated salt_data values exactly as well as confirming the id's of
    the yaml represented states.

    :param OrderedDict salt_data: pyobjects generated state data
    :param YSOrderedDict test_data: De-serialized test data
    :return: number of errors in test1 and test2
    :rtype: int, int

    The best way to run tests is to call the state you are running directly
    like:
    `salt-call --local --out=yaml state.show_sls users`

    test_data can be included in the state file and defined as a list like:

    .. code-block:: yaml

        $test_file:
          - salt://users/tests.mel
          - salt://users/tests.bobby

    And the test_data file should look something like this:

    .. code-block:: yaml

        local:
          mel_shadow_group:
            group:
            - addusers: null
            - delusers: null
            - gid: null
            - members: null
            - name: shadow
            - system: false
            - present
          mel_sudo_group:
          ...

    The test runs two ways, first confirming all expected salt_data is with
    test_data, then the other way around testing if there are extra values
    within the salt_data that are not in the test_data.
    '''
    # Ignore these keys since they may differ on each run
    ignore = ['order', '__sls__', '__env__']

    # Compile salt_data into a valid yamlscript structure
    salt_data = compile_state_data(salt_data)

    # Deserialize test state file
    if isinstance(test_data, str):
        test_data = yaml_serializer.deserialize(test_data)

    # Compile test_data into a valid yamlscript structure and allow test_data to
    # contain the parent 'local' key as shown 'state.show_sls users' or not
    test_data = compile_state_data(test_data.get('local', test_data))

    def compare(test_data, data, text=None, mismatch='mismatch', key_error='key_error'):
        '''
        Function that compares test_data to salt_data and generates a list of
        errors that will be displayed

        :param YSOrderedDict test_data: used as the base to test from
        :param YSOrderedDict data: data is compared to see if it matches test_data
        :param dict text: dictionary of all default text messages to use
        :param str mismatch: key to use to identify a data mismatch that refers to a message in text
        :param str key_error: key to use to identify a data key_error that refers to a message in text
        :return: a list of error messages
        :rtype: list
        '''
        if not text:
            text = {}
        errors = []
        for state_id, states in test_data.items():
            for state_name, state_values in states.items():
                for key, value in state_values.items():
                    if key in ignore:
                        continue
                    try:
                        result_vars = dict(state_id=state_id,
                                           state_name=state_name,
                                           key=key,
                                           value=value)
                        data_value = data[state_id][state_name][key]
                        result_vars.update(data_value=data_value)
                        if value != data_value:
                            # MISMATCH
                            if result_vars['value'] == '':
                                result_vars['value'] = "\'\'"
                            if result_vars['data_value'] == '':
                                result_vars['data_value'] = "\'\'"
                            errors.append(text[mismatch].format(result_vars))
                    except KeyError:
                        # KEY ERROR
                        if result_vars['value'] == '':
                            result_vars['value'] = "\'\'"
                        errors.append(text[key_error].format(result_vars))
        return errors

    sls = ' ({0})'.format(sls) if sls else sls
    text = {
        'mismatch': '<> MISMATCH: {{{0[state_id]}}}:{{{0[state_name]}}}:{{{0[key]}}} is {0[data_value]} but should '
                    'be: {0[value]}',
        'key_error': '-- MISSING : {{{0[state_id]}}}:{{{0[state_name]}}} does not contain key {{{0[key]}: {0[value]}}}',
        'key_error2': '++ EXTRA   : {{{0[state_id]}}}:{{{0[state_name]}}}:{{{0[key]}: {0[value]}}} not in test_data',
        'test_data': 'TEST RESULTS - THE FOLLOWING IS MISSING FROM RENDERED STATE FILE',
        'ruler': '========================================================================================',
        'salt_data': 'TEST RESULTS - THE FOLLOWING IS PRESENT IN GENERATED STATE FILE, BUT NOT IN TEST FILE',
        'end': 'TEST RESULTS - END =====================================================================',
        'blank': '', 'no_error_test': 'Yamlscript Renderer{0}: No errors for test_data'.format(sls),
        'no_error_salt': 'Yamlscript Renderer{0}: No errors for salt_data'.format(sls)
    }

    test1 = compare(test_data, salt_data, text=text)
    if test1:
        print text['test_data']
        print text['ruler']
        for message in test1:
            print message
        print text['blank']
    else:
        print text['no_error_test']

    test2 = compare(salt_data, test_data, text=text, mismatch='', key_error='key_error2')
    if test2:
        print text['salt_data']
        print text['ruler']
        for message in test2:
            print message
        print text['blank']
    else:
        print text['no_error_salt']

    return len(test1), len(test2)