Example #1
0
    def test_change_no_context_with_full_path_multiple_files(self):
        """
        Test handling of different paths with no context supplied
        """
        changes = [
            "set /files/etc/hosts/service-name test",
            "set /files/etc/services/service-name test",
        ]
        filename = "/etc/hosts/service-name"
        filename_ = "/etc/services/service-name"
        comt = (
            "Error: Changes should be made to one file at a time, "
            "detected changes to {0} and {1}".format(filename, filename_)
        )
        self.ret.update(dict(comment=comt, result=False))

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {
                "augeas.execute": mock_execute,
                "augeas.method_map": self.mock_method_map,
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=changes), self.ret
                )
Example #2
0
def test_change_no_context_with_full_path_pass(setup_func):
    """
    Test handling of no context with full path with execute pass
    """
    name = "zabbix"
    fp_changes = [
        "ins service-name after /files/etc/services/service-name[last()]",
        "set /files/etc/services/service-name[last()] zabbix-agent",
    ]
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    ret.update(
        dict(
            comment="Changes have been saved",
            result=True,
            changes={"diff": "+ zabbix-agent"},
        ))

    with patch.dict(augeas.__opts__, {"test": False}):
        mock_execute = MagicMock(return_value=dict(retval=True))
        mock_dict_ = {
            "augeas.execute": mock_execute,
            "augeas.method_map": setup_func.mock_method_map,
        }
        with patch.dict(augeas.__salt__, mock_dict_):
            mock_filename = MagicMock(return_value="/etc/services")
            with patch.object(augeas, "_workout_filename",
                              mock_filename), patch(
                                  "os.path.isfile",
                                  MagicMock(return_value=True)):
                with patch("salt.utils.files.fopen", MagicMock(mock_open)):
                    mock_diff = MagicMock(return_value=["+ zabbix-agent"])
                    with patch("difflib.unified_diff", mock_diff):
                        assert augeas.change(name, changes=fp_changes) == ret
Example #3
0
    def test_change_no_context_with_full_path_pass(self):
        '''
        Test handling of no context with full path with execute pass
        '''
        self.ret.update(
            dict(comment='Changes have been saved',
                 result=True,
                 changes={'diff': '+ zabbix-agent'}))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {
                'augeas.execute': mock_execute,
                'augeas.method_map': self.mock_method_map
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                mock_filename = MagicMock(return_value='/etc/services')
                with patch.object(augeas, '_workout_filename', mock_filename), \
                        patch('os.path.isfile', MagicMock(return_value=True)):
                    with patch('salt.utils.files.fopen', MagicMock(mock_open)):
                        mock_diff = MagicMock(return_value=['+ zabbix-agent'])
                        with patch('difflib.unified_diff', mock_diff):
                            self.assertDictEqual(
                                augeas.change(self.name,
                                              changes=self.fp_changes),
                                self.ret)
Example #4
0
def test_change_with_context_without_old_file(setup_func):
    """
    Test handling of context without oldfile pass
    """
    name = "zabbix"
    context = "/files/etc/services"
    changes = [
        "ins service-name after service-name[last()]",
        "set service-name[last()] zabbix-agent",
    ]
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    ret.update(
        dict(
            comment="Changes have been saved",
            result=True,
            changes={"updates": changes},
        ))

    with patch.dict(augeas.__opts__, {"test": False}):
        mock_execute = MagicMock(return_value=dict(retval=True))
        mock_dict_ = {
            "augeas.execute": mock_execute,
            "augeas.method_map": setup_func.mock_method_map,
        }
        with patch.dict(augeas.__salt__, mock_dict_):
            mock_isfile = MagicMock(return_value=False)
            with patch.object(os.path, "isfile", mock_isfile):
                assert augeas.change(name, context=context,
                                     changes=changes) == ret
Example #5
0
    def test_change_with_context_without_old_file(self):
        """
        Test handling of context without oldfile pass
        """
        self.ret.update(
            dict(
                comment="Changes have been saved",
                result=True,
                changes={"updates": self.changes},
            )
        )

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {
                "augeas.execute": mock_execute,
                "augeas.method_map": self.mock_method_map,
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                mock_isfile = MagicMock(return_value=False)
                with patch.object(os.path, "isfile", mock_isfile):
                    self.assertDictEqual(
                        augeas.change(
                            self.name, context=self.context, changes=self.changes
                        ),
                        self.ret,
                    )
Example #6
0
    def test_change_no_context_with_full_path_pass(self):
        """
        Test handling of no context with full path with execute pass
        """
        self.ret.update(
            dict(
                comment="Changes have been saved",
                result=True,
                changes={"diff": "+ zabbix-agent"},
            )
        )

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {
                "augeas.execute": mock_execute,
                "augeas.method_map": self.mock_method_map,
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                mock_filename = MagicMock(return_value="/etc/services")
                with patch.object(augeas, "_workout_filename", mock_filename), patch(
                    "os.path.isfile", MagicMock(return_value=True)
                ):
                    with patch("salt.utils.files.fopen", MagicMock(mock_open)):
                        mock_diff = MagicMock(return_value=["+ zabbix-agent"])
                        with patch("difflib.unified_diff", mock_diff):
                            self.assertDictEqual(
                                augeas.change(self.name, changes=self.fp_changes),
                                self.ret,
                            )
Example #7
0
    def test_change_non_list_changes(self):
        """
        Test if none list changes handled correctly
        """
        comt = "'changes' must be specified as a list"
        self.ret.update({"comment": comt})

        self.assertDictEqual(augeas.change(self.name), self.ret)
Example #8
0
    def test_change_non_list_changes(self):
        '''
        Test if none list changes handled correctly
        '''
        comt = ('\'changes\' must be specified as a list')
        self.ret.update({'comment': comt})

        self.assertDictEqual(augeas.change(self.name), self.ret)
Example #9
0
    def test_change_non_list_changes(self):
        '''
        Test if none list changes handled correctly
        '''
        comt = ('\'changes\' must be specified as a list')
        self.ret.update({'comment': comt})

        self.assertDictEqual(augeas.change(self.name), self.ret)
Example #10
0
    def test_change_non_list_load_path(self):
        '''
        Test if none list load_path is handled correctly
        '''
        comt = ('\'load_path\' must be specified as a list')
        self.ret.update({'comment': comt})

        self.assertDictEqual(augeas.change(
            self.name, self.context, self.changes, load_path='x'), self.ret)
Example #11
0
    def test_change_non_list_load_path(self):
        '''
        Test if none list load_path is handled correctly
        '''
        comt = ('\'load_path\' must be specified as a list')
        self.ret.update({'comment': comt})

        self.assertDictEqual(augeas.change(
            self.name, self.context, self.changes, load_path='x'), self.ret)
Example #12
0
def test_change_non_list_changes():
    """
    Test if none list changes handled correctly
    """
    name = "zabbix"
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    comt = "'changes' must be specified as a list"
    ret.update({"comment": comt})

    assert augeas.change(name) == ret
Example #13
0
    def test_change(self):
        '''
        Test to issue changes to Augeas, optionally for a specific context,
        with a specific lens.
        '''
        name = 'zabbix'
        context = '/files/etc/services'
        changes = [
            'ins service-name after service-name[last()]',
            'set service-name[last()] zabbix-agent'
        ]

        ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}

        comt = ('\'changes\' must be specified as a list')
        ret.update({'comment': comt})
        self.assertDictEqual(augeas.change(name), ret)

        comt = ('Executing commands in file "/files/etc/services":\n'
                'ins service-name after service-name[last()]'
                '\nset service-name[last()] zabbix-agent')
        ret.update({'comment': comt, 'result': None})
        with patch.dict(augeas.__opts__, {'test': True}):
            self.assertDictEqual(augeas.change(name, context, changes), ret)

        with patch.dict(augeas.__opts__, {'test': False}):
            mock = MagicMock(return_value={'retval': False, 'error': 'error'})
            with patch.dict(augeas.__salt__, {'augeas.execute': mock}):
                ret.update({'comment': 'Error: error', 'result': False})
                self.assertDictEqual(augeas.change(name, changes=changes), ret)

            chang = [
                'ins service-name after service-name[last()]',
                'set service-name[last()] zabbix-agent'
            ]
            mock = MagicMock(return_value={'retval': True})
            with patch.dict(augeas.__salt__, {'augeas.execute': mock}):
                ret.update({
                    'comment': 'Changes have been saved',
                    'result': True,
                    'changes': chang
                })
                self.assertDictEqual(augeas.change(name, changes=changes), ret)
Example #14
0
    def test_change_non_list_load_path(self):
        """
        Test if none list load_path is handled correctly
        """
        comt = "'load_path' must be specified as a list"
        self.ret.update({"comment": comt})

        self.assertDictEqual(
            augeas.change(self.name, self.context, self.changes, load_path="x"),
            self.ret,
        )
Example #15
0
    def test_change_in_test_mode(self):
        '''
        Test test mode handling
        '''
        comt = ('Executing commands in file "/files/etc/services":\n'
                'ins service-name after service-name[last()]'
                '\nset service-name[last()] zabbix-agent')
        self.ret.update({'comment': comt, 'result': True})

        with patch.dict(augeas.__opts__, {'test': True}):
            self.assertDictEqual(
                augeas.change(self.name, self.context, self.changes), self.ret)
Example #16
0
    def test_change_no_context_without_full_path(self):
        '''
        Test handling of no context without full path
        '''
        comt = ('Error: Changes should be prefixed with /files if no '
                'context is provided, change: {0}'.format(self.changes[0]))
        self.ret.update({'comment': comt, 'result': False})

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_dict_ = {'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=self.changes), self.ret)
Example #17
0
    def test_change_in_test_mode(self):
        '''
        Test test mode handling
        '''
        comt = ('Executing commands in file "/files/etc/services":\n'
                'ins service-name after service-name[last()]'
                '\nset service-name[last()] zabbix-agent')
        self.ret.update({'comment': comt, 'result': None})

        with patch.dict(augeas.__opts__, {'test': True}):
            self.assertDictEqual(
                augeas.change(self.name, self.context, self.changes),
                self.ret)
Example #18
0
    def test_change(self):
        '''
        Test to issue changes to Augeas, optionally for a specific context,
        with a specific lens.
        '''
        name = 'zabbix'
        context = '/files/etc/services'
        changes = ['ins service-name after service-name[last()]',
                   'set service-name[last()] zabbix-agent']
        changes_ret = {'updates': changes}

        ret = {'name': name,
               'result': False,
               'changes': {},
               'comment': ''}

        comt = ('\'changes\' must be specified as a list')
        ret.update({'comment': comt})
        self.assertDictEqual(augeas.change(name), ret)

        comt = ('Executing commands in file "/files/etc/services":\n'
                'ins service-name after service-name[last()]'
                '\nset service-name[last()] zabbix-agent')
        ret.update({'comment': comt, 'result': None})
        with patch.dict(augeas.__opts__, {'test': True}):
            self.assertDictEqual(augeas.change(name, context, changes), ret)

        with patch.dict(augeas.__opts__, {'test': False}):
            mock = MagicMock(return_value={'retval': False, 'error': 'error'})
            with patch.dict(augeas.__salt__, {'augeas.execute': mock}):
                ret.update({'comment': 'Error: error', 'result': False})
                self.assertDictEqual(augeas.change(name, changes=changes), ret)

            mock = MagicMock(return_value={'retval': True})
            with patch.dict(augeas.__salt__, {'augeas.execute': mock}):
                ret.update({'comment': 'Changes have been saved',
                            'result': True, 'changes': changes_ret})
                self.assertDictEqual(augeas.change(name, changes=changes), ret)
Example #19
0
    def test_change_in_test_mode(self):
        """
        Test test mode handling
        """
        comt = (
            'Executing commands in file "/files/etc/services":\n'
            "ins service-name after service-name[last()]"
            "\nset service-name[last()] zabbix-agent"
        )
        self.ret.update({"comment": comt, "result": True})

        with patch.dict(augeas.__opts__, {"test": True}):
            self.assertDictEqual(
                augeas.change(self.name, self.context, self.changes), self.ret
            )
Example #20
0
    def test_change_no_context_without_full_path(self):
        '''
        Test handling of no context without full path
        '''
        comt = 'Error: Changes should be prefixed with /files if no ' \
                'context is provided, change: {0}'\
                .format(self.changes[0])
        self.ret.update({'comment': comt, 'result': False})

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_dict_ = {'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=self.changes),
                    self.ret)
Example #21
0
def test_change_non_list_load_path():
    """
    Test if none list load_path is handled correctly
    """
    name = "zabbix"
    context = "/files/etc/services"
    changes = [
        "ins service-name after service-name[last()]",
        "set service-name[last()] zabbix-agent",
    ]
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    comt = "'load_path' must be specified as a list"
    ret.update({"comment": comt})

    assert augeas.change(name, context, changes, load_path="x") == ret
Example #22
0
    def test_change_no_context_with_full_path_fail(self):
        '''
        Test handling of no context with full path with execute fail
        '''
        self.ret.update({'comment': 'Error: error', 'result': False})

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(
                return_value=dict(retval=False, error='error'))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=self.fp_changes),
                    self.ret)
Example #23
0
    def test_change_no_context_with_full_path_fail(self):
        '''
        Test handling of no context with full path with execute fail
        '''
        self.ret.update({'comment': 'Error: error', 'result': False})

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(
                return_value=dict(retval=False, error='error'))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=self.fp_changes),
                    self.ret)
Example #24
0
    def test_change_no_context_without_full_path_invalid_cmd(self):
        '''
        Test handling of invalid commands when no context supplied
        '''
        self.ret.update(dict(comment='Error: Command det is not supported (yet)',
                            result=False))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                changes = ['det service-name[last()] zabbix-agent']
                self.assertDictEqual(augeas.change(self.name,
                                    changes=changes),
                                    self.ret)
Example #25
0
    def test_change_no_context_without_full_path_invalid_cmd(self):
        '''
        Test handling of invalid commands when no context supplied
        '''
        self.ret.update(dict(comment='Error: Command det is not supported (yet)',
                            result=False))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                changes = ['det service-name[last()] zabbix-agent']
                self.assertDictEqual(augeas.change(self.name,
                                    changes=changes),
                                    self.ret)
Example #26
0
    def test_change_no_context_without_full_path(self):
        """
        Test handling of no context without full path
        """
        comt = (
            "Error: Changes should be prefixed with /files if no "
            "context is provided, change: {0}".format(self.changes[0])
        )
        self.ret.update({"comment": comt, "result": False})

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_dict_ = {"augeas.method_map": self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=self.changes), self.ret
                )
Example #27
0
    def test_change_no_context_with_full_path_fail(self):
        """
        Test handling of no context with full path with execute fail
        """
        self.ret.update({"comment": "Error: error", "result": False})

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_execute = MagicMock(return_value=dict(retval=False, error="error"))
            mock_dict_ = {
                "augeas.execute": mock_execute,
                "augeas.method_map": self.mock_method_map,
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=self.fp_changes), self.ret
                )
Example #28
0
    def test_change_with_context_without_full_path_fail(self):
        '''
        Test handling of context without full path fails
        '''
        self.ret.update(dict(comment='Error: error', result=False))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(
                return_value=dict(retval=False, error='error'))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                with patch('salt.utils.fopen', MagicMock(mock_open)):
                    self.assertDictEqual(augeas.change(self.name,
                                        context=self.context,
                                        changes=self.changes),
                                        self.ret)
Example #29
0
    def test_change_with_context_without_full_path_fail(self):
        '''
        Test handling of context without full path fails
        '''
        self.ret.update(dict(comment='Error: error', result=False))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(
                return_value=dict(retval=False, error='error'))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                with patch('salt.utils.fopen', MagicMock(mock_open)):
                    self.assertDictEqual(augeas.change(self.name,
                                        context=self.context,
                                        changes=self.changes),
                                        self.ret)
Example #30
0
def test_change_no_context_without_full_path_invalid_change(setup_func):
    """
    Test handling of invalid change when no context supplied
    """
    name = "zabbix"
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    comt = "Error: Invalid formatted command, see debug log for details: require"
    ret.update(dict(comment=comt, result=False))
    changes = ["require"]

    with patch.dict(augeas.__opts__, {"test": False}):
        mock_execute = MagicMock(return_value=dict(retval=True))
        mock_dict_ = {
            "augeas.execute": mock_execute,
            "augeas.method_map": setup_func.mock_method_map,
        }
        with patch.dict(augeas.__salt__, mock_dict_):
            assert augeas.change(name, changes=changes) == ret
Example #31
0
def test_change_in_test_mode():
    """
    Test test mode handling
    """
    name = "zabbix"
    context = "/files/etc/services"
    changes = [
        "ins service-name after service-name[last()]",
        "set service-name[last()] zabbix-agent",
    ]
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    comt = ('Executing commands in file "/files/etc/services":\n'
            "ins service-name after service-name[last()]"
            "\nset service-name[last()] zabbix-agent")
    ret.update({"comment": comt, "result": True})

    with patch.dict(augeas.__opts__, {"test": True}):
        assert augeas.change(name, context, changes) == ret
Example #32
0
    def test_change_no_context_without_full_path_invalid_change(self):
        """
        Test handling of invalid change when no context supplied
        """
        comt = "Error: Invalid formatted command, see " "debug log for details: require"
        self.ret.update(dict(comment=comt, result=False))
        changes = ["require"]

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {
                "augeas.execute": mock_execute,
                "augeas.method_map": self.mock_method_map,
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(
                    augeas.change(self.name, changes=changes), self.ret
                )
Example #33
0
    def test_change_no_context_without_full_path_invalid_change(self):
        '''
        Test handling of invalid change when no context supplied
        '''
        comt = ('Error: Invalid formatted command, see '
                'debug log for details: require')
        self.ret.update(dict(comment=comt,
                            result=False))
        changes = ['require']

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(augeas.change(self.name,
                                    changes=changes),
                                    self.ret)
Example #34
0
    def test_change_no_context_without_full_path_invalid_change(self):
        '''
        Test handling of invalid change when no context supplied
        '''
        comt = ('Error: Invalid formatted command, see '
                'debug log for details: require')
        self.ret.update(dict(comment=comt, result=False))
        changes = ['require']

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {
                'augeas.execute': mock_execute,
                'augeas.method_map': self.mock_method_map
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(augeas.change(self.name, changes=changes),
                                     self.ret)
Example #35
0
def test_change_no_context_without_full_path(setup_func):
    """
    Test handling of no context without full path
    """
    name = "zabbix"
    context = "/files/etc/services"
    changes = [
        "ins service-name after service-name[last()]",
        "set service-name[last()] zabbix-agent",
    ]
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    comt = ("Error: Changes should be prefixed with /files if no "
            "context is provided, change: {}".format(changes[0]))
    ret.update({"comment": comt, "result": False})

    with patch.dict(augeas.__opts__, {"test": False}):
        mock_dict_ = {"augeas.method_map": setup_func.mock_method_map}
        with patch.dict(augeas.__salt__, mock_dict_):
            assert augeas.change(name, changes=changes) == ret
Example #36
0
    def test_change_with_context_without_old_file(self):
        '''
        Test handling of context without oldfile pass
        '''
        self.ret.update(dict(comment='Changes have been saved',
                            result=True,
                            changes={'updates': self.changes}))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                mock_isfile = MagicMock(return_value=False)
                with patch.object(os.path, 'isfile', mock_isfile):
                    self.assertDictEqual(augeas.change(self.name,
                                        context=self.context,
                                        changes=self.changes),
                                        self.ret)
Example #37
0
def test_change_no_context_without_full_path_invalid_cmd(setup_func):
    """
    Test handling of invalid commands when no context supplied
    """
    name = "zabbix"
    ret = {"name": name, "result": False, "changes": {}, "comment": ""}
    ret.update(
        dict(comment="Error: Command det is not supported (yet)",
             result=False))

    with patch.dict(augeas.__opts__, {"test": False}):
        mock_execute = MagicMock(return_value=dict(retval=True))
        mock_dict_ = {
            "augeas.execute": mock_execute,
            "augeas.method_map": setup_func.mock_method_map,
        }
        with patch.dict(augeas.__salt__, mock_dict_):
            changes = ["det service-name[last()] zabbix-agent"]
            assert augeas.change(name, changes=changes) == ret
Example #38
0
    def test_change_with_context_without_old_file(self):
        '''
        Test handling of context without oldfile pass
        '''
        self.ret.update(dict(comment='Changes have been saved',
                            result=True,
                            changes={'updates': self.changes}))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                mock_isfile = MagicMock(return_value=False)
                with patch.object(os.path, 'isfile', mock_isfile):
                    self.assertDictEqual(augeas.change(self.name,
                                        context=self.context,
                                        changes=self.changes),
                                        self.ret)
Example #39
0
    def test_change_with_context_without_full_path_fail(self):
        """
        Test handling of context without full path fails
        """
        self.ret.update(dict(comment="Error: error", result=False))

        with patch.dict(augeas.__opts__, {"test": False}):
            mock_execute = MagicMock(return_value=dict(retval=False, error="error"))
            mock_dict_ = {
                "augeas.execute": mock_execute,
                "augeas.method_map": self.mock_method_map,
            }
            with patch.dict(augeas.__salt__, mock_dict_):
                with patch("salt.utils.files.fopen", MagicMock(mock_open)):
                    self.assertDictEqual(
                        augeas.change(
                            self.name, context=self.context, changes=self.changes
                        ),
                        self.ret,
                    )
Example #40
0
    def test_change_no_context_with_full_path_multiple_files(self):
        '''
        Test handling of different paths with no context supplied
        '''
        changes = ['set /files/etc/hosts/service-name test',
                   'set /files/etc/services/service-name test']
        filename = '/etc/hosts/service-name'
        filename_ = '/etc/services/service-name'
        comt = 'Error: Changes should be made to one file at a time, ' \
                'detected changes to {0} and {1}'.format(filename, filename_)
        self.ret.update(dict(comment=comt,
                            result=False))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(augeas.change(self.name,
                                    changes=changes),
                                    self.ret)
Example #41
0
    def test_change_no_context_with_full_path_pass(self):
        '''
        Test handling of no context with full path with execute pass
        '''
        self.ret.update(dict(comment='Changes have been saved',
                            result=True,
                            changes={'diff': '+ zabbix-agent'}))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                mock_filename = MagicMock(return_value='/etc/services')
                with patch.object(augeas, '_workout_filename', mock_filename):
                    with patch('salt.utils.fopen', MagicMock(mock_open)):
                        mock_diff = MagicMock(return_value=['+ zabbix-agent'])
                        with patch('difflib.unified_diff', mock_diff):
                            self.assertDictEqual(augeas.change(self.name,
                                                 changes=self.fp_changes),
                                                 self.ret)
Example #42
0
    def test_change_no_context_with_full_path_multiple_files(self):
        '''
        Test handling of different paths with no context supplied
        '''
        changes = ['set /files/etc/hosts/service-name test',
                   'set /files/etc/services/service-name test']
        filename = '/etc/hosts/service-name'
        filename_ = '/etc/services/service-name'
        comt = 'Error: Changes should be made to one file at a time, ' \
                'detected changes to {0} and {1}'.format(filename, filename_)
        self.ret.update(dict(comment=comt,
                            result=False))

        with patch.dict(augeas.__opts__, {'test': False}):
            mock_execute = MagicMock(return_value=dict(retval=True))
            mock_dict_ = {'augeas.execute': mock_execute,
                        'augeas.method_map': self.mock_method_map}
            with patch.dict(augeas.__salt__, mock_dict_):
                self.assertDictEqual(augeas.change(self.name,
                                    changes=changes),
                                    self.ret)