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
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_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)
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)
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_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():
"""
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
