Пример #1
0
    def test_setenv_unset_multi(self):
        '''test basically same things that above tests but with multiple values passed'''
        ret = envstate.setenv('notimportant', {'foo': 'bar'})
        self.assertEqual(ret['changes'], {'foo': 'bar'})

        with patch.dict(envstate.__salt__, {'reg.read_value': MagicMock()}):
            ret = envstate.setenv('notimportant', {
                'test': False,
                'foo': 'baz'
            },
                                  false_unsets=True)
        self.assertEqual(ret['changes'], {'test': None, 'foo': 'baz'})
        self.assertEqual(envstate.os.environ, {
            'INITIAL': 'initial',
            'foo': 'baz'
        })

        with patch.dict(envstate.__salt__, {'reg.read_value': MagicMock()}):
            ret = envstate.setenv('notimportant', {
                'test': False,
                'foo': 'bax'
            })
        self.assertEqual(ret['changes'], {'test': '', 'foo': 'bax'})
        self.assertEqual(envstate.os.environ, {
            'INITIAL': 'initial',
            'foo': 'bax',
            'test': ''
        })
Пример #2
0
 def test_setenv_test_mode(self):
     '''test that imitating action returns good values'''
     envstate.__opts__ = {'test': True}
     ret = envstate.setenv('test', 'value')
     self.assertEqual(ret['changes'], {'test': 'value'})
     ret = envstate.setenv('INITIAL', 'initial')
     self.assertEqual(ret['changes'], {})
Пример #3
0
 def test_setenv_test_mode(self):
     """test that imitating action returns good values"""
     envstate.__opts__ = {"test": True}
     ret = envstate.setenv("test", "value")
     self.assertEqual(ret["changes"], {"test": "value"})
     ret = envstate.setenv("INITIAL", "initial")
     self.assertEqual(ret["changes"], {})
Пример #4
0
 def test_setenv_test_mode(self):
     '''test that imitating action returns good values'''
     envstate.__opts__ = {'test': True}
     ret = envstate.setenv('test', 'value')
     self.assertEqual(ret['changes'], {'test': 'value'})
     ret = envstate.setenv('INITIAL', 'initial')
     self.assertEqual(ret['changes'], {})
Пример #5
0
def test_setenv_unset_multi():
    """
    test basically same things that above tests but with multiple values passed
    """
    with patch.dict(os.environ, {"INITIAL": "initial"}, clear=True):
        ret = envstate.setenv("notimportant", {"foo": "bar"})
        assert ret["changes"] == {"foo": "bar"}

        with patch.dict(envstate.__utils__, {"reg.read_value": MagicMock()}):
            ret = envstate.setenv(
                "notimportant", {"test": False, "foo": "baz"}, false_unsets=True
            )
        assert ret["changes"] == {"test": None, "foo": "baz"}
        if salt.utils.platform.is_windows():
            assert envstate.os.environ == {"INITIAL": "initial", "FOO": "baz"}
        else:
            assert envstate.os.environ == {"INITIAL": "initial", "foo": "baz"}

        with patch.dict(envstate.__utils__, {"reg.read_value": MagicMock()}):
            ret = envstate.setenv("notimportant", {"test": False, "foo": "bax"})
        assert ret["changes"] == {"test": "", "foo": "bax"}
        if salt.utils.platform.is_windows():
            assert envstate.os.environ == {
                "INITIAL": "initial",
                "FOO": "bax",
                "TEST": "",
            }
        else:
            assert envstate.os.environ == {
                "INITIAL": "initial",
                "foo": "bax",
                "test": "",
            }
Пример #6
0
    def test_setenv_unset(self):
        '''test that ``false_unsets`` option removes variable from environment'''
        ret = envstate.setenv('test', 'value')
        self.assertEqual(ret['changes'], {'test': 'value'})

        ret = envstate.setenv('notimportant', {'test': False}, false_unsets=True)
        self.assertEqual(ret['changes'], {'test': None})
        self.assertEqual(envstate.os.environ, {'INITIAL': 'initial'})
Пример #7
0
    def test_setenv_unset(self):
        """test that ``false_unsets`` option removes variable from environment"""
        ret = envstate.setenv("test", "value")
        self.assertEqual(ret["changes"], {"test": "value"})

        ret = envstate.setenv("notimportant", {"test": False}, false_unsets=True)
        self.assertEqual(ret["changes"], {"test": None})
        self.assertEqual(envstate.os.environ, {"INITIAL": "initial"})
Пример #8
0
    def test_setenv_unset(self):
        '''test that ``false_unsets`` option removes variable from environment'''
        ret = envstate.setenv('test', 'value')
        self.assertEqual(ret['changes'], {'test': 'value'})

        ret = envstate.setenv('notimportant', {'test': False}, false_unsets=True)
        self.assertEqual(ret['changes'], {'test': None})
        self.assertEqual(envstate.os.environ, {'INITIAL': 'initial'})
Пример #9
0
    def test_setenv_permanent(self):
        with patch.dict(envmodule.__salt__, {'reg.set_value': MagicMock(), 'reg.delete_value': MagicMock()}):
            ret = envstate.setenv('test', 'value', permanent=True)
            self.assertEqual(ret['changes'], {'test': 'value'})
            envmodule.__salt__['reg.set_value'].assert_called_with("HKCU", "Environment", 'test', 'value')

            ret = envstate.setenv('test', False, false_unsets=True, permanent=True)
            self.assertEqual(ret['changes'], {'test': None})
            envmodule.__salt__['reg.delete_value'].assert_called_with("HKCU", "Environment", 'test')
Пример #10
0
    def test_setenv_permanent(self):
        with patch.dict(envmodule.__salt__, {'reg.set_value': MagicMock(), 'reg.delete_value': MagicMock()}):
            ret = envstate.setenv('test', 'value', permanent=True)
            self.assertEqual(ret['changes'], {'test': 'value'})
            envmodule.__salt__['reg.set_value'].assert_called_with("HKCU", "Environment", 'test', 'value')

            ret = envstate.setenv('test', False, false_unsets=True, permanent=True)
            self.assertEqual(ret['changes'], {'test': None})
            envmodule.__salt__['reg.delete_value'].assert_called_with("HKCU", "Environment", 'test')
Пример #11
0
 def test_setenv_test_mode(self):
     """
     test that imitating action returns good values
     """
     with patch.dict(envstate.__opts__, {"test": True}):
         ret = envstate.setenv("test", "value")
         self.assertEqual(ret["changes"], {"test": "value"})
         ret = envstate.setenv("INITIAL", "initial")
         self.assertEqual(ret["changes"], {})
Пример #12
0
def test_setenv_test_mode():
    """
    test that imitating action returns good values
    """
    with patch.dict(os.environ, {"INITIAL": "initial"}, clear=True):
        with patch.dict(envstate.__opts__, {"test": True}):
            ret = envstate.setenv("test", "value")
            assert ret["changes"] == {"test": "value"}
            ret = envstate.setenv("INITIAL", "initial")
            assert ret["changes"] == {}
Пример #13
0
    def test_setenv_unset(self):
        """
        test that ``false_unsets`` option removes variable from environment
        """
        ret = envstate.setenv("test", "value")
        self.assertEqual(ret["changes"], {"test": "value"})

        ret = envstate.setenv("notimportant", {"test": False},
                              false_unsets=True)
        self.assertEqual(ret["changes"], {"test": None})
        self.assertEqual(envstate.os.environ, {"INITIAL": "initial"})
Пример #14
0
def test_setenv_unset():
    """
    test that ``false_unsets`` option removes variable from environment
    """
    with patch.dict(os.environ, {"INITIAL": "initial"}, clear=True):
        ret = envstate.setenv("test", "value")
        assert ret["changes"] == {"test": "value"}

        ret = envstate.setenv("notimportant", {"test": False}, false_unsets=True)
        assert ret["changes"] == {"test": None}
        assert envstate.os.environ == {"INITIAL": "initial"}
Пример #15
0
    def test_setenv_permanent(self):
        '''
        test that we can set perminent environment variables (requires pywin32)
        '''
        with patch.dict(envmodule.__utils__, {'reg.set_value': MagicMock(), 'reg.delete_value': MagicMock()}):
            ret = envstate.setenv('test', 'value', permanent=True)
            self.assertEqual(ret['changes'], {'test': 'value'})
            envmodule.__utils__['reg.set_value'].assert_called_with("HKCU", "Environment", 'test', 'value')

            ret = envstate.setenv('test', False, false_unsets=True, permanent=True)
            self.assertEqual(ret['changes'], {'test': None})
            envmodule.__utils__['reg.delete_value'].assert_called_with("HKCU", "Environment", 'test')
Пример #16
0
    def test_setenv(self):
        """test that a subsequent calls of setenv changes nothing"""

        ret = envstate.setenv("test", "value")
        self.assertEqual(ret["changes"], {"test": "value"})

        ret = envstate.setenv("test", "other")
        self.assertEqual(ret["changes"], {"test": "other"})

        # once again with the same value
        ret = envstate.setenv("test", "other")
        self.assertEqual(ret["changes"], {})
Пример #17
0
    def test_setenv_unset_multi(self):
        '''test basically same things that above tests but with multiple values passed'''
        ret = envstate.setenv('notimportant', {'foo': 'bar'})
        self.assertEqual(ret['changes'], {'foo': 'bar'})

        ret = envstate.setenv('notimportant', {'test': False, 'foo': 'baz'}, false_unsets=True)
        self.assertEqual(ret['changes'], {'test': None, 'foo': 'baz'})
        self.assertEqual(envstate.os.environ, {'INITIAL': 'initial', 'foo': 'baz'})

        ret = envstate.setenv('notimportant', {'test': False, 'foo': 'bax'})
        self.assertEqual(ret['changes'], {'test': '', 'foo': 'bax'})
        self.assertEqual(envstate.os.environ, {'INITIAL': 'initial', 'foo': 'bax', 'test': ''})
Пример #18
0
    def test_setenv(self):
        '''test that a subsequent calls of setenv changes nothing'''

        ret = envstate.setenv('test', 'value')
        self.assertEqual(ret['changes'], {'test': 'value'})

        ret = envstate.setenv('test', 'other')
        self.assertEqual(ret['changes'], {'test': 'other'})

        # once again with the same value
        ret = envstate.setenv('test', 'other')
        self.assertEqual(ret['changes'], {})
Пример #19
0
    def test_setenv(self):
        '''test that a subsequent calls of setenv changes nothing'''

        ret = envstate.setenv('test', 'value')
        self.assertEqual(ret['changes'], {'test': 'value'})

        ret = envstate.setenv('test', 'other')
        self.assertEqual(ret['changes'], {'test': 'other'})

        # once again with the same value
        ret = envstate.setenv('test', 'other')
        self.assertEqual(ret['changes'], {})
Пример #20
0
    def test_setenv_unset_multi(self):
        """test basically same things that above tests but with multiple values passed"""
        ret = envstate.setenv("notimportant", {"foo": "bar"})
        self.assertEqual(ret["changes"], {"foo": "bar"})

        ret = envstate.setenv("notimportant", {"test": False, "foo": "baz"}, false_unsets=True)
        self.assertEqual(ret["changes"], {"test": None, "foo": "baz"})
        self.assertEqual(envstate.os.environ, {"INITIAL": "initial", "foo": "baz"})

        ret = envstate.setenv("notimportant", {"test": False, "foo": "bax"})
        self.assertEqual(ret["changes"], {"test": "", "foo": "bax"})
        self.assertEqual(envstate.os.environ, {"INITIAL": "initial", "foo": "bax", "test": ""})
Пример #21
0
def test_setenv():
    """
    test that a subsequent calls of setenv changes nothing
    """
    ret = envstate.setenv("test", "value")
    assert ret["changes"] == {"test": "value"}

    ret = envstate.setenv("test", "other")
    assert ret["changes"] == {"test": "other"}

    # once again with the same value
    ret = envstate.setenv("test", "other")
    assert ret["changes"] == {}
Пример #22
0
    def test_setenv(self):
        """
        test that a subsequent calls of setenv changes nothing
        """
        ret = envstate.setenv("test", "value")
        self.assertEqual(ret["changes"], {"test": "value"})

        ret = envstate.setenv("test", "other")
        self.assertEqual(ret["changes"], {"test": "other"})

        # once again with the same value
        ret = envstate.setenv("test", "other")
        self.assertEqual(ret["changes"], {})
Пример #23
0
 def test_setenv_clearall(self):
     '''
     test that ``clear_all`` option sets other values to ''
     '''
     ret = envstate.setenv('test', 'value', clear_all=True)
     self.assertEqual(ret['changes'], {'test': 'value', 'INITIAL': ''})
     self.assertEqual(envstate.os.environ, {'test': 'value', 'INITIAL': ''})
Пример #24
0
 def test_setenv_int(self):
     """
     test that setenv can not be invoked with int
     (actually it's anything other than strings and dict)
     """
     ret = envstate.setenv("test", 1)
     self.assertEqual(ret["result"], False)
Пример #25
0
 def test_setenv_int(self):
     '''
     test that setenv can not be invoked with int
     (actually it's anything other than strings and dict)
     '''
     ret = envstate.setenv('test', 1)
     self.assertEqual(ret['result'], False)
Пример #26
0
def test_setenv_int():
    """
    test that setenv can not be invoked with int
    (actually it's anything other than strings and dict)
    """
    ret = envstate.setenv("test", 1)
    assert ret["result"] is False
Пример #27
0
 def test_setenv_clearall_with_unset(self):
     '''test that ``clear_all`` option combined with ``false_unsets``
     unsets other values from environment'''
     ret = envstate.setenv('test',
                           'value',
                           false_unsets=True,
                           clear_all=True)
     self.assertEqual(ret['changes'], {'test': 'value', 'INITIAL': None})
     self.assertEqual(envstate.os.environ, {'test': 'value'})
Пример #28
0
    def test_setenv_unset_multi(self):
        """
        test basically same things that above tests but with multiple values passed
        """
        ret = envstate.setenv("notimportant", {"foo": "bar"})
        self.assertEqual(ret["changes"], {"foo": "bar"})

        with patch.dict(envstate.__utils__, {'reg.read_value': MagicMock()}):
            ret = envstate.setenv("notimportant", {
                "test": False,
                "foo": "baz"
            },
                                  false_unsets=True)
        self.assertEqual(ret["changes"], {"test": None, "foo": "baz"})
        if salt.utils.platform.is_windows():
            self.assertEqual(envstate.os.environ, {
                "INITIAL": "initial",
                "FOO": "baz"
            })
        else:
            self.assertEqual(envstate.os.environ, {
                "INITIAL": "initial",
                "foo": "baz"
            })

        with patch.dict(envstate.__utils__, {'reg.read_value': MagicMock()}):
            ret = envstate.setenv('notimportant', {
                'test': False,
                'foo': 'bax'
            })
        self.assertEqual(ret['changes'], {'test': '', 'foo': 'bax'})
        if salt.utils.platform.is_windows():
            self.assertEqual(envstate.os.environ, {
                "INITIAL": "initial",
                "FOO": "bax",
                "TEST": ""
            })
        else:
            self.assertEqual(envstate.os.environ, {
                "INITIAL": "initial",
                "foo": "bax",
                "test": ""
            })
Пример #29
0
 def test_setenv_clearall(self):
     '''
     test that ``clear_all`` option sets other values to ''
     '''
     ret = envstate.setenv('test', 'value', clear_all=True)
     self.assertEqual(ret['changes'], {'test': 'value', 'INITIAL': ''})
     if salt.utils.platform.is_windows():
         self.assertEqual(envstate.os.environ, {'TEST': 'value', 'INITIAL': ''})
     else:
         self.assertEqual(envstate.os.environ, {'test': 'value', 'INITIAL': ''})
Пример #30
0
def test_setenv_clearall():
    """
    test that ``clear_all`` option sets other values to ''
    """
    with patch.dict(os.environ, {"INITIAL": "initial"}, clear=True):
        ret = envstate.setenv("test", "value", clear_all=True)
        assert ret["changes"] == {"test": "value", "INITIAL": ""}
        if salt.utils.platform.is_windows():
            assert envstate.os.environ == {"TEST": "value", "INITIAL": ""}
        else:
            assert envstate.os.environ == {"test": "value", "INITIAL": ""}
Пример #31
0
def test_setenv_clearall_with_unset():
    """
    test that ``clear_all`` option combined with ``false_unsets``
    unsets other values from environment
    """
    with patch.dict(os.environ, {"INITIAL": "initial"}, clear=True):
        ret = envstate.setenv("test", "value", false_unsets=True, clear_all=True)
        assert ret["changes"] == {"test": "value", "INITIAL": None}
        if salt.utils.platform.is_windows():
            assert envstate.os.environ == {"TEST": "value"}
        else:
            assert envstate.os.environ == {"test": "value"}
Пример #32
0
def test_setenv_permanent():
    """
    test that we can set permanent environment variables (requires pywin32)
    """
    with patch.dict(
            envmodule.__utils__,
        {
            "reg.set_value": MagicMock(),
            "reg.delete_value": MagicMock(),
            "win_functions.broadcast_setting_change": MagicMock(),
        },
    ):
        ret = envstate.setenv("test", "value", permanent=True)
        assert ret["changes"] == {"test": "value"}
        envmodule.__utils__["reg.set_value"].assert_called_with(
            "HKCU", "Environment", "test", "value")

        ret = envstate.setenv("test", False, false_unsets=True, permanent=True)
        assert ret["changes"] == {"test": None}
        envmodule.__utils__["reg.delete_value"].assert_called_with(
            "HKCU", "Environment", "test")
Пример #33
0
    def test_setenv_permanent(self):
        """
        test that we can set perminent environment variables (requires pywin32)
        """
        with patch.dict(
                envmodule.__utils__,
            {
                "reg.set_value": MagicMock(),
                "reg.delete_value": MagicMock()
            },
        ):
            ret = envstate.setenv("test", "value", permanent=True)
            self.assertEqual(ret["changes"], {"test": "value"})
            envmodule.__utils__["reg.set_value"].assert_called_with(
                "HKCU", "Environment", "test", "value")

            ret = envstate.setenv("test",
                                  False,
                                  false_unsets=True,
                                  permanent=True)
            self.assertEqual(ret["changes"], {"test": None})
            envmodule.__utils__["reg.delete_value"].assert_called_with(
                "HKCU", "Environment", "test")
Пример #34
0
 def test_setenv_clearall_with_unset(self):
     """
     test that ``clear_all`` option combined with ``false_unsets``
     unsets other values from environment
     """
     ret = envstate.setenv("test",
                           "value",
                           false_unsets=True,
                           clear_all=True)
     self.assertEqual(ret["changes"], {"test": "value", "INITIAL": None})
     if salt.utils.platform.is_windows():
         self.assertEqual(envstate.os.environ, {"TEST": "value"})
     else:
         self.assertEqual(envstate.os.environ, {"test": "value"})
Пример #35
0
 def test_setenv_clearall(self):
     """
     test that ``clear_all`` option sets other values to ''
     """
     ret = envstate.setenv("test", "value", clear_all=True)
     self.assertEqual(ret["changes"], {"test": "value", "INITIAL": ""})
     if salt.utils.platform.is_windows():
         self.assertEqual(envstate.os.environ, {
             "TEST": "value",
             "INITIAL": ""
         })
     else:
         self.assertEqual(envstate.os.environ, {
             "test": "value",
             "INITIAL": ""
         })
Пример #36
0
 def test_setenv_clearall(self):
     """test that ``clear_all`` option sets other values to '' """
     ret = envstate.setenv("test", "value", clear_all=True)
     self.assertEqual(ret["changes"], {"test": "value", "INITIAL": ""})
     self.assertEqual(envstate.os.environ, {"test": "value", "INITIAL": ""})
Пример #37
0
 def test_setenv_dict(self):
     '''test that setenv can be invoked with dict'''
     ret = envstate.setenv('notimportant', {'test': 'value'})
     self.assertEqual(ret['changes'], {'test': 'value'})
Пример #38
0
 def test_setenv_dict(self):
     '''test that setenv can be invoked with dict'''
     ret = envstate.setenv('notimportant', {'test': 'value'})
     self.assertEqual(ret['changes'], {'test': 'value'})
Пример #39
0
 def test_setenv_int(self):
     '''test that setenv can not be invoked with int
     (actually it's anything other than strings and dict)'''
     ret = envstate.setenv('test', 1)
     self.assertEqual(ret['result'], False)
Пример #40
0
 def test_setenv_int(self):
     """test that setenv can not be invoked with int
     (actually it's anything other than strings and dict)"""
     ret = envstate.setenv("test", 1)
     self.assertEqual(ret["result"], False)
Пример #41
0
 def test_setenv_clearall(self):
     '''test that ``clear_all`` option sets other values to '' '''
     ret = envstate.setenv('test', 'value', clear_all=True)
     self.assertEqual(ret['changes'], {'test': 'value', 'INITIAL': ''})
     self.assertEqual(envstate.os.environ, {'test': 'value', 'INITIAL': ''})
Пример #42
0
 def test_setenv_clearall_with_unset(self):
     '''test that ``clear_all`` option combined with ``false_unsets``
     unsets other values from environment'''
     ret = envstate.setenv('test', 'value', false_unsets=True, clear_all=True)
     self.assertEqual(ret['changes'], {'test': 'value', 'INITIAL': None})
     self.assertEqual(envstate.os.environ, {'test': 'value'})
Пример #43
0
 def test_setenv_dict(self):
     """
     test that setenv can be invoked with dict
     """
     ret = envstate.setenv("notimportant", {"test": "value"})
     self.assertEqual(ret["changes"], {"test": "value"})
Пример #44
0
 def test_setenv_dict(self):
     """test that setenv can be invoked with dict"""
     ret = envstate.setenv("notimportant", {"test": "value"})
     self.assertEqual(ret["changes"], {"test": "value"})
Пример #45
0
 def test_setenv_clearall_with_unset(self):
     """test that ``clear_all`` option combined with ``false_unsets``
     unsets other values from environment"""
     ret = envstate.setenv("test", "value", false_unsets=True, clear_all=True)
     self.assertEqual(ret["changes"], {"test": "value", "INITIAL": None})
     self.assertEqual(envstate.os.environ, {"test": "value"})
Пример #46
0
def test_setenv_dict():
    """
    test that setenv can be invoked with dict
    """
    ret = envstate.setenv("notimportant", {"test": "value"})
    assert ret["changes"] == {"test": "value"}