def test_absent(self):
'''
Test to ensure that the named extension is absent.
'''
name = 'frank'
ret = {'name': name,
'changes': {},
'result': False,
'comment': ''}
mock_t = MagicMock(side_effect=[True, False])
mock = MagicMock(side_effect=[True, True, True, False])
with patch.dict(postgres_extension.__salt__,
{'postgres.is_installed_extension': mock,
'postgres.drop_extension': mock_t}):
with patch.dict(postgres_extension.__opts__, {'test': True}):
comt = ('Extension {0} is set to be removed'.format(name))
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(postgres_extension.absent(name), ret)
with patch.dict(postgres_extension.__opts__, {'test': False}):
comt = ('Extension {0} has been removed'.format(name))
ret.update({'comment': comt, 'result': True,
'changes': {name: 'Absent'}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = ('Extension {0} failed to be removed'.format(name))
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = ('Extension {0} is not present, so it cannot be removed'
.format(name))
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(postgres_extension.absent(name), ret)
def test_absent(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': 'Extension foo has been removed',
'changes': {
'foo': 'Absent'
},
'name': 'foo',
'result': True
})
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': ('Extension foo is not present, '
'so it cannot be removed'),
'changes': {},
'name':
'foo',
'result':
True
})
def test_absent(self):
'''
Test to ensure that the named extension is absent.
'''
name = 'frank'
ret = {'name': name,
'changes': {},
'result': False,
'comment': ''}
mock_t = MagicMock(side_effect=[True, False])
mock = MagicMock(side_effect=[True, True, True, False])
with patch.dict(postgres_extension.__salt__,
{'postgres.is_installed_extension': mock,
'postgres.drop_extension': mock_t}):
with patch.dict(postgres_extension.__opts__, {'test': True}):
comt = ('Extension {0} is set to be removed'.format(name))
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(postgres_extension.absent(name), ret)
with patch.dict(postgres_extension.__opts__, {'test': False}):
comt = ('Extension {0} has been removed'.format(name))
ret.update({'comment': comt, 'result': True,
'changes': {name: 'Absent'}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = ('Extension {0} failed to be removed'.format(name))
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = ('Extension {0} is not present, so it cannot be removed'
.format(name))
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(postgres_extension.absent(name), ret)
def test_absent(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
with patch.dict(postgres_extension.__salt__, {
'postgres.is_installed_extension': Mock(side_effect=[
True, False,
]),
'postgres.drop_extension': Mock(side_effect=[
True, True,
])}):
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': 'Extension foo has been removed',
'changes': {'foo': 'Absent'}, 'name': 'foo', 'result': True}
)
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': (
'Extension foo is not present, '
'so it cannot be removed'),
'changes': {}, 'name': 'foo', 'result': True}
)
def test_absent():
"""
scenario of creating upgrading extensions with possible schema and
version specifications
"""
with patch.dict(
postgres_extension.__salt__,
{
"postgres.is_installed_extension": Mock(side_effect=[True, False]),
"postgres.drop_extension": Mock(side_effect=[True, True]),
},
):
ret = postgres_extension.absent("foo")
assert ret == {
"comment": "Extension foo has been removed",
"changes": {
"foo": "Absent"
},
"name": "foo",
"result": True,
}
ret = postgres_extension.absent("foo")
assert ret == {
"comment": "Extension foo is not present, so it cannot be removed",
"changes": {},
"name": "foo",
"result": True,
}
def test_absent_failed(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
with patch.dict(postgres_extension.__opts__, {'test': False}):
with patch.dict(
postgres_extension.__salt__, {
'postgres.is_installed_extension':
Mock(side_effect=[
True,
True,
]),
'postgres.drop_extension':
Mock(side_effect=[
False,
False,
])
}):
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': 'Extension foo failed to be removed',
'changes': {},
'name': 'foo',
'result': False
})
def test_absent_failed(self):
"""
scenario of creating upgrading extensions with possible schema and
version specifications
"""
with patch.dict(postgres_extension.__opts__, {"test": False}):
with patch.dict(
postgres_extension.__salt__,
{
"postgres.is_installed_extension":
Mock(side_effect=[True, True]),
"postgres.drop_extension":
Mock(side_effect=[False, False]),
},
):
ret = postgres_extension.absent("foo")
self.assertEqual(
ret,
{
"comment": "Extension foo failed to be removed",
"changes": {},
"name": "foo",
"result": False,
},
)
def test_absent_failedtest(self):
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': 'Extension foo is set to be removed',
'changes': {}, 'name': 'foo', 'result': None}
)
def test_absent_failed(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': 'Extension foo failed to be removed',
'changes': {}, 'name': 'foo', 'result': False}
)
def test_absent(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': 'Extension foo has been removed',
'changes': {'foo': 'Absent'}, 'name': 'foo', 'result': True}
)
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': (
'Extension foo is not present, '
'so it cannot be removed'),
'changes': {}, 'name': 'foo', 'result': True}
)
def test_absent_failed(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': 'Extension foo failed to be removed',
'changes': {}, 'name': 'foo', 'result': False}
)
def test_absent_failedtest(self):
with patch.dict(postgres_extension.__salt__, {
'postgres.is_installed_extension': Mock(side_effect=[
True, True,
]),
'postgres.drop_extension': Mock(side_effect=[
False, False,
])}):
with patch.dict(postgres_extension.__opts__, {'test': True}):
ret = postgres_extension.absent('foo')
self.assertEqual(
ret,
{'comment': 'Extension foo is set to be removed',
'changes': {}, 'name': 'foo', 'result': None}
)
def test_absent(self):
"""
Test to ensure that the named extension is absent.
"""
name = "frank"
ret = {"name": name, "changes": {}, "result": False, "comment": ""}
mock_t = MagicMock(side_effect=[True, False])
mock = MagicMock(side_effect=[True, True, True, False])
with patch.dict(
postgres_extension.__salt__,
{
"postgres.is_installed_extension": mock,
"postgres.drop_extension": mock_t,
},
):
with patch.dict(postgres_extension.__opts__, {"test": True}):
comt = "Extension {0} is set to be removed".format(name)
ret.update({"comment": comt, "result": None})
self.assertDictEqual(postgres_extension.absent(name), ret)
with patch.dict(postgres_extension.__opts__, {"test": False}):
comt = "Extension {0} has been removed".format(name)
ret.update(
{"comment": comt, "result": True, "changes": {name: "Absent"}}
)
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = "Extension {0} failed to be removed".format(name)
ret.update({"comment": comt, "result": False, "changes": {}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = "Extension {0} is not present, so it cannot be removed".format(name)
ret.update({"comment": comt, "result": True})
self.assertDictEqual(postgres_extension.absent(name), ret)
def test_absent_failedtest():
with patch.dict(
postgres_extension.__salt__,
{
"postgres.is_installed_extension": Mock(side_effect=[True, True]),
"postgres.drop_extension": Mock(side_effect=[False, False]),
},
):
with patch.dict(postgres_extension.__opts__, {"test": True}):
ret = postgres_extension.absent("foo")
assert ret == {
"comment": "Extension foo is set to be removed",
"changes": {},
"name": "foo",
"result": None,
}
