Example #1
0
def test_present_non_existing_pass():
    """
    Test present, language not present in database - pass
    """
    name = "plpgsql"
    ret = {"name": name, "changes": {}, "result": False, "comment": ""}
    mock_true = MagicMock(return_value=True)
    mock_empty_language_list = MagicMock(return_value={})
    with patch.dict(
            postgres_language.__salt__,
        {
            "postgres.language_list": mock_empty_language_list,
            "postgres.language_create": mock_true,
        },
    ):
        with patch.dict(postgres_language.__opts__, {"test": True}):
            comt = "Language {} is set to be installed".format(name)
            ret.update({"comment": comt, "result": None})
            assert postgres_language.present(name, "testdb") == ret

        with patch.dict(postgres_language.__opts__, {"test": False}):
            comt = "Language {} has been installed".format(name)
            ret.update({
                "comment": comt,
                "result": True,
                "changes": {
                    "plpgsql": "Present"
                }
            })
            assert postgres_language.present(name, "testdb") == ret
Example #2
0
    def test_present_non_existing_pass(self):
        '''
        Test present, language not present in database - pass
        '''
        with patch.dict(
                postgres_language.__salt__, {
                    'postgres.language_list': self.mock_empty_language_list,
                    'postgres.language_create': self.mock_true
                }):
            with patch.dict(postgres_language.__opts__, {'test': True}):
                comt = 'Language {0} is set to be installed'.format(self.name)
                self.ret.update({'comment': comt, 'result': None})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)

            with patch.dict(postgres_language.__opts__, {'test': False}):
                comt = 'Language {0} has been installed'.format(self.name)
                self.ret.update({
                    'comment': comt,
                    'result': True,
                    'changes': {
                        'plpgsql': 'Present'
                    }
                })
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)
Example #3
0
    def test_present_non_existing_pass(self):
        """
        Test present, language not present in database - pass
        """
        with patch.dict(
                postgres_language.__salt__,
            {
                "postgres.language_list": self.mock_empty_language_list,
                "postgres.language_create": self.mock_true,
            },
        ):
            with patch.dict(postgres_language.__opts__, {"test": True}):
                comt = "Language {0} is set to be installed".format(self.name)
                self.ret.update({"comment": comt, "result": None})
                self.assertDictEqual(
                    postgres_language.present(self.name, "testdb"), self.ret)

            with patch.dict(postgres_language.__opts__, {"test": False}):
                comt = "Language {0} has been installed".format(self.name)
                self.ret.update({
                    "comment": comt,
                    "result": True,
                    "changes": {
                        "plpgsql": "Present"
                    }
                })
                self.assertDictEqual(
                    postgres_language.present(self.name, "testdb"), self.ret)
    def test_present_non_existing_fail(self):
        '''
        Test present, language not present in database - fail
        '''
        with patch.dict(postgres_language.__salt__,
            {'postgres.language_list': self.mock_empty_language_list,
                'postgres.language_create': self.mock_false}):
            with patch.dict(postgres_language.__opts__, {'test': True}):
                comt = 'Language {0} is set to be installed'.format(self.name)
                self.ret.update({'comment': comt, 'result': None})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)

            with patch.dict(postgres_language.__opts__, {'test': False}):
                comt = 'Failed to install language {0}'.format(self.name)
                self.ret.update({'comment': comt, 'result': False})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)
    def test_present_non_existing_fail(self):
        '''
        Test present, language not present in database - fail
        '''
        with patch.dict(postgres_language.__salt__,
            {'postgres.language_list': self.mock_empty_language_list,
                'postgres.language_create': self.mock_false}):
            with patch.dict(postgres_language.__opts__, {'test': True}):
                comt = 'Language {0} is set to be installed'.format(self.name)
                self.ret.update({'comment': comt, 'result': None})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)

            with patch.dict(postgres_language.__opts__, {'test': False}):
                comt = 'Failed to install language {0}'.format(self.name)
                self.ret.update({'comment': comt, 'result': False})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)
 def test_present_existing(self):
     '''
     Test present, language is already present in database
     '''
     with patch.dict(postgres_language.__salt__,
             {'postgres.language_list': self.mock_language_list}):
         comt = 'Language {0} is already installed'.format(self.name)
         self.ret.update({'comment': comt, 'result': True})
         self.assertDictEqual(
             postgres_language.present(self.name, 'testdb'), self.ret)
Example #7
0
 def test_present_existing(self):
     '''
     Test present, language is already present in database
     '''
     with patch.dict(postgres_language.__salt__,
                     {'postgres.language_list': self.mock_language_list}):
         comt = 'Language {0} is already installed'.format(self.name)
         self.ret.update({'comment': comt, 'result': True})
         self.assertDictEqual(
             postgres_language.present(self.name, 'testdb'), self.ret)
    def test_present_non_existing_pass(self):
        '''
        Test present, language not present in database - pass
        '''
        with patch.dict(postgres_language.__salt__,
            {'postgres.language_list': self.mock_empty_language_list,
                'postgres.language_create': self.mock_true}):
            with patch.dict(postgres_language.__opts__, {'test': True}):
                comt = 'Language {0} is set to be installed'.format(self.name)
                self.ret.update({'comment': comt, 'result': None})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)

            with patch.dict(postgres_language.__opts__, {'test': False}):
                comt = 'Language {0} has been installed'.format(self.name)
                self.ret.update({'comment': comt,
                            'result': True,
                            'changes': {'plpgsql': 'Present'}})
                self.assertDictEqual(
                    postgres_language.present(self.name, 'testdb'), self.ret)
Example #9
0
 def test_present_existing(self):
     """
     Test present, language is already present in database
     """
     with patch.dict(
             postgres_language.__salt__,
         {"postgres.language_list": self.mock_language_list},
     ):
         comt = "Language {0} is already installed".format(self.name)
         self.ret.update({"comment": comt, "result": True})
         self.assertDictEqual(
             postgres_language.present(self.name, "testdb"), self.ret)
Example #10
0
    def test_present_non_existing_fail(self):
        """
        Test present, language not present in database - fail
        """
        with patch.dict(
                postgres_language.__salt__,
            {
                "postgres.language_list": self.mock_empty_language_list,
                "postgres.language_create": self.mock_false,
            },
        ):
            with patch.dict(postgres_language.__opts__, {"test": True}):
                comt = "Language {0} is set to be installed".format(self.name)
                self.ret.update({"comment": comt, "result": None})
                self.assertDictEqual(
                    postgres_language.present(self.name, "testdb"), self.ret)

            with patch.dict(postgres_language.__opts__, {"test": False}):
                comt = "Failed to install language {0}".format(self.name)
                self.ret.update({"comment": comt, "result": False})
                self.assertDictEqual(
                    postgres_language.present(self.name, "testdb"), self.ret)
Example #11
0
def test_present_existing():
    """
    Test present, language is already present in database
    """
    name = "plpgsql"
    ret = {"name": name, "changes": {}, "result": False, "comment": ""}
    mock_language_list = MagicMock(return_value={"plpgsql": name})
    with patch.dict(
            postgres_language.__salt__,
        {"postgres.language_list": mock_language_list},
    ):
        comt = "Language {} is already installed".format(name)
        ret.update({"comment": comt, "result": True})
        assert postgres_language.present(name, "testdb") == ret