def test_present__update(self):
# test=True
with patch.dict(postgres_group.__opts__, {'test': True}):
ret = postgres_group.present('foo', login=True, replication=False)
self.assertEqual(
ret,
{'comment': 'Group foo is set to be updated',
'changes': {'foo': {'login': True}}, 'name': 'foo', 'result': None}
)
self.assertEqual(SALT_STUB['postgres.group_update'].call_count, 0)
# test=False
ret = postgres_group.present('foo', login=True, replication=False)
self.assertEqual(
ret,
{'comment': 'The group foo has been updated',
'changes': {'foo': {'login': True}}, 'name': 'foo', 'result': True}
)
SALT_STUB['postgres.group_update'].assert_called_once_with(superuser=None,
replication=False,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
groupname='foo',
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=True,
password=None,
createdb=None)
def test_present_create_basic(mocks, db_args):
assert postgres_group.present("groupname") == {
"name": "groupname",
"result": True,
"changes": {
"groupname": "Present"
},
"comment": "The group groupname has been created",
}
mocks["postgres.role_get"].assert_called_once_with("groupname",
return_password=True,
**db_args)
mocks["postgres.group_create"].assert_called_once_with(
groupname="groupname",
createdb=None,
createroles=None,
encrypted="md5",
superuser=None,
login=None,
inherit=None,
replication=None,
rolepassword=None,
groups=None,
**db_args)
mocks["postgres.group_update"].assert_not_called()
def test_present_update_password_no_check(mocks, existing_group, md5_pw,
db_args):
mocks["postgres.role_get"].return_value = existing_group
assert postgres_group.present("groupname",
password="******",
encrypted=True,
refresh_password=True) == {
"name": "groupname",
"result": True,
"changes": {
"groupname": {
"password": True
}
},
"comment":
"The group groupname has been updated",
}
mocks["postgres.role_get"].assert_called_once_with("groupname",
return_password=False,
**db_args)
mocks["postgres.group_create"].assert_not_called()
mocks["postgres.group_update"].assert_called_once_with(
groupname="groupname",
createdb=None,
createroles=None,
encrypted=True,
superuser=None,
login=None,
inherit=None,
replication=None,
rolepassword=md5_pw,
groups=None,
**db_args)
def test_present_create_md5_password_default_encrypted(mocks, monkeypatch,
md5_pw, db_args):
monkeypatch.setattr(postgres, "_DEFAULT_PASSWORDS_ENCRYPTION", True)
assert postgres_group.present("groupname", password="******") == {
"name": "groupname",
"result": True,
"changes": {
"groupname": "Present"
},
"comment": "The group groupname has been created",
}
mocks["postgres.role_get"].assert_called_once()
mocks["postgres.group_create"].assert_called_once_with(
groupname="groupname",
createdb=None,
createroles=None,
encrypted=True,
superuser=None,
login=None,
inherit=None,
replication=None,
rolepassword=md5_pw,
groups=None,
**db_args)
mocks["postgres.group_update"].assert_not_called()
def test_present__update(self):
# test=True
with patch.dict(OPTS, {'test': True}):
ret = postgres_group.present('foo', login=True, replication=False)
self.assertEqual(
ret, {
'comment': 'Group foo is set to be updated',
'changes': {
'foo': {
'login': True
}
},
'name': 'foo',
'result': None
})
self.assertEqual(SALT_STUB['postgres.group_update'].call_count, 0)
# test=False
ret = postgres_group.present('foo', login=True, replication=False)
self.assertEqual(
ret, {
'comment': 'The group foo has been updated',
'changes': {
'foo': {
'login': True
}
},
'name': 'foo',
'result': True
})
SALT_STUB['postgres.group_update'].assert_called_once_with(
superuser=None,
replication=False,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
groupname='foo',
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=True,
password=None,
createdb=None)
def test_present__update(self):
# test=True
with patch.dict(postgres_group.__salt__, {'postgres.role_get': Mock(return_value={
'can create databases': False,
'can create roles': False,
'can login': False,
'can update system catalogs': False,
'connections': None,
'defaults variables': {},
'expiry time': None,
'inherits privileges': True,
'replication': False,
'superuser': False,
}),
'postgres.group_update': MagicMock()}):
with patch.dict(postgres_group.__opts__, {'test': True}):
ret = postgres_group.present('foo', login=True, replication=False)
self.assertEqual(
ret,
{'comment': 'Group foo is set to be updated',
'changes': {'foo': {'login': True}}, 'name': 'foo', 'result': None}
)
self.assertEqual(self.salt_stub['postgres.group_update'].call_count, 0)
# test=False
ret = postgres_group.present('foo', login=True, replication=False)
self.assertEqual(
ret,
{'comment': 'The group foo has been updated',
'changes': {'foo': {'login': True}}, 'name': 'foo', 'result': True}
)
self.salt_stub['postgres.group_update'].assert_called_once_with(superuser=None,
replication=False,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
groupname='foo',
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=True,
password=None,
createdb=None)
def test_present__no_update(self):
# test=True
with patch.dict(
postgres_group.__salt__, {
'postgres.role_get':
Mock(
return_value={
'can create databases': False,
'can create roles': False,
'can login': False,
'can update system catalogs': False,
'connections': None,
'defaults variables': {},
'expiry time': None,
'inherits privileges': True,
'replication': False,
'superuser': False,
}),
'postgres.group_update':
MagicMock()
}):
with patch.dict(postgres_group.__opts__, {'test': True}):
ret = postgres_group.present('foo',
login=False,
replication=False)
self.assertEqual(
ret, {
'comment': 'Group foo is already present',
'changes': {},
'name': 'foo',
'result': True
})
self.assertEqual(
self.salt_stub['postgres.group_update'].call_count, 0)
# test=False
ret = postgres_group.present('foo', login=False, replication=False)
self.assertEqual(
ret, {
'comment': 'Group foo is already present',
'changes': {},
'name': 'foo',
'result': True
})
self.assertEqual(
self.salt_stub['postgres.group_update'].call_count, 0)
def test_present__creation(self):
# test=True
with patch.dict(
postgres_group.__salt__, {
'postgres.role_get': Mock(return_value=None),
'postgres.group_create': MagicMock()
}):
with patch.dict(postgres_group.__opts__, {'test': True}):
ret = postgres_group.present('foo')
self.assertEqual(
ret, {
'comment': 'Group foo is set to be created',
'changes': {},
'name': 'foo',
'result': None
})
self.assertEqual(
self.salt_stub['postgres.group_create'].call_count, 0)
# test=False
ret = postgres_group.present('foo')
self.assertEqual(
ret, {
'comment': 'The group foo has been created',
'changes': {},
'name': 'foo',
'result': True
})
self.salt_stub['postgres.group_create'].assert_called_once_with(
superuser=None,
replication=None,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
groupname='foo',
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=None,
password=None,
createdb=None)
def test_present__no_update(self):
# test=True
with patch.dict(OPTS, {'test': True}):
ret = postgres_group.present('foo', login=False, replication=False)
self.assertEqual(
ret,
{'comment': 'Group foo is already present',
'changes': {}, 'name': 'foo', 'result': True}
)
self.assertEqual(SALT_STUB['postgres.group_update'].call_count, 0)
# test=False
ret = postgres_group.present('foo', login=False, replication=False)
self.assertEqual(
ret,
{'comment': 'Group foo is already present',
'changes': {}, 'name': 'foo', 'result': True}
)
self.assertEqual(SALT_STUB['postgres.group_update'].call_count, 0)
def test_present__no_update(self):
# test=True
with patch.dict(OPTS, {'test': True}):
ret = postgres_group.present('foo', login=False, replication=False)
self.assertEqual(
ret,
{'comment': 'Group foo is already present',
'changes': {}, 'name': 'foo', 'result': True}
)
self.assertEqual(SALT_STUB['postgres.group_update'].call_count, 0)
# test=False
ret = postgres_group.present('foo', login=False, replication=False)
self.assertEqual(
ret,
{'comment': 'Group foo is already present',
'changes': {}, 'name': 'foo', 'result': True}
)
self.assertEqual(SALT_STUB['postgres.group_update'].call_count, 0)
def test_present(self):
"""
Test to ensure that the named group is present
with the specified privileges.
"""
name = "frank"
ret = {"name": name, "changes": {}, "result": False, "comment": ""}
mock_t = MagicMock(return_value=True)
mock = MagicMock(return_value=None)
with patch.dict(postgres_group.__salt__, {"postgres.role_get": mock, "postgres.group_create": mock_t}):
with patch.dict(postgres_group.__opts__, {"test": True}):
comt = "Group {0} is set to be created".format(name)
ret.update({"comment": comt, "result": None})
self.assertDictEqual(postgres_group.present(name), ret)
with patch.dict(postgres_group.__opts__, {"test": False}):
comt = "The group {0} has been created".format(name)
ret.update({"comment": comt, "result": True})
self.assertDictEqual(postgres_group.present(name), ret)
def test_present_create_basic_test(mocks, db_args):
assert postgres_group.present("groupname") == {
"name": "groupname",
"result": None,
"changes": {},
"comment": "Group groupname is set to be created",
}
mocks["postgres.role_get"].assert_called_once_with("groupname",
return_password=True,
**db_args)
mocks["postgres.group_create"].assert_not_called()
mocks["postgres.group_update"].assert_not_called()
def test_present_md5_matches_prehashed(mocks, existing_group, md5_pw):
existing_group["password"] = md5_pw
mocks["postgres.role_get"].return_value = existing_group
assert postgres_group.present("groupname", password=md5_pw, encrypted=True) == {
"name": "groupname",
"result": True,
"changes": {},
"comment": "Group groupname is already present",
}
mocks["postgres.role_get"].assert_called_once()
mocks["postgres.group_create"].assert_not_called()
mocks["postgres.group_update"].assert_not_called()
def test_present_update_error(mocks, existing_group):
existing_group["password"] = "******"
mocks["postgres.role_get"].return_value = existing_group
mocks["postgres.group_update"].return_value = False
assert postgres_group.present("groupname", password="******", encrypted=True) == {
"name": "groupname",
"result": False,
"changes": {},
"comment": "Failed to update group groupname",
}
mocks["postgres.role_get"].assert_called_once()
mocks["postgres.group_create"].assert_not_called()
mocks["postgres.group_update"].assert_called_once()
def test_present_create_basic_error(mocks, db_args):
mocks["postgres.group_create"].return_value = False
assert postgres_group.present("groupname") == {
"name": "groupname",
"result": False,
"changes": {},
"comment": "Failed to create group groupname",
}
mocks["postgres.role_get"].assert_called_once_with("groupname",
return_password=True,
**db_args)
mocks["postgres.group_create"].assert_called_once()
mocks["postgres.group_update"].assert_not_called()
def test_present_exists_basic(mocks, existing_group, db_args):
mocks["postgres.role_get"].return_value = existing_group
assert postgres_group.present("groupname") == {
"name": "groupname",
"result": True,
"changes": {},
"comment": "Group groupname is already present",
}
mocks["postgres.role_get"].assert_called_once_with("groupname",
return_password=True,
**db_args)
mocks["postgres.group_create"].assert_not_called()
mocks["postgres.group_update"].assert_not_called()
def test_present(self):
'''
Test to ensure that the named group is present
with the specified privileges.
'''
name = 'frank'
ret = {'name': name, 'changes': {}, 'result': False, 'comment': ''}
mock_t = MagicMock(return_value=True)
mock = MagicMock(return_value=None)
with patch.dict(postgres_group.__salt__, {
'postgres.role_get': mock,
'postgres.group_create': mock_t
}):
with patch.dict(postgres_group.__opts__, {'test': True}):
comt = ('Group {0} is set to be created'.format(name))
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(postgres_group.present(name), ret)
with patch.dict(postgres_group.__opts__, {'test': False}):
comt = ('The group {0} has been created'.format(name))
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(postgres_group.present(name), ret)
def test_present(self):
"""
Test to ensure that the named group is present
with the specified privileges.
"""
name = "frank"
ret = {"name": name, "changes": {}, "result": False, "comment": ""}
mock_t = MagicMock(return_value=True)
mock = MagicMock(return_value=None)
with patch.dict(
postgres_group.__salt__,
{"postgres.role_get": mock, "postgres.group_create": mock_t},
):
with patch.dict(postgres_group.__opts__, {"test": True}):
comt = "Group {0} is set to be created".format(name)
ret.update({"comment": comt, "result": None})
self.assertDictEqual(postgres_group.present(name), ret)
with patch.dict(postgres_group.__opts__, {"test": False}):
comt = "The group {0} has been created".format(name)
ret.update({"comment": comt, "result": True})
self.assertDictEqual(postgres_group.present(name), ret)
def test_present__update(self):
# test=True
with patch.dict(
postgres_group.__salt__,
{
"postgres.role_get":
Mock(
return_value={
"can create databases": False,
"can create roles": False,
"can login": False,
"can update system catalogs": False,
"connections": None,
"defaults variables": {},
"expiry time": None,
"inherits privileges": True,
"replication": False,
"superuser": False,
}),
"postgres.group_update":
MagicMock(),
},
):
with patch.dict(postgres_group.__opts__, {"test": True}):
ret = postgres_group.present("foo",
login=True,
replication=False)
self.assertEqual(
ret,
{
"comment": "Group foo is set to be updated",
"changes": {
"foo": {
"login": True
}
},
"name": "foo",
"result": None,
},
)
self.assertEqual(
self.salt_stub["postgres.group_update"].call_count, 0)
# test=False
ret = postgres_group.present("foo", login=True, replication=False)
self.assertEqual(
ret,
{
"comment": "The group foo has been updated",
"changes": {
"foo": {
"login": True
}
},
"name": "foo",
"result": True,
},
)
self.salt_stub["postgres.group_update"].assert_called_once_with(
superuser=None,
replication=False,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
groupname="foo",
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=True,
password=None,
createdb=None,
)
