ansible-collections/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2025-04-06 10:40:32 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 11

[PR #9838/a1781d09 backport][stable-10] Unit tests: make set_module_args() a context manager, and remove copies of it in some tests (#9839)

Browse source 
Unit tests: make set_module_args() a context manager, and remove copies of it in some tests (#9838)

Make set_module_args() a context manager, and remove copies of set_module_args().

Prepares for Data Tagging.

(cherry picked from commit a1781d09dd)

Co-authored-by: Felix Fontein <felix@fontein.de>
This commit is contained in:
patchback[bot] 2025-03-07 07:27:55 +01:00 • committed by GitHub
parent cd0ca389ed
commit 7d45b678e4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
84 changed files with 4043 additions and 4302 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

147
tests/unit/plugins/modules/test_alerta_customer.py
View file

@ -82,169 +82,160 @@ class TestAlertaCustomerModule(ModuleTestCase):
def test_without_parameters(self): def test_without_parameters(self):
"""Failure if no parameters set""" """Failure if no parameters set"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_without_content(self): def test_without_content(self):
"""Failure if customer and match are missing""" """Failure if customer and match are missing"""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password" 'api_password': "password"
}) }):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_successful_existing_customer_creation(self): def test_successful_existing_customer_creation(self):
"""Test the customer creation (already exists).""" """Test the customer creation (already exists)."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev@example.com' 'match': 'dev@example.com'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = customer_response_page1()
fetch_url_mock.return_value = customer_response_page1() with self.assertRaises(AnsibleExitJson):
with self.assertRaises(AnsibleExitJson): self.module.main()
self.module.main() self.assertTrue(fetch_url_mock.call_count, 1)
self.assertTrue(fetch_url_mock.call_count, 1)
def test_successful_customer_creation(self): def test_successful_customer_creation(self):
"""Test the customer creation.""" """Test the customer creation."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev2@example.com' 'match': 'dev2@example.com'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = customer_response_page1()
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 1)
fetch_url_mock.return_value = customer_response_page1() call_data = json.loads(fetch_url_mock.call_args[1]['data'])
with self.assertRaises(AnsibleExitJson): assert call_data['match'] == "dev2@example.com"
self.module.main() assert call_data['customer'] == "Developer"
self.assertTrue(fetch_url_mock.call_count, 1)
call_data = json.loads(fetch_url_mock.call_args[1]['data'])
assert call_data['match'] == "dev2@example.com"
assert call_data['customer'] == "Developer"
def test_successful_customer_creation_key(self): def test_successful_customer_creation_key(self):
"""Test the customer creation using api_key.""" """Test the customer creation using api_key."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_key': "demo-key", 'api_key': "demo-key",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev2@example.com' 'match': 'dev2@example.com'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = customer_response_page1()
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 1)
fetch_url_mock.return_value = customer_response_page1() call_data = json.loads(fetch_url_mock.call_args[1]['data'])
with self.assertRaises(AnsibleExitJson): assert call_data['match'] == "dev2@example.com"
self.module.main() assert call_data['customer'] == "Developer"
self.assertTrue(fetch_url_mock.call_count, 1)
call_data = json.loads(fetch_url_mock.call_args[1]['data'])
assert call_data['match'] == "dev2@example.com"
assert call_data['customer'] == "Developer"
def test_failed_not_found(self): def test_failed_not_found(self):
"""Test failure with wrong URL.""" """Test failure with wrong URL."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080/s", 'alerta_url': "http://localhost:8080/s",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev@example.com' 'match': 'dev@example.com'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'Not found for request GET on http://localhost:8080/a/api/customers'})
fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'Not found for request GET on http://localhost:8080/a/api/customers'}) with self.assertRaises(AnsibleFailJson):
with self.assertRaises(AnsibleFailJson): self.module.main()
self.module.main()
def test_failed_forbidden(self): def test_failed_forbidden(self):
"""Test failure with wrong user.""" """Test failure with wrong user."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "dev@example.com", 'api_username': "dev@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev@example.com' 'match': 'dev@example.com'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = (None, {"status": 403, 'msg': 'Permission Denied for GET on http://localhost:8080/api/customers'})
fetch_url_mock.return_value = (None, {"status": 403, 'msg': 'Permission Denied for GET on http://localhost:8080/api/customers'}) with self.assertRaises(AnsibleFailJson):
with self.assertRaises(AnsibleFailJson): self.module.main()
self.module.main()
def test_failed_unauthorized(self): def test_failed_unauthorized(self):
"""Test failure with wrong username or password.""" """Test failure with wrong username or password."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password_wrong", 'api_password': "password_wrong",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev@example.com' 'match': 'dev@example.com'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = (None, {"status": 401, 'msg': 'Unauthorized to request GET on http://localhost:8080/api/customers'})
fetch_url_mock.return_value = (None, {"status": 401, 'msg': 'Unauthorized to request GET on http://localhost:8080/api/customers'}) with self.assertRaises(AnsibleFailJson):
with self.assertRaises(AnsibleFailJson): self.module.main()
self.module.main()
def test_successful_customer_deletion(self): def test_successful_customer_deletion(self):
"""Test the customer deletion.""" """Test the customer deletion."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev@example.com', 'match': 'dev@example.com',
'state': 'absent' 'state': 'absent'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = customer_response_page1()
fetch_url_mock.return_value = customer_response_page1() with self.assertRaises(AnsibleExitJson):
with self.assertRaises(AnsibleExitJson): self.module.main()
self.module.main()
def test_successful_customer_deletion_page2(self): def test_successful_customer_deletion_page2(self):
"""Test the customer deletion on the second page.""" """Test the customer deletion on the second page."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Developer', 'customer': 'Developer',
'match': 'dev@example.com', 'match': 'dev@example.com',
'state': 'absent' 'state': 'absent'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = customer_response_page2()
fetch_url_mock.return_value = customer_response_page2() with self.assertRaises(AnsibleExitJson):
with self.assertRaises(AnsibleExitJson): self.module.main()
self.module.main()
def test_successful_nonexisting_customer_deletion(self): def test_successful_nonexisting_customer_deletion(self):
"""Test the customer deletion (non existing).""" """Test the customer deletion (non existing)."""
set_module_args({ with set_module_args({
'alerta_url': "http://localhost:8080", 'alerta_url': "http://localhost:8080",
'api_username': "admin@example.com", 'api_username': "admin@example.com",
'api_password': "password", 'api_password': "password",
'customer': 'Billing', 'customer': 'Billing',
'match': 'dev@example.com', 'match': 'dev@example.com',
'state': 'absent' 'state': 'absent'
}) }):
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock:
with patch.object(alerta_customer, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = customer_response_page1()
fetch_url_mock.return_value = customer_response_page1() with self.assertRaises(AnsibleExitJson):
with self.assertRaises(AnsibleExitJson): self.module.main()
self.module.main()

31
tests/unit/plugins/modules/test_archive.py
View file

@ -25,27 +25,26 @@ class TestArchive(ModuleTestCase):
self.os_path_isdir = self.mock_os_path_isdir.stop() self.os_path_isdir = self.mock_os_path_isdir.stop()
def test_archive_removal_safety(self): def test_archive_removal_safety(self):
set_module_args( with set_module_args(
dict( dict(
path=['/foo', '/bar', '/baz'], path=['/foo', '/bar', '/baz'],
dest='/foo/destination.tgz', dest='/foo/destination.tgz',
remove=True remove=True
) )
) ):
module = AnsibleModule(
module = AnsibleModule( argument_spec=dict(
argument_spec=dict( path=dict(type='list', elements='path', required=True),
path=dict(type='list', elements='path', required=True), format=dict(type='str', default='gz', choices=['bz2', 'gz', 'tar', 'xz', 'zip']),
format=dict(type='str', default='gz', choices=['bz2', 'gz', 'tar', 'xz', 'zip']), dest=dict(type='path'),
dest=dict(type='path'), exclude_path=dict(type='list', elements='path', default=[]),
exclude_path=dict(type='list', elements='path', default=[]), exclusion_patterns=dict(type='list', elements='path'),
exclusion_patterns=dict(type='list', elements='path'), force_archive=dict(type='bool', default=False),
force_archive=dict(type='bool', default=False), remove=dict(type='bool', default=False),
remove=dict(type='bool', default=False), ),
), add_file_common_args=True,
add_file_common_args=True, supports_check_mode=True,
supports_check_mode=True, )
)
self.os_path_isdir.side_effect = [True, False, False, True] self.os_path_isdir.side_effect = [True, False, False, True]

54
tests/unit/plugins/modules/test_bitbucket_access_key.py
View file

@ -19,15 +19,15 @@ class TestBucketAccessKeyModule(ModuleTestCase):
def test_missing_key_with_present_state(self): def test_missing_key_with_present_state(self):
with self.assertRaises(AnsibleFailJson) as exec_info: with self.assertRaises(AnsibleFailJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'label': 'key name', 'label': 'key name',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(exec_info.exception.args[0]['msg'], self.module.error_messages['required_key']) self.assertEqual(exec_info.exception.args[0]['msg'], self.module.error_messages['required_key'])
@ -35,7 +35,7 @@ class TestBucketAccessKeyModule(ModuleTestCase):
def test_create_deploy_key(self, *args): def test_create_deploy_key(self, *args):
with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock: with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'user': 'ABC', 'user': 'ABC',
'password': 'XXX', 'password': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -43,8 +43,8 @@ class TestBucketAccessKeyModule(ModuleTestCase):
'key': 'public_key', 'key': 'public_key',
'label': 'key name', 'label': 'key name',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(create_deploy_key_mock.call_count, 1) self.assertEqual(create_deploy_key_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -54,7 +54,7 @@ class TestBucketAccessKeyModule(ModuleTestCase):
def test_create_deploy_key_check_mode(self, *args): def test_create_deploy_key_check_mode(self, *args):
with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock: with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -63,8 +63,8 @@ class TestBucketAccessKeyModule(ModuleTestCase):
'label': 'key name', 'label': 'key name',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(create_deploy_key_mock.call_count, 0) self.assertEqual(create_deploy_key_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -105,7 +105,7 @@ class TestBucketAccessKeyModule(ModuleTestCase):
with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock: with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock:
with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock: with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -113,8 +113,8 @@ class TestBucketAccessKeyModule(ModuleTestCase):
'key': 'new public key', 'key': 'new public key',
'label': 'mykey', 'label': 'mykey',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_deploy_key_mock.call_count, 1) self.assertEqual(delete_deploy_key_mock.call_count, 1)
self.assertEqual(create_deploy_key_mock.call_count, 1) self.assertEqual(create_deploy_key_mock.call_count, 1)
@ -156,7 +156,7 @@ class TestBucketAccessKeyModule(ModuleTestCase):
with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock: with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock:
with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock: with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -164,8 +164,8 @@ class TestBucketAccessKeyModule(ModuleTestCase):
'key': 'new public key', 'key': 'new public key',
'label': 'mykey', 'label': 'mykey',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_deploy_key_mock.call_count, 0) self.assertEqual(delete_deploy_key_mock.call_count, 0)
self.assertEqual(create_deploy_key_mock.call_count, 0) self.assertEqual(create_deploy_key_mock.call_count, 0)
@ -207,7 +207,7 @@ class TestBucketAccessKeyModule(ModuleTestCase):
with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock: with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock:
with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock: with patch.object(self.module, 'create_deploy_key') as create_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -216,8 +216,8 @@ class TestBucketAccessKeyModule(ModuleTestCase):
'label': 'mykey', 'label': 'mykey',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_deploy_key_mock.call_count, 0) self.assertEqual(delete_deploy_key_mock.call_count, 0)
self.assertEqual(create_deploy_key_mock.call_count, 0) self.assertEqual(create_deploy_key_mock.call_count, 0)
@ -258,15 +258,15 @@ class TestBucketAccessKeyModule(ModuleTestCase):
def test_delete_deploy_key(self, *args): def test_delete_deploy_key(self, *args):
with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock: with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'label': 'mykey', 'label': 'mykey',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_deploy_key_mock.call_count, 1) self.assertEqual(delete_deploy_key_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -276,15 +276,15 @@ class TestBucketAccessKeyModule(ModuleTestCase):
def test_delete_absent_deploy_key(self, *args): def test_delete_absent_deploy_key(self, *args):
with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock: with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'label': 'mykey', 'label': 'mykey',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_deploy_key_mock.call_count, 0) self.assertEqual(delete_deploy_key_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -324,7 +324,7 @@ class TestBucketAccessKeyModule(ModuleTestCase):
def test_delete_deploy_key_check_mode(self, *args): def test_delete_deploy_key_check_mode(self, *args):
with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock: with patch.object(self.module, 'delete_deploy_key') as delete_deploy_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -332,8 +332,8 @@ class TestBucketAccessKeyModule(ModuleTestCase):
'label': 'mykey', 'label': 'mykey',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_deploy_key_mock.call_count, 0) self.assertEqual(delete_deploy_key_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)

54
tests/unit/plugins/modules/test_bitbucket_pipeline_key_pair.py
View file

@ -19,14 +19,14 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_missing_keys_with_present_state(self): def test_missing_keys_with_present_state(self):
with self.assertRaises(AnsibleFailJson) as exec_info: with self.assertRaises(AnsibleFailJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(exec_info.exception.args[0]['msg'], self.module.error_messages['required_keys']) self.assertEqual(exec_info.exception.args[0]['msg'], self.module.error_messages['required_keys'])
@ -34,7 +34,7 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_create_keys(self, *args): def test_create_keys(self, *args):
with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock: with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'user': 'ABC', 'user': 'ABC',
'password': 'XXX', 'password': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -42,8 +42,8 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
'public_key': 'public', 'public_key': 'public',
'private_key': 'PRIVATE', 'private_key': 'PRIVATE',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_ssh_key_pair_mock.call_count, 1) self.assertEqual(update_ssh_key_pair_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -53,7 +53,7 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_create_keys_check_mode(self, *args): def test_create_keys_check_mode(self, *args):
with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock: with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -62,8 +62,8 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
'private_key': 'PRIVATE', 'private_key': 'PRIVATE',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(update_ssh_key_pair_mock.call_count, 0) self.assertEqual(update_ssh_key_pair_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -76,7 +76,7 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_update_keys(self, *args): def test_update_keys(self, *args):
with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock: with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -84,8 +84,8 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
'public_key': 'public', 'public_key': 'public',
'private_key': 'PRIVATE', 'private_key': 'PRIVATE',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_ssh_key_pair_mock.call_count, 1) self.assertEqual(update_ssh_key_pair_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -98,7 +98,7 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_dont_update_same_key(self, *args): def test_dont_update_same_key(self, *args):
with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock: with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -106,8 +106,8 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
'public_key': 'public', 'public_key': 'public',
'private_key': 'PRIVATE', 'private_key': 'PRIVATE',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_ssh_key_pair_mock.call_count, 0) self.assertEqual(update_ssh_key_pair_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -120,7 +120,7 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_update_keys_check_mode(self, *args): def test_update_keys_check_mode(self, *args):
with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock: with patch.object(self.module, 'update_ssh_key_pair') as update_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -129,8 +129,8 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
'private_key': 'PRIVATE', 'private_key': 'PRIVATE',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(update_ssh_key_pair_mock.call_count, 0) self.assertEqual(update_ssh_key_pair_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -143,14 +143,14 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_delete_keys(self, *args): def test_delete_keys(self, *args):
with patch.object(self.module, 'delete_ssh_key_pair') as delete_ssh_key_pair_mock: with patch.object(self.module, 'delete_ssh_key_pair') as delete_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_ssh_key_pair_mock.call_count, 1) self.assertEqual(delete_ssh_key_pair_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -160,14 +160,14 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_delete_absent_keys(self, *args): def test_delete_absent_keys(self, *args):
with patch.object(self.module, 'delete_ssh_key_pair') as delete_ssh_key_pair_mock: with patch.object(self.module, 'delete_ssh_key_pair') as delete_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_ssh_key_pair_mock.call_count, 0) self.assertEqual(delete_ssh_key_pair_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -180,15 +180,15 @@ class TestBucketPipelineKeyPairModule(ModuleTestCase):
def test_delete_keys_check_mode(self, *args): def test_delete_keys_check_mode(self, *args):
with patch.object(self.module, 'delete_ssh_key_pair') as delete_ssh_key_pair_mock: with patch.object(self.module, 'delete_ssh_key_pair') as delete_ssh_key_pair_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_ssh_key_pair_mock.call_count, 0) self.assertEqual(delete_ssh_key_pair_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)

42
tests/unit/plugins/modules/test_bitbucket_pipeline_known_host.py
View file

@ -26,15 +26,15 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_create_known_host(self, *args): def test_create_known_host(self, *args):
with patch.object(self.module, 'create_known_host') as create_known_host_mock: with patch.object(self.module, 'create_known_host') as create_known_host_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(create_known_host_mock.call_count, 1) self.assertEqual(create_known_host_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -44,7 +44,7 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_create_known_host_with_key(self, *args): def test_create_known_host_with_key(self, *args):
with patch.object(self.module, 'get_host_key') as get_host_key_mock: with patch.object(self.module, 'get_host_key') as get_host_key_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'user': 'ABC', 'user': 'ABC',
'password': 'XXX', 'password': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -52,8 +52,8 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'key': 'ssh-rsa public', 'key': 'ssh-rsa public',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(get_host_key_mock.call_count, 0) self.assertEqual(get_host_key_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -75,15 +75,15 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_dont_create_same_value(self, *args): def test_dont_create_same_value(self, *args):
with patch.object(self.module, 'create_known_host') as create_known_host_mock: with patch.object(self.module, 'create_known_host') as create_known_host_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(create_known_host_mock.call_count, 0) self.assertEqual(create_known_host_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -94,7 +94,7 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_create_known_host_check_mode(self, *args): def test_create_known_host_check_mode(self, *args):
with patch.object(self.module, 'create_known_host') as create_known_host_mock: with patch.object(self.module, 'create_known_host') as create_known_host_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -102,8 +102,8 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(create_known_host_mock.call_count, 0) self.assertEqual(create_known_host_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -125,15 +125,15 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_delete_known_host(self, *args): def test_delete_known_host(self, *args):
with patch.object(self.module, 'delete_known_host') as delete_known_host_mock: with patch.object(self.module, 'delete_known_host') as delete_known_host_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_known_host_mock.call_count, 1) self.assertEqual(delete_known_host_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -144,15 +144,15 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_delete_absent_known_host(self, *args): def test_delete_absent_known_host(self, *args):
with patch.object(self.module, 'delete_known_host') as delete_known_host_mock: with patch.object(self.module, 'delete_known_host') as delete_known_host_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_known_host_mock.call_count, 0) self.assertEqual(delete_known_host_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -174,7 +174,7 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
def test_delete_known_host_check_mode(self, *args): def test_delete_known_host_check_mode(self, *args):
with patch.object(self.module, 'delete_known_host') as delete_known_host_mock: with patch.object(self.module, 'delete_known_host') as delete_known_host_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -182,8 +182,8 @@ class TestBucketPipelineKnownHostModule(ModuleTestCase):
'name': 'bitbucket.org', 'name': 'bitbucket.org',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_known_host_mock.call_count, 0) self.assertEqual(delete_known_host_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)

84
tests/unit/plugins/modules/test_bitbucket_pipeline_variable.py
View file

@ -19,27 +19,27 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
with self.assertRaises(AnsibleFailJson) as exec_info: with self.assertRaises(AnsibleFailJson) as exec_info:
set_module_args({ with set_module_args({
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(exec_info.exception.args[0]['failed'], True) self.assertEqual(exec_info.exception.args[0]['failed'], True)
def test_missing_value_with_present_state(self): def test_missing_value_with_present_state(self):
with self.assertRaises(AnsibleFailJson) as exec_info: with self.assertRaises(AnsibleFailJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(exec_info.exception.args[0]['msg'], self.module.error_messages['required_value']) self.assertEqual(exec_info.exception.args[0]['msg'], self.module.error_messages['required_value'])
@ -51,13 +51,13 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
@patch.object(bitbucket_pipeline_variable, 'get_existing_pipeline_variable', return_value=None) @patch.object(bitbucket_pipeline_variable, 'get_existing_pipeline_variable', return_value=None)
def test_oauth_env_vars_params(self, *args): def test_oauth_env_vars_params(self, *args):
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
set_module_args({ with set_module_args({
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
@patch.dict('os.environ', { @patch.dict('os.environ', {
'BITBUCKET_USERNAME': 'ABC', 'BITBUCKET_USERNAME': 'ABC',
@ -66,19 +66,19 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
@patch.object(bitbucket_pipeline_variable, 'get_existing_pipeline_variable', return_value=None) @patch.object(bitbucket_pipeline_variable, 'get_existing_pipeline_variable', return_value=None)
def test_basic_auth_env_vars_params(self, *args): def test_basic_auth_env_vars_params(self, *args):
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
set_module_args({ with set_module_args({
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
@patch.object(bitbucket_pipeline_variable, 'get_existing_pipeline_variable', return_value=None) @patch.object(bitbucket_pipeline_variable, 'get_existing_pipeline_variable', return_value=None)
def test_create_variable(self, *args): def test_create_variable(self, *args):
with patch.object(self.module, 'create_pipeline_variable') as create_pipeline_variable_mock: with patch.object(self.module, 'create_pipeline_variable') as create_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'user': 'ABC', 'user': 'ABC',
'password': 'XXX', 'password': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -86,8 +86,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'value': '42', 'value': '42',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(create_pipeline_variable_mock.call_count, 1) self.assertEqual(create_pipeline_variable_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -97,7 +97,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_create_variable_check_mode(self, *args): def test_create_variable_check_mode(self, *args):
with patch.object(self.module, 'create_pipeline_variable') as create_pipeline_variable_mock: with patch.object(self.module, 'create_pipeline_variable') as create_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -106,8 +106,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'value': '42', 'value': '42',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(create_pipeline_variable_mock.call_count, 0) self.assertEqual(create_pipeline_variable_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -123,7 +123,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_update_variable(self, *args): def test_update_variable(self, *args):
with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock: with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -131,8 +131,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'value': '42', 'value': '42',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_pipeline_variable_mock.call_count, 1) self.assertEqual(update_pipeline_variable_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -147,7 +147,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_update_secured_variable(self, *args): def test_update_secured_variable(self, *args):
with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock: with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -156,8 +156,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'value': '42', 'value': '42',
'secured': True, 'secured': True,
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_pipeline_variable_mock.call_count, 1) self.assertEqual(update_pipeline_variable_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -173,7 +173,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_update_secured_state(self, *args): def test_update_secured_state(self, *args):
with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock: with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -182,8 +182,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'value': '42', 'value': '42',
'secured': True, 'secured': True,
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_pipeline_variable_mock.call_count, 1) self.assertEqual(update_pipeline_variable_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -199,7 +199,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_dont_update_same_value(self, *args): def test_dont_update_same_value(self, *args):
with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock: with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -207,8 +207,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'value': '42', 'value': '42',
'state': 'present', 'state': 'present',
}) }):
self.module.main() self.module.main()
self.assertEqual(update_pipeline_variable_mock.call_count, 0) self.assertEqual(update_pipeline_variable_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -224,7 +224,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_update_variable_check_mode(self, *args): def test_update_variable_check_mode(self, *args):
with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock: with patch.object(self.module, 'update_pipeline_variable') as update_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -233,8 +233,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'value': '42', 'value': '42',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(update_pipeline_variable_mock.call_count, 0) self.assertEqual(update_pipeline_variable_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -250,15 +250,15 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_delete_variable(self, *args): def test_delete_variable(self, *args):
with patch.object(self.module, 'delete_pipeline_variable') as delete_pipeline_variable_mock: with patch.object(self.module, 'delete_pipeline_variable') as delete_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_pipeline_variable_mock.call_count, 1) self.assertEqual(delete_pipeline_variable_mock.call_count, 1)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)
@ -268,15 +268,15 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_delete_absent_variable(self, *args): def test_delete_absent_variable(self, *args):
with patch.object(self.module, 'delete_pipeline_variable') as delete_pipeline_variable_mock: with patch.object(self.module, 'delete_pipeline_variable') as delete_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
'repository': 'repo', 'repository': 'repo',
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'absent', 'state': 'absent',
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_pipeline_variable_mock.call_count, 0) self.assertEqual(delete_pipeline_variable_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], False) self.assertEqual(exec_info.exception.args[0]['changed'], False)
@ -292,7 +292,7 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
def test_delete_variable_check_mode(self, *args): def test_delete_variable_check_mode(self, *args):
with patch.object(self.module, 'delete_pipeline_variable') as delete_pipeline_variable_mock: with patch.object(self.module, 'delete_pipeline_variable') as delete_pipeline_variable_mock:
with self.assertRaises(AnsibleExitJson) as exec_info: with self.assertRaises(AnsibleExitJson) as exec_info:
set_module_args({ with set_module_args({
'client_id': 'ABC', 'client_id': 'ABC',
'client_secret': 'XXX', 'client_secret': 'XXX',
'workspace': 'name', 'workspace': 'name',
@ -300,8 +300,8 @@ class TestBucketPipelineVariableModule(ModuleTestCase):
'name': 'PIPELINE_VAR_NAME', 'name': 'PIPELINE_VAR_NAME',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.module.main() self.module.main()
self.assertEqual(delete_pipeline_variable_mock.call_count, 0) self.assertEqual(delete_pipeline_variable_mock.call_count, 0)
self.assertEqual(exec_info.exception.args[0]['changed'], True) self.assertEqual(exec_info.exception.args[0]['changed'], True)

56
tests/unit/plugins/modules/test_bootc_manage.py
View file

@ -21,52 +21,52 @@ class TestBootcManageModule(ModuleTestCase):
def test_switch_without_image(self): def test_switch_without_image(self):
"""Failure if state is 'switch' but no image provided""" """Failure if state is 'switch' but no image provided"""
set_module_args({'state': 'switch'}) with set_module_args({'state': 'switch'}):
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], "state is switch but all of the following are missing: image") self.assertEqual(result.exception.args[0]['msg'], "state is switch but all of the following are missing: image")
def test_switch_with_image(self): def test_switch_with_image(self):
"""Test successful switch with image provided""" """Test successful switch with image provided"""
set_module_args({'state': 'switch', 'image': 'example.com/image:latest'}) with set_module_args({'state': 'switch', 'image': 'example.com/image:latest'}):
with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock: with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock:
run_command_mock.return_value = (0, 'Queued for next boot: ', '') run_command_mock.return_value = (0, 'Queued for next boot: ', '')
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_latest_state(self): def test_latest_state(self):
"""Test successful upgrade to the latest state""" """Test successful upgrade to the latest state"""
set_module_args({'state': 'latest'}) with set_module_args({'state': 'latest'}):
with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock: with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock:
run_command_mock.return_value = (0, 'Queued for next boot: ', '') run_command_mock.return_value = (0, 'Queued for next boot: ', '')
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_latest_state_no_change(self): def test_latest_state_no_change(self):
"""Test no change for latest state""" """Test no change for latest state"""
set_module_args({'state': 'latest'}) with set_module_args({'state': 'latest'}):
with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock: with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock:
run_command_mock.return_value = (0, 'No changes in ', '') run_command_mock.return_value = (0, 'No changes in ', '')
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertFalse(result.exception.args[0]['changed']) self.assertFalse(result.exception.args[0]['changed'])
def test_switch_image_failure(self): def test_switch_image_failure(self):
"""Test failure during image switch""" """Test failure during image switch"""
set_module_args({'state': 'switch', 'image': 'example.com/image:latest'}) with set_module_args({'state': 'switch', 'image': 'example.com/image:latest'}):
with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock: with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock:
run_command_mock.return_value = (1, '', 'ERROR') run_command_mock.return_value = (1, '', 'ERROR')
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], 'ERROR: Command execution failed.') self.assertEqual(result.exception.args[0]['msg'], 'ERROR: Command execution failed.')
def test_latest_state_failure(self): def test_latest_state_failure(self):
"""Test failure during upgrade""" """Test failure during upgrade"""
set_module_args({'state': 'latest'}) with set_module_args({'state': 'latest'}):
with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock: with patch('ansible.module_utils.basic.AnsibleModule.run_command') as run_command_mock:
run_command_mock.return_value = (1, '', 'ERROR') run_command_mock.return_value = (1, '', 'ERROR')
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], 'ERROR: Command execution failed.') self.assertEqual(result.exception.args[0]['msg'], 'ERROR: Command execution failed.')

75
tests/unit/plugins/modules/test_campfire.py
View file

@ -27,70 +27,67 @@ class TestCampfireModule(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
"""Failure must occurs when all parameters are missing""" """Failure must occurs when all parameters are missing"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_successful_message(self): def test_successful_message(self):
"""Test failure message""" """Test failure message"""
set_module_args({ with set_module_args({
'subscription': 'test', 'subscription': 'test',
'token': 'abc', 'token': 'abc',
'room': 'test', 'room': 'test',
'msg': 'test' 'msg': 'test'
}) }):
with patch.object(campfire, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(campfire, "fetch_url") as fetch_url_mock: assert fetch_url_mock.call_count == 1
fetch_url_mock.return_value = (None, {"status": 200}) url = fetch_url_mock.call_args[0][1]
with self.assertRaises(AnsibleExitJson): data = fetch_url_mock.call_args[1]['data']
self.module.main()
assert fetch_url_mock.call_count == 1 assert url == 'https://test.campfirenow.com/room/test/speak.xml'
url = fetch_url_mock.call_args[0][1] assert data == '<message><body>test</body></message>'
data = fetch_url_mock.call_args[1]['data']
assert url == 'https://test.campfirenow.com/room/test/speak.xml'
assert data == '<message><body>test</body></message>'
def test_successful_message_with_notify(self): def test_successful_message_with_notify(self):
"""Test failure message""" """Test failure message"""
set_module_args({ with set_module_args({
'subscription': 'test', 'subscription': 'test',
'token': 'abc', 'token': 'abc',
'room': 'test', 'room': 'test',
'msg': 'test', 'msg': 'test',
'notify': 'bell' 'notify': 'bell'
}) }):
with patch.object(campfire, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(campfire, "fetch_url") as fetch_url_mock: assert fetch_url_mock.call_count == 2
fetch_url_mock.return_value = (None, {"status": 200}) notify_call = fetch_url_mock.mock_calls[0]
with self.assertRaises(AnsibleExitJson): url = notify_call[1][1]
self.module.main() data = notify_call[2]['data']
assert fetch_url_mock.call_count == 2 assert url == 'https://test.campfirenow.com/room/test/speak.xml'
notify_call = fetch_url_mock.mock_calls[0] assert data == '<message><type>SoundMessage</type><body>bell</body></message>'
url = notify_call[1][1]
data = notify_call[2]['data']
assert url == 'https://test.campfirenow.com/room/test/speak.xml' message_call = fetch_url_mock.mock_calls[1]
assert data == '<message><type>SoundMessage</type><body>bell</body></message>' url = message_call[1][1]
data = message_call[2]['data']
message_call = fetch_url_mock.mock_calls[1] assert url == 'https://test.campfirenow.com/room/test/speak.xml'
url = message_call[1][1] assert data == '<message><body>test</body></message>'
data = message_call[2]['data']
assert url == 'https://test.campfirenow.com/room/test/speak.xml'
assert data == '<message><body>test</body></message>'
def test_failure_message(self): def test_failure_message(self):
"""Test failure message""" """Test failure message"""
set_module_args({ with set_module_args({
'subscription': 'test', 'subscription': 'test',
'token': 'abc', 'token': 'abc',
'room': 'test', 'room': 'test',
'msg': 'test' 'msg': 'test'
}) }):
with patch.object(campfire, "fetch_url") as fetch_url_mock:
with patch.object(campfire, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = (None, {"status": 403})
fetch_url_mock.return_value = (None, {"status": 403}) with self.assertRaises(AnsibleFailJson):
with self.assertRaises(AnsibleFailJson): self.module.main()
self.module.main()

171
tests/unit/plugins/modules/test_circonus_annotation.py
View file

@ -30,45 +30,46 @@ class TestCirconusAnnotation(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
"""Failure must occurs when all parameters are missing""" """Failure must occurs when all parameters are missing"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_add_annotation(self): def test_add_annotation(self):
"""Check that result is changed""" """Check that result is changed"""
set_module_args({ with set_module_args({
'category': 'test category', 'category': 'test category',
'description': 'test description', 'description': 'test description',
'title': 'test title', 'title': 'test title',
'api_key': str(uuid.uuid4()), 'api_key': str(uuid.uuid4()),
}) }):
cid = '/annotation/100000' cid = '/annotation/100000'
def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None): def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
data = { data = {
'_cid': cid, '_cid': cid,
'_created': 1502146995, '_created': 1502146995,
'_last_modified': 1502146995, '_last_modified': 1502146995,
'_last_modified_by': '/user/1000', '_last_modified_by': '/user/1000',
'category': 'test category', 'category': 'test category',
'description': 'test description', 'description': 'test description',
'rel_metrics': [], 'rel_metrics': [],
'start': 1502145480, 'start': 1502145480,
'stop': None, 'stop': None,
'title': 'test title', 'title': 'test title',
} }
raw = to_bytes(json.dumps(data)) raw = to_bytes(json.dumps(data))
resp = HTTPResponse(body=io.BytesIO(raw), preload_content=False) resp = HTTPResponse(body=io.BytesIO(raw), preload_content=False)
resp.status = 200 resp.status = 200
resp.reason = 'OK' resp.reason = 'OK'
resp.headers = {'X-Circonus-API-Version': '2.00'} resp.headers = {'X-Circonus-API-Version': '2.00'}
return self.build_response(request, resp) return self.build_response(request, resp)
with patch('requests.adapters.HTTPAdapter.send', autospec=True, side_effect=send) as send: with patch('requests.adapters.HTTPAdapter.send', autospec=True, side_effect=send) as send:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['annotation']['_cid'], cid) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['annotation']['_cid'], cid)
self.assertEqual(send.call_count, 1) self.assertEqual(send.call_count, 1)
def test_add_annotation_unicode(self): def test_add_annotation_unicode(self):
@ -76,78 +77,80 @@ class TestCirconusAnnotation(ModuleTestCase):
Note: it seems there is a bug which prevent to create an annotation Note: it seems there is a bug which prevent to create an annotation
with a non-ASCII category if this category already exists, in such with a non-ASCII category if this category already exists, in such
case an Internal Server Error (500) occurs.""" case an Internal Server Error (500) occurs."""
set_module_args({ with set_module_args({
'category': 'new catégorÿ', 'category': 'new catégorÿ',
'description': 'test description', 'description': 'test description',
'title': 'test title', 'title': 'test title',
'api_key': str(uuid.uuid4()), 'api_key': str(uuid.uuid4()),
}) }):
cid = '/annotation/100000' cid = '/annotation/100000'
def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None): def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
data = { data = {
'_cid': '/annotation/100000', '_cid': '/annotation/100000',
'_created': 1502236928, '_created': 1502236928,
'_last_modified': 1502236928, '_last_modified': 1502236928,
'_last_modified_by': '/user/1000', '_last_modified_by': '/user/1000',
# use res['annotation']['category'].encode('latin1').decode('utf8') # use res['annotation']['category'].encode('latin1').decode('utf8')
'category': u'new cat\xc3\xa9gor\xc3\xbf', 'category': u'new cat\xc3\xa9gor\xc3\xbf',
'description': 'test description', 'description': 'test description',
'rel_metrics': [], 'rel_metrics': [],
'start': 1502236927, 'start': 1502236927,
'stop': 1502236927, 'stop': 1502236927,
'title': 'test title', 'title': 'test title',
} }
raw = to_bytes(json.dumps(data), encoding='latin1') raw = to_bytes(json.dumps(data), encoding='latin1')
resp = HTTPResponse(body=io.BytesIO(raw), preload_content=False) resp = HTTPResponse(body=io.BytesIO(raw), preload_content=False)
resp.status = 200 resp.status = 200
resp.reason = 'OK' resp.reason = 'OK'
resp.headers = {'X-Circonus-API-Version': '2.00'} resp.headers = {'X-Circonus-API-Version': '2.00'}
return self.build_response(request, resp) return self.build_response(request, resp)
with patch('requests.adapters.HTTPAdapter.send', autospec=True, side_effect=send) as send: with patch('requests.adapters.HTTPAdapter.send', autospec=True, side_effect=send) as send:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['annotation']['_cid'], cid) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['annotation']['_cid'], cid)
self.assertEqual(send.call_count, 1) self.assertEqual(send.call_count, 1)
def test_auth_failure(self): def test_auth_failure(self):
"""Check that an error is raised when authentication failed""" """Check that an error is raised when authentication failed"""
set_module_args({ with set_module_args({
'category': 'test category', 'category': 'test category',
'description': 'test description', 'description': 'test description',
'title': 'test title', 'title': 'test title',
'api_key': str(uuid.uuid4()), 'api_key': str(uuid.uuid4()),
}) }):
cid = '/annotation/100000' cid = '/annotation/100000'
def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None): def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
data = { data = {
'_cid': cid, '_cid': cid,
'_created': 1502146995, '_created': 1502146995,
'_last_modified': 1502146995, '_last_modified': 1502146995,
'_last_modified_by': '/user/1000', '_last_modified_by': '/user/1000',
'category': 'test category', 'category': 'test category',
'description': 'test description', 'description': 'test description',
'rel_metrics': [], 'rel_metrics': [],
'start': 1502145480, 'start': 1502145480,
'stop': None, 'stop': None,
'title': 'test title', 'title': 'test title',
} }
raw = to_bytes(json.dumps(data)) raw = to_bytes(json.dumps(data))
resp = HTTPResponse(body=io.BytesIO(raw), preload_content=False) resp = HTTPResponse(body=io.BytesIO(raw), preload_content=False)
resp.status = 403 resp.status = 403
resp.reason = 'Forbidden' resp.reason = 'Forbidden'
resp.headers = {'X-Circonus-API-Version': '2.00'} resp.headers = {'X-Circonus-API-Version': '2.00'}
return self.build_response(request, resp) return self.build_response(request, resp)
with patch('requests.adapters.HTTPAdapter.send', autospec=True, side_effect=send) as send: with patch('requests.adapters.HTTPAdapter.send', autospec=True, side_effect=send) as send:
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertTrue(result.exception.args[0]['failed'])
self.assertTrue(re.match(r'\b403\b', result.exception.args[0]['reason'])) self.assertTrue(result.exception.args[0]['failed'])
self.assertTrue(re.match(r'\b403\b', result.exception.args[0]['reason']))
self.assertEqual(send.call_count, 1) self.assertEqual(send.call_count, 1)

222
tests/unit/plugins/modules/test_datadog_downtime.py
View file

@ -33,12 +33,12 @@ class TestDatadogDowntime(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
"""Failure must occurs when all parameters are missing""" """Failure must occurs when all parameters are missing"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
@patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi") @patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi")
def test_create_downtime_when_no_id(self, downtimes_api_mock): def test_create_downtime_when_no_id(self, downtimes_api_mock):
set_module_args({ with set_module_args({
"monitor_tags": ["foo:bar"], "monitor_tags": ["foo:bar"],
"scope": ["*"], "scope": ["*"],
"monitor_id": 12345, "monitor_id": 12345,
@ -49,32 +49,32 @@ class TestDatadogDowntime(ModuleTestCase):
"rrule": "rrule", "rrule": "rrule",
"api_key": "an_api_key", "api_key": "an_api_key",
"app_key": "an_app_key", "app_key": "an_app_key",
}) }):
downtime = Downtime()
downtime.monitor_tags = ["foo:bar"]
downtime.scope = ["*"]
downtime.monitor_id = 12345
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
downtime = Downtime() create_downtime_mock = MagicMock(return_value=self.__downtime_with_id(12345))
downtime.monitor_tags = ["foo:bar"] downtimes_api_mock.return_value = MagicMock(create_downtime=create_downtime_mock)
downtime.scope = ["*"] with self.assertRaises(AnsibleExitJson) as result:
downtime.monitor_id = 12345 self.module.main()
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
create_downtime_mock = MagicMock(return_value=self.__downtime_with_id(12345))
downtimes_api_mock.return_value = MagicMock(create_downtime=create_downtime_mock)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['downtime']['id'], 12345) self.assertEqual(result.exception.args[0]['downtime']['id'], 12345)
create_downtime_mock.assert_called_once_with(downtime) create_downtime_mock.assert_called_once_with(downtime)
@patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi") @patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi")
def test_create_downtime_when_id_and_disabled(self, downtimes_api_mock): def test_create_downtime_when_id_and_disabled(self, downtimes_api_mock):
set_module_args({ with set_module_args({
"id": 1212, "id": 1212,
"monitor_tags": ["foo:bar"], "monitor_tags": ["foo:bar"],
"scope": ["*"], "scope": ["*"],
@ -86,32 +86,32 @@ class TestDatadogDowntime(ModuleTestCase):
"rrule": "rrule", "rrule": "rrule",
"api_key": "an_api_key", "api_key": "an_api_key",
"app_key": "an_app_key", "app_key": "an_app_key",
}) }):
downtime = Downtime()
downtime.monitor_tags = ["foo:bar"]
downtime.scope = ["*"]
downtime.monitor_id = 12345
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
downtime = Downtime() disabled_downtime = Downtime()
downtime.monitor_tags = ["foo:bar"] disabled_downtime.disabled = True
downtime.scope = ["*"] disabled_downtime.id = 1212
downtime.monitor_id = 12345
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
disabled_downtime = Downtime() create_downtime_mock = MagicMock(return_value=self.__downtime_with_id(12345))
disabled_downtime.disabled = True get_downtime_mock = MagicMock(return_value=disabled_downtime)
disabled_downtime.id = 1212 downtimes_api_mock.return_value = MagicMock(
create_downtime=create_downtime_mock, get_downtime=get_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
create_downtime_mock = MagicMock(return_value=self.__downtime_with_id(12345))
get_downtime_mock = MagicMock(return_value=disabled_downtime)
downtimes_api_mock.return_value = MagicMock(
create_downtime=create_downtime_mock, get_downtime=get_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['downtime']['id'], 12345) self.assertEqual(result.exception.args[0]['downtime']['id'], 12345)
create_downtime_mock.assert_called_once_with(downtime) create_downtime_mock.assert_called_once_with(downtime)
@ -119,7 +119,7 @@ class TestDatadogDowntime(ModuleTestCase):
@patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi") @patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi")
def test_update_downtime_when_not_disabled(self, downtimes_api_mock): def test_update_downtime_when_not_disabled(self, downtimes_api_mock):
set_module_args({ with set_module_args({
"id": 1212, "id": 1212,
"monitor_tags": ["foo:bar"], "monitor_tags": ["foo:bar"],
"scope": ["*"], "scope": ["*"],
@ -131,32 +131,32 @@ class TestDatadogDowntime(ModuleTestCase):
"rrule": "rrule", "rrule": "rrule",
"api_key": "an_api_key", "api_key": "an_api_key",
"app_key": "an_app_key", "app_key": "an_app_key",
}) }):
downtime = Downtime()
downtime.monitor_tags = ["foo:bar"]
downtime.scope = ["*"]
downtime.monitor_id = 12345
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
downtime = Downtime() enabled_downtime = Downtime()
downtime.monitor_tags = ["foo:bar"] enabled_downtime.disabled = False
downtime.scope = ["*"] enabled_downtime.id = 1212
downtime.monitor_id = 12345
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
enabled_downtime = Downtime() update_downtime_mock = MagicMock(return_value=self.__downtime_with_id(1212))
enabled_downtime.disabled = False get_downtime_mock = MagicMock(return_value=enabled_downtime)
enabled_downtime.id = 1212 downtimes_api_mock.return_value = MagicMock(
update_downtime=update_downtime_mock, get_downtime=get_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
update_downtime_mock = MagicMock(return_value=self.__downtime_with_id(1212))
get_downtime_mock = MagicMock(return_value=enabled_downtime)
downtimes_api_mock.return_value = MagicMock(
update_downtime=update_downtime_mock, get_downtime=get_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['downtime']['id'], 1212) self.assertEqual(result.exception.args[0]['downtime']['id'], 1212)
update_downtime_mock.assert_called_once_with(1212, downtime) update_downtime_mock.assert_called_once_with(1212, downtime)
@ -164,7 +164,7 @@ class TestDatadogDowntime(ModuleTestCase):
@patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi") @patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi")
def test_update_downtime_no_change(self, downtimes_api_mock): def test_update_downtime_no_change(self, downtimes_api_mock):
set_module_args({ with set_module_args({
"id": 1212, "id": 1212,
"monitor_tags": ["foo:bar"], "monitor_tags": ["foo:bar"],
"scope": ["*"], "scope": ["*"],
@ -176,42 +176,42 @@ class TestDatadogDowntime(ModuleTestCase):
"rrule": "rrule", "rrule": "rrule",
"api_key": "an_api_key", "api_key": "an_api_key",
"app_key": "an_app_key", "app_key": "an_app_key",
}) }):
downtime = Downtime()
downtime.monitor_tags = ["foo:bar"]
downtime.scope = ["*"]
downtime.monitor_id = 12345
downtime.message = "Message"
downtime.start = 1111
downtime.end = 2222
downtime.timezone = "UTC"
downtime.recurrence = DowntimeRecurrence(
rrule="rrule",
type="rrule"
)
downtime = Downtime() downtime_get = Downtime()
downtime.monitor_tags = ["foo:bar"] downtime_get.id = 1212
downtime.scope = ["*"] downtime_get.disabled = False
downtime.monitor_id = 12345 downtime_get.monitor_tags = ["foo:bar"]
downtime.message = "Message" downtime_get.scope = ["*"]
downtime.start = 1111 downtime_get.monitor_id = 12345
downtime.end = 2222 downtime_get.message = "Message"
downtime.timezone = "UTC" downtime_get.start = 1111
downtime.recurrence = DowntimeRecurrence( downtime_get.end = 2222
rrule="rrule", downtime_get.timezone = "UTC"
type="rrule" downtime_get.recurrence = DowntimeRecurrence(
) rrule="rrule"
)
downtime_get = Downtime() update_downtime_mock = MagicMock(return_value=downtime_get)
downtime_get.id = 1212 get_downtime_mock = MagicMock(return_value=downtime_get)
downtime_get.disabled = False downtimes_api_mock.return_value = MagicMock(
downtime_get.monitor_tags = ["foo:bar"] update_downtime=update_downtime_mock, get_downtime=get_downtime_mock
downtime_get.scope = ["*"] )
downtime_get.monitor_id = 12345 with self.assertRaises(AnsibleExitJson) as result:
downtime_get.message = "Message" self.module.main()
downtime_get.start = 1111
downtime_get.end = 2222
downtime_get.timezone = "UTC"
downtime_get.recurrence = DowntimeRecurrence(
rrule="rrule"
)
update_downtime_mock = MagicMock(return_value=downtime_get)
get_downtime_mock = MagicMock(return_value=downtime_get)
downtimes_api_mock.return_value = MagicMock(
update_downtime=update_downtime_mock, get_downtime=get_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
self.assertFalse(result.exception.args[0]['changed']) self.assertFalse(result.exception.args[0]['changed'])
self.assertEqual(result.exception.args[0]['downtime']['id'], 1212) self.assertEqual(result.exception.args[0]['downtime']['id'], 1212)
update_downtime_mock.assert_called_once_with(1212, downtime) update_downtime_mock.assert_called_once_with(1212, downtime)
@ -219,20 +219,20 @@ class TestDatadogDowntime(ModuleTestCase):
@patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi") @patch("ansible_collections.community.general.plugins.modules.datadog_downtime.DowntimesApi")
def test_delete_downtime(self, downtimes_api_mock): def test_delete_downtime(self, downtimes_api_mock):
set_module_args({ with set_module_args({
"id": 1212, "id": 1212,
"state": "absent", "state": "absent",
"api_key": "an_api_key", "api_key": "an_api_key",
"app_key": "an_app_key", "app_key": "an_app_key",
}) }):
cancel_downtime_mock = MagicMock()
downtimes_api_mock.return_value = MagicMock(
get_downtime=self.__downtime_with_id,
cancel_downtime=cancel_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
cancel_downtime_mock = MagicMock()
downtimes_api_mock.return_value = MagicMock(
get_downtime=self.__downtime_with_id,
cancel_downtime=cancel_downtime_mock
)
with self.assertRaises(AnsibleExitJson) as result:
self.module.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
cancel_downtime_mock.assert_called_once_with(1212) cancel_downtime_mock.assert_called_once_with(1212)

63
tests/unit/plugins/modules/test_discord.py
View file

@ -28,30 +28,30 @@ class TestDiscordModule(ModuleTestCase):
def test_without_parameters(self): def test_without_parameters(self):
"""Failure if no parameters set""" """Failure if no parameters set"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_without_content(self): def test_without_content(self):
"""Failure if content and embeds both are missing""" """Failure if content and embeds both are missing"""
set_module_args({ with set_module_args({
'webhook_id': 'xxx', 'webhook_id': 'xxx',
'webhook_token': 'xxx' 'webhook_token': 'xxx'
}) }):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_successful_message(self): def test_successful_message(self):
"""Test a basic message successfully.""" """Test a basic message successfully."""
set_module_args({ with set_module_args({
'webhook_id': 'xxx', 'webhook_id': 'xxx',
'webhook_token': 'xxx', 'webhook_token': 'xxx',
'content': 'test' 'content': 'test'
}) }):
with patch.object(discord, "fetch_url") as fetch_url_mock: with patch.object(discord, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 204, 'msg': 'OK (0 bytes)'}) fetch_url_mock.return_value = (None, {"status": 204, 'msg': 'OK (0 bytes)'})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
self.assertTrue(fetch_url_mock.call_count, 1) self.assertTrue(fetch_url_mock.call_count, 1)
call_data = json.loads(fetch_url_mock.call_args[1]['data']) call_data = json.loads(fetch_url_mock.call_args[1]['data'])
@ -59,17 +59,17 @@ class TestDiscordModule(ModuleTestCase):
def test_message_with_username(self): def test_message_with_username(self):
"""Test a message with username set successfully.""" """Test a message with username set successfully."""
set_module_args({ with set_module_args({
'webhook_id': 'xxx', 'webhook_id': 'xxx',
'webhook_token': 'xxx', 'webhook_token': 'xxx',
'content': 'test', 'content': 'test',
'username': 'Ansible Bot' 'username': 'Ansible Bot'
}) }):
with patch.object(discord, "fetch_url") as fetch_url_mock: with patch.object(discord, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 204, 'msg': 'OK (0 bytes)'}) fetch_url_mock.return_value = (None, {"status": 204, 'msg': 'OK (0 bytes)'})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
self.assertTrue(fetch_url_mock.call_count, 1) self.assertTrue(fetch_url_mock.call_count, 1)
call_data = json.loads(fetch_url_mock.call_args[1]['data']) call_data = json.loads(fetch_url_mock.call_args[1]['data'])
@ -79,27 +79,30 @@ class TestDiscordModule(ModuleTestCase):
def test_failed_message(self): def test_failed_message(self):
"""Test failure because webhook id is wrong.""" """Test failure because webhook id is wrong."""
set_module_args({ with set_module_args({
'webhook_id': 'wrong', 'webhook_id': 'wrong',
'webhook_token': 'xxx', 'webhook_token': 'xxx',
'content': 'test' 'content': 'test'
}) }):
with patch.object(discord, "fetch_url") as fetch_url_mock: with patch.object(discord, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'HTTP Error 404: Not Found', 'body': '{"message": "Unknown Webhook", "code": 10015}'}) fetch_url_mock.return_value = (
with self.assertRaises(AnsibleFailJson): None,
self.module.main() {"status": 404, 'msg': 'HTTP Error 404: Not Found', 'body': '{"message": "Unknown Webhook", "code": 10015}'},
)
with self.assertRaises(AnsibleFailJson):
self.module.main()
def test_failed_message_without_body(self): def test_failed_message_without_body(self):
"""Test failure with empty response body.""" """Test failure with empty response body."""
set_module_args({ with set_module_args({
'webhook_id': 'wrong', 'webhook_id': 'wrong',
'webhook_token': 'xxx', 'webhook_token': 'xxx',
'content': 'test' 'content': 'test'
}) }):
with patch.object(discord, "fetch_url") as fetch_url_mock: with patch.object(discord, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'HTTP Error 404: Not Found'}) fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'HTTP Error 404: Not Found'})
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()

76
tests/unit/plugins/modules/test_dnf_config_manager.py
View file

@ -305,22 +305,22 @@ class TestDNFConfigManager(ModuleTestCase):
return result return result
def test_get_repo_states(self): def test_get_repo_states(self):
set_module_args({}) with set_module_args({}):
self.set_command_mock(execute_return=(0, mock_repolist_crb_enabled, '')) self.set_command_mock(execute_return=(0, mock_repolist_crb_enabled, ''))
result = self.execute_module(changed=False) result = self.execute_module(changed=False)
self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_enabled) self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_enabled)
self.assertEqual(result['repo_states_post'], expected_repo_states_crb_enabled) self.assertEqual(result['repo_states_post'], expected_repo_states_crb_enabled)
self.assertEqual(result['changed_repos'], []) self.assertEqual(result['changed_repos'], [])
self.run_command.assert_has_calls(calls=[call_get_repo_states, call_get_repo_states], any_order=False) self.run_command.assert_has_calls(calls=[call_get_repo_states, call_get_repo_states], any_order=False)
def test_enable_disabled_repo(self): def test_enable_disabled_repo(self):
set_module_args({ with set_module_args({
'name': ['crb'], 'name': ['crb'],
'state': 'enabled' 'state': 'enabled'
}) }):
side_effects = [(0, mock_repolist_crb_disabled, ''), (0, '', ''), (0, mock_repolist_crb_enabled, '')] side_effects = [(0, mock_repolist_crb_disabled, ''), (0, '', ''), (0, mock_repolist_crb_enabled, '')]
self.set_command_mock(execute_side_effect=side_effects) self.set_command_mock(execute_side_effect=side_effects)
result = self.execute_module(changed=True) result = self.execute_module(changed=True)
self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_disabled) self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_disabled)
self.assertEqual(result['repo_states_post'], expected_repo_states_crb_enabled) self.assertEqual(result['repo_states_post'], expected_repo_states_crb_enabled)
self.assertEqual(result['changed_repos'], ['crb']) self.assertEqual(result['changed_repos'], ['crb'])
@ -328,25 +328,25 @@ class TestDNFConfigManager(ModuleTestCase):
self.run_command.assert_has_calls(calls=expected_calls, any_order=False) self.run_command.assert_has_calls(calls=expected_calls, any_order=False)
def test_enable_disabled_repo_check_mode(self): def test_enable_disabled_repo_check_mode(self):
set_module_args({ with set_module_args({
'name': ['crb'], 'name': ['crb'],
'state': 'enabled', 'state': 'enabled',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
side_effects = [(0, mock_repolist_crb_disabled, ''), (0, mock_repolist_crb_disabled, '')] side_effects = [(0, mock_repolist_crb_disabled, ''), (0, mock_repolist_crb_disabled, '')]
self.set_command_mock(execute_side_effect=side_effects) self.set_command_mock(execute_side_effect=side_effects)
result = self.execute_module(changed=True) result = self.execute_module(changed=True)
self.assertEqual(result['changed_repos'], ['crb']) self.assertEqual(result['changed_repos'], ['crb'])
self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False) self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False)
def test_disable_enabled_repo(self): def test_disable_enabled_repo(self):
set_module_args({ with set_module_args({
'name': ['crb'], 'name': ['crb'],
'state': 'disabled' 'state': 'disabled'
}) }):
side_effects = [(0, mock_repolist_crb_enabled, ''), (0, '', ''), (0, mock_repolist_crb_disabled, '')] side_effects = [(0, mock_repolist_crb_enabled, ''), (0, '', ''), (0, mock_repolist_crb_disabled, '')]
self.set_command_mock(execute_side_effect=side_effects) self.set_command_mock(execute_side_effect=side_effects)
result = self.execute_module(changed=True) result = self.execute_module(changed=True)
self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_enabled) self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_enabled)
self.assertEqual(result['repo_states_post'], expected_repo_states_crb_disabled) self.assertEqual(result['repo_states_post'], expected_repo_states_crb_disabled)
self.assertEqual(result['changed_repos'], ['crb']) self.assertEqual(result['changed_repos'], ['crb'])
@ -354,49 +354,49 @@ class TestDNFConfigManager(ModuleTestCase):
self.run_command.assert_has_calls(calls=expected_calls, any_order=False) self.run_command.assert_has_calls(calls=expected_calls, any_order=False)
def test_crb_already_enabled(self): def test_crb_already_enabled(self):
set_module_args({ with set_module_args({
'name': ['crb'], 'name': ['crb'],
'state': 'enabled' 'state': 'enabled'
}) }):
side_effects = [(0, mock_repolist_crb_enabled, ''), (0, mock_repolist_crb_enabled, '')] side_effects = [(0, mock_repolist_crb_enabled, ''), (0, mock_repolist_crb_enabled, '')]
self.set_command_mock(execute_side_effect=side_effects) self.set_command_mock(execute_side_effect=side_effects)
result = self.execute_module(changed=False) result = self.execute_module(changed=False)
self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_enabled) self.assertEqual(result['repo_states_pre'], expected_repo_states_crb_enabled)
self.assertEqual(result['repo_states_post'], expected_repo_states_crb_enabled) self.assertEqual(result['repo_states_post'], expected_repo_states_crb_enabled)
self.assertEqual(result['changed_repos'], []) self.assertEqual(result['changed_repos'], [])
self.run_command.assert_has_calls(calls=[call_get_repo_states, call_get_repo_states], any_order=False) self.run_command.assert_has_calls(calls=[call_get_repo_states, call_get_repo_states], any_order=False)
def test_get_repo_states_fail_no_status(self): def test_get_repo_states_fail_no_status(self):
set_module_args({}) with set_module_args({}):
self.set_command_mock(execute_return=(0, mock_repolist_no_status, '')) self.set_command_mock(execute_return=(0, mock_repolist_no_status, ''))
result = self.execute_module(failed=True) result = self.execute_module(failed=True)
self.assertEqual(result['msg'], 'dnf repolist parse failure: parsed another repo id before next status') self.assertEqual(result['msg'], 'dnf repolist parse failure: parsed another repo id before next status')
self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False) self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False)
def test_get_repo_states_fail_status_before_id(self): def test_get_repo_states_fail_status_before_id(self):
set_module_args({}) with set_module_args({}):
self.set_command_mock(execute_return=(0, mock_repolist_status_before_id, '')) self.set_command_mock(execute_return=(0, mock_repolist_status_before_id, ''))
result = self.execute_module(failed=True) result = self.execute_module(failed=True)
self.assertEqual(result['msg'], 'dnf repolist parse failure: parsed status before repo id') self.assertEqual(result['msg'], 'dnf repolist parse failure: parsed status before repo id')
self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False) self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False)
def test_failed__unknown_repo_id(self): def test_failed__unknown_repo_id(self):
set_module_args({ with set_module_args({
'name': ['fake'] 'name': ['fake']
}) }):
self.set_command_mock(execute_return=(0, mock_repolist_crb_disabled, '')) self.set_command_mock(execute_return=(0, mock_repolist_crb_disabled, ''))
result = self.execute_module(failed=True) result = self.execute_module(failed=True)
self.assertEqual(result['msg'], "did not find repo with ID 'fake' in dnf repolist --all --verbose") self.assertEqual(result['msg'], "did not find repo with ID 'fake' in dnf repolist --all --verbose")
self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False) self.run_command.assert_has_calls(calls=[call_get_repo_states], any_order=False)
def test_failed_state_change_ineffective(self): def test_failed_state_change_ineffective(self):
set_module_args({ with set_module_args({
'name': ['crb'], 'name': ['crb'],
'state': 'enabled' 'state': 'enabled'
}) }):
side_effects = [(0, mock_repolist_crb_disabled, ''), (0, '', ''), (0, mock_repolist_crb_disabled, '')] side_effects = [(0, mock_repolist_crb_disabled, ''), (0, '', ''), (0, mock_repolist_crb_disabled, '')]
self.set_command_mock(execute_side_effect=side_effects) self.set_command_mock(execute_side_effect=side_effects)
result = self.execute_module(failed=True) result = self.execute_module(failed=True)
self.assertEqual(result['msg'], "dnf config-manager failed to make 'crb' enabled") self.assertEqual(result['msg'], "dnf config-manager failed to make 'crb' enabled")
expected_calls = [call_get_repo_states, call_enable_crb, call_get_repo_states] expected_calls = [call_get_repo_states, call_enable_crb, call_get_repo_states]
self.run_command.assert_has_calls(calls=expected_calls, any_order=False) self.run_command.assert_has_calls(calls=expected_calls, any_order=False)

4
tests/unit/plugins/modules/test_dnsimple.py
View file

@ -38,8 +38,8 @@ class TestDNSimple(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
"""Failure must occurs when all parameters are missing""" """Failure must occurs when all parameters are missing"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
@patch('dnsimple.service.Identity.whoami') @patch('dnsimple.service.Identity.whoami')
def test_account_token(self, mock_whoami): def test_account_token(self, mock_whoami):

22
tests/unit/plugins/modules/test_dnsimple_info.py
View file

@ -56,19 +56,19 @@ class TestDNSimple_Info(ModuleTestCase):
def test_with_no_parameters(self): def test_with_no_parameters(self):
"""Failure must occurs when all parameters are missing""" """Failure must occurs when all parameters are missing"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
@with_httmock(zones_resp) @with_httmock(zones_resp)
def test_only_key_and_account(self): def test_only_key_and_account(self):
"""key and account will pass, returns domains""" """key and account will pass, returns domains"""
account_id = "1234" account_id = "1234"
with self.assertRaises(AnsibleExitJson) as exc_info: with self.assertRaises(AnsibleExitJson) as exc_info:
set_module_args({ with set_module_args({
"api_key": "abcd1324", "api_key": "abcd1324",
"account_id": account_id "account_id": account_id
}) }):
self.module.main() self.module.main()
result = exc_info.exception.args[0] result = exc_info.exception.args[0]
# nothing should change # nothing should change
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
@ -80,12 +80,12 @@ class TestDNSimple_Info(ModuleTestCase):
"""name and no record should not fail, returns the record""" """name and no record should not fail, returns the record"""
name = "example.com" name = "example.com"
with self.assertRaises(AnsibleExitJson) as exc_info: with self.assertRaises(AnsibleExitJson) as exc_info:
set_module_args({ with set_module_args({
"api_key": "abcd1324", "api_key": "abcd1324",
"name": "example.com", "name": "example.com",
"account_id": "1234" "account_id": "1234"
}) }):
self.module.main() self.module.main()
result = exc_info.exception.args[0] result = exc_info.exception.args[0]
# nothing should change # nothing should change
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
@ -97,13 +97,13 @@ class TestDNSimple_Info(ModuleTestCase):
"""name and record should not fail, returns the record""" """name and record should not fail, returns the record"""
record = "example" record = "example"
with self.assertRaises(AnsibleExitJson) as exc_info: with self.assertRaises(AnsibleExitJson) as exc_info:
set_module_args({ with set_module_args({
"api_key": "abcd1324", "api_key": "abcd1324",
"account_id": "1234", "account_id": "1234",
"name": "example.com", "name": "example.com",
"record": "example" "record": "example"
}) }):
self.module.main() self.module.main()
result = exc_info.exception.args[0] result = exc_info.exception.args[0]
# nothing should change # nothing should change
self.assertFalse(result['changed']) self.assertFalse(result['changed'])

54
tests/unit/plugins/modules/test_gem.py
View file

@ -55,14 +55,13 @@ class TestGem(ModuleTestCase):
return self.mocker.patch(target) return self.mocker.patch(target)
def test_fails_when_user_install_and_install_dir_are_combined(self): def test_fails_when_user_install_and_install_dir_are_combined(self):
set_module_args({ with set_module_args({
'name': 'dummy', 'name': 'dummy',
'user_install': True, 'user_install': True,
'install_dir': '/opt/dummy', 'install_dir': '/opt/dummy',
}) }):
with pytest.raises(AnsibleFailJson) as exc:
with pytest.raises(AnsibleFailJson) as exc: gem.main()
gem.main()
result = exc.value.args[0] result = exc.value.args[0]
assert result['failed'] assert result['failed']
@ -75,18 +74,17 @@ class TestGem(ModuleTestCase):
# test mocks. The only thing that matters is the assertion that this 'gem install' is # test mocks. The only thing that matters is the assertion that this 'gem install' is
# invoked with '--install-dir'. # invoked with '--install-dir'.
set_module_args({ with set_module_args({
'name': 'dummy', 'name': 'dummy',
'user_install': False, 'user_install': False,
'install_dir': '/opt/dummy', 'install_dir': '/opt/dummy',
}) }):
self.patch_rubygems_version()
self.patch_installed_versions([])
run_command = self.patch_run_command()
self.patch_rubygems_version() with pytest.raises(AnsibleExitJson) as exc:
self.patch_installed_versions([]) gem.main()
run_command = self.patch_run_command()
with pytest.raises(AnsibleExitJson) as exc:
gem.main()
result = exc.value.args[0] result = exc.value.args[0]
assert result['changed'] assert result['changed']
@ -98,20 +96,19 @@ class TestGem(ModuleTestCase):
# XXX: This test is also extremely fragile because of mocking. # XXX: This test is also extremely fragile because of mocking.
# If this breaks, the only that matters is to check whether '--install-dir' is # If this breaks, the only that matters is to check whether '--install-dir' is
# in the run command, and that GEM_HOME is passed to the command. # in the run command, and that GEM_HOME is passed to the command.
set_module_args({ with set_module_args({
'name': 'dummy', 'name': 'dummy',
'user_install': False, 'user_install': False,
'install_dir': '/opt/dummy', 'install_dir': '/opt/dummy',
'state': 'absent', 'state': 'absent',
}) }):
self.patch_rubygems_version()
self.patch_installed_versions(['1.0.0'])
self.patch_rubygems_version() run_command = self.patch_run_command()
self.patch_installed_versions(['1.0.0'])
run_command = self.patch_run_command() with pytest.raises(AnsibleExitJson) as exc:
gem.main()
with pytest.raises(AnsibleExitJson) as exc:
gem.main()
result = exc.value.args[0] result = exc.value.args[0]
@ -124,17 +121,16 @@ class TestGem(ModuleTestCase):
assert update_environ.get('GEM_HOME') == '/opt/dummy' assert update_environ.get('GEM_HOME') == '/opt/dummy'
def test_passes_add_force_option(self): def test_passes_add_force_option(self):
set_module_args({ with set_module_args({
'name': 'dummy', 'name': 'dummy',
'force': True, 'force': True,
}) }):
self.patch_rubygems_version()
self.patch_installed_versions([])
run_command = self.patch_run_command()
self.patch_rubygems_version() with pytest.raises(AnsibleExitJson) as exc:
self.patch_installed_versions([]) gem.main()
run_command = self.patch_run_command()
with pytest.raises(AnsibleExitJson) as exc:
gem.main()
result = exc.value.args[0] result = exc.value.args[0]
assert result['changed'] assert result['changed']

60
tests/unit/plugins/modules/test_icinga2_feature.py
View file

@ -38,63 +38,63 @@ class TestIcinga2Feature(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
"""Failure must occurs when all parameters are missing.""" """Failure must occurs when all parameters are missing."""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_enable_feature(self): def test_enable_feature(self):
"""Check that result is changed.""" """Check that result is changed."""
set_module_args({ with set_module_args({
'name': 'api', 'name': 'api',
}) }):
with patch.object(basic.AnsibleModule, 'run_command') as run_command: with patch.object(basic.AnsibleModule, 'run_command') as run_command:
run_command.return_value = 0, '', '' # successful execution, no output run_command.return_value = 0, '', '' # successful execution, no output
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
icinga2_feature.main() icinga2_feature.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(run_command.call_count, 2) self.assertEqual(run_command.call_count, 2)
self.assertEqual(run_command.call_args[0][0][-1], 'api') self.assertEqual(run_command.call_args[0][0][-1], 'api')
def test_enable_feature_with_check_mode(self): def test_enable_feature_with_check_mode(self):
"""Check that result is changed in check mode.""" """Check that result is changed in check mode."""
set_module_args({ with set_module_args({
'name': 'api', 'name': 'api',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch.object(basic.AnsibleModule, 'run_command') as run_command: with patch.object(basic.AnsibleModule, 'run_command') as run_command:
run_command.return_value = 0, '', '' # successful execution, no output run_command.return_value = 0, '', '' # successful execution, no output
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
icinga2_feature.main() icinga2_feature.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(run_command.call_count, 1) self.assertEqual(run_command.call_count, 1)
def test_disable_feature(self): def test_disable_feature(self):
"""Check that result is changed.""" """Check that result is changed."""
set_module_args({ with set_module_args({
'name': 'api', 'name': 'api',
'state': 'absent' 'state': 'absent'
}) }):
with patch.object(basic.AnsibleModule, 'run_command') as run_command: with patch.object(basic.AnsibleModule, 'run_command') as run_command:
run_command.return_value = 0, '', '' # successful execution, no output run_command.return_value = 0, '', '' # successful execution, no output
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
icinga2_feature.main() icinga2_feature.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(run_command.call_count, 2) self.assertEqual(run_command.call_count, 2)
self.assertEqual(run_command.call_args[0][0][-1], 'api') self.assertEqual(run_command.call_args[0][0][-1], 'api')
def test_disable_feature_with_check_mode(self): def test_disable_feature_with_check_mode(self):
"""Check that result is changed in check mode.""" """Check that result is changed in check mode."""
set_module_args({ with set_module_args({
'name': 'api', 'name': 'api',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch.object(basic.AnsibleModule, 'run_command') as run_command: with patch.object(basic.AnsibleModule, 'run_command') as run_command:
run_command.return_value = 0, '', '' # successful execution, no output run_command.return_value = 0, '', '' # successful execution, no output
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
icinga2_feature.main() icinga2_feature.main()
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
self.assertEqual(run_command.call_count, 1) self.assertEqual(run_command.call_count, 1)

13
tests/unit/plugins/modules/test_ipa_getkeytab.py
View file

@ -34,18 +34,17 @@ class IPAKeytabModuleTestCase(ModuleTestCase):
return exc.exception.args[0] return exc.exception.args[0]
def test_present(self): def test_present(self):
set_module_args({ with set_module_args({
'path': '/tmp/test.keytab', 'path': '/tmp/test.keytab',
'principal': 'HTTP/freeipa-dc02.ipa.test', 'principal': 'HTTP/freeipa-dc02.ipa.test',
'ipa_host': 'freeipa-dc01.ipa.test', 'ipa_host': 'freeipa-dc01.ipa.test',
'state': 'present' 'state': 'present'
}) }):
self.module_main_command.side_effect = [
(0, '{}', ''),
]
self.module_main_command.side_effect = [ result = self.module_main(AnsibleExitJson)
(0, '{}', ''),
]
result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([

19
tests/unit/plugins/modules/test_ipa_otpconfig.py
View file

@ -61,12 +61,12 @@ class TestIPAOTPConfig(ModuleTestCase):
changed (bool): changed (bool):
Whether or not the module is supposed to be marked as changed Whether or not the module is supposed to be marked as changed
""" """
set_module_args(module_args)
# Run the module # Run the module
with patch_ipa(return_value=return_value) as (mock_login, mock_post): with set_module_args(module_args):
with self.assertRaises(AnsibleExitJson) as exec_info: with patch_ipa(return_value=return_value) as (mock_login, mock_post):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify that the calls to _post_json match what is expected # Verify that the calls to _post_json match what is expected
expected_call_count = len(mock_calls) expected_call_count = len(mock_calls)
@ -389,16 +389,15 @@ class TestIPAOTPConfig(ModuleTestCase):
def test_fail_post(self): def test_fail_post(self):
"""Fail due to an exception raised from _post_json""" """Fail due to an exception raised from _post_json"""
set_module_args({ with set_module_args({
'ipatokentotpauthwindow': 11, 'ipatokentotpauthwindow': 11,
'ipatokentotpsyncwindow': 12, 'ipatokentotpsyncwindow': 12,
'ipatokenhotpauthwindow': 13, 'ipatokenhotpauthwindow': 13,
'ipatokenhotpsyncwindow': 14 'ipatokenhotpsyncwindow': 14
}) }):
with patch_ipa(side_effect=Exception('ERROR MESSAGE')) as (mock_login, mock_post):
with patch_ipa(side_effect=Exception('ERROR MESSAGE')) as (mock_login, mock_post): with self.assertRaises(AnsibleFailJson) as exec_info:
with self.assertRaises(AnsibleFailJson) as exec_info: self.module.main()
self.module.main()
self.assertEqual(exec_info.exception.args[0]['msg'], 'ERROR MESSAGE') self.assertEqual(exec_info.exception.args[0]['msg'], 'ERROR MESSAGE')

22
tests/unit/plugins/modules/test_ipa_otptoken.py
View file

@ -61,12 +61,11 @@ class TestIPAOTPToken(ModuleTestCase):
changed (bool): changed (bool):
Whether or not the module is supposed to be marked as changed Whether or not the module is supposed to be marked as changed
""" """
set_module_args(module_args) with set_module_args(module_args):
# Run the module
# Run the module with patch_ipa(return_value=return_value) as (mock_login, mock_post):
with patch_ipa(return_value=return_value) as (mock_login, mock_post): with self.assertRaises(AnsibleExitJson) as exec_info:
with self.assertRaises(AnsibleExitJson) as exec_info: self.module.main()
self.module.main()
# Verify that the calls to _post_json match what is expected # Verify that the calls to _post_json match what is expected
expected_call_count = len(mock_calls) expected_call_count = len(mock_calls)
@ -481,13 +480,12 @@ class TestIPAOTPToken(ModuleTestCase):
def test_fail_post(self): def test_fail_post(self):
"""Fail due to an exception raised from _post_json""" """Fail due to an exception raised from _post_json"""
set_module_args({ with set_module_args({
'uniqueid': 'NewToken1' 'uniqueid': 'NewToken1'
}) }):
with patch_ipa(side_effect=Exception('ERROR MESSAGE')) as (mock_login, mock_post):
with patch_ipa(side_effect=Exception('ERROR MESSAGE')) as (mock_login, mock_post): with self.assertRaises(AnsibleFailJson) as exec_info:
with self.assertRaises(AnsibleFailJson) as exec_info: self.module.main()
self.module.main()
self.assertEqual(exec_info.exception.args[0]['msg'], 'ERROR MESSAGE') self.assertEqual(exec_info.exception.args[0]['msg'], 'ERROR MESSAGE')

22
tests/unit/plugins/modules/test_ipa_pwpolicy.py
View file

@ -62,12 +62,11 @@ class TestIPAPwPolicy(ModuleTestCase):
changed (bool): changed (bool):
Whether or not the module is supposed to be marked as changed Whether or not the module is supposed to be marked as changed
""" """
set_module_args(module_args) with set_module_args(module_args):
# Run the module
# Run the module with patch_ipa(return_value=return_value) as (mock_login, mock_post):
with patch_ipa(return_value=return_value) as (mock_login, mock_post): with self.assertRaises(AnsibleExitJson) as exec_info:
with self.assertRaises(AnsibleExitJson) as exec_info: self.module.main()
self.module.main()
# Verify that the calls to _post_json match what is expected # Verify that the calls to _post_json match what is expected
expected_call_count = len(mock_calls) expected_call_count = len(mock_calls)
@ -693,14 +692,13 @@ class TestIPAPwPolicy(ModuleTestCase):
def test_fail_post(self): def test_fail_post(self):
"""Fail due to an exception raised from _post_json""" """Fail due to an exception raised from _post_json"""
set_module_args({ with set_module_args({
'group': 'admins', 'group': 'admins',
'state': 'absent' 'state': 'absent'
}) }):
with patch_ipa(side_effect=Exception('ERROR MESSAGE')) as (mock_login, mock_post):
with patch_ipa(side_effect=Exception('ERROR MESSAGE')) as (mock_login, mock_post): with self.assertRaises(AnsibleFailJson) as exec_info:
with self.assertRaises(AnsibleFailJson) as exec_info: self.module.main()
self.module.main()
self.assertEqual(exec_info.exception.args[0]['msg'], 'ERROR MESSAGE') self.assertEqual(exec_info.exception.args[0]['msg'], 'ERROR MESSAGE')

160
tests/unit/plugins/modules/test_java_keystore.py
View file

@ -83,20 +83,20 @@ class TestCreateJavaKeystore(ModuleTestCase):
self.mock_os_path_exists.stop() self.mock_os_path_exists.stop()
def test_create_jks_success(self): def test_create_jks_success(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='test', name='test',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
with patch('os.remove', return_value=True): with patch('os.remove', return_value=True):
self.create_path.side_effect = ['/tmp/tmpgrzm2ah7'] self.create_path.side_effect = ['/tmp/tmpgrzm2ah7']
@ -115,21 +115,21 @@ class TestCreateJavaKeystore(ModuleTestCase):
} }
def test_create_jks_keypass_fail_export_pkcs12(self): def test_create_jks_keypass_fail_export_pkcs12(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
private_key_passphrase='passphrase-foo', private_key_passphrase='passphrase-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='test', name='test',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
module.exit_json = Mock() module.exit_json = Mock()
module.fail_json = Mock() module.fail_json = Mock()
@ -154,20 +154,20 @@ class TestCreateJavaKeystore(ModuleTestCase):
) )
def test_create_jks_fail_export_pkcs12(self): def test_create_jks_fail_export_pkcs12(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='test', name='test',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
module.exit_json = Mock() module.exit_json = Mock()
module.fail_json = Mock() module.fail_json = Mock()
@ -191,20 +191,20 @@ class TestCreateJavaKeystore(ModuleTestCase):
) )
def test_create_jks_fail_import_key(self): def test_create_jks_fail_import_key(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='test', name='test',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
module.exit_json = Mock() module.exit_json = Mock()
module.fail_json = Mock() module.fail_json = Mock()
@ -257,20 +257,20 @@ class TestCertChanged(ModuleTestCase):
self.mock_atomic_move.stop() self.mock_atomic_move.stop()
def test_cert_unchanged_same_fingerprint(self): def test_cert_unchanged_same_fingerprint(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='foo', name='foo',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
with patch('os.remove', return_value=True): with patch('os.remove', return_value=True):
self.create_file.side_effect = ['/tmp/placeholder', ''] self.create_file.side_effect = ['/tmp/placeholder', '']
@ -282,20 +282,20 @@ class TestCertChanged(ModuleTestCase):
self.assertFalse(result, 'Fingerprint is identical') self.assertFalse(result, 'Fingerprint is identical')
def test_cert_changed_fingerprint_mismatch(self): def test_cert_changed_fingerprint_mismatch(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='foo', name='foo',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
with patch('os.remove', return_value=True): with patch('os.remove', return_value=True):
self.create_file.side_effect = ['/tmp/placeholder', ''] self.create_file.side_effect = ['/tmp/placeholder', '']
@ -307,20 +307,20 @@ class TestCertChanged(ModuleTestCase):
self.assertTrue(result, 'Fingerprint mismatch') self.assertTrue(result, 'Fingerprint mismatch')
def test_cert_changed_alias_does_not_exist(self): def test_cert_changed_alias_does_not_exist(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='foo', name='foo',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
with patch('os.remove', return_value=True): with patch('os.remove', return_value=True):
self.create_file.side_effect = ['/tmp/placeholder', ''] self.create_file.side_effect = ['/tmp/placeholder', '']
@ -332,20 +332,20 @@ class TestCertChanged(ModuleTestCase):
self.assertTrue(result, 'Alias mismatch detected') self.assertTrue(result, 'Alias mismatch detected')
def test_cert_changed_password_mismatch(self): def test_cert_changed_password_mismatch(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='foo', name='foo',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
with patch('os.remove', return_value=True): with patch('os.remove', return_value=True):
self.create_file.side_effect = ['/tmp/placeholder', ''] self.create_file.side_effect = ['/tmp/placeholder', '']
@ -357,20 +357,20 @@ class TestCertChanged(ModuleTestCase):
self.assertTrue(result, 'Password mismatch detected') self.assertTrue(result, 'Password mismatch detected')
def test_cert_changed_fail_read_cert(self): def test_cert_changed_fail_read_cert(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='foo', name='foo',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
module.exit_json = Mock() module.exit_json = Mock()
module.fail_json = Mock() module.fail_json = Mock()
@ -390,20 +390,20 @@ class TestCertChanged(ModuleTestCase):
) )
def test_cert_changed_fail_read_keystore(self): def test_cert_changed_fail_read_keystore(self):
set_module_args(dict( with set_module_args(dict(
certificate='cert-foo', certificate='cert-foo',
private_key='private-foo', private_key='private-foo',
dest='/path/to/keystore.jks', dest='/path/to/keystore.jks',
name='foo', name='foo',
password='changeit' password='changeit'
)) )):
module = AnsibleModule( module = AnsibleModule(
argument_spec=module_argument_spec, argument_spec=module_argument_spec,
supports_check_mode=module_supports_check_mode, supports_check_mode=module_supports_check_mode,
mutually_exclusive=module_choose_between, mutually_exclusive=module_choose_between,
required_one_of=module_choose_between required_one_of=module_choose_between
) )
module.exit_json = Mock() module.exit_json = Mock()
module.fail_json = Mock(return_value=True) module.fail_json = Mock(return_value=True)

85
tests/unit/plugins/modules/test_jenkins_build.py
View file

@ -8,39 +8,8 @@ __metaclass__ = type
from ansible_collections.community.general.tests.unit.compat import unittest from ansible_collections.community.general.tests.unit.compat import unittest
from ansible_collections.community.general.tests.unit.compat.mock import patch from ansible_collections.community.general.tests.unit.compat.mock import patch
from ansible.module_utils import basic from ansible.module_utils import basic
from ansible.module_utils.common.text.converters import to_bytes
from ansible_collections.community.general.plugins.modules import jenkins_build from ansible_collections.community.general.plugins.modules import jenkins_build
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, set_module_args, exit_json, fail_json
import json
def set_module_args(args):
"""prepare arguments so that they will be picked up during module creation"""
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
class AnsibleExitJson(Exception):
"""Exception class to be raised by module.exit_json and caught by the test case"""
pass
class AnsibleFailJson(Exception):
"""Exception class to be raised by module.fail_json and caught by the test case"""
pass
def exit_json(*args, **kwargs):
"""function to patch over exit_json; package return data into an exception"""
if 'changed' not in kwargs:
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
def fail_json(*args, **kwargs):
"""function to patch over fail_json; package return data into an exception"""
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
class jenkins: class jenkins:
@ -131,18 +100,18 @@ class TestJenkinsBuild(unittest.TestCase):
def test_module_fail_when_required_args_missing(self, test_deps): def test_module_fail_when_required_args_missing(self, test_deps):
test_deps.return_value = None test_deps.return_value = None
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
jenkins_build.main() jenkins_build.main()
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies')
def test_module_fail_when_missing_build_number(self, test_deps): def test_module_fail_when_missing_build_number(self, test_deps):
test_deps.return_value = None test_deps.return_value = None
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
"name": "required-if", "name": "required-if",
"state": "stopped" "state": "stopped"
}) }):
jenkins_build.main() jenkins_build.main()
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies')
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection')
@ -151,12 +120,12 @@ class TestJenkinsBuild(unittest.TestCase):
jenkins_connection.return_value = JenkinsMock() jenkins_connection.return_value = JenkinsMock()
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
set_module_args({ with set_module_args({
"name": "host-check", "name": "host-check",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build.main() jenkins_build.main()
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies')
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection')
@ -165,14 +134,14 @@ class TestJenkinsBuild(unittest.TestCase):
jenkins_connection.return_value = JenkinsMock() jenkins_connection.return_value = JenkinsMock()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "host-check", "name": "host-check",
"build_number": "1234", "build_number": "1234",
"state": "stopped", "state": "stopped",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build.main() jenkins_build.main()
self.assertTrue(return_json.exception.args[0]['changed']) self.assertTrue(return_json.exception.args[0]['changed'])
@ -183,14 +152,14 @@ class TestJenkinsBuild(unittest.TestCase):
jenkins_connection.return_value = JenkinsMockIdempotent() jenkins_connection.return_value = JenkinsMockIdempotent()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "host-check", "name": "host-check",
"build_number": "1234", "build_number": "1234",
"state": "stopped", "state": "stopped",
"user": "abc", "user": "abc",
"password": "xyz" "password": "xyz"
}) }):
jenkins_build.main() jenkins_build.main()
self.assertFalse(return_json.exception.args[0]['changed']) self.assertFalse(return_json.exception.args[0]['changed'])
@ -203,14 +172,14 @@ class TestJenkinsBuild(unittest.TestCase):
build_status.return_value = JenkinsBuildMock().get_build_status() build_status.return_value = JenkinsBuildMock().get_build_status()
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
set_module_args({ with set_module_args({
"name": "host-delete", "name": "host-delete",
"build_number": "1234", "build_number": "1234",
"state": "absent", "state": "absent",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build.main() jenkins_build.main()
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies')
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection')
@ -219,14 +188,14 @@ class TestJenkinsBuild(unittest.TestCase):
jenkins_connection.return_value = JenkinsMockIdempotent() jenkins_connection.return_value = JenkinsMockIdempotent()
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
"name": "host-delete", "name": "host-delete",
"build_number": "1234", "build_number": "1234",
"state": "absent", "state": "absent",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build.main() jenkins_build.main()
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.test_dependencies')
@patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection') @patch('ansible_collections.community.general.plugins.modules.jenkins_build.JenkinsBuild.get_jenkins_connection')
@ -237,12 +206,12 @@ class TestJenkinsBuild(unittest.TestCase):
build_status.return_value = JenkinsBuildMock().get_build_status() build_status.return_value = JenkinsBuildMock().get_build_status()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "create-detached", "name": "create-detached",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build.main() jenkins_build.main()
self.assertFalse(return_json.exception.args[0]['changed']) self.assertFalse(return_json.exception.args[0]['changed'])
@ -253,12 +222,12 @@ class TestJenkinsBuild(unittest.TestCase):
jenkins_connection.return_value = JenkinsMock() jenkins_connection.return_value = JenkinsMock()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "create-detached", "name": "create-detached",
"user": "abc", "user": "abc",
"token": "xyz", "token": "xyz",
"detach": True "detach": True
}) }):
jenkins_build.main() jenkins_build.main()
self.assertTrue(return_json.exception.args[0]['changed']) self.assertTrue(return_json.exception.args[0]['changed'])

61
tests/unit/plugins/modules/test_jenkins_build_info.py
View file

@ -8,39 +8,8 @@ __metaclass__ = type
from ansible_collections.community.general.tests.unit.compat import unittest from ansible_collections.community.general.tests.unit.compat import unittest
from ansible_collections.community.general.tests.unit.compat.mock import patch from ansible_collections.community.general.tests.unit.compat.mock import patch
from ansible.module_utils import basic from ansible.module_utils import basic
from ansible.module_utils.common.text.converters import to_bytes
from ansible_collections.community.general.plugins.modules import jenkins_build_info from ansible_collections.community.general.plugins.modules import jenkins_build_info
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, set_module_args, exit_json, fail_json
import json
def set_module_args(args):
"""prepare arguments so that they will be picked up during module creation"""
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
class AnsibleExitJson(Exception):
"""Exception class to be raised by module.exit_json and caught by the test case"""
pass
class AnsibleFailJson(Exception):
"""Exception class to be raised by module.fail_json and caught by the test case"""
pass
def exit_json(*args, **kwargs):
"""function to patch over exit_json; package return data into an exception"""
if 'changed' not in kwargs:
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
def fail_json(*args, **kwargs):
"""function to patch over fail_json; package return data into an exception"""
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
class jenkins: class jenkins:
@ -101,8 +70,8 @@ class TestJenkinsBuildInfo(unittest.TestCase):
def test_module_fail_when_required_args_missing(self, test_deps): def test_module_fail_when_required_args_missing(self, test_deps):
test_deps.return_value = None test_deps.return_value = None
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
jenkins_build_info.main() jenkins_build_info.main()
@patch('ansible_collections.community.general.plugins.modules.jenkins_build_info.test_dependencies') @patch('ansible_collections.community.general.plugins.modules.jenkins_build_info.test_dependencies')
@patch('ansible_collections.community.general.plugins.modules.jenkins_build_info.JenkinsBuildInfo.get_jenkins_connection') @patch('ansible_collections.community.general.plugins.modules.jenkins_build_info.JenkinsBuildInfo.get_jenkins_connection')
@ -111,13 +80,13 @@ class TestJenkinsBuildInfo(unittest.TestCase):
jenkins_connection.return_value = JenkinsMock() jenkins_connection.return_value = JenkinsMock()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "job-present", "name": "job-present",
"user": "abc", "user": "abc",
"token": "xyz", "token": "xyz",
"build_number": 30 "build_number": 30
}) }):
jenkins_build_info.main() jenkins_build_info.main()
self.assertFalse(return_json.exception.args[0]["changed"]) self.assertFalse(return_json.exception.args[0]["changed"])
@ -130,13 +99,13 @@ class TestJenkinsBuildInfo(unittest.TestCase):
build_status.return_value = JenkinsBuildMock("job-absent", 30).get_build_status() build_status.return_value = JenkinsBuildMock("job-absent", 30).get_build_status()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "job-absent", "name": "job-absent",
"user": "abc", "user": "abc",
"token": "xyz", "token": "xyz",
"build_number": 30 "build_number": 30
}) }):
jenkins_build_info.main() jenkins_build_info.main()
self.assertFalse(return_json.exception.args[0]['changed']) self.assertFalse(return_json.exception.args[0]['changed'])
self.assertTrue(return_json.exception.args[0]['failed']) self.assertTrue(return_json.exception.args[0]['failed'])
@ -149,12 +118,12 @@ class TestJenkinsBuildInfo(unittest.TestCase):
jenkins_connection.return_value = JenkinsMock() jenkins_connection.return_value = JenkinsMock()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "job-present", "name": "job-present",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build_info.main() jenkins_build_info.main()
self.assertFalse(return_json.exception.args[0]['changed']) self.assertFalse(return_json.exception.args[0]['changed'])
self.assertEqual("SUCCESS", return_json.exception.args[0]['build_info']['result']) self.assertEqual("SUCCESS", return_json.exception.args[0]['build_info']['result'])
@ -168,12 +137,12 @@ class TestJenkinsBuildInfo(unittest.TestCase):
build_status.return_value = JenkinsBuildMock("job-absent").get_build_status() build_status.return_value = JenkinsBuildMock("job-absent").get_build_status()
with self.assertRaises(AnsibleExitJson) as return_json: with self.assertRaises(AnsibleExitJson) as return_json:
set_module_args({ with set_module_args({
"name": "job-absent", "name": "job-absent",
"user": "abc", "user": "abc",
"token": "xyz" "token": "xyz"
}) }):
jenkins_build_info.main() jenkins_build_info.main()
self.assertFalse(return_json.exception.args[0]['changed']) self.assertFalse(return_json.exception.args[0]['changed'])
self.assertTrue(return_json.exception.args[0]['failed']) self.assertTrue(return_json.exception.args[0]['failed'])

407
tests/unit/plugins/modules/test_jenkins_node.py
View file

@ -6,16 +6,14 @@ from __future__ import absolute_import, division, print_function
__metaclass__ = type __metaclass__ = type
import jenkins import jenkins
import json
from xml.etree import ElementTree as et from xml.etree import ElementTree as et
import pytest import pytest
from ansible.module_utils import basic
from ansible.module_utils.common.text.converters import to_bytes
from ansible_collections.community.general.tests.unit.compat.mock import patch, call from ansible_collections.community.general.tests.unit.compat.mock import patch, call
from ansible_collections.community.general.plugins.modules import jenkins_node from ansible_collections.community.general.plugins.modules import jenkins_node
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, set_module_args, exit_json, fail_json
from pytest import fixture, raises, mark, param from pytest import fixture, raises, mark, param
@ -62,35 +60,6 @@ def assert_xml_equal(x, y):
raise AssertionError("{} != {}".format(x, y)) raise AssertionError("{} != {}".format(x, y))
def set_module_args(args):
"""prepare arguments so that they will be picked up during module creation"""
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
class AnsibleExitJson(Exception):
def __init__(self, value):
self.value = value
def __getitem__(self, item):
return self.value[item]
def exit_json(*args, **kwargs):
if 'changed' not in kwargs:
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
class AnsibleFailJson(Exception):
pass
def fail_json(*args, **kwargs):
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
@fixture(autouse=True) @fixture(autouse=True)
def module(): def module():
with patch.multiple( with patch.multiple(
@ -120,16 +89,16 @@ def get_instance(instance):
def test_get_jenkins_instance_with_user_and_token(instance): def test_get_jenkins_instance_with_user_and_token(instance):
instance.node_exists.return_value = False instance.node_exists.return_value = False
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
"url": "https://localhost:8080", "url": "https://localhost:8080",
"user": "admin", "user": "admin",
"token": "password", "token": "password",
}) }):
with pytest.raises(AnsibleExitJson): with pytest.raises(AnsibleExitJson):
jenkins_node.main() jenkins_node.main()
assert instance.call_args == call("https://localhost:8080", "admin", "password") assert instance.call_args == call("https://localhost:8080", "admin", "password")
@ -137,15 +106,15 @@ def test_get_jenkins_instance_with_user_and_token(instance):
def test_get_jenkins_instance_with_user(instance): def test_get_jenkins_instance_with_user(instance):
instance.node_exists.return_value = False instance.node_exists.return_value = False
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
"url": "https://localhost:8080", "url": "https://localhost:8080",
"user": "admin", "user": "admin",
}) }):
with pytest.raises(AnsibleExitJson): with pytest.raises(AnsibleExitJson):
jenkins_node.main() jenkins_node.main()
assert instance.call_args == call("https://localhost:8080", "admin") assert instance.call_args == call("https://localhost:8080", "admin")
@ -153,14 +122,14 @@ def test_get_jenkins_instance_with_user(instance):
def test_get_jenkins_instance_with_no_credential(instance): def test_get_jenkins_instance_with_no_credential(instance):
instance.node_exists.return_value = False instance.node_exists.return_value = False
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
"url": "https://localhost:8080", "url": "https://localhost:8080",
}) }):
with pytest.raises(AnsibleExitJson): with pytest.raises(AnsibleExitJson):
jenkins_node.main() jenkins_node.main()
assert instance.call_args == call("https://localhost:8080") assert instance.call_args == call("https://localhost:8080")
@ -173,18 +142,18 @@ def test_state_present_when_absent(get_instance, instance, state):
instance.node_exists.return_value = False instance.node_exists.return_value = False
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": state, "state": state,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.create_node.call_args == call("my-node", launcher=jenkins.LAUNCHER_SSH) assert instance.create_node.call_args == call("my-node", launcher=jenkins.LAUNCHER_SSH)
assert result.value["created"] is True assert result.value.args[0]["created"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
@mark.parametrize(["state"], [param(state) for state in PRESENT_STATES]) @mark.parametrize(["state"], [param(state) for state in PRESENT_STATES])
@ -192,19 +161,19 @@ def test_state_present_when_absent_check_mode(get_instance, instance, state):
instance.node_exists.return_value = False instance.node_exists.return_value = False
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": state, "state": state,
"_ansible_check_mode": True, "_ansible_check_mode": True,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.create_node.called assert not instance.create_node.called
assert result.value["created"] is True assert result.value.args[0]["created"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
@mark.parametrize(["state"], [param(state) for state in PRESENT_STATES]) @mark.parametrize(["state"], [param(state) for state in PRESENT_STATES])
@ -215,18 +184,18 @@ def test_state_present_when_absent_redirect_auth_error_handled(
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.create_node.side_effect = jenkins.JenkinsException instance.create_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": state, "state": state,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.create_node.call_args == call("my-node", launcher=jenkins.LAUNCHER_SSH) assert instance.create_node.call_args == call("my-node", launcher=jenkins.LAUNCHER_SSH)
assert result.value["created"] is True assert result.value.args[0]["created"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
@mark.parametrize(["state"], [param(state) for state in PRESENT_STATES]) @mark.parametrize(["state"], [param(state) for state in PRESENT_STATES])
@ -235,72 +204,72 @@ def test_state_present_when_absent_other_error_raised(get_instance, instance, st
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.create_node.side_effect = jenkins.JenkinsException instance.create_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": state, "state": state,
}) }):
with raises(AnsibleFailJson) as result: with raises(AnsibleFailJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.create_node.call_args == call("my-node", launcher=jenkins.LAUNCHER_SSH) assert instance.create_node.call_args == call("my-node", launcher=jenkins.LAUNCHER_SSH)
assert "Create node failed" in str(result.value) assert "Create node failed" in str(result.value.args[0])
def test_state_present_when_present(get_instance, instance): def test_state_present_when_present(get_instance, instance):
instance.node_exists.return_value = True instance.node_exists.return_value = True
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.create_node.called assert not instance.create_node.called
assert result.value["created"] is False assert result.value.args[0]["created"] is False
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_state_absent_when_present(get_instance, instance): def test_state_absent_when_present(get_instance, instance):
instance.node_exists.return_value = True instance.node_exists.return_value = True
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.delete_node.call_args == call("my-node") assert instance.delete_node.call_args == call("my-node")
assert result.value["deleted"] is True assert result.value.args[0]["deleted"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_absent_when_present_check_mode(get_instance, instance): def test_state_absent_when_present_check_mode(get_instance, instance):
instance.node_exists.return_value = True instance.node_exists.return_value = True
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
"_ansible_check_mode": True, "_ansible_check_mode": True,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.delete_node.called assert not instance.delete_node.called
assert result.value["deleted"] is True assert result.value.args[0]["deleted"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_absent_when_present_redirect_auth_error_handled(get_instance, instance): def test_state_absent_when_present_redirect_auth_error_handled(get_instance, instance):
@ -308,18 +277,18 @@ def test_state_absent_when_present_redirect_auth_error_handled(get_instance, ins
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.delete_node.side_effect = jenkins.JenkinsException instance.delete_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.delete_node.call_args == call("my-node") assert instance.delete_node.call_args == call("my-node")
assert result.value["deleted"] is True assert result.value.args[0]["deleted"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_absent_when_present_other_error_raised(get_instance, instance): def test_state_absent_when_present_other_error_raised(get_instance, instance):
@ -327,35 +296,35 @@ def test_state_absent_when_present_other_error_raised(get_instance, instance):
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.delete_node.side_effect = jenkins.JenkinsException instance.delete_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
}) }):
with raises(AnsibleFailJson) as result: with raises(AnsibleFailJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.delete_node.call_args == call("my-node") assert instance.delete_node.call_args == call("my-node")
assert "Delete node failed" in str(result.value) assert "Delete node failed" in str(result.value.args[0])
def test_state_absent_when_absent(get_instance, instance): def test_state_absent_when_absent(get_instance, instance):
instance.node_exists.return_value = False instance.node_exists.return_value = False
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "absent", "state": "absent",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.delete_node.called assert not instance.delete_node.called
assert result.value["deleted"] is False assert result.value.args[0]["deleted"] is False
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_state_enabled_when_offline(get_instance, instance): def test_state_enabled_when_offline(get_instance, instance):
@ -363,18 +332,18 @@ def test_state_enabled_when_offline(get_instance, instance):
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.get_node_info.return_value = {"offline": True} instance.get_node_info.return_value = {"offline": True}
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "enabled", "state": "enabled",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.enable_node.call_args == call("my-node") assert instance.enable_node.call_args == call("my-node")
assert result.value["enabled"] is True assert result.value.args[0]["enabled"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_enabled_when_offline_check_mode(get_instance, instance): def test_state_enabled_when_offline_check_mode(get_instance, instance):
@ -382,19 +351,19 @@ def test_state_enabled_when_offline_check_mode(get_instance, instance):
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.get_node_info.return_value = {"offline": True} instance.get_node_info.return_value = {"offline": True}
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "enabled", "state": "enabled",
"_ansible_check_mode": True, "_ansible_check_mode": True,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.enable_node.called assert not instance.enable_node.called
assert result.value["enabled"] is True assert result.value.args[0]["enabled"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_enabled_when_offline_redirect_auth_error_handled(get_instance, instance): def test_state_enabled_when_offline_redirect_auth_error_handled(get_instance, instance):
@ -403,18 +372,18 @@ def test_state_enabled_when_offline_redirect_auth_error_handled(get_instance, in
instance.get_node_info.side_effect = [{"offline": True}, {"offline": False}] instance.get_node_info.side_effect = [{"offline": True}, {"offline": False}]
instance.enable_node.side_effect = jenkins.JenkinsException instance.enable_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "enabled", "state": "enabled",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.enable_node.call_args == call("my-node") assert instance.enable_node.call_args == call("my-node")
assert result.value["enabled"] is True assert result.value.args[0]["enabled"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_enabled_when_offline_other_error_raised(get_instance, instance): def test_state_enabled_when_offline_other_error_raised(get_instance, instance):
@ -423,17 +392,17 @@ def test_state_enabled_when_offline_other_error_raised(get_instance, instance):
instance.get_node_info.side_effect = [{"offline": True}, {"offline": True}] instance.get_node_info.side_effect = [{"offline": True}, {"offline": True}]
instance.enable_node.side_effect = jenkins.JenkinsException instance.enable_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "enabled", "state": "enabled",
}) }):
with raises(AnsibleFailJson) as result: with raises(AnsibleFailJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.enable_node.call_args == call("my-node") assert instance.enable_node.call_args == call("my-node")
assert "Enable node failed" in str(result.value) assert "Enable node failed" in str(result.value.args[0])
def test_state_enabled_when_not_offline(get_instance, instance): def test_state_enabled_when_not_offline(get_instance, instance):
@ -441,18 +410,18 @@ def test_state_enabled_when_not_offline(get_instance, instance):
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
instance.get_node_info.return_value = {"offline": False} instance.get_node_info.return_value = {"offline": False}
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "enabled", "state": "enabled",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.enable_node.called assert not instance.enable_node.called
assert result.value["enabled"] is False assert result.value.args[0]["enabled"] is False
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_state_disabled_when_not_offline(get_instance, instance): def test_state_disabled_when_not_offline(get_instance, instance):
@ -463,18 +432,18 @@ def test_state_disabled_when_not_offline(get_instance, instance):
"offlineCauseReason": "", "offlineCauseReason": "",
} }
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.disable_node.call_args == call("my-node", "") assert instance.disable_node.call_args == call("my-node", "")
assert result.value["disabled"] is True assert result.value.args[0]["disabled"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_disabled_when_not_offline_redirect_auth_error_handled( def test_state_disabled_when_not_offline_redirect_auth_error_handled(
@ -494,18 +463,18 @@ def test_state_disabled_when_not_offline_redirect_auth_error_handled(
] ]
instance.disable_node.side_effect = jenkins.JenkinsException instance.disable_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.disable_node.call_args == call("my-node", "") assert instance.disable_node.call_args == call("my-node", "")
assert result.value["disabled"] is True assert result.value.args[0]["disabled"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_disabled_when_not_offline_other_error_raised(get_instance, instance): def test_state_disabled_when_not_offline_other_error_raised(get_instance, instance):
@ -523,17 +492,17 @@ def test_state_disabled_when_not_offline_other_error_raised(get_instance, instan
] ]
instance.disable_node.side_effect = jenkins.JenkinsException instance.disable_node.side_effect = jenkins.JenkinsException
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
}) }):
with raises(AnsibleFailJson) as result: with raises(AnsibleFailJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.disable_node.call_args == call("my-node", "") assert instance.disable_node.call_args == call("my-node", "")
assert "Disable node failed" in str(result.value) assert "Disable node failed" in str(result.value.args[0])
def test_state_disabled_when_not_offline_check_mode(get_instance, instance): def test_state_disabled_when_not_offline_check_mode(get_instance, instance):
@ -544,19 +513,19 @@ def test_state_disabled_when_not_offline_check_mode(get_instance, instance):
"offlineCauseReason": "", "offlineCauseReason": "",
} }
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
"_ansible_check_mode": True, "_ansible_check_mode": True,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.disable_node.called assert not instance.disable_node.called
assert result.value["disabled"] is True assert result.value.args[0]["disabled"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_state_disabled_when_offline(get_instance, instance): def test_state_disabled_when_offline(get_instance, instance):
@ -567,32 +536,32 @@ def test_state_disabled_when_offline(get_instance, instance):
"offlineCauseReason": "", "offlineCauseReason": "",
} }
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.disable_node.called assert not instance.disable_node.called
assert result.value["disabled"] is False assert result.value.args[0]["disabled"] is False
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_configure_num_executors_when_not_configured(get_instance, instance): def test_configure_num_executors_when_not_configured(get_instance, instance):
instance.node_exists.return_value = True instance.node_exists.return_value = True
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"num_executors": 3, "num_executors": 3,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.reconfig_node.call_args[0][0] == "my-node" assert instance.reconfig_node.call_args[0][0] == "my-node"
assert_xml_equal(instance.reconfig_node.call_args[0][1], """ assert_xml_equal(instance.reconfig_node.call_args[0][1], """
@ -601,8 +570,8 @@ def test_configure_num_executors_when_not_configured(get_instance, instance):
</slave> </slave>
""") """)
assert result.value["configured"] is True assert result.value.args[0]["configured"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_configure_num_executors_when_not_equal(get_instance, instance): def test_configure_num_executors_when_not_equal(get_instance, instance):
@ -613,14 +582,14 @@ def test_configure_num_executors_when_not_equal(get_instance, instance):
</slave> </slave>
""" """
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"num_executors": 2, "num_executors": 2,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert_xml_equal(instance.reconfig_node.call_args[0][1], """ assert_xml_equal(instance.reconfig_node.call_args[0][1], """
<slave> <slave>
@ -628,8 +597,8 @@ def test_configure_num_executors_when_not_equal(get_instance, instance):
</slave> </slave>
""") """)
assert result.value["configured"] is True assert result.value.args[0]["configured"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_configure_num_executors_when_equal(get_instance, instance): def test_configure_num_executors_when_equal(get_instance, instance):
@ -640,26 +609,26 @@ def test_configure_num_executors_when_equal(get_instance, instance):
</slave> </slave>
""" """
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"num_executors": 2, "num_executors": 2,
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.reconfig_node.called assert not instance.reconfig_node.called
assert result.value["configured"] is False assert result.value.args[0]["configured"] is False
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_configure_labels_when_not_configured(get_instance, instance): def test_configure_labels_when_not_configured(get_instance, instance):
instance.node_exists.return_value = True instance.node_exists.return_value = True
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"labels": [ "labels": [
@ -667,10 +636,10 @@ def test_configure_labels_when_not_configured(get_instance, instance):
"b", "b",
"c", "c",
], ],
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.reconfig_node.call_args[0][0] == "my-node" assert instance.reconfig_node.call_args[0][0] == "my-node"
assert_xml_equal(instance.reconfig_node.call_args[0][1], """ assert_xml_equal(instance.reconfig_node.call_args[0][1], """
@ -679,8 +648,8 @@ def test_configure_labels_when_not_configured(get_instance, instance):
</slave> </slave>
""") """)
assert result.value["configured"] is True assert result.value.args[0]["configured"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_configure_labels_when_not_equal(get_instance, instance): def test_configure_labels_when_not_equal(get_instance, instance):
@ -691,7 +660,7 @@ def test_configure_labels_when_not_equal(get_instance, instance):
</slave> </slave>
""" """
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"labels": [ "labels": [
@ -699,10 +668,10 @@ def test_configure_labels_when_not_equal(get_instance, instance):
"z", "z",
"c", "c",
], ],
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.reconfig_node.call_args[0][0] == "my-node" assert instance.reconfig_node.call_args[0][0] == "my-node"
assert_xml_equal(instance.reconfig_node.call_args[0][1], """ assert_xml_equal(instance.reconfig_node.call_args[0][1], """
@ -711,8 +680,8 @@ def test_configure_labels_when_not_equal(get_instance, instance):
</slave> </slave>
""") """)
assert result.value["configured"] is True assert result.value.args[0]["configured"] is True
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
def test_configure_labels_when_equal(get_instance, instance): def test_configure_labels_when_equal(get_instance, instance):
@ -723,7 +692,7 @@ def test_configure_labels_when_equal(get_instance, instance):
</slave> </slave>
""" """
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"labels": [ "labels": [
@ -731,45 +700,45 @@ def test_configure_labels_when_equal(get_instance, instance):
"b", "b",
"c", "c",
], ],
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.reconfig_node.called assert not instance.reconfig_node.called
assert result.value["configured"] is False assert result.value.args[0]["configured"] is False
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_configure_labels_fail_when_contains_space(get_instance, instance): def test_configure_labels_fail_when_contains_space(get_instance, instance):
instance.node_exists.return_value = True instance.node_exists.return_value = True
instance.get_node_config.return_value = "<slave />" instance.get_node_config.return_value = "<slave />"
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "present", "state": "present",
"labels": [ "labels": [
"a error", "a error",
], ],
}) }):
with raises(AnsibleFailJson): with raises(AnsibleFailJson):
jenkins_node.main() jenkins_node.main()
assert not instance.reconfig_node.called assert not instance.reconfig_node.called
@mark.parametrize(["state"], [param(state) for state in ["enabled", "present", "absent"]]) @mark.parametrize(["state"], [param(state) for state in ["enabled", "present", "absent"]])
def test_raises_error_if_offline_message_when_state_not_disabled(get_instance, instance, state): def test_raises_error_if_offline_message_when_state_not_disabled(get_instance, instance, state):
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": state, "state": state,
"offline_message": "This is a message...", "offline_message": "This is a message...",
}) }):
with raises(AnsibleFailJson): with raises(AnsibleFailJson):
jenkins_node.main() jenkins_node.main()
assert not instance.disable_node.called assert not instance.disable_node.called
@ -782,18 +751,18 @@ def test_set_offline_message_when_equal(get_instance, instance):
"offlineCauseReason": "This is an old message...", "offlineCauseReason": "This is an old message...",
} }
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
"offline_message": "This is an old message...", "offline_message": "This is an old message...",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.disable_node.called assert not instance.disable_node.called
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False
def test_set_offline_message_when_not_equal_not_offline(get_instance, instance): def test_set_offline_message_when_not_equal_not_offline(get_instance, instance):
@ -804,18 +773,18 @@ def test_set_offline_message_when_not_equal_not_offline(get_instance, instance):
"offlineCauseReason": "This is an old message...", "offlineCauseReason": "This is an old message...",
} }
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
"offline_message": "This is a new message...", "offline_message": "This is a new message...",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert instance.disable_node.call_args == call("my-node", "This is a new message...") assert instance.disable_node.call_args == call("my-node", "This is a new message...")
assert result.value["changed"] is True assert result.value.args[0]["changed"] is True
# Not calling disable_node when already offline seems like a sensible thing to do. # Not calling disable_node when already offline seems like a sensible thing to do.
@ -829,15 +798,15 @@ def test_set_offline_message_when_not_equal_offline(get_instance, instance):
"offlineCauseReason": "This is an old message...", "offlineCauseReason": "This is an old message...",
} }
set_module_args({ with set_module_args({
"name": "my-node", "name": "my-node",
"state": "disabled", "state": "disabled",
"offline_message": "This is a new message...", "offline_message": "This is a new message...",
}) }):
with raises(AnsibleExitJson) as result: with raises(AnsibleExitJson) as result:
jenkins_node.main() jenkins_node.main()
assert not instance.disable_node.called assert not instance.disable_node.called
assert result.value["changed"] is False assert result.value.args[0]["changed"] is False

115
tests/unit/plugins/modules/test_keycloak_authentication.py
View file

@ -163,17 +163,16 @@ class TestKeycloakAuthentication(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before, copy_auth_flow=return_value_copied, with mock_good_connection():
get_executions_representation=return_value_executions_after) \ with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before, copy_auth_flow=return_value_copied,
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, get_executions_representation=return_value_executions_after) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)
@ -256,17 +255,16 @@ class TestKeycloakAuthentication(ModuleTestCase):
] ]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before, with mock_good_connection():
get_executions_representation=return_value_executions_after) \ with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before,
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, get_executions_representation=return_value_executions_after) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)
@ -328,17 +326,16 @@ class TestKeycloakAuthentication(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before, with mock_good_connection():
get_executions_representation=return_value_executions_after, create_empty_auth_flow=return_value_created_empty_flow) \ with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before,
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, get_executions_representation=return_value_executions_after, create_empty_auth_flow=return_value_created_empty_flow) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)
@ -419,17 +416,16 @@ class TestKeycloakAuthentication(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before, with mock_good_connection():
get_executions_representation=return_value_executions_after) \ with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before,
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, get_executions_representation=return_value_executions_after) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)
@ -472,16 +468,15 @@ class TestKeycloakAuthentication(ModuleTestCase):
}] }]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before) \ with mock_good_connection():
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)
@ -508,16 +503,15 @@ class TestKeycloakAuthentication(ModuleTestCase):
return_value_auth_flow_before = [{}] return_value_auth_flow_before = [{}]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before) \ with mock_good_connection():
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)
@ -596,17 +590,16 @@ class TestKeycloakAuthentication(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before, with mock_good_connection():
get_executions_representation=return_value_executions_after, create_empty_auth_flow=return_value_created_empty_flow) \ with patch_keycloak_api(get_authentication_flow_by_alias=return_value_auth_flow_before,
as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow, get_executions_representation=return_value_executions_after, create_empty_auth_flow=return_value_created_empty_flow) \
mock_get_executions_representation, mock_delete_authentication_flow_by_id): as (mock_get_authentication_flow_by_alias, mock_copy_auth_flow, mock_create_empty_auth_flow,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_executions_representation, mock_delete_authentication_flow_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1) self.assertEqual(len(mock_get_authentication_flow_by_alias.mock_calls), 1)

125
tests/unit/plugins/modules/test_keycloak_authentication_required_actions.py
View file

@ -235,20 +235,19 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api( with mock_good_connection():
get_required_actions=return_value_required_actions, with patch_keycloak_api(
) as ( get_required_actions=return_value_required_actions,
mock_get_required_actions, ) as (
mock_register_required_action, mock_get_required_actions,
mock_update_required_action, mock_register_required_action,
mock_delete_required_action, mock_update_required_action,
): mock_delete_required_action,
with self.assertRaises(AnsibleExitJson) as exec_info: ):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_required_actions.mock_calls), 1) self.assertEqual(len(mock_get_required_actions.mock_calls), 1)
@ -386,20 +385,19 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api( with mock_good_connection():
get_required_actions=return_value_required_actions, with patch_keycloak_api(
) as ( get_required_actions=return_value_required_actions,
mock_get_required_actions, ) as (
mock_register_required_action, mock_get_required_actions,
mock_update_required_action, mock_register_required_action,
mock_delete_required_action, mock_update_required_action,
): mock_delete_required_action,
with self.assertRaises(AnsibleExitJson) as exec_info: ):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_required_actions.mock_calls), 1) self.assertEqual(len(mock_get_required_actions.mock_calls), 1)
@ -537,20 +535,19 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api( with mock_good_connection():
get_required_actions=return_value_required_actions, with patch_keycloak_api(
) as ( get_required_actions=return_value_required_actions,
mock_get_required_actions, ) as (
mock_register_required_action, mock_get_required_actions,
mock_update_required_action, mock_register_required_action,
mock_delete_required_action, mock_update_required_action,
): mock_delete_required_action,
with self.assertRaises(AnsibleExitJson) as exec_info: ):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_required_actions.mock_calls), 1) self.assertEqual(len(mock_get_required_actions.mock_calls), 1)
@ -676,20 +673,19 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api( with mock_good_connection():
get_required_actions=return_value_required_actions, with patch_keycloak_api(
) as ( get_required_actions=return_value_required_actions,
mock_get_required_actions, ) as (
mock_register_required_action, mock_get_required_actions,
mock_update_required_action, mock_register_required_action,
mock_delete_required_action, mock_update_required_action,
): mock_delete_required_action,
with self.assertRaises(AnsibleExitJson) as exec_info: ):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_required_actions.mock_calls), 1) self.assertEqual(len(mock_get_required_actions.mock_calls), 1)
@ -806,20 +802,19 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api( with mock_good_connection():
get_required_actions=return_value_required_actions, with patch_keycloak_api(
) as ( get_required_actions=return_value_required_actions,
mock_get_required_actions, ) as (
mock_register_required_action, mock_get_required_actions,
mock_update_required_action, mock_register_required_action,
mock_delete_required_action, mock_update_required_action,
): mock_delete_required_action,
with self.assertRaises(AnsibleExitJson) as exec_info: ):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(len(mock_get_required_actions.mock_calls), 1) self.assertEqual(len(mock_get_required_actions.mock_calls), 1)

13
tests/unit/plugins/modules/test_keycloak_client.py
View file

@ -126,15 +126,14 @@ class TestKeycloakRealm(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_client_by_clientid=return_value_get_client_by_clientid) \ with mock_good_connection():
as (mock_get_client_by_clientid, mock_get_client_by_id, mock_create_client, mock_update_client, mock_delete_client): with patch_keycloak_api(get_client_by_clientid=return_value_get_client_by_clientid) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_client_by_clientid, mock_get_client_by_id, mock_create_client, mock_update_client, mock_delete_client):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_client_by_clientid.call_count, 2) self.assertEqual(mock_get_client_by_clientid.call_count, 2)
self.assertEqual(mock_get_client_by_id.call_count, 0) self.assertEqual(mock_get_client_by_id.call_count, 0)

115
tests/unit/plugins/modules/test_keycloak_client_rolemapping.py
View file

@ -188,20 +188,19 @@ class TestKeycloakRealm(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id, with mock_good_connection():
get_client_role_id_by_name=return_value_get_client_role_id_by_name, with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id,
get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings, get_client_role_id_by_name=return_value_get_client_role_id_by_name,
get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \ get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings,
as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping, get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \
mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings, as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping,
mock_delete_group_rolemapping): mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_group_rolemapping):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_group_by_name.call_count, 1) self.assertEqual(mock_get_group_by_name.call_count, 1)
self.assertEqual(mock_get_client_id.call_count, 1) self.assertEqual(mock_get_client_id.call_count, 1)
@ -272,20 +271,19 @@ class TestKeycloakRealm(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id, with mock_good_connection():
get_client_role_id_by_name=return_value_get_client_role_id_by_name, with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id,
get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings, get_client_role_id_by_name=return_value_get_client_role_id_by_name,
get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \ get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings,
as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping, get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \
mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings, as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping,
mock_delete_group_rolemapping): mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_group_rolemapping):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_group_by_name.call_count, 1) self.assertEqual(mock_get_group_by_name.call_count, 1)
self.assertEqual(mock_get_client_id.call_count, 1) self.assertEqual(mock_get_client_id.call_count, 1)
@ -374,20 +372,19 @@ class TestKeycloakRealm(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id, with mock_good_connection():
get_client_role_id_by_name=return_value_get_client_role_id_by_name, with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id,
get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings, get_client_role_id_by_name=return_value_get_client_role_id_by_name,
get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \ get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings,
as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping, get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \
mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings, as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping,
mock_delete_group_rolemapping): mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_group_rolemapping):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_group_by_name.call_count, 0) self.assertEqual(mock_get_group_by_name.call_count, 0)
self.assertEqual(mock_get_client_id.call_count, 0) self.assertEqual(mock_get_client_id.call_count, 0)
@ -461,20 +458,19 @@ class TestKeycloakRealm(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id, with mock_good_connection():
get_client_role_id_by_name=return_value_get_client_role_id_by_name, with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id,
get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings, get_client_role_id_by_name=return_value_get_client_role_id_by_name,
get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \ get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings,
as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping, get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \
mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings, as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping,
mock_delete_group_rolemapping): mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_group_rolemapping):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_group_by_name.call_count, 1) self.assertEqual(mock_get_group_by_name.call_count, 1)
self.assertEqual(mock_get_client_id.call_count, 1) self.assertEqual(mock_get_client_id.call_count, 1)
@ -547,20 +543,19 @@ class TestKeycloakRealm(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id, with mock_good_connection():
get_client_role_id_by_name=return_value_get_client_role_id_by_name, with patch_keycloak_api(get_group_by_name=return_value_get_group_by_name, get_client_id=return_value_get_client_id,
get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings, get_client_role_id_by_name=return_value_get_client_role_id_by_name,
get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \ get_client_group_available_rolemappings=return_value_get_client_group_available_rolemappings,
as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping, get_client_group_composite_rolemappings=return_value_get_client_group_composite_rolemappings) \
mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings, as (mock_get_group_by_name, mock_get_client_id, mock_get_client_role_id_by_name, mock_add_group_rolemapping,
mock_delete_group_rolemapping): mock_get_client_group_rolemapping_by_id, mock_get_client_group_available_rolemappings, mock_get_client_group_composite_rolemappings,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_group_rolemapping):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_group_by_name.call_count, 1) self.assertEqual(mock_get_group_by_name.call_count, 1)
self.assertEqual(mock_get_client_id.call_count, 1) self.assertEqual(mock_get_client_id.call_count, 1)

116
tests/unit/plugins/modules/test_keycloak_clientscope.py
View file

@ -142,18 +142,17 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \ with mock_good_connection():
as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope, with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \
mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name, as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope,
mock_update_clientscope_protocolmappers, mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name,
mock_create_clientscope_protocolmapper, mock_delete_clientscope): mock_update_clientscope_protocolmappers,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_create_clientscope_protocolmapper, mock_delete_clientscope):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(mock_get_clientscope_by_name.call_count, 2) self.assertEqual(mock_get_clientscope_by_name.call_count, 2)
@ -188,18 +187,17 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \ with mock_good_connection():
as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope, with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \
mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name, as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope,
mock_update_clientscope_protocolmappers, mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name,
mock_create_clientscope_protocolmapper, mock_delete_clientscope): mock_update_clientscope_protocolmappers,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_create_clientscope_protocolmapper, mock_delete_clientscope):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(mock_get_clientscope_by_name.call_count, 1) self.assertEqual(mock_get_clientscope_by_name.call_count, 1)
@ -234,18 +232,17 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \ with mock_good_connection():
as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope, with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \
mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name, as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope,
mock_update_clientscope_protocolmappers, mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name,
mock_create_clientscope_protocolmapper, mock_delete_clientscope): mock_update_clientscope_protocolmappers,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_create_clientscope_protocolmapper, mock_delete_clientscope):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(mock_get_clientscope_by_name.call_count, 1) self.assertEqual(mock_get_clientscope_by_name.call_count, 1)
@ -276,18 +273,17 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \ with mock_good_connection():
as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope, with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \
mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name, as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope,
mock_update_clientscope_protocolmappers, mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name,
mock_create_clientscope_protocolmapper, mock_delete_clientscope): mock_update_clientscope_protocolmappers,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_create_clientscope_protocolmapper, mock_delete_clientscope):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(mock_get_clientscope_by_name.call_count, 1) self.assertEqual(mock_get_clientscope_by_name.call_count, 1)
@ -405,18 +401,17 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \ with mock_good_connection():
as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope, with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name) \
mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name, as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope,
mock_update_clientscope_protocolmappers, mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name,
mock_create_clientscope_protocolmapper, mock_delete_clientscope): mock_update_clientscope_protocolmappers,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_create_clientscope_protocolmapper, mock_delete_clientscope):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(mock_get_clientscope_by_name.call_count, 2) self.assertEqual(mock_get_clientscope_by_name.call_count, 2)
@ -582,19 +577,18 @@ class TestKeycloakAuthentication(ModuleTestCase):
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name, with mock_good_connection():
get_clientscope_by_clientscopeid=return_value_get_clientscope_by_clientscopeid) \ with patch_keycloak_api(get_clientscope_by_name=return_value_get_clientscope_by_name,
as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope, get_clientscope_by_clientscopeid=return_value_get_clientscope_by_clientscopeid) \
mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name, as (mock_get_clientscope_by_name, mock_get_clientscope_by_clientscopeid, mock_create_clientscope,
mock_update_clientscope_protocolmappers, mock_update_clientscope, mock_get_clientscope_protocolmapper_by_name,
mock_create_clientscope_protocolmapper, mock_delete_clientscope): mock_update_clientscope_protocolmappers,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_create_clientscope_protocolmapper, mock_delete_clientscope):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
# Verify number of call on each mock # Verify number of call on each mock
self.assertEqual(mock_get_clientscope_by_name.call_count, 1) self.assertEqual(mock_get_clientscope_by_name.call_count, 1)

54
tests/unit/plugins/modules/test_keycloak_component.py
View file

@ -126,15 +126,14 @@ class TestKeycloakComponent(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \ with mock_good_connection():
as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_create_component.mock_calls), 1) self.assertEqual(len(mock_create_component.mock_calls), 1)
@ -199,16 +198,15 @@ class TestKeycloakComponent(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, with mock_good_connection():
update_component=return_value_component_update) \ with patch_keycloak_api(get_components=return_value_components_get,
as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component): update_component=return_value_component_update) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_create_component.mock_calls), 0) self.assertEqual(len(mock_create_component.mock_calls), 0)
@ -241,15 +239,14 @@ class TestKeycloakComponent(ModuleTestCase):
] ]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get) \ with mock_good_connection():
as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_create_component.mock_calls), 0) self.assertEqual(len(mock_create_component.mock_calls), 0)
@ -304,15 +301,14 @@ class TestKeycloakComponent(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, delete_component=return_value_component_delete) \ with mock_good_connection():
as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, delete_component=return_value_component_delete) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_create_component.mock_calls), 0) self.assertEqual(len(mock_create_component.mock_calls), 0)

99
tests/unit/plugins/modules/test_keycloak_identity_provider.py
View file

@ -238,19 +238,18 @@ class TestKeycloakIdentityProvider(ModuleTestCase):
return_value_mapper_created = [None, None] return_value_mapper_created = [None, None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get, with mock_good_connection():
create_identity_provider=return_value_idp_created, create_identity_provider_mapper=return_value_mapper_created, with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get,
get_realm_by_id=return_value_realm_get) \ create_identity_provider=return_value_idp_created, create_identity_provider_mapper=return_value_mapper_created,
as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider, get_realm_by_id=return_value_realm_get) \
mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper, as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider,
mock_delete_identity_provider_mapper, mock_get_realm_by_id): mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_identity_provider_mapper, mock_get_realm_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_identity_provider.mock_calls), 2) self.assertEqual(len(mock_get_identity_provider.mock_calls), 2)
self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 1) self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 1)
@ -547,19 +546,18 @@ class TestKeycloakIdentityProvider(ModuleTestCase):
return_value_mapper_created = [None] return_value_mapper_created = [None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get, with mock_good_connection():
update_identity_provider=return_value_idp_updated, update_identity_provider_mapper=return_value_mapper_updated, with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get,
create_identity_provider_mapper=return_value_mapper_created, get_realm_by_id=return_value_realm_get) \ update_identity_provider=return_value_idp_updated, update_identity_provider_mapper=return_value_mapper_updated,
as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider, create_identity_provider_mapper=return_value_mapper_created, get_realm_by_id=return_value_realm_get) \
mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper, as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider,
mock_delete_identity_provider_mapper, mock_get_realm_by_id): mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_identity_provider_mapper, mock_get_realm_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_identity_provider.mock_calls), 2) self.assertEqual(len(mock_get_identity_provider.mock_calls), 2)
self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 5) self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 5)
@ -697,19 +695,18 @@ class TestKeycloakIdentityProvider(ModuleTestCase):
return_value_mapper_created = [None] return_value_mapper_created = [None]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get, with mock_good_connection():
update_identity_provider=return_value_idp_updated, update_identity_provider_mapper=return_value_mapper_updated, with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get,
create_identity_provider_mapper=return_value_mapper_created, get_realm_by_id=return_value_realm_get) \ update_identity_provider=return_value_idp_updated, update_identity_provider_mapper=return_value_mapper_updated,
as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider, create_identity_provider_mapper=return_value_mapper_created, get_realm_by_id=return_value_realm_get) \
mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper, as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider,
mock_delete_identity_provider_mapper, mock_get_realm_by_id): mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_identity_provider_mapper, mock_get_realm_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_identity_provider.mock_calls), 1) self.assertEqual(len(mock_get_identity_provider.mock_calls), 1)
self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 2) self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 2)
@ -738,17 +735,16 @@ class TestKeycloakIdentityProvider(ModuleTestCase):
return_value_idp_get = [None] return_value_idp_get = [None]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_identity_provider=return_value_idp_get) \ with mock_good_connection():
as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider, with patch_keycloak_api(get_identity_provider=return_value_idp_get) \
mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper, as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider,
mock_delete_identity_provider_mapper, mock_get_realm_by_id): mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_identity_provider_mapper, mock_get_realm_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_identity_provider.mock_calls), 1) self.assertEqual(len(mock_get_identity_provider.mock_calls), 1)
self.assertEqual(len(mock_delete_identity_provider.mock_calls), 0) self.assertEqual(len(mock_delete_identity_provider.mock_calls), 0)
@ -844,18 +840,17 @@ class TestKeycloakIdentityProvider(ModuleTestCase):
return_value_idp_deleted = [None] return_value_idp_deleted = [None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get, with mock_good_connection():
delete_identity_provider=return_value_idp_deleted, get_realm_by_id=return_value_realm_get) \ with patch_keycloak_api(get_identity_provider=return_value_idp_get, get_identity_provider_mappers=return_value_mappers_get,
as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider, delete_identity_provider=return_value_idp_deleted, get_realm_by_id=return_value_realm_get) \
mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper, as (mock_get_identity_provider, mock_create_identity_provider, mock_update_identity_provider, mock_delete_identity_provider,
mock_delete_identity_provider_mapper, mock_get_realm_by_id): mock_get_identity_provider_mappers, mock_create_identity_provider_mapper, mock_update_identity_provider_mapper,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_delete_identity_provider_mapper, mock_get_realm_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_identity_provider.mock_calls), 1) self.assertEqual(len(mock_get_identity_provider.mock_calls), 1)
self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 1) self.assertEqual(len(mock_get_identity_provider_mappers.mock_calls), 1)

65
tests/unit/plugins/modules/test_keycloak_realm.py
View file

@ -113,15 +113,14 @@ class TestKeycloakRealm(ModuleTestCase):
}] }]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_by_id=return_value_absent, create_realm=return_value_created) \ with mock_good_connection():
as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm): with patch_keycloak_api(get_realm_by_id=return_value_absent, create_realm=return_value_created) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_by_id.mock_calls), 2) self.assertEqual(len(mock_get_realm_by_id.mock_calls), 2)
self.assertEqual(len(mock_create_realm.mock_calls), 1) self.assertEqual(len(mock_create_realm.mock_calls), 1)
@ -164,15 +163,14 @@ class TestKeycloakRealm(ModuleTestCase):
}] }]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_by_id=return_value_absent, update_realm=return_value_updated) \ with mock_good_connection():
as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm): with patch_keycloak_api(get_realm_by_id=return_value_absent, update_realm=return_value_updated) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_by_id.mock_calls), 2) self.assertEqual(len(mock_get_realm_by_id.mock_calls), 2)
self.assertEqual(len(mock_create_realm.mock_calls), 0) self.assertEqual(len(mock_create_realm.mock_calls), 0)
@ -215,15 +213,14 @@ class TestKeycloakRealm(ModuleTestCase):
}] }]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_by_id=return_value_absent, update_realm=return_value_updated) \ with mock_good_connection():
as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm): with patch_keycloak_api(get_realm_by_id=return_value_absent, update_realm=return_value_updated) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_by_id.mock_calls), 2) self.assertEqual(len(mock_get_realm_by_id.mock_calls), 2)
self.assertEqual(len(mock_create_realm.mock_calls), 0) self.assertEqual(len(mock_create_realm.mock_calls), 0)
@ -251,15 +248,14 @@ class TestKeycloakRealm(ModuleTestCase):
return_value_deleted = [None] return_value_deleted = [None]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_by_id=return_value_absent, delete_realm=return_value_deleted) \ with mock_good_connection():
as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm): with patch_keycloak_api(get_realm_by_id=return_value_absent, delete_realm=return_value_deleted) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_by_id.mock_calls), 1) self.assertEqual(len(mock_get_realm_by_id.mock_calls), 1)
self.assertEqual(len(mock_delete_realm.mock_calls), 0) self.assertEqual(len(mock_delete_realm.mock_calls), 0)
@ -290,15 +286,14 @@ class TestKeycloakRealm(ModuleTestCase):
return_value_deleted = [None] return_value_deleted = [None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_by_id=return_value_absent, delete_realm=return_value_deleted) \ with mock_good_connection():
as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm): with patch_keycloak_api(get_realm_by_id=return_value_absent, delete_realm=return_value_deleted) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_realm_by_id, mock_create_realm, mock_update_realm, mock_delete_realm):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_by_id.mock_calls), 1) self.assertEqual(len(mock_get_realm_by_id.mock_calls), 1)
self.assertEqual(len(mock_delete_realm.mock_calls), 1) self.assertEqual(len(mock_delete_realm.mock_calls), 1)

13
tests/unit/plugins/modules/test_keycloak_realm_info.py
View file

@ -105,15 +105,14 @@ class TestKeycloakRealmRole(ModuleTestCase):
} }
] ]
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_info_by_id=return_value) \ with mock_good_connection():
as (mock_get_realm_info_by_id): with patch_keycloak_api(get_realm_info_by_id=return_value) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_realm_info_by_id):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_info_by_id.mock_calls), 1) self.assertEqual(len(mock_get_realm_info_by_id.mock_calls), 1)

54
tests/unit/plugins/modules/test_keycloak_realm_keys.py
View file

@ -139,15 +139,14 @@ class TestKeycloakRealmKeys(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -232,16 +231,15 @@ class TestKeycloakRealmKeys(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, with mock_good_connection():
update_component=return_value_component_update) \ with patch_keycloak_api(get_components=return_value_components_get,
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): update_component=return_value_component_update) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -277,15 +275,14 @@ class TestKeycloakRealmKeys(ModuleTestCase):
] ]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -356,15 +353,14 @@ class TestKeycloakRealmKeys(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, delete_component=return_value_component_delete) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, delete_component=return_value_component_delete) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)

27
tests/unit/plugins/modules/test_keycloak_realm_keys_metadata_info.py
View file

@ -158,23 +158,22 @@ class TestKeycloakRealmRole(ModuleTestCase):
} }
] ]
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(side_effect=return_value) as ( with mock_good_connection():
mock_get_realm_keys_metadata_by_id with patch_keycloak_api(side_effect=return_value) as (
): mock_get_realm_keys_metadata_by_id
with self.assertRaises(AnsibleExitJson) as exec_info: ):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
result = exec_info.exception.args[0] result = exec_info.exception.args[0]
self.assertIs(result["changed"], False) self.assertIs(result["changed"], False)
self.assertEqual( self.assertEqual(
result["msg"], "Get realm keys metadata successful for ID my-realm" result["msg"], "Get realm keys metadata successful for ID my-realm"
) )
self.assertEqual(result["keys_metadata"], return_value[0]) self.assertEqual(result["keys_metadata"], return_value[0])
self.assertEqual(len(mock_get_realm_keys_metadata_by_id.mock_calls), 1) self.assertEqual(len(mock_get_realm_keys_metadata_by_id.mock_calls), 1)

142
tests/unit/plugins/modules/test_keycloak_role.py
View file

@ -129,17 +129,16 @@ class TestKeycloakRealmRole(ModuleTestCase):
return_value_created = [None] return_value_created = [None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_role=return_value_absent, create_realm_role=return_value_created) \ with mock_good_connection():
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, with patch_keycloak_api(get_realm_role=return_value_absent, create_realm_role=return_value_created) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 2) self.assertEqual(len(mock_get_realm_role.mock_calls), 2)
self.assertEqual(len(mock_create_realm_role.mock_calls), 1) self.assertEqual(len(mock_create_realm_role.mock_calls), 1)
@ -185,17 +184,16 @@ class TestKeycloakRealmRole(ModuleTestCase):
return_value_updated = [None] return_value_updated = [None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_role=return_value_present, update_realm_role=return_value_updated) \ with mock_good_connection():
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, with patch_keycloak_api(get_realm_role=return_value_present, update_realm_role=return_value_updated) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 2) self.assertEqual(len(mock_get_realm_role.mock_calls), 2)
self.assertEqual(len(mock_create_realm_role.mock_calls), 0) self.assertEqual(len(mock_create_realm_role.mock_calls), 0)
@ -241,17 +239,16 @@ class TestKeycloakRealmRole(ModuleTestCase):
return_value_updated = [None] return_value_updated = [None]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_role=return_value_present, update_realm_role=return_value_updated) \ with mock_good_connection():
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, with patch_keycloak_api(get_realm_role=return_value_present, update_realm_role=return_value_updated) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 1) self.assertEqual(len(mock_get_realm_role.mock_calls), 1)
self.assertEqual(len(mock_create_realm_role.mock_calls), 0) self.assertEqual(len(mock_create_realm_role.mock_calls), 0)
@ -371,19 +368,18 @@ class TestKeycloakRealmRole(ModuleTestCase):
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_role=return_value_present, update_realm_role=return_value_updated, with mock_good_connection():
get_client_by_id=return_get_client_by_client_id, with patch_keycloak_api(get_realm_role=return_value_present, update_realm_role=return_value_updated,
get_role_composites=return_get_role_composites) \ get_client_by_id=return_get_client_by_client_id,
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, get_role_composites=return_get_role_composites) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 1) self.assertEqual(len(mock_get_realm_role.mock_calls), 1)
self.assertEqual(len(mock_create_realm_role.mock_calls), 0) self.assertEqual(len(mock_create_realm_role.mock_calls), 0)
@ -412,17 +408,16 @@ class TestKeycloakRealmRole(ModuleTestCase):
return_value_deleted = [None] return_value_deleted = [None]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_role=return_value_absent, delete_realm_role=return_value_deleted) \ with mock_good_connection():
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, with patch_keycloak_api(get_realm_role=return_value_absent, delete_realm_role=return_value_deleted) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 1) self.assertEqual(len(mock_get_realm_role.mock_calls), 1)
self.assertEqual(len(mock_delete_realm_role.mock_calls), 0) self.assertEqual(len(mock_delete_realm_role.mock_calls), 0)
@ -458,17 +453,16 @@ class TestKeycloakRealmRole(ModuleTestCase):
return_value_deleted = [None] return_value_deleted = [None]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_realm_role=return_value_absent, delete_realm_role=return_value_deleted) \ with mock_good_connection():
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, with patch_keycloak_api(get_realm_role=return_value_absent, delete_realm_role=return_value_deleted) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 1) self.assertEqual(len(mock_get_realm_role.mock_calls), 1)
self.assertEqual(len(mock_delete_realm_role.mock_calls), 1) self.assertEqual(len(mock_delete_realm_role.mock_calls), 1)
@ -531,17 +525,16 @@ class TestKeycloakClientRole(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_client_role=return_get_client_role) \ with mock_good_connection():
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, with patch_keycloak_api(get_client_role=return_get_client_role) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 0) self.assertEqual(len(mock_get_realm_role.mock_calls), 0)
self.assertEqual(len(mock_create_realm_role.mock_calls), 0) self.assertEqual(len(mock_create_realm_role.mock_calls), 0)
@ -653,18 +646,17 @@ class TestKeycloakClientRole(ModuleTestCase):
] ]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_client_role=return_get_client_role, get_client_by_id=return_get_client_by_client_id, with mock_good_connection():
get_role_composites=return_get_role_composites) \ with patch_keycloak_api(get_client_role=return_get_client_role, get_client_by_id=return_get_client_by_client_id,
as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role, get_role_composites=return_get_role_composites) \
mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role, as (mock_get_realm_role, mock_create_realm_role, mock_update_realm_role, mock_delete_realm_role,
mock_get_client_by_client_id, mock_get_role_composites): mock_get_client_role, mock_create_client_role, mock_update_client_role, mock_delete_client_role,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_client_by_client_id, mock_get_role_composites):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_realm_role.mock_calls), 0) self.assertEqual(len(mock_get_realm_role.mock_calls), 0)
self.assertEqual(len(mock_create_realm_role.mock_calls), 0) self.assertEqual(len(mock_create_realm_role.mock_calls), 0)

132
tests/unit/plugins/modules/test_keycloak_user.py
View file

@ -114,25 +114,24 @@ class TestKeycloakUser(ModuleTestCase):
return_update_user = None return_update_user = None
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username, with mock_good_connection():
create_user=return_create_user, with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username,
update_user_groups_membership=return_value_update_user_groups_membership, create_user=return_create_user,
get_user_groups=return_get_user_groups, update_user_groups_membership=return_value_update_user_groups_membership,
update_user=return_update_user, get_user_groups=return_get_user_groups,
delete_user=return_delete_user) \ update_user=return_update_user,
as (mock_get_user_by_username, delete_user=return_delete_user) \
mock_create_user, as (mock_get_user_by_username,
mock_update_user_groups_membership, mock_create_user,
mock_get_user_groups, mock_update_user_groups_membership,
mock_delete_user, mock_get_user_groups,
mock_update_user): mock_delete_user,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_update_user):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_user_by_username.call_count, 1) self.assertEqual(mock_get_user_by_username.call_count, 1)
self.assertEqual(mock_create_user.call_count, 1) self.assertEqual(mock_create_user.call_count, 1)
@ -176,25 +175,24 @@ class TestKeycloakUser(ModuleTestCase):
return_update_user = None return_update_user = None
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username, with mock_good_connection():
create_user=return_create_user, with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username,
update_user_groups_membership=return_value_update_user_groups_membership, create_user=return_create_user,
get_user_groups=return_get_user_groups, update_user_groups_membership=return_value_update_user_groups_membership,
update_user=return_update_user, get_user_groups=return_get_user_groups,
delete_user=return_delete_user) \ update_user=return_update_user,
as (mock_get_user_by_username, delete_user=return_delete_user) \
mock_create_user, as (mock_get_user_by_username,
mock_update_user_groups_membership, mock_create_user,
mock_get_user_groups, mock_update_user_groups_membership,
mock_delete_user, mock_get_user_groups,
mock_update_user): mock_delete_user,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_update_user):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_user_by_username.call_count, 1) self.assertEqual(mock_get_user_by_username.call_count, 1)
self.assertEqual(mock_create_user.call_count, 0) self.assertEqual(mock_create_user.call_count, 0)
@ -257,25 +255,24 @@ class TestKeycloakUser(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username, with mock_good_connection():
create_user=return_create_user, with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username,
update_user_groups_membership=return_value_update_user_groups_membership, create_user=return_create_user,
get_user_groups=return_get_user_groups, update_user_groups_membership=return_value_update_user_groups_membership,
update_user=return_update_user, get_user_groups=return_get_user_groups,
delete_user=return_delete_user) \ update_user=return_update_user,
as (mock_get_user_by_username, delete_user=return_delete_user) \
mock_create_user, as (mock_get_user_by_username,
mock_update_user_groups_membership, mock_create_user,
mock_get_user_groups, mock_update_user_groups_membership,
mock_delete_user, mock_get_user_groups,
mock_update_user): mock_delete_user,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_update_user):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_user_by_username.call_count, 1) self.assertEqual(mock_get_user_by_username.call_count, 1)
self.assertEqual(mock_create_user.call_count, 0) self.assertEqual(mock_create_user.call_count, 0)
@ -319,25 +316,24 @@ class TestKeycloakUser(ModuleTestCase):
return_update_user = None return_update_user = None
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username, with mock_good_connection():
create_user=return_create_user, with patch_keycloak_api(get_user_by_username=return_value_get_user_by_username,
update_user_groups_membership=return_value_update_user_groups_membership, create_user=return_create_user,
get_user_groups=return_get_user_groups, update_user_groups_membership=return_value_update_user_groups_membership,
update_user=return_update_user, get_user_groups=return_get_user_groups,
delete_user=return_delete_user) \ update_user=return_update_user,
as (mock_get_user_by_username, delete_user=return_delete_user) \
mock_create_user, as (mock_get_user_by_username,
mock_update_user_groups_membership, mock_create_user,
mock_get_user_groups, mock_update_user_groups_membership,
mock_delete_user, mock_get_user_groups,
mock_update_user): mock_delete_user,
with self.assertRaises(AnsibleExitJson) as exec_info: mock_update_user):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(mock_get_user_by_username.call_count, 1) self.assertEqual(mock_get_user_by_username.call_count, 1)
self.assertEqual(mock_create_user.call_count, 0) self.assertEqual(mock_create_user.call_count, 0)

67
tests/unit/plugins/modules/test_keycloak_user_federation.py
View file

@ -150,15 +150,14 @@ class TestKeycloakUserFederation(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 3) self.assertEqual(len(mock_get_components.mock_calls), 3)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -272,16 +271,15 @@ class TestKeycloakUserFederation(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, get_component=return_value_component_get, with mock_good_connection():
update_component=return_value_component_update) \ with patch_keycloak_api(get_components=return_value_components_get, get_component=return_value_component_get,
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): update_component=return_value_component_update) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 3) self.assertEqual(len(mock_get_components.mock_calls), 3)
self.assertEqual(len(mock_get_component.mock_calls), 1) self.assertEqual(len(mock_get_component.mock_calls), 1)
@ -494,15 +492,14 @@ class TestKeycloakUserFederation(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, create_component=return_value_component_create) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 3) self.assertEqual(len(mock_get_components.mock_calls), 3)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -530,15 +527,14 @@ class TestKeycloakUserFederation(ModuleTestCase):
] ]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -604,15 +600,14 @@ class TestKeycloakUserFederation(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_components_get, delete_component=return_value_component_delete) \ with mock_good_connection():
as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_components_get, delete_component=return_value_component_delete) \
with self.assertRaises(AnsibleExitJson) as exec_info: as (mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 2) self.assertEqual(len(mock_get_components.mock_calls), 2)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)

54
tests/unit/plugins/modules/test_keycloak_userprofile.py
View file

@ -350,15 +350,14 @@ class TestKeycloakUserprofile(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_get_components_get, create_component=return_value_component_create) as ( with mock_good_connection():
mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_get_components_get, create_component=return_value_component_create) as (
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -639,16 +638,15 @@ class TestKeycloakUserprofile(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_get_components_get, with mock_good_connection():
update_component=return_value_component_update) as ( with patch_keycloak_api(get_components=return_value_get_components_get,
mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): update_component=return_value_component_update) as (
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -676,15 +674,14 @@ class TestKeycloakUserprofile(ModuleTestCase):
] ]
changed = False changed = False
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_get_components_get) as ( with mock_good_connection():
mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_get_components_get) as (
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)
@ -844,15 +841,14 @@ class TestKeycloakUserprofile(ModuleTestCase):
] ]
changed = True changed = True
set_module_args(module_args)
# Run the module # Run the module
with mock_good_connection(): with set_module_args(module_args):
with patch_keycloak_api(get_components=return_value_get_components_get, delete_component=return_value_component_delete) as ( with mock_good_connection():
mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component): with patch_keycloak_api(get_components=return_value_get_components_get, delete_component=return_value_component_delete) as (
with self.assertRaises(AnsibleExitJson) as exec_info: mock_get_components, mock_get_component, mock_create_component, mock_update_component, mock_delete_component):
self.module.main() with self.assertRaises(AnsibleExitJson) as exec_info:
self.module.main()
self.assertEqual(len(mock_get_components.mock_calls), 1) self.assertEqual(len(mock_get_components.mock_calls), 1)
self.assertEqual(len(mock_get_component.mock_calls), 0) self.assertEqual(len(mock_get_component.mock_calls), 0)

4
tests/unit/plugins/modules/test_linode.py
View file

@ -18,5 +18,5 @@ if not linode.HAS_LINODE:
def test_name_is_a_required_parameter(api_key, auth): def test_name_is_a_required_parameter(api_key, auth):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
set_module_args({}) with set_module_args({}):
linode.main() linode.main()

162
tests/unit/plugins/modules/test_linode_v4.py
View file

@ -30,8 +30,8 @@ from .linode_conftest import access_token, no_access_token_in_env, default_args,
def test_mandatory_state_is_validated(capfd): def test_mandatory_state_is_validated(capfd):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
set_module_args({'label': 'foo'}) with set_module_args({'label': 'foo'}):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -42,8 +42,8 @@ def test_mandatory_state_is_validated(capfd):
def test_mandatory_label_is_validated(capfd): def test_mandatory_label_is_validated(capfd):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
set_module_args({'state': 'present'}) with set_module_args({'state': 'present'}):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -56,8 +56,8 @@ def test_mandatory_access_token_is_validated(default_args,
no_access_token_in_env, no_access_token_in_env,
capfd): capfd):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
set_module_args(default_args) with set_module_args(default_args):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -72,12 +72,12 @@ def test_mandatory_access_token_is_validated(default_args,
def test_mandatory_access_token_passed_in_env(default_args, def test_mandatory_access_token_passed_in_env(default_args,
access_token): access_token):
set_module_args(default_args) with set_module_args(default_args):
try: try:
module = linode_v4.initialise_module() module = linode_v4.initialise_module()
except SystemExit: except SystemExit:
pytest.fail("'access_token' is passed in environment") pytest.fail("'access_token' is passed in environment")
now_set_token = module.params['access_token'] now_set_token = module.params['access_token']
assert now_set_token == os.environ['LINODE_ACCESS_TOKEN'] assert now_set_token == os.environ['LINODE_ACCESS_TOKEN']
@ -86,26 +86,26 @@ def test_mandatory_access_token_passed_in_env(default_args,
def test_mandatory_access_token_passed_in_as_parameter(default_args, def test_mandatory_access_token_passed_in_as_parameter(default_args,
no_access_token_in_env): no_access_token_in_env):
default_args.update({'access_token': 'foo'}) default_args.update({'access_token': 'foo'})
set_module_args(default_args) with set_module_args(default_args):
try: try:
module = linode_v4.initialise_module() module = linode_v4.initialise_module()
except SystemExit: except SystemExit:
pytest.fail("'access_token' is passed in as parameter") pytest.fail("'access_token' is passed in as parameter")
assert module.params['access_token'] == 'foo' assert module.params['access_token'] == 'foo'
def test_instance_by_label_cannot_authenticate(capfd, access_token, def test_instance_by_label_cannot_authenticate(capfd, access_token,
default_args): default_args):
set_module_args(default_args) with set_module_args(default_args):
module = linode_v4.initialise_module() module = linode_v4.initialise_module()
client = LinodeClient(module.params['access_token']) client = LinodeClient(module.params['access_token'])
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, side_effect=LinodeApiError('foo')): with mock.patch(target, side_effect=LinodeApiError('foo')):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
linode_v4.maybe_instance_from_label(module, client) linode_v4.maybe_instance_from_label(module, client)
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -116,23 +116,23 @@ def test_instance_by_label_cannot_authenticate(capfd, access_token,
def test_no_instances_found_with_label_gives_none(default_args, def test_no_instances_found_with_label_gives_none(default_args,
access_token): access_token):
set_module_args(default_args) with set_module_args(default_args):
module = linode_v4.initialise_module() module = linode_v4.initialise_module()
client = LinodeClient(module.params['access_token']) client = LinodeClient(module.params['access_token'])
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[]): with mock.patch(target, return_value=[]):
result = linode_v4.maybe_instance_from_label(module, client) result = linode_v4.maybe_instance_from_label(module, client)
assert result is None assert result is None
def test_optional_region_is_validated(default_args, capfd, access_token): def test_optional_region_is_validated(default_args, capfd, access_token):
default_args.update({'type': 'foo', 'image': 'bar'}) default_args.update({'type': 'foo', 'image': 'bar'})
set_module_args(default_args) with set_module_args(default_args):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -147,10 +147,10 @@ def test_optional_region_is_validated(default_args, capfd, access_token):
def test_optional_type_is_validated(default_args, capfd, access_token): def test_optional_type_is_validated(default_args, capfd, access_token):
default_args.update({'region': 'foo', 'image': 'bar'}) default_args.update({'region': 'foo', 'image': 'bar'})
set_module_args(default_args) with set_module_args(default_args):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -165,10 +165,10 @@ def test_optional_type_is_validated(default_args, capfd, access_token):
def test_optional_image_is_validated(default_args, capfd, access_token): def test_optional_image_is_validated(default_args, capfd, access_token):
default_args.update({'type': 'foo', 'region': 'bar'}) default_args.update({'type': 'foo', 'region': 'bar'})
set_module_args(default_args) with set_module_args(default_args):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -184,9 +184,9 @@ def test_optional_image_is_validated(default_args, capfd, access_token):
@pytest.mark.parametrize('value', [True, False]) @pytest.mark.parametrize('value', [True, False])
def test_private_ip_valid_values(default_args, access_token, value): def test_private_ip_valid_values(default_args, access_token, value):
default_args.update({'private_ip': value}) default_args.update({'private_ip': value})
set_module_args(default_args) with set_module_args(default_args):
module = linode_v4.initialise_module() module = linode_v4.initialise_module()
assert module.params['private_ip'] is value assert module.params['private_ip'] is value
@ -194,10 +194,10 @@ def test_private_ip_valid_values(default_args, access_token, value):
@pytest.mark.parametrize('value', ['not-a-bool', 42]) @pytest.mark.parametrize('value', ['not-a-bool', 42])
def test_private_ip_invalid_values(default_args, capfd, access_token, value): def test_private_ip_invalid_values(default_args, capfd, access_token, value):
default_args.update({'private_ip': value}) default_args.update({'private_ip': value})
set_module_args(default_args) with set_module_args(default_args):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
linode_v4.initialise_module() linode_v4.initialise_module()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -208,23 +208,23 @@ def test_private_ip_invalid_values(default_args, capfd, access_token, value):
def test_private_ip_default_value(default_args, access_token): def test_private_ip_default_value(default_args, access_token):
default_args.pop('private_ip', None) default_args.pop('private_ip', None)
set_module_args(default_args) with set_module_args(default_args):
module = linode_v4.initialise_module() module = linode_v4.initialise_module()
assert module.params['private_ip'] is False assert module.params['private_ip'] is False
def test_private_ip_is_forwarded_to_linode(default_args, mock_linode, access_token): def test_private_ip_is_forwarded_to_linode(default_args, mock_linode, access_token):
default_args.update({'private_ip': True}) default_args.update({'private_ip': True})
set_module_args(default_args) with set_module_args(default_args):
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[]): with mock.patch(target, return_value=[]):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
target = 'linode_api4.linode_client.LinodeGroup.instance_create' target = 'linode_api4.linode_client.LinodeGroup.instance_create'
with mock.patch(target, return_value=(mock_linode, 'passw0rd')) as instance_create_mock: with mock.patch(target, return_value=(mock_linode, 'passw0rd')) as instance_create_mock:
linode_v4.main() linode_v4.main()
args, kwargs = instance_create_mock.call_args args, kwargs = instance_create_mock.call_args
assert kwargs['private_ip'] is True assert kwargs['private_ip'] is True
@ -239,12 +239,12 @@ def test_instance_already_created(default_args,
'region': 'bar', 'region': 'bar',
'image': 'baz' 'image': 'baz'
}) })
set_module_args(default_args) with set_module_args(default_args):
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[mock_linode]): with mock.patch(target, return_value=[mock_linode]):
with pytest.raises(SystemExit) as sys_exit_exc: with pytest.raises(SystemExit) as sys_exit_exc:
linode_v4.main() linode_v4.main()
assert sys_exit_exc.value.code == 0 assert sys_exit_exc.value.code == 0
@ -268,14 +268,14 @@ def test_instance_to_be_created_without_root_pass(default_args,
'region': 'bar', 'region': 'bar',
'image': 'baz' 'image': 'baz'
}) })
set_module_args(default_args) with set_module_args(default_args):
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[]): with mock.patch(target, return_value=[]):
with pytest.raises(SystemExit) as sys_exit_exc: with pytest.raises(SystemExit) as sys_exit_exc:
target = 'linode_api4.linode_client.LinodeGroup.instance_create' target = 'linode_api4.linode_client.LinodeGroup.instance_create'
with mock.patch(target, return_value=(mock_linode, 'passw0rd')): with mock.patch(target, return_value=(mock_linode, 'passw0rd')):
linode_v4.main() linode_v4.main()
assert sys_exit_exc.value.code == 0 assert sys_exit_exc.value.code == 0
@ -300,14 +300,14 @@ def test_instance_to_be_created_with_root_pass(default_args,
'image': 'baz', 'image': 'baz',
'root_pass': 'passw0rd', 'root_pass': 'passw0rd',
}) })
set_module_args(default_args) with set_module_args(default_args):
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[]): with mock.patch(target, return_value=[]):
with pytest.raises(SystemExit) as sys_exit_exc: with pytest.raises(SystemExit) as sys_exit_exc:
target = 'linode_api4.linode_client.LinodeGroup.instance_create' target = 'linode_api4.linode_client.LinodeGroup.instance_create'
with mock.patch(target, return_value=mock_linode): with mock.patch(target, return_value=mock_linode):
linode_v4.main() linode_v4.main()
assert sys_exit_exc.value.code == 0 assert sys_exit_exc.value.code == 0
@ -327,12 +327,12 @@ def test_instance_to_be_deleted(default_args,
capfd, capfd,
access_token): access_token):
default_args.update({'state': 'absent'}) default_args.update({'state': 'absent'})
set_module_args(default_args) with set_module_args(default_args):
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[mock_linode]): with mock.patch(target, return_value=[mock_linode]):
with pytest.raises(SystemExit) as sys_exit_exc: with pytest.raises(SystemExit) as sys_exit_exc:
linode_v4.main() linode_v4.main()
assert sys_exit_exc.value.code == 0 assert sys_exit_exc.value.code == 0
@ -351,12 +351,12 @@ def test_instance_already_deleted_no_change(default_args,
capfd, capfd,
access_token): access_token):
default_args.update({'state': 'absent'}) default_args.update({'state': 'absent'})
set_module_args(default_args) with set_module_args(default_args):
target = 'linode_api4.linode_client.LinodeGroup.instances' target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[]): with mock.patch(target, return_value=[]):
with pytest.raises(SystemExit) as sys_exit_exc: with pytest.raises(SystemExit) as sys_exit_exc:
linode_v4.main() linode_v4.main()
assert sys_exit_exc.value.code == 0 assert sys_exit_exc.value.code == 0

36
tests/unit/plugins/modules/test_lvg_rename.py
View file

@ -48,10 +48,10 @@ class TestLvgRename(ModuleTestCase):
'vg': 'vg_missing', 'vg': 'vg_missing',
'vg_new': 'vg_data_testhost2', 'vg_new': 'vg_data_testhost2',
} }
set_module_args(args=module_args) with set_module_args(args=module_args):
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertEqual(len(self.mock_module_run_command.mock_calls), 1) self.assertEqual(len(self.mock_module_run_command.mock_calls), 1)
self.assertIs(result.exception.args[0]['failed'], failed) self.assertIs(result.exception.args[0]['failed'], failed)
@ -67,10 +67,10 @@ class TestLvgRename(ModuleTestCase):
'vg': 'Yfj4YG-c8nI-z7w5-B7Fw-i2eM-HqlF-ApFVp0', 'vg': 'Yfj4YG-c8nI-z7w5-B7Fw-i2eM-HqlF-ApFVp0',
'vg_new': 'vg_data_testhost2', 'vg_new': 'vg_data_testhost2',
} }
set_module_args(args=module_args) with set_module_args(args=module_args):
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertEqual(len(self.mock_module_run_command.mock_calls), 1) self.assertEqual(len(self.mock_module_run_command.mock_calls), 1)
self.assertIs(result.exception.args[0]['failed'], failed) self.assertIs(result.exception.args[0]['failed'], failed)
@ -86,10 +86,10 @@ class TestLvgRename(ModuleTestCase):
'vg': 'vg_data_testhost1', 'vg': 'vg_data_testhost1',
'vg_new': 'vg_sys_testhost2', 'vg_new': 'vg_sys_testhost2',
} }
set_module_args(args=module_args) with set_module_args(args=module_args):
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
self.module.main() self.module.main()
self.assertEqual(len(self.mock_module_run_command.mock_calls), 1) self.assertEqual(len(self.mock_module_run_command.mock_calls), 1)
self.assertIs(result.exception.args[0]['failed'], failed) self.assertIs(result.exception.args[0]['failed'], failed)
@ -109,10 +109,10 @@ class TestLvgRename(ModuleTestCase):
'vg': '/dev/vg_data_testhost1', 'vg': '/dev/vg_data_testhost1',
'vg_new': 'vg_data_testhost2', 'vg_new': 'vg_data_testhost2',
} }
set_module_args(args=module_args) with set_module_args(args=module_args):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertEqual(len(self.mock_module_run_command.mock_calls), 2) self.assertEqual(len(self.mock_module_run_command.mock_calls), 2)
self.assertIs(result.exception.args[0]['changed'], changed) self.assertIs(result.exception.args[0]['changed'], changed)
@ -130,10 +130,10 @@ class TestLvgRename(ModuleTestCase):
'vg_new': 'vg_data_testhost2', 'vg_new': 'vg_data_testhost2',
'_ansible_check_mode': True, '_ansible_check_mode': True,
} }
set_module_args(args=module_args) with set_module_args(args=module_args):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertEqual(len(self.mock_module_run_command.mock_calls), 1) self.assertEqual(len(self.mock_module_run_command.mock_calls), 1)
self.assertIs(result.exception.args[0]['changed'], changed) self.assertIs(result.exception.args[0]['changed'], changed)
@ -150,10 +150,10 @@ class TestLvgRename(ModuleTestCase):
'vg': 'vg_data_testhostX', 'vg': 'vg_data_testhostX',
'vg_new': 'vg_data_testhost1', 'vg_new': 'vg_data_testhost1',
} }
set_module_args(args=module_args) with set_module_args(args=module_args):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
self.module.main() self.module.main()
self.assertEqual(len(self.mock_module_run_command.mock_calls), 1) self.assertEqual(len(self.mock_module_run_command.mock_calls), 1)
self.assertIs(result.exception.args[0]['changed'], changed) self.assertIs(result.exception.args[0]['changed'], changed)

295
tests/unit/plugins/modules/test_modprobe.py
View file

@ -36,19 +36,18 @@ class TestLoadModule(ModuleTestCase):
self.mock_get_bin_path.stop() self.mock_get_bin_path.stop()
def test_load_module_success(self): def test_load_module_success(self):
set_module_args(dict( with set_module_args(dict(
name='test', name='test',
state='present', state='present',
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.module_loaded.side_effect = [True]
self.run_command.side_effect = [(0, '', '')]
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
self.module_loaded.side_effect = [True] modprobe.load_module()
self.run_command.side_effect = [(0, '', '')]
modprobe = Modprobe(module)
modprobe.load_module()
assert modprobe.result == { assert modprobe.result == {
'changed': True, 'changed': True,
@ -58,21 +57,20 @@ class TestLoadModule(ModuleTestCase):
} }
def test_load_module_unchanged(self): def test_load_module_unchanged(self):
set_module_args(dict( with set_module_args(dict(
name='test', name='test',
state='present', state='present',
)) )):
module = build_module()
module = build_module() module.warn = Mock()
module.warn = Mock() self.get_bin_path.side_effect = ['modprobe']
self.module_loaded.side_effect = [False]
self.run_command.side_effect = [(0, '', ''), (1, '', '')]
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
self.module_loaded.side_effect = [False] modprobe.load_module()
self.run_command.side_effect = [(0, '', ''), (1, '', '')]
modprobe = Modprobe(module)
modprobe.load_module()
module.warn.assert_called_once_with('') module.warn.assert_called_once_with('')
@ -99,19 +97,18 @@ class TestUnloadModule(ModuleTestCase):
self.mock_get_bin_path.stop() self.mock_get_bin_path.stop()
def test_unload_module_success(self): def test_unload_module_success(self):
set_module_args(dict( with set_module_args(dict(
name='test', name='test',
state='absent', state='absent',
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.module_loaded.side_effect = [False]
self.run_command.side_effect = [(0, '', '')]
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
self.module_loaded.side_effect = [False] modprobe.unload_module()
self.run_command.side_effect = [(0, '', '')]
modprobe = Modprobe(module)
modprobe.unload_module()
assert modprobe.result == { assert modprobe.result == {
'changed': True, 'changed': True,
@ -121,21 +118,20 @@ class TestUnloadModule(ModuleTestCase):
} }
def test_unload_module_failure(self): def test_unload_module_failure(self):
set_module_args(dict( with set_module_args(dict(
name='test', name='test',
state='absent', state='absent',
)) )):
module = build_module()
module = build_module() module.fail_json = Mock()
module.fail_json = Mock() self.get_bin_path.side_effect = ['modprobe']
self.module_loaded.side_effect = [True]
self.run_command.side_effect = [(1, '', '')]
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
self.module_loaded.side_effect = [True] modprobe.unload_module()
self.run_command.side_effect = [(1, '', '')]
modprobe = Modprobe(module)
modprobe.unload_module()
dummy_result = { dummy_result = {
'changed': False, 'changed': False,
@ -168,63 +164,60 @@ class TestModuleIsLoadedPersistently(ModuleTestCase):
def test_module_is_loaded(self): def test_module_is_loaded(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='dummy')) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
modprobe.modules_files = ['/etc/modules-load.d/dummy.conf']
modprobe = Modprobe(module) assert modprobe.module_is_loaded_persistently
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='dummy')) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
modprobe.modules_files = ['/etc/modules-load.d/dummy.conf']
assert modprobe.module_is_loaded_persistently
mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf') mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf')
def test_module_is_not_loaded_empty_file(self): def test_module_is_not_loaded_empty_file(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='')) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
modprobe.modules_files = ['/etc/modules-load.d/dummy.conf']
modprobe = Modprobe(module) assert not modprobe.module_is_loaded_persistently
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='')) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
modprobe.modules_files = ['/etc/modules-load.d/dummy.conf']
assert not modprobe.module_is_loaded_persistently
mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf') mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf')
def test_module_is_not_loaded_no_files(self): def test_module_is_not_loaded_no_files(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
modprobe.modules_files = []
modprobe = Modprobe(module) assert not modprobe.module_is_loaded_persistently
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
modprobe.modules_files = []
assert not modprobe.module_is_loaded_persistently
class TestPermanentParams(ModuleTestCase): class TestPermanentParams(ModuleTestCase):
@ -251,24 +244,23 @@ class TestPermanentParams(ModuleTestCase):
] ]
mock_files_content = [mock_open(read_data=content).return_value for content in files_content] mock_files_content = [mock_open(read_data=content).return_value for content in files_content]
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open()) as mocked_file:
mocked_file.side_effect = mock_files_content
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'):
modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf', '/etc/modprobe.d/dummy2.conf']
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open()) as mocked_file: assert modprobe.permanent_params == set(['numdummies=4', 'dummy_parameter1=6', 'dummy_parameter2=5'])
mocked_file.side_effect = mock_files_content
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'):
modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf', '/etc/modprobe.d/dummy2.conf']
assert modprobe.permanent_params == set(['numdummies=4', 'dummy_parameter1=6', 'dummy_parameter2=5'])
def test_module_permanent_params_empty(self): def test_module_permanent_params_empty(self):
@ -278,24 +270,23 @@ class TestPermanentParams(ModuleTestCase):
] ]
mock_files_content = [mock_open(read_data=content).return_value for content in files_content] mock_files_content = [mock_open(read_data=content).return_value for content in files_content]
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='')) as mocked_file:
mocked_file.side_effect = mock_files_content
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'):
modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf', '/etc/modprobe.d/dummy2.conf']
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='')) as mocked_file: assert modprobe.permanent_params == set()
mocked_file.side_effect = mock_files_content
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'):
modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf', '/etc/modprobe.d/dummy2.conf']
assert modprobe.permanent_params == set()
class TestCreateModuleFIle(ModuleTestCase): class TestCreateModuleFIle(ModuleTestCase):
@ -314,22 +305,21 @@ class TestCreateModuleFIle(ModuleTestCase):
def test_create_file(self): def test_create_file(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open()) as mocked_file:
modprobe.create_module_file()
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open()) as mocked_file: mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf', 'w')
modprobe.create_module_file() mocked_file().write.assert_called_once_with('dummy\n')
mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf', 'w')
mocked_file().write.assert_called_once_with('dummy\n')
class TestCreateModuleOptionsFIle(ModuleTestCase): class TestCreateModuleOptionsFIle(ModuleTestCase):
@ -348,23 +338,22 @@ class TestCreateModuleOptionsFIle(ModuleTestCase):
def test_create_file(self): def test_create_file(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
params='numdummies=4', params='numdummies=4',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open()) as mocked_file:
modprobe.create_module_options_file()
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open()) as mocked_file: mocked_file.assert_called_once_with('/etc/modprobe.d/dummy.conf', 'w')
modprobe.create_module_options_file() mocked_file().write.assert_called_once_with('options dummy numdummies=4\n')
mocked_file.assert_called_once_with('/etc/modprobe.d/dummy.conf', 'w')
mocked_file().write.assert_called_once_with('options dummy numdummies=4\n')
class TestDisableOldParams(ModuleTestCase): class TestDisableOldParams(ModuleTestCase):
@ -384,47 +373,45 @@ class TestDisableOldParams(ModuleTestCase):
def test_disable_old_params_file_changed(self): def test_disable_old_params_file_changed(self):
mock_data = 'options dummy numdummies=4' mock_data = 'options dummy numdummies=4'
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
params='numdummies=4', params='numdummies=4',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data=mock_data)) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'):
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data=mock_data)) as mocked_file: modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf']
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'): modprobe.disable_old_params()
modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf'] mocked_file.assert_called_with('/etc/modprobe.d/dummy1.conf', 'w')
modprobe.disable_old_params() mocked_file().write.assert_called_once_with('#options dummy numdummies=4')
mocked_file.assert_called_with('/etc/modprobe.d/dummy1.conf', 'w')
mocked_file().write.assert_called_once_with('#options dummy numdummies=4')
def test_disable_old_params_file_unchanged(self): def test_disable_old_params_file_unchanged(self):
mock_data = 'options notdummy numdummies=4' mock_data = 'options notdummy numdummies=4'
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
params='numdummies=4', params='numdummies=4',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data=mock_data)) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'):
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data=mock_data)) as mocked_file: modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf']
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modprobe_files'): modprobe.disable_old_params()
modprobe.modprobe_files = ['/etc/modprobe.d/dummy1.conf'] mocked_file.assert_called_once_with('/etc/modprobe.d/dummy1.conf')
modprobe.disable_old_params()
mocked_file.assert_called_once_with('/etc/modprobe.d/dummy1.conf')
class TestDisableModulePermanent(ModuleTestCase): class TestDisableModulePermanent(ModuleTestCase):
@ -443,43 +430,41 @@ class TestDisableModulePermanent(ModuleTestCase):
def test_disable_module_permanent_file_changed(self): def test_disable_module_permanent_file_changed(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
params='numdummies=4', params='numdummies=4',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='dummy')) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='dummy')) as mocked_file: modprobe.modules_files = ['/etc/modules-load.d/dummy.conf']
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'): modprobe.disable_module_permanent()
modprobe.modules_files = ['/etc/modules-load.d/dummy.conf'] mocked_file.assert_called_with('/etc/modules-load.d/dummy.conf', 'w')
modprobe.disable_module_permanent() mocked_file().write.assert_called_once_with('#dummy')
mocked_file.assert_called_with('/etc/modules-load.d/dummy.conf', 'w')
mocked_file().write.assert_called_once_with('#dummy')
def test_disable_module_permanent_file_unchanged(self): def test_disable_module_permanent_file_unchanged(self):
set_module_args(dict( with set_module_args(dict(
name='dummy', name='dummy',
state='present', state='present',
params='numdummies=4', params='numdummies=4',
persistent='present' persistent='present'
)) )):
module = build_module()
module = build_module() self.get_bin_path.side_effect = ['modprobe']
self.get_bin_path.side_effect = ['modprobe'] modprobe = Modprobe(module)
modprobe = Modprobe(module) with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='notdummy')) as mocked_file:
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'):
with patch('ansible_collections.community.general.plugins.modules.modprobe.open', mock_open(read_data='notdummy')) as mocked_file: modprobe.modules_files = ['/etc/modules-load.d/dummy.conf']
with patch('ansible_collections.community.general.plugins.modules.modprobe.Modprobe.modules_files'): modprobe.disable_module_permanent()
modprobe.modules_files = ['/etc/modules-load.d/dummy.conf'] mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf')
modprobe.disable_module_permanent()
mocked_file.assert_called_once_with('/etc/modules-load.d/dummy.conf')

88
tests/unit/plugins/modules/test_nomad_token.py
View file

@ -11,9 +11,7 @@ __metaclass__ = type
import nomad import nomad
from ansible_collections.community.general.plugins.modules import nomad_token from ansible_collections.community.general.plugins.modules import nomad_token
from ansible_collections.community.general.tests.unit.compat.mock import patch from ansible_collections.community.general.tests.unit.compat.mock import patch
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, \ from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, ModuleTestCase, set_module_args
ModuleTestCase, \
set_module_args
def mock_acl_get_tokens(empty_list=False): def mock_acl_get_tokens(empty_list=False):
@ -102,8 +100,8 @@ class TestNomadTokenModule(ModuleTestCase):
def test_should_fail_without_parameters(self): def test_should_fail_without_parameters(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_should_create_token_type_client(self): def test_should_create_token_type_client(self):
module_args = { module_args = {
@ -113,12 +111,12 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'present' 'state': 'present'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.object(nomad.api.acl.Acl, 'get_tokens', return_value=mock_acl_get_tokens()) as mock_get_tokens: with patch.object(nomad.api.acl.Acl, 'get_tokens', return_value=mock_acl_get_tokens()) as mock_get_tokens:
with patch.object(nomad.api.acl.Acl, 'create_token', return_value=mock_acl_create_update_token()) as \ with patch.object(nomad.api.acl.Acl, 'create_token', return_value=mock_acl_create_update_token()) as \
mock_create_update_token: mock_create_update_token:
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
self.assertIs(mock_get_tokens.call_count, 1) self.assertIs(mock_get_tokens.call_count, 1)
self.assertIs(mock_create_update_token.call_count, 1) self.assertIs(mock_create_update_token.call_count, 1)
@ -130,15 +128,15 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'present' 'state': 'present'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens: with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens:
with patch.object(nomad.api.Acl, 'generate_bootstrap') as mock_generate_bootstrap: with patch.object(nomad.api.Acl, 'generate_bootstrap') as mock_generate_bootstrap:
mock_get_tokens.return_value = mock_acl_get_tokens(empty_list=True) mock_get_tokens.return_value = mock_acl_get_tokens(empty_list=True)
mock_generate_bootstrap.return_value = mock_acl_generate_bootstrap() mock_generate_bootstrap.return_value = mock_acl_generate_bootstrap()
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
self.assertIs(mock_get_tokens.call_count, 1) self.assertIs(mock_get_tokens.call_count, 1)
self.assertIs(mock_generate_bootstrap.call_count, 1) self.assertIs(mock_generate_bootstrap.call_count, 1)
@ -149,14 +147,14 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'absent' 'state': 'absent'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens: with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens:
with patch.object(nomad.api.acl.Acl, 'delete_token') as mock_delete_token: with patch.object(nomad.api.acl.Acl, 'delete_token') as mock_delete_token:
mock_get_tokens.return_value = mock_acl_get_tokens() mock_get_tokens.return_value = mock_acl_get_tokens()
mock_delete_token.return_value = mock_acl_delete_token() mock_delete_token.return_value = mock_acl_delete_token()
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_should_fail_delete_bootstrap_token(self): def test_should_fail_delete_bootstrap_token(self):
module_args = { module_args = {
@ -165,10 +163,10 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'absent' 'state': 'absent'
} }
set_module_args(module_args) with set_module_args(module_args):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_should_fail_delete_boostrap_token_by_name(self): def test_should_fail_delete_boostrap_token_by_name(self):
module_args = { module_args = {
@ -177,10 +175,10 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'absent' 'state': 'absent'
} }
set_module_args(module_args) with set_module_args(module_args):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_should_delete_client_token(self): def test_should_delete_client_token(self):
module_args = { module_args = {
@ -189,15 +187,15 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'absent' 'state': 'absent'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens: with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens:
with patch.object(nomad.api.acl.Acl, 'delete_token') as mock_delete_token: with patch.object(nomad.api.acl.Acl, 'delete_token') as mock_delete_token:
mock_get_tokens.return_value = mock_acl_get_tokens() mock_get_tokens.return_value = mock_acl_get_tokens()
mock_delete_token.return_value = mock_acl_delete_token() mock_delete_token.return_value = mock_acl_delete_token()
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
self.assertIs(mock_delete_token.call_count, 1) self.assertIs(mock_delete_token.call_count, 1)
@ -209,14 +207,14 @@ class TestNomadTokenModule(ModuleTestCase):
'state': 'present' 'state': 'present'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens: with patch.object(nomad.api.acl.Acl, 'get_tokens') as mock_get_tokens:
with patch.object(nomad.api.acl.Acl, 'update_token') as mock_create_update_token: with patch.object(nomad.api.acl.Acl, 'update_token') as mock_create_update_token:
mock_get_tokens.return_value = mock_acl_get_tokens() mock_get_tokens.return_value = mock_acl_get_tokens()
mock_create_update_token.return_value = mock_acl_create_update_token() mock_create_update_token.return_value = mock_acl_create_update_token()
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
self.assertIs(mock_get_tokens.call_count, 1) self.assertIs(mock_get_tokens.call_count, 1)
self.assertIs(mock_create_update_token.call_count, 1) self.assertIs(mock_create_update_token.call_count, 1)

168
tests/unit/plugins/modules/test_npm.py
View file

@ -34,17 +34,17 @@ class NPMModuleTestCase(ModuleTestCase):
return exc.exception.args[0] return exc.exception.args[0]
def test_present(self): def test_present(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'present' 'state': 'present'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{}', ''), (0, '{}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -53,17 +53,17 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_missing(self): def test_present_missing(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'present', 'state': 'present',
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{"dependencies": {"coffee-script": {"missing" : true}}}', ''), (0, '{"dependencies": {"coffee-script": {"missing" : true}}}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -72,18 +72,18 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_version(self): def test_present_version(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'present', 'state': 'present',
'version': '2.5.1' 'version': '2.5.1'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{}', ''), (0, '{}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -92,18 +92,18 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_version_update(self): def test_present_version_update(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'present', 'state': 'present',
'version': '2.5.1' 'version': '2.5.1'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{"dependencies": {"coffee-script": {"version" : "2.5.0"}}}', ''), (0, '{"dependencies": {"coffee-script": {"version" : "2.5.0"}}}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -112,18 +112,18 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_version_exists(self): def test_present_version_exists(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'present', 'state': 'present',
'version': '2.5.1' 'version': '2.5.1'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{"dependencies": {"coffee-script": {"version" : "2.5.1"}}}', ''), (0, '{"dependencies": {"coffee-script": {"version" : "2.5.1"}}}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -131,17 +131,17 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_absent(self): def test_absent(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'absent' 'state': 'absent'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{"dependencies": {"coffee-script": {"version" : "2.5.1"}}}', ''), (0, '{"dependencies": {"coffee-script": {"version" : "2.5.1"}}}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -150,18 +150,18 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_absent_version(self): def test_absent_version(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'absent', 'state': 'absent',
'version': '2.5.1' 'version': '2.5.1'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{"dependencies": {"coffee-script": {"version" : "2.5.1"}}}', ''), (0, '{"dependencies": {"coffee-script": {"version" : "2.5.1"}}}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -170,18 +170,18 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_absent_version_different(self): def test_absent_version_different(self):
set_module_args({ with set_module_args({
'name': 'coffee-script', 'name': 'coffee-script',
'global': 'true', 'global': 'true',
'state': 'absent', 'state': 'absent',
'version': '2.5.1' 'version': '2.5.1'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{"dependencies": {"coffee-script": {"version" : "2.5.0"}}}', ''), (0, '{"dependencies": {"coffee-script": {"version" : "2.5.0"}}}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -190,16 +190,16 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_package_json(self): def test_present_package_json(self):
set_module_args({ with set_module_args({
'global': 'true', 'global': 'true',
'state': 'present' 'state': 'present'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{}', ''), (0, '{}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -207,17 +207,17 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_package_json_production(self): def test_present_package_json_production(self):
set_module_args({ with set_module_args({
'production': 'true', 'production': 'true',
'global': 'true', 'global': 'true',
'state': 'present', 'state': 'present',
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{}', ''), (0, '{}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -225,17 +225,17 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_package_json_ci(self): def test_present_package_json_ci(self):
set_module_args({ with set_module_args({
'ci': 'true', 'ci': 'true',
'global': 'true', 'global': 'true',
'state': 'present' 'state': 'present'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{}', ''), (0, '{}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([
@ -243,18 +243,18 @@ class NPMModuleTestCase(ModuleTestCase):
]) ])
def test_present_package_json_ci_production(self): def test_present_package_json_ci_production(self):
set_module_args({ with set_module_args({
'ci': 'true', 'ci': 'true',
'production': 'true', 'production': 'true',
'global': 'true', 'global': 'true',
'state': 'present' 'state': 'present'
}) }):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '{}', ''), (0, '{}', ''),
(0, '{}', ''), (0, '{}', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.module_main_command.assert_has_calls([ self.module_main_command.assert_has_calls([

154
tests/unit/plugins/modules/test_ocapi_command.py
View file

@ -188,20 +188,20 @@ class TestOcapiCommand(unittest.TestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({}) with set_module_args({}):
module.main() module.main()
self.assertIn("missing required arguments:", get_exception_message(ansible_fail_json)) self.assertIn("missing required arguments:", get_exception_message(ansible_fail_json))
def test_module_fail_when_unknown_category(self): def test_module_fail_when_unknown_category(self):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'unknown', 'category': 'unknown',
'command': 'IndicatorLedOn', 'command': 'IndicatorLedOn',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'baseuri': MOCK_BASE_URI 'baseuri': MOCK_BASE_URI
}) }):
module.main() module.main()
self.assertIn("Invalid Category 'unknown", get_exception_message(ansible_fail_json)) self.assertIn("Invalid Category 'unknown", get_exception_message(ansible_fail_json))
def test_set_power_mode(self): def test_set_power_mode(self):
@ -210,14 +210,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_put_request): put_request=mock_put_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'PowerModeLow', 'command': 'PowerModeLow',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -227,14 +227,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_put_request): put_request=mock_put_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'IndicatorLedOn', 'command': 'IndicatorLedOn',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -244,14 +244,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'PowerModeNormal', 'command': 'PowerModeNormal',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertFalse(is_changed(ansible_exit_json)) self.assertFalse(is_changed(ansible_exit_json))
@ -261,15 +261,15 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'IndicatorLedOn', 'command': 'IndicatorLedOn',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -279,15 +279,15 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'IndicatorLedOn', 'command': 'IndicatorLedOn',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -297,14 +297,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'IndicatorLedOff', 'command': 'IndicatorLedOff',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertFalse(is_changed(ansible_exit_json)) self.assertFalse(is_changed(ansible_exit_json))
@ -314,15 +314,15 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'IndicatorLedOff', 'command': 'IndicatorLedOff',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
"_ansible_check_mode": True "_ansible_check_mode": True
}) }):
module.main() module.main()
self.assertEqual(NO_ACTION_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(NO_ACTION_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertFalse(is_changed(ansible_exit_json)) self.assertFalse(is_changed(ansible_exit_json))
@ -331,14 +331,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_put_request): put_request=mock_put_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Chassis', 'category': 'Chassis',
'command': 'IndicatorLedBright', 'command': 'IndicatorLedBright',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertIn("Invalid Command", get_exception_message(ansible_fail_json)) self.assertIn("Invalid Command", get_exception_message(ansible_fail_json))
def test_reset_enclosure(self): def test_reset_enclosure(self):
@ -346,14 +346,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_put_request): put_request=mock_put_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Systems', 'category': 'Systems',
'command': 'PowerGracefulRestart', 'command': 'PowerGracefulRestart',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -362,15 +362,15 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Systems', 'category': 'Systems',
'command': 'PowerGracefulRestart', 'command': 'PowerGracefulRestart',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
"_ansible_check_mode": True "_ansible_check_mode": True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -379,14 +379,14 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_put_request): put_request=mock_put_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWUpload', 'command': 'FWUpload',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual("Missing update_image_path.", get_exception_message(ansible_fail_json)) self.assertEqual("Missing update_image_path.", get_exception_message(ansible_fail_json))
def test_firmware_upload_file_not_found(self): def test_firmware_upload_file_not_found(self):
@ -394,15 +394,15 @@ class TestOcapiCommand(unittest.TestCase):
get_request=mock_get_request, get_request=mock_get_request,
put_request=mock_invalid_http_request): put_request=mock_invalid_http_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWUpload', 'command': 'FWUpload',
'update_image_path': 'nonexistentfile.bin', 'update_image_path': 'nonexistentfile.bin',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual("File does not exist.", get_exception_message(ansible_fail_json)) self.assertEqual("File does not exist.", get_exception_message(ansible_fail_json))
def test_firmware_upload(self): def test_firmware_upload(self):
@ -417,15 +417,15 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_put_request, put_request=mock_put_request,
post_request=mock_post_request): post_request=mock_post_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWUpload', 'command': 'FWUpload',
'update_image_path': filepath, 'update_image_path': filepath,
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -441,7 +441,7 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_put_request, put_request=mock_put_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWUpload', 'command': 'FWUpload',
'update_image_path': filepath, 'update_image_path': filepath,
@ -449,8 +449,8 @@ class TestOcapiCommand(unittest.TestCase):
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
"_ansible_check_mode": True "_ansible_check_mode": True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -460,14 +460,14 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_put_request, put_request=mock_put_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWUpdate', 'command': 'FWUpdate',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -477,15 +477,15 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWUpdate', 'command': 'FWUpdate',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
"_ansible_check_mode": True "_ansible_check_mode": True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -495,14 +495,14 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_put_request, put_request=mock_put_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWActivate', 'command': 'FWActivate',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -512,15 +512,15 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWActivate', 'command': 'FWActivate',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
"_ansible_check_mode": True "_ansible_check_mode": True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -531,15 +531,15 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'DeleteJob', 'command': 'DeleteJob',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'job_name': MOCK_JOB_NAME, 'job_name': MOCK_JOB_NAME,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -550,15 +550,15 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'DeleteJob', 'command': 'DeleteJob',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'job_name': MOCK_JOB_NAME, 'job_name': MOCK_JOB_NAME,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual("Cannot delete job because it is in progress.", get_exception_message(ansible_fail_json)) self.assertEqual("Cannot delete job because it is in progress.", get_exception_message(ansible_fail_json))
def test_delete_job_in_progress_only_on_delete(self): def test_delete_job_in_progress_only_on_delete(self):
@ -568,15 +568,15 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'DeleteJob', 'command': 'DeleteJob',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'job_name': MOCK_JOB_NAME, 'job_name': MOCK_JOB_NAME,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual("Cannot delete job because it is in progress.", get_exception_message(ansible_fail_json)) self.assertEqual("Cannot delete job because it is in progress.", get_exception_message(ansible_fail_json))
def test_delete_job_check_mode(self): def test_delete_job_check_mode(self):
@ -586,7 +586,7 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'DeleteJob', 'command': 'DeleteJob',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
@ -594,8 +594,8 @@ class TestOcapiCommand(unittest.TestCase):
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
module.main() module.main()
self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json)) self.assertEqual(UPDATE_NOT_PERFORMED_IN_CHECK_MODE, get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
@ -606,7 +606,7 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'DeleteJob', 'command': 'DeleteJob',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
@ -614,8 +614,8 @@ class TestOcapiCommand(unittest.TestCase):
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
module.main() module.main()
self.assertEqual("Job already deleted.", get_exception_message(ansible_exit_json)) self.assertEqual("Job already deleted.", get_exception_message(ansible_exit_json))
self.assertFalse(is_changed(ansible_exit_json)) self.assertFalse(is_changed(ansible_exit_json))
@ -626,7 +626,7 @@ class TestOcapiCommand(unittest.TestCase):
put_request=mock_invalid_http_request, put_request=mock_invalid_http_request,
post_request=mock_invalid_http_request): post_request=mock_invalid_http_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'DeleteJob', 'command': 'DeleteJob',
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
@ -634,6 +634,6 @@ class TestOcapiCommand(unittest.TestCase):
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21', 'password': 'PASSWORD=21',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
module.main() module.main()
self.assertEqual("Cannot delete job because it is in progress.", get_exception_message(ansible_fail_json)) self.assertEqual("Cannot delete job because it is in progress.", get_exception_message(ansible_fail_json))

34
tests/unit/plugins/modules/test_ocapi_info.py
View file

@ -127,32 +127,32 @@ class TestOcapiInfo(unittest.TestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({}) with set_module_args({}):
module.main() module.main()
self.assertIn("missing required arguments:", get_exception_message(ansible_fail_json)) self.assertIn("missing required arguments:", get_exception_message(ansible_fail_json))
def test_module_fail_when_unknown_category(self): def test_module_fail_when_unknown_category(self):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'unknown', 'category': 'unknown',
'command': 'JobStatus', 'command': 'JobStatus',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'baseuri': MOCK_BASE_URI 'baseuri': MOCK_BASE_URI
}) }):
module.main() module.main()
self.assertIn("Invalid Category 'unknown", get_exception_message(ansible_fail_json)) self.assertIn("Invalid Category 'unknown", get_exception_message(ansible_fail_json))
def test_module_fail_when_unknown_command(self): def test_module_fail_when_unknown_command(self):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'unknown', 'command': 'unknown',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'baseuri': MOCK_BASE_URI 'baseuri': MOCK_BASE_URI
}) }):
module.main() module.main()
self.assertIn("Invalid Command 'unknown", get_exception_message(ansible_fail_json)) self.assertIn("Invalid Command 'unknown", get_exception_message(ansible_fail_json))
def test_job_status_in_progress(self): def test_job_status_in_progress(self):
@ -162,15 +162,15 @@ class TestOcapiInfo(unittest.TestCase):
delete_request=mock_delete_request, delete_request=mock_delete_request,
post_request=mock_post_request): post_request=mock_post_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'JobStatus', 'command': 'JobStatus',
'job_name': MOCK_JOB_NAME_IN_PROGRESS, 'job_name': MOCK_JOB_NAME_IN_PROGRESS,
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
response_data = ansible_exit_json.exception.args[0] response_data = ansible_exit_json.exception.args[0]
self.assertEqual(MOCK_HTTP_RESPONSE_JOB_IN_PROGRESS["data"]["PercentComplete"], response_data["percentComplete"]) self.assertEqual(MOCK_HTTP_RESPONSE_JOB_IN_PROGRESS["data"]["PercentComplete"], response_data["percentComplete"])
@ -190,15 +190,15 @@ class TestOcapiInfo(unittest.TestCase):
delete_request=mock_delete_request, delete_request=mock_delete_request,
post_request=mock_post_request): post_request=mock_post_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'JobStatus', 'command': 'JobStatus',
'job_name': MOCK_JOB_NAME_COMPLETE, 'job_name': MOCK_JOB_NAME_COMPLETE,
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
response_data = ansible_exit_json.exception.args[0] response_data = ansible_exit_json.exception.args[0]
self.assertEqual(MOCK_HTTP_RESPONSE_JOB_COMPLETE["data"]["PercentComplete"], response_data["percentComplete"]) self.assertEqual(MOCK_HTTP_RESPONSE_JOB_COMPLETE["data"]["PercentComplete"], response_data["percentComplete"])
@ -218,15 +218,15 @@ class TestOcapiInfo(unittest.TestCase):
delete_request=mock_delete_request, delete_request=mock_delete_request,
post_request=mock_post_request): post_request=mock_post_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
set_module_args({ with set_module_args({
'category': 'Jobs', 'category': 'Jobs',
'command': 'JobStatus', 'command': 'JobStatus',
'job_name': MOCK_JOB_NAME_DOES_NOT_EXIST, 'job_name': MOCK_JOB_NAME_DOES_NOT_EXIST,
'baseuri': MOCK_BASE_URI, 'baseuri': MOCK_BASE_URI,
'username': 'USERID', 'username': 'USERID',
'password': 'PASSWORD=21' 'password': 'PASSWORD=21'
}) }):
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL, get_exception_message(ansible_exit_json))
response_data = ansible_exit_json.exception.args[0] response_data = ansible_exit_json.exception.args[0]
self.assertFalse(response_data["jobExists"]) self.assertFalse(response_data["jobExists"])

144
tests/unit/plugins/modules/test_pacman.py
View file

@ -152,25 +152,25 @@ class TestPacman:
def test_fail_without_required_args(self): def test_fail_without_required_args(self):
with pytest.raises(AnsibleFailJson) as e: with pytest.raises(AnsibleFailJson) as e:
set_module_args({}) with set_module_args({}):
pacman.main() pacman.main()
assert e.match(r"one of the following is required") assert e.match(r"one of the following is required")
def test_success(self, mock_empty_inventory): def test_success(self, mock_empty_inventory):
set_module_args({"update_cache": True}) # Simplest args to let init go through with set_module_args({"update_cache": True}): # Simplest args to let init go through
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(AnsibleExitJson) as e: with pytest.raises(AnsibleExitJson) as e:
P.success() P.success()
def test_fail(self, mock_empty_inventory): def test_fail(self, mock_empty_inventory):
set_module_args({"update_cache": True}) with set_module_args({"update_cache": True}):
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
args = dict( args = dict(
msg="msg", stdout="something", stderr="somethingelse", cmd=["command", "with", "args"], rc=1 msg="msg", stdout="something", stderr="somethingelse", cmd=["command", "with", "args"], rc=1
) )
with pytest.raises(AnsibleFailJson) as e: with pytest.raises(AnsibleFailJson) as e:
P.fail(**args) P.fail(**args)
assert all(item in e.value.args[0] for item in args) assert all(item in e.value.args[0] for item in args)
@ -333,33 +333,33 @@ class TestPacman:
def test_build_inventory(self, expected, run_command_side_effect, raises): def test_build_inventory(self, expected, run_command_side_effect, raises):
self.mock_run_command.side_effect = run_command_side_effect self.mock_run_command.side_effect = run_command_side_effect
set_module_args({"update_cache": True}) with set_module_args({"update_cache": True}):
if raises: if raises:
with pytest.raises(raises): with pytest.raises(raises):
P = pacman.Pacman(pacman.setup_module())
P._build_inventory()
else:
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
P._build_inventory() assert P._build_inventory() == expected
else:
P = pacman.Pacman(pacman.setup_module())
assert P._build_inventory() == expected
@pytest.mark.parametrize("check_mode_value", [True, False]) @pytest.mark.parametrize("check_mode_value", [True, False])
def test_upgrade_check_empty_inventory(self, mock_empty_inventory, check_mode_value): def test_upgrade_check_empty_inventory(self, mock_empty_inventory, check_mode_value):
set_module_args({"upgrade": True, "_ansible_check_mode": check_mode_value}) with set_module_args({"upgrade": True, "_ansible_check_mode": check_mode_value}):
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(AnsibleExitJson) as e: with pytest.raises(AnsibleExitJson) as e:
P.run() P.run()
self.mock_run_command.call_count == 0 assert self.mock_run_command.call_count == 0
out = e.value.args[0] out = e.value.args[0]
assert "packages" not in out assert "packages" not in out
assert not out["changed"] assert not out["changed"]
assert "diff" not in out assert "diff" not in out
def test_update_db_check(self, mock_empty_inventory): def test_update_db_check(self, mock_empty_inventory):
set_module_args({"update_cache": True, "_ansible_check_mode": True}) with set_module_args({"update_cache": True, "_ansible_check_mode": True}):
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(AnsibleExitJson) as e: with pytest.raises(AnsibleExitJson) as e:
P.run() P.run()
self.mock_run_command.call_count == 0 self.mock_run_command.call_count == 0
out = e.value.args[0] out = e.value.args[0]
assert "packages" not in out assert "packages" not in out
@ -422,14 +422,14 @@ class TestPacman:
def test_update_db(self, module_args, expected_calls, changed): def test_update_db(self, module_args, expected_calls, changed):
args = {"update_cache": True} args = {"update_cache": True}
args.update(module_args) args.update(module_args)
set_module_args(args) with set_module_args(args):
self.mock_run_command.side_effect = [ self.mock_run_command.side_effect = [
(rc, stdout, stderr) for expected_call, kwargs, rc, stdout, stderr in expected_calls (rc, stdout, stderr) for expected_call, kwargs, rc, stdout, stderr in expected_calls
] ]
with pytest.raises(AnsibleExitJson) as e: with pytest.raises(AnsibleExitJson) as e:
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
P.run() P.run()
self.mock_run_command.assert_has_calls([ self.mock_run_command.assert_has_calls([
mock.call(mock.ANY, expected_call, **kwargs) for expected_call, kwargs, rc, stdout, stderr in expected_calls mock.call(mock.ANY, expected_call, **kwargs) for expected_call, kwargs, rc, stdout, stderr in expected_calls
@ -475,16 +475,16 @@ class TestPacman:
args = {"upgrade": True, "_ansible_check_mode": check_mode_value} args = {"upgrade": True, "_ansible_check_mode": check_mode_value}
if upgrade_extra_args: if upgrade_extra_args:
args["upgrade_extra_args"] = upgrade_extra_args args["upgrade_extra_args"] = upgrade_extra_args
set_module_args(args) with set_module_args(args):
if run_command_data and "return_value" in run_command_data: if run_command_data and "return_value" in run_command_data:
self.mock_run_command.return_value = run_command_data["return_value"] self.mock_run_command.return_value = run_command_data["return_value"]
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(AnsibleExitJson) as e: with pytest.raises(AnsibleExitJson) as e:
P.run() P.run()
out = e.value.args[0] out = e.value.args[0]
if check_mode_value: if check_mode_value:
self.mock_run_command.call_count == 0 self.mock_run_command.call_count == 0
@ -499,13 +499,13 @@ class TestPacman:
assert out["diff"]["before"] and out["diff"]["after"] assert out["diff"]["before"] and out["diff"]["after"]
def test_upgrade_fail(self, mock_valid_inventory): def test_upgrade_fail(self, mock_valid_inventory):
set_module_args({"upgrade": True}) with set_module_args({"upgrade": True}):
self.mock_run_command.return_value = [1, "stdout", "stderr"] self.mock_run_command.return_value = [1, "stdout", "stderr"]
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(AnsibleFailJson) as e: with pytest.raises(AnsibleFailJson) as e:
P.run() P.run()
self.mock_run_command.call_count == 1 assert self.mock_run_command.call_count == 1
out = e.value.args[0] out = e.value.args[0]
assert out["failed"] assert out["failed"]
assert out["stdout"] == "stdout" assert out["stdout"] == "stdout"
@ -633,19 +633,19 @@ class TestPacman:
def test_package_list( def test_package_list(
self, mock_valid_inventory, state, pkg_names, expected, run_command_data, raises self, mock_valid_inventory, state, pkg_names, expected, run_command_data, raises
): ):
set_module_args({"name": pkg_names, "state": state}) with set_module_args({"name": pkg_names, "state": state}):
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
P.inventory = P._build_inventory() P.inventory = P._build_inventory()
if run_command_data:
self.mock_run_command.side_effect = run_command_data["side_effect"]
if raises:
with pytest.raises(raises):
P.package_list()
else:
assert sorted(P.package_list()) == sorted(expected)
if run_command_data: if run_command_data:
assert self.mock_run_command.mock_calls == run_command_data["calls"] self.mock_run_command.side_effect = run_command_data["side_effect"]
if raises:
with pytest.raises(raises):
P.package_list()
else:
assert sorted(P.package_list()) == sorted(expected)
if run_command_data:
assert self.mock_run_command.mock_calls == run_command_data["calls"]
@pytest.mark.parametrize("check_mode_value", [True, False]) @pytest.mark.parametrize("check_mode_value", [True, False])
@pytest.mark.parametrize( @pytest.mark.parametrize(
@ -658,11 +658,11 @@ class TestPacman:
def test_op_packages_nothing_to_do( def test_op_packages_nothing_to_do(
self, mock_valid_inventory, mock_package_list, check_mode_value, name, state, package_list self, mock_valid_inventory, mock_package_list, check_mode_value, name, state, package_list
): ):
set_module_args({"name": name, "state": state, "_ansible_check_mode": check_mode_value}) with set_module_args({"name": name, "state": state, "_ansible_check_mode": check_mode_value}):
mock_package_list.return_value = package_list mock_package_list.return_value = package_list
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(AnsibleExitJson) as e: with pytest.raises(AnsibleExitJson) as e:
P.run() P.run()
out = e.value.args[0] out = e.value.args[0]
assert not out["changed"] assert not out["changed"]
assert "packages" in out assert "packages" in out
@ -1079,13 +1079,13 @@ class TestPacman:
run_command_data, run_command_data,
raises, raises,
): ):
set_module_args(module_args) with set_module_args(module_args):
self.mock_run_command.side_effect = run_command_data["side_effect"] self.mock_run_command.side_effect = run_command_data["side_effect"]
mock_package_list.return_value = package_list_out mock_package_list.return_value = package_list_out
P = pacman.Pacman(pacman.setup_module()) P = pacman.Pacman(pacman.setup_module())
with pytest.raises(raises) as e: with pytest.raises(raises) as e:
P.run() P.run()
out = e.value.args[0] out = e.value.args[0]
assert self.mock_run_command.mock_calls == run_command_data["calls"] assert self.mock_run_command.mock_calls == run_command_data["calls"]

40
tests/unit/plugins/modules/test_pagerduty_alert.py
View file

@ -64,22 +64,22 @@ class TestPagerDutyAlertModule(ModuleTestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_ensure_alert_created_with_minimal_data(self): def test_ensure_alert_created_with_minimal_data(self):
set_module_args({ with set_module_args({
'state': 'triggered', 'state': 'triggered',
'api_version': 'v2', 'api_version': 'v2',
'integration_key': 'test', 'integration_key': 'test',
'source': 'My Ansible Script', 'source': 'My Ansible Script',
'desc': 'Description for alert' 'desc': 'Description for alert'
}) }):
with patch.object(pagerduty_alert, 'fetch_url') as fetch_url_mock: with patch.object(pagerduty_alert, 'fetch_url') as fetch_url_mock:
fetch_url_mock.return_value = (Response(), {"status": 202}) fetch_url_mock.return_value = (Response(), {"status": 202})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
assert fetch_url_mock.call_count == 1 assert fetch_url_mock.call_count == 1
url = fetch_url_mock.call_args[0][1] url = fetch_url_mock.call_args[0][1]
@ -95,7 +95,7 @@ class TestPagerDutyAlertModule(ModuleTestCase):
assert data['payload']['timestamp'] is not None assert data['payload']['timestamp'] is not None
def test_ensure_alert_created_with_full_data(self): def test_ensure_alert_created_with_full_data(self):
set_module_args({ with set_module_args({
'api_version': 'v2', 'api_version': 'v2',
'component': 'mysql', 'component': 'mysql',
'custom_details': {'environment': 'production', 'notes': 'this is a test note'}, 'custom_details': {'environment': 'production', 'notes': 'this is a test note'},
@ -106,12 +106,12 @@ class TestPagerDutyAlertModule(ModuleTestCase):
'link_text': 'PagerDuty', 'link_text': 'PagerDuty',
'state': 'triggered', 'state': 'triggered',
'source': 'My Ansible Script', 'source': 'My Ansible Script',
}) }):
with patch.object(pagerduty_alert, 'fetch_url') as fetch_url_mock: with patch.object(pagerduty_alert, 'fetch_url') as fetch_url_mock:
fetch_url_mock.return_value = (Response(), {"status": 202}) fetch_url_mock.return_value = (Response(), {"status": 202})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
assert fetch_url_mock.call_count == 1 assert fetch_url_mock.call_count == 1
url = fetch_url_mock.call_args[0][1] url = fetch_url_mock.call_args[0][1]
@ -130,17 +130,17 @@ class TestPagerDutyAlertModule(ModuleTestCase):
assert data['links'][0]['text'] == 'PagerDuty' assert data['links'][0]['text'] == 'PagerDuty'
def test_ensure_alert_acknowledged(self): def test_ensure_alert_acknowledged(self):
set_module_args({ with set_module_args({
'state': 'acknowledged', 'state': 'acknowledged',
'api_version': 'v2', 'api_version': 'v2',
'integration_key': 'test', 'integration_key': 'test',
'incident_key': 'incident_test_id', 'incident_key': 'incident_test_id',
}) }):
with patch.object(pagerduty_alert, 'fetch_url') as fetch_url_mock: with patch.object(pagerduty_alert, 'fetch_url') as fetch_url_mock:
fetch_url_mock.return_value = (Response(), {"status": 202}) fetch_url_mock.return_value = (Response(), {"status": 202})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
assert fetch_url_mock.call_count == 1 assert fetch_url_mock.call_count == 1
url = fetch_url_mock.call_args[0][1] url = fetch_url_mock.call_args[0][1]

28
tests/unit/plugins/modules/test_pagerduty_change.py
View file

@ -26,19 +26,19 @@ class TestPagerDutyChangeModule(ModuleTestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_ensure_change_event_created_with_minimal_data(self): def test_ensure_change_event_created_with_minimal_data(self):
set_module_args({ with set_module_args({
'integration_key': 'test', 'integration_key': 'test',
'summary': 'Testing' 'summary': 'Testing'
}) }):
with patch.object(pagerduty_change, 'fetch_url') as fetch_url_mock: with patch.object(pagerduty_change, 'fetch_url') as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 202}) fetch_url_mock.return_value = (None, {"status": 202})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
assert fetch_url_mock.call_count == 1 assert fetch_url_mock.call_count == 1
url = fetch_url_mock.call_args[0][1] url = fetch_url_mock.call_args[0][1]
@ -51,7 +51,7 @@ class TestPagerDutyChangeModule(ModuleTestCase):
assert data['payload']['source'] == 'Ansible' assert data['payload']['source'] == 'Ansible'
def test_ensure_change_event_created_with_full_data(self): def test_ensure_change_event_created_with_full_data(self):
set_module_args({ with set_module_args({
'integration_key': 'test', 'integration_key': 'test',
'summary': 'Testing', 'summary': 'Testing',
'source': 'My Ansible Script', 'source': 'My Ansible Script',
@ -61,12 +61,12 @@ class TestPagerDutyChangeModule(ModuleTestCase):
'environment': 'production', 'environment': 'production',
'link_url': 'https://pagerduty.com', 'link_url': 'https://pagerduty.com',
'link_text': 'PagerDuty' 'link_text': 'PagerDuty'
}) }):
with patch.object(pagerduty_change, 'fetch_url') as fetch_url_mock: with patch.object(pagerduty_change, 'fetch_url') as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 202}) fetch_url_mock.return_value = (None, {"status": 202})
with self.assertRaises(AnsibleExitJson): with self.assertRaises(AnsibleExitJson):
self.module.main() self.module.main()
assert fetch_url_mock.call_count == 1 assert fetch_url_mock.call_count == 1
url = fetch_url_mock.call_args[0][1] url = fetch_url_mock.call_args[0][1]

116
tests/unit/plugins/modules/test_parted.py
View file

@ -187,93 +187,93 @@ class TestParted(ModuleTestCase):
self.assertEqual(parse_partition_info(parted_output2, 'MB'), parted_dict2) self.assertEqual(parse_partition_info(parted_output2, 'MB'), parted_dict2)
def test_partition_already_exists(self): def test_partition_already_exists(self):
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 1, 'number': 1,
'state': 'present', 'state': 'present',
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=False) self.execute_module(changed=False)
def test_create_new_partition(self): def test_create_new_partition(self):
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 4, 'number': 4,
'state': 'present', 'state': 'present',
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='unit KiB mkpart primary 0% 100%') self.execute_module(changed=True, script='unit KiB mkpart primary 0% 100%')
def test_create_new_partition_1G(self): def test_create_new_partition_1G(self):
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 4, 'number': 4,
'state': 'present', 'state': 'present',
'part_end': '1GiB', 'part_end': '1GiB',
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='unit KiB mkpart primary 0% 1GiB') self.execute_module(changed=True, script='unit KiB mkpart primary 0% 1GiB')
def test_create_new_partition_minus_1G(self): def test_create_new_partition_minus_1G(self):
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 4, 'number': 4,
'state': 'present', 'state': 'present',
'fs_type': 'ext2', 'fs_type': 'ext2',
'part_start': '-1GiB', 'part_start': '-1GiB',
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='unit KiB mkpart primary ext2 -1GiB 100%') self.execute_module(changed=True, script='unit KiB mkpart primary ext2 -1GiB 100%')
def test_remove_partition_number_1(self): def test_remove_partition_number_1(self):
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 1, 'number': 1,
'state': 'absent', 'state': 'absent',
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='rm 1') self.execute_module(changed=True, script='rm 1')
def test_resize_partition(self): def test_resize_partition(self):
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 3, 'number': 3,
'state': 'present', 'state': 'present',
'part_end': '100%', 'part_end': '100%',
'resize': True 'resize': True
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='resizepart 3 100%') self.execute_module(changed=True, script='resizepart 3 100%')
def test_change_flag(self): def test_change_flag(self):
# Flags are set in a second run of parted(). # Flags are set in a second run of parted().
# Between the two runs, the partition dict is updated. # Between the two runs, the partition dict is updated.
# use checkmode here allow us to continue even if the dictionary is # use checkmode here allow us to continue even if the dictionary is
# not updated. # not updated.
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 3, 'number': 3,
'state': 'present', 'state': 'present',
'flags': ['lvm', 'boot'], 'flags': ['lvm', 'boot'],
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.parted.reset_mock() self.parted.reset_mock()
self.execute_module(changed=True) self.execute_module(changed=True)
# When using multiple flags: # When using multiple flags:
# order of execution is non deterministic, because set() operations are used in # order of execution is non deterministic, because set() operations are used in
# the current implementation. # the current implementation.
expected_calls_order1 = [call('unit KiB set 3 lvm on set 3 boot on ', expected_calls_order1 = [call('unit KiB set 3 lvm on set 3 boot on ',
'/dev/sdb', 'optimal')] '/dev/sdb', 'optimal')]
expected_calls_order2 = [call('unit KiB set 3 boot on set 3 lvm on ', expected_calls_order2 = [call('unit KiB set 3 boot on set 3 lvm on ',
'/dev/sdb', 'optimal')] '/dev/sdb', 'optimal')]
self.assertTrue(self.parted.mock_calls == expected_calls_order1 or self.assertTrue(self.parted.mock_calls == expected_calls_order1 or
self.parted.mock_calls == expected_calls_order2) self.parted.mock_calls == expected_calls_order2)
def test_create_new_primary_lvm_partition(self): def test_create_new_primary_lvm_partition(self):
# use check_mode, see previous test comment # use check_mode, see previous test comment
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 4, 'number': 4,
'flags': ["boot"], 'flags': ["boot"],
@ -281,15 +281,15 @@ class TestParted(ModuleTestCase):
'part_start': '257GiB', 'part_start': '257GiB',
'fs_type': 'ext3', 'fs_type': 'ext3',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='unit KiB mkpart primary ext3 257GiB 100% unit KiB set 4 boot on') self.execute_module(changed=True, script='unit KiB mkpart primary ext3 257GiB 100% unit KiB set 4 boot on')
def test_create_label_gpt(self): def test_create_label_gpt(self):
# Like previous test, current implementation use parted to create the partition and # Like previous test, current implementation use parted to create the partition and
# then retrieve and update the dictionary. Use check_mode to force to continue even if # then retrieve and update the dictionary. Use check_mode to force to continue even if
# dictionary is not updated. # dictionary is not updated.
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 1, 'number': 1,
'flags': ["lvm"], 'flags': ["lvm"],
@ -297,48 +297,48 @@ class TestParted(ModuleTestCase):
'name': 'lvmpartition', 'name': 'lvmpartition',
'state': 'present', 'state': 'present',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict2): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict2):
self.execute_module(changed=True, script='unit KiB mklabel gpt mkpart primary 0% 100% unit KiB name 1 \'"lvmpartition"\' set 1 lvm on') self.execute_module(changed=True, script='unit KiB mklabel gpt mkpart primary 0% 100% unit KiB name 1 \'"lvmpartition"\' set 1 lvm on')
def test_change_label_gpt(self): def test_change_label_gpt(self):
# When partitions already exists and label is changed, mkpart should be called even when partition already exists, # When partitions already exists and label is changed, mkpart should be called even when partition already exists,
# because new empty label will be created anyway # because new empty label will be created anyway
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 1, 'number': 1,
'state': 'present', 'state': 'present',
'label': 'gpt', 'label': 'gpt',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict1):
self.execute_module(changed=True, script='unit KiB mklabel gpt mkpart primary 0% 100%') self.execute_module(changed=True, script='unit KiB mklabel gpt mkpart primary 0% 100%')
def test_check_mode_unchanged(self): def test_check_mode_unchanged(self):
# Test that get_device_info result is checked in check mode too # Test that get_device_info result is checked in check mode too
# No change on partition 1 # No change on partition 1
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 1, 'number': 1,
'state': 'present', 'state': 'present',
'flags': ['some_flag'], 'flags': ['some_flag'],
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict3): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict3):
self.execute_module(changed=False) self.execute_module(changed=False)
def test_check_mode_changed(self): def test_check_mode_changed(self):
# Test that get_device_info result is checked in check mode too # Test that get_device_info result is checked in check mode too
# Flag change on partition 1 # Flag change on partition 1
set_module_args({ with set_module_args({
'device': '/dev/sdb', 'device': '/dev/sdb',
'number': 1, 'number': 1,
'state': 'present', 'state': 'present',
'flags': ['other_flag'], 'flags': ['other_flag'],
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict3): with patch('ansible_collections.community.general.plugins.modules.parted.get_device_info', return_value=parted_dict3):
self.execute_module(changed=True) self.execute_module(changed=True)
def test_version_info(self): def test_version_info(self):
"""Test that the parse_parted_version returns the expected tuple""" """Test that the parse_parted_version returns the expected tuple"""

280
tests/unit/plugins/modules/test_pmem.py
View file

@ -321,81 +321,81 @@ class TestPmem(ModuleTestCase):
def test_fail_when_required_args_missing(self): def test_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
pmem_module.main() pmem_module.main()
def test_fail_when_appdirect_only(self): def test_fail_when_appdirect_only(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'appdirect': 10, 'appdirect': 10,
}) }):
pmem_module.main() pmem_module.main()
def test_fail_when_MemosyMode_only(self): def test_fail_when_MemosyMode_only(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'memorymode': 70, 'memorymode': 70,
}) }):
pmem_module.main() pmem_module.main()
def test_fail_when_reserved_only(self): def test_fail_when_reserved_only(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'reserved': 10, 'reserved': 10,
}) }):
pmem_module.main() pmem_module.main()
def test_fail_when_appdirect_memorymode_reserved_total_not_100(self): def test_fail_when_appdirect_memorymode_reserved_total_not_100(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'appdirect': 10, 'appdirect': 10,
'memorymode': 70, 'memorymode': 70,
'reserved': 10, 'reserved': 10,
}) }):
pmem_module.main() pmem_module.main()
def test_when_appdirect_memorymode(self): def test_when_appdirect_memorymode(self):
set_module_args({ with set_module_args({
'appdirect': 10, 'appdirect': 10,
'memorymode': 70, 'memorymode': 70,
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[goal_plain, goal, dimmlist]): side_effect=[goal_plain, goal, dimmlist]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check(result, False, [25769803776], [188978561024], [328230764544]) self.result_check(result, False, [25769803776], [188978561024], [328230764544])
def test_when_appdirect_memorymode_reserved(self): def test_when_appdirect_memorymode_reserved(self):
set_module_args({ with set_module_args({
'appdirect': 10, 'appdirect': 10,
'memorymode': 70, 'memorymode': 70,
'reserved': 20, 'reserved': 20,
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[goal_plain, goal, dimmlist]): side_effect=[goal_plain, goal, dimmlist]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check(result, False, [25769803776], [188978561024], [328230764544]) self.result_check(result, False, [25769803776], [188978561024], [328230764544])
def test_when_appdirect_notinterleaved_memorymode_reserved(self): def test_when_appdirect_notinterleaved_memorymode_reserved(self):
set_module_args({ with set_module_args({
'appdirect': 10, 'appdirect': 10,
'appdirect_interleaved': False, 'appdirect_interleaved': False,
'memorymode': 70, 'memorymode': 70,
'reserved': 20, 'reserved': 20,
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[goal_plain, goal, dimmlist]): side_effect=[goal_plain, goal, dimmlist]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check(result, False, [25769803776], [188978561024], [328230764544]) self.result_check(result, False, [25769803776], [188978561024], [328230764544])
def test_fail_when_socket_id_appdirect(self): def test_fail_when_socket_id_appdirect(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'socket': [ 'socket': [
{ {
'id': 0, 'id': 0,
@ -406,12 +406,12 @@ class TestPmem(ModuleTestCase):
'appdirect': 10, 'appdirect': 10,
}, },
], ],
}) }):
pmem_module.main() pmem_module.main()
def test_fail_when_socket0_id_memorymode_socket1_id_appdirect(self): def test_fail_when_socket0_id_memorymode_socket1_id_appdirect(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'socket': [ 'socket': [
{ {
'id': 0, 'id': 0,
@ -422,12 +422,12 @@ class TestPmem(ModuleTestCase):
'appdirect': 10, 'appdirect': 10,
}, },
], ],
}) }):
pmem_module.main() pmem_module.main()
def test_fail_when_socket0_without_id(self): def test_fail_when_socket0_without_id(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'socket': [ 'socket': [
{ {
'appdirect': 10, 'appdirect': 10,
@ -439,11 +439,11 @@ class TestPmem(ModuleTestCase):
'memorymode': 70, 'memorymode': 70,
}, },
], ],
}) }):
pmem_module.main() pmem_module.main()
def test_when_socket0_and_1_appdirect_memorymode(self): def test_when_socket0_and_1_appdirect_memorymode(self):
set_module_args({ with set_module_args({
'socket': [ 'socket': [
{ {
'id': 0, 'id': 0,
@ -456,18 +456,18 @@ class TestPmem(ModuleTestCase):
'memorymode': 70, 'memorymode': 70,
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ side_effect=[
show_skt, goal_plain_sk0, goal_sk0, dimmlist_sk0, goal_plain_sk1, goal_sk1, dimmlist_sk1]): show_skt, goal_plain_sk0, goal_sk0, dimmlist_sk0, goal_plain_sk1, goal_sk1, dimmlist_sk1]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check( self.result_check(
result, True, [12884901888, 12884901888], [94489280512, 94489280512], [164115382272, 164115382272]) result, True, [12884901888, 12884901888], [94489280512, 94489280512], [164115382272, 164115382272])
def test_when_socket0_and_1_appdirect_memorymode_reserved(self): def test_when_socket0_and_1_appdirect_memorymode_reserved(self):
set_module_args({ with set_module_args({
'socket': [ 'socket': [
{ {
'id': 0, 'id': 0,
@ -482,18 +482,18 @@ class TestPmem(ModuleTestCase):
'reserved': 20, 'reserved': 20,
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ side_effect=[
show_skt, goal_plain_sk0, goal_sk0, dimmlist_sk0, goal_plain_sk1, goal_sk1, dimmlist_sk1]): show_skt, goal_plain_sk0, goal_sk0, dimmlist_sk0, goal_plain_sk1, goal_sk1, dimmlist_sk1]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check( self.result_check(
result, True, [12884901888, 12884901888], [94489280512, 94489280512], [164115382272, 164115382272]) result, True, [12884901888, 12884901888], [94489280512, 94489280512], [164115382272, 164115382272])
def test_when_socket0_appdirect_notinterleaved_memorymode_reserved_socket1_appdirect_memorymode_reserved(self): def test_when_socket0_appdirect_notinterleaved_memorymode_reserved_socket1_appdirect_memorymode_reserved(self):
set_module_args({ with set_module_args({
'socket': [ 'socket': [
{ {
'id': 0, 'id': 0,
@ -509,19 +509,19 @@ class TestPmem(ModuleTestCase):
'reserved': 20, 'reserved': 20,
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ side_effect=[
show_skt, goal_plain_sk0, goal_sk0, dimmlist_sk0, goal_plain_sk1, goal_sk1, dimmlist_sk1]): show_skt, goal_plain_sk0, goal_sk0, dimmlist_sk0, goal_plain_sk1, goal_sk1, dimmlist_sk1]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check( self.result_check(
result, True, [12884901888, 12884901888], [94489280512, 94489280512], [164115382272, 164115382272]) result, True, [12884901888, 12884901888], [94489280512, 94489280512], [164115382272, 164115382272])
def test_fail_when_namespace_without_mode(self): def test_fail_when_namespace_without_mode(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '1GB', 'size': '1GB',
@ -532,12 +532,12 @@ class TestPmem(ModuleTestCase):
'type': 'blk', 'type': 'blk',
}, },
], ],
}) }):
pmem_module.main() pmem_module.main()
def test_fail_when_region_is_empty(self): def test_fail_when_region_is_empty(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '1GB', 'size': '1GB',
@ -545,15 +545,15 @@ class TestPmem(ModuleTestCase):
'mode': 'sector', 'mode': 'sector',
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region_empty]): side_effect=[ndctl_region_empty]):
pmem_module.main() pmem_module.main()
def test_fail_when_namespace_invalid_size(self): def test_fail_when_namespace_invalid_size(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '1XXX', 'size': '1XXX',
@ -561,15 +561,15 @@ class TestPmem(ModuleTestCase):
'mode': 'sector', 'mode': 'sector',
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region]): side_effect=[ndctl_region]):
pmem_module.main() pmem_module.main()
def test_fail_when_size_is_invalid_alignment(self): def test_fail_when_size_is_invalid_alignment(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '400MB', 'size': '400MB',
@ -582,15 +582,15 @@ class TestPmem(ModuleTestCase):
'mode': 'sector' 'mode': 'sector'
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region]): side_effect=[ndctl_region]):
pmem_module.main() pmem_module.main()
def test_fail_when_blk_is_unsupported_type(self): def test_fail_when_blk_is_unsupported_type(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '4GB', 'size': '4GB',
@ -603,15 +603,15 @@ class TestPmem(ModuleTestCase):
'mode': 'sector' 'mode': 'sector'
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region]): side_effect=[ndctl_region]):
pmem_module.main() pmem_module.main()
def test_fail_when_size_isnot_set_to_multiple_namespaces(self): def test_fail_when_size_isnot_set_to_multiple_namespaces(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'type': 'pmem', 'type': 'pmem',
@ -623,15 +623,15 @@ class TestPmem(ModuleTestCase):
'mode': 'sector' 'mode': 'sector'
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region]): side_effect=[ndctl_region]):
pmem_module.main() pmem_module.main()
def test_fail_when_size_of_namespace_over_available(self): def test_fail_when_size_of_namespace_over_available(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '400GB', 'size': '400GB',
@ -644,30 +644,30 @@ class TestPmem(ModuleTestCase):
'mode': 'sector' 'mode': 'sector'
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region]): side_effect=[ndctl_region]):
pmem_module.main() pmem_module.main()
def test_when_namespace0_without_size(self): def test_when_namespace0_without_size(self):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'type': 'pmem', 'type': 'pmem',
'mode': 'sector' 'mode': 'sector'
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region, ndctl_create_without_size, ndctl_list_N]): side_effect=[ndctl_region, ndctl_create_without_size, ndctl_list_N]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check_ns(result, ndctl_list_N) self.result_check_ns(result, ndctl_list_N)
def test_when_namespace0_with_namespace_append(self): def test_when_namespace0_with_namespace_append(self):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '640MB', 'size': '640MB',
@ -676,16 +676,16 @@ class TestPmem(ModuleTestCase):
}, },
], ],
'namespace_append': True, 'namespace_append': True,
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region, ndctl_create_640M, ndctl_list_N_two_namespaces]): side_effect=[ndctl_region, ndctl_create_640M, ndctl_list_N_two_namespaces]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check_ns(result, ndctl_list_N_two_namespaces) self.result_check_ns(result, ndctl_list_N_two_namespaces)
def test_when_namespace0_1GiB_pmem_sector_namespace1_640MiB_pmem_raw(self): def test_when_namespace0_1GiB_pmem_sector_namespace1_640MiB_pmem_raw(self):
set_module_args({ with set_module_args({
'namespace': [ 'namespace': [
{ {
'size': '1GB', 'size': '1GB',
@ -698,10 +698,10 @@ class TestPmem(ModuleTestCase):
'mode': 'raw', 'mode': 'raw',
}, },
], ],
}) }):
with patch( with patch(
'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command', 'ansible_collections.community.general.plugins.modules.pmem.PersistentMemory.pmem_run_command',
side_effect=[ndctl_region, ndctl_create_1G, ndctl_create_640M, ndctl_list_N_two_namespaces]): side_effect=[ndctl_region, ndctl_create_1G, ndctl_create_640M, ndctl_list_N_two_namespaces]):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
pmem_module.main() pmem_module.main()
self.result_check_ns(result, ndctl_list_N_two_namespaces) self.result_check_ns(result, ndctl_list_N_two_namespaces)

146
tests/unit/plugins/modules/test_pritunl_org.py
View file

@ -64,14 +64,14 @@ class TestPritunlOrg(ModuleTestCase):
def test_without_parameters(self): def test_without_parameters(self):
"""Test without parameters""" """Test without parameters"""
set_module_args({}) with set_module_args({}):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_present(self): def test_present(self):
"""Test Pritunl organization creation.""" """Test Pritunl organization creation."""
org_params = {"name": "NewOrg"} org_params = {"name": "NewOrg"}
set_module_args( with set_module_args(
dict_merge( dict_merge(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
@ -80,32 +80,32 @@ class TestPritunlOrg(ModuleTestCase):
}, },
org_params, org_params,
) )
) ):
# Test creation # Test creation
with self.patch_get_pritunl_organizations( with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationMock side_effect=PritunlListOrganizationMock
) as mock_get: ) as mock_get:
with self.patch_add_pritunl_organization( with self.patch_add_pritunl_organization(
side_effect=PritunlPostOrganizationMock side_effect=PritunlPostOrganizationMock
) as mock_add: ) as mock_add:
with self.assertRaises(AnsibleExitJson) as create_result: with self.assertRaises(AnsibleExitJson) as create_result:
self.module.main() self.module.main()
create_exc = create_result.exception.args[0] create_exc = create_result.exception.args[0]
self.assertTrue(create_exc["changed"]) self.assertTrue(create_exc["changed"])
self.assertEqual(create_exc["response"]["name"], org_params["name"]) self.assertEqual(create_exc["response"]["name"], org_params["name"])
self.assertEqual(create_exc["response"]["user_count"], 0) self.assertEqual(create_exc["response"]["user_count"], 0)
# Test module idempotency # Test module idempotency
with self.patch_get_pritunl_organizations( with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationAfterPostMock side_effect=PritunlListOrganizationAfterPostMock
) as mock_get: ) as mock_get:
with self.patch_add_pritunl_organization( with self.patch_add_pritunl_organization(
side_effect=PritunlPostOrganizationMock side_effect=PritunlPostOrganizationMock
) as mock_add: ) as mock_add:
with self.assertRaises(AnsibleExitJson) as idempotent_result: with self.assertRaises(AnsibleExitJson) as idempotent_result:
self.module.main() self.module.main()
idempotent_exc = idempotent_result.exception.args[0] idempotent_exc = idempotent_result.exception.args[0]
@ -120,7 +120,7 @@ class TestPritunlOrg(ModuleTestCase):
def test_absent(self): def test_absent(self):
"""Test organization removal from Pritunl.""" """Test organization removal from Pritunl."""
org_params = {"name": "NewOrg"} org_params = {"name": "NewOrg"}
set_module_args( with set_module_args(
dict_merge( dict_merge(
{ {
"state": "absent", "state": "absent",
@ -130,31 +130,31 @@ class TestPritunlOrg(ModuleTestCase):
}, },
org_params, org_params,
) )
) ):
# Test deletion # Test deletion
with self.patch_get_pritunl_organizations( with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationAfterPostMock side_effect=PritunlListOrganizationAfterPostMock
) as mock_get: ) as mock_get:
with self.patch_delete_pritunl_organization( with self.patch_delete_pritunl_organization(
side_effect=PritunlDeleteOrganizationMock side_effect=PritunlDeleteOrganizationMock
) as mock_delete: ) as mock_delete:
with self.assertRaises(AnsibleExitJson) as delete_result: with self.assertRaises(AnsibleExitJson) as delete_result:
self.module.main() self.module.main()
delete_exc = delete_result.exception.args[0] delete_exc = delete_result.exception.args[0]
self.assertTrue(delete_exc["changed"]) self.assertTrue(delete_exc["changed"])
self.assertEqual(delete_exc["response"], {}) self.assertEqual(delete_exc["response"], {})
# Test module idempotency # Test module idempotency
with self.patch_get_pritunl_organizations( with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationMock side_effect=PritunlListOrganizationMock
) as mock_get: ) as mock_get:
with self.patch_delete_pritunl_organization( with self.patch_delete_pritunl_organization(
side_effect=PritunlDeleteOrganizationMock side_effect=PritunlDeleteOrganizationMock
) as mock_add: ) as mock_add:
with self.assertRaises(AnsibleExitJson) as idempotent_result: with self.assertRaises(AnsibleExitJson) as idempotent_result:
self.module.main() self.module.main()
idempotent_exc = idempotent_result.exception.args[0] idempotent_exc = idempotent_result.exception.args[0]
@ -172,33 +172,31 @@ class TestPritunlOrg(ModuleTestCase):
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
"name": "GumGum", "name": "GumGum",
} }
set_module_args(module_args) with set_module_args(module_args):
# Test deletion
with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationMock
) as mock_get:
with self.patch_delete_pritunl_organization(
side_effect=PritunlDeleteOrganizationMock
) as mock_delete:
with self.assertRaises(AnsibleFailJson) as failure_result:
self.module.main()
# Test deletion failure_exc = failure_result.exception.args[0]
with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationMock
) as mock_get:
with self.patch_delete_pritunl_organization(
side_effect=PritunlDeleteOrganizationMock
) as mock_delete:
with self.assertRaises(AnsibleFailJson) as failure_result:
self.module.main()
failure_exc = failure_result.exception.args[0] self.assertRegex(failure_exc["msg"], "Can not remove organization")
self.assertRegex(failure_exc["msg"], "Can not remove organization") # Switch force=True which should run successfully
with set_module_args(dict_merge(module_args, {"force": True})):
# Switch force=True which should run successfully with self.patch_get_pritunl_organizations(
set_module_args(dict_merge(module_args, {"force": True})) side_effect=PritunlListOrganizationMock
) as mock_get:
with self.patch_get_pritunl_organizations( with self.patch_delete_pritunl_organization(
side_effect=PritunlListOrganizationMock side_effect=PritunlDeleteOrganizationMock
) as mock_get: ) as mock_delete:
with self.patch_delete_pritunl_organization( with self.assertRaises(AnsibleExitJson) as delete_result:
side_effect=PritunlDeleteOrganizationMock self.module.main()
) as mock_delete:
with self.assertRaises(AnsibleExitJson) as delete_result:
self.module.main()
delete_exc = delete_result.exception.args[0] delete_exc = delete_result.exception.args[0]

30
tests/unit/plugins/modules/test_pritunl_org_info.py
View file

@ -49,9 +49,9 @@ class TestPritunlOrgInfo(ModuleTestCase):
with self.patch_get_pritunl_organizations( with self.patch_get_pritunl_organizations(
side_effect=PritunlListOrganizationMock side_effect=PritunlListOrganizationMock
) as org_mock: ) as org_mock:
set_module_args({}) with set_module_args({}):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 0) self.assertEqual(org_mock.call_count, 0)
@ -61,14 +61,14 @@ class TestPritunlOrgInfo(ModuleTestCase):
side_effect=PritunlEmptyOrganizationMock side_effect=PritunlEmptyOrganizationMock
) as org_mock: ) as org_mock:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)
@ -81,15 +81,15 @@ class TestPritunlOrgInfo(ModuleTestCase):
side_effect=PritunlListOrganizationMock side_effect=PritunlListOrganizationMock
) as org_mock: ) as org_mock:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
"org": "GumGum", "org": "GumGum",
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)
@ -102,15 +102,15 @@ class TestPritunlOrgInfo(ModuleTestCase):
side_effect=PritunlListOrganizationMock side_effect=PritunlListOrganizationMock
) as org_mock: ) as org_mock:
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
"org": "Unknown", "org": "Unknown",
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)
@ -123,14 +123,14 @@ class TestPritunlOrgInfo(ModuleTestCase):
side_effect=PritunlListOrganizationMock side_effect=PritunlListOrganizationMock
) as org_mock: ) as org_mock:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)

55
tests/unit/plugins/modules/test_pritunl_user.py
View file

@ -94,9 +94,9 @@ class TestPritunlUser(ModuleTestCase):
def test_without_parameters(self): def test_without_parameters(self):
"""Test without parameters""" """Test without parameters"""
set_module_args({}) with set_module_args({}):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
@mock_pritunl_api @mock_pritunl_api
def test_present(self): def test_present(self):
@ -105,7 +105,7 @@ class TestPritunlUser(ModuleTestCase):
"user_name": "alice", "user_name": "alice",
"user_email": "alice@company.com", "user_email": "alice@company.com",
} }
set_module_args( with set_module_args(
dict_merge( dict_merge(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
@ -115,13 +115,12 @@ class TestPritunlUser(ModuleTestCase):
}, },
user_params, user_params,
) )
) ):
with self.patch_update_pritunl_users(
with self.patch_update_pritunl_users( side_effect=PritunlPostUserMock
side_effect=PritunlPostUserMock ) as post_mock:
) as post_mock: with self.assertRaises(AnsibleExitJson) as create_result:
with self.assertRaises(AnsibleExitJson) as create_result: self.module.main()
self.module.main()
create_exc = create_result.exception.args[0] create_exc = create_result.exception.args[0]
@ -137,7 +136,7 @@ class TestPritunlUser(ModuleTestCase):
"user_email": "bob@company.com", "user_email": "bob@company.com",
"user_disabled": True, "user_disabled": True,
} }
set_module_args( with set_module_args(
dict_merge( dict_merge(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
@ -147,14 +146,12 @@ class TestPritunlUser(ModuleTestCase):
}, },
new_user_params, new_user_params,
) )
) ):
with self.patch_update_pritunl_users(
with self.patch_update_pritunl_users( side_effect=PritunlPutUserMock
side_effect=PritunlPutUserMock ) as put_mock:
) as put_mock: with self.assertRaises(AnsibleExitJson) as update_result:
self.module.main()
with self.assertRaises(AnsibleExitJson) as update_result:
self.module.main()
update_exc = update_result.exception.args[0] update_exc = update_result.exception.args[0]
@ -168,7 +165,7 @@ class TestPritunlUser(ModuleTestCase):
@mock_pritunl_api @mock_pritunl_api
def test_absent(self): def test_absent(self):
"""Test user removal from Pritunl.""" """Test user removal from Pritunl."""
set_module_args( with set_module_args(
{ {
"state": "absent", "state": "absent",
"pritunl_api_token": "token", "pritunl_api_token": "token",
@ -177,10 +174,9 @@ class TestPritunlUser(ModuleTestCase):
"organization": "GumGum", "organization": "GumGum",
"user_name": "florian", "user_name": "florian",
} }
) ):
with self.assertRaises(AnsibleExitJson) as result:
with self.assertRaises(AnsibleExitJson) as result: self.module.main()
self.module.main()
exc = result.exception.args[0] exc = result.exception.args[0]
@ -190,7 +186,7 @@ class TestPritunlUser(ModuleTestCase):
@mock_pritunl_api @mock_pritunl_api
def test_absent_failure(self): def test_absent_failure(self):
"""Test user removal from a non existing organization.""" """Test user removal from a non existing organization."""
set_module_args( with set_module_args(
{ {
"state": "absent", "state": "absent",
"pritunl_api_token": "token", "pritunl_api_token": "token",
@ -199,10 +195,9 @@ class TestPritunlUser(ModuleTestCase):
"organization": "Unknown", "organization": "Unknown",
"user_name": "floria@company.com", "user_name": "floria@company.com",
} }
) ):
with self.assertRaises(AnsibleFailJson) as result:
with self.assertRaises(AnsibleFailJson) as result: self.module.main()
self.module.main()
exc = result.exception.args[0] exc = result.exception.args[0]

24
tests/unit/plugins/modules/test_pritunl_user_info.py
View file

@ -59,9 +59,9 @@ class TestPritunlUserInfo(ModuleTestCase):
with self.patch_get_pritunl_users( with self.patch_get_pritunl_users(
side_effect=PritunlListUserMock side_effect=PritunlListUserMock
) as user_mock: ) as user_mock:
set_module_args({}) with set_module_args({}):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 0) self.assertEqual(org_mock.call_count, 0)
self.assertEqual(user_mock.call_count, 0) self.assertEqual(user_mock.call_count, 0)
@ -75,15 +75,15 @@ class TestPritunlUserInfo(ModuleTestCase):
side_effect=PritunlListUserMock side_effect=PritunlListUserMock
) as user_mock: ) as user_mock:
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
"organization": "Unknown", "organization": "Unknown",
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)
self.assertEqual(user_mock.call_count, 0) self.assertEqual(user_mock.call_count, 0)
@ -103,15 +103,15 @@ class TestPritunlUserInfo(ModuleTestCase):
side_effect=PritunlListUserMock side_effect=PritunlListUserMock
) as user_mock: ) as user_mock:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
"pritunl_url": "https://pritunl.domain.com", "pritunl_url": "https://pritunl.domain.com",
"organization": "GumGum", "organization": "GumGum",
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)
self.assertEqual(user_mock.call_count, 1) self.assertEqual(user_mock.call_count, 1)
@ -137,7 +137,7 @@ class TestPritunlUserInfo(ModuleTestCase):
side_effect=PritunlListUserMock side_effect=PritunlListUserMock
) as user_mock: ) as user_mock:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args( with set_module_args(
{ {
"pritunl_api_token": "token", "pritunl_api_token": "token",
"pritunl_api_secret": "secret", "pritunl_api_secret": "secret",
@ -146,8 +146,8 @@ class TestPritunlUserInfo(ModuleTestCase):
"user_name": expected_user_name, "user_name": expected_user_name,
"user_type": expected_user_type, "user_type": expected_user_type,
} }
) ):
self.module.main() self.module.main()
self.assertEqual(org_mock.call_count, 1) self.assertEqual(org_mock.call_count, 1)
self.assertEqual(user_mock.call_count, 1) self.assertEqual(user_mock.call_count, 1)

134
tests/unit/plugins/modules/test_proxmox_backup.py
View file

@ -247,20 +247,23 @@ class TestProxmoxBackup(ModuleTestCase):
super(TestProxmoxBackup, self).tearDown() super(TestProxmoxBackup, self).tearDown()
def test_proxmox_backup_without_argument(self): def test_proxmox_backup_without_argument(self):
set_module_args({}) with set_module_args({}):
with pytest.raises(AnsibleFailJson): with pytest.raises(AnsibleFailJson):
proxmox_backup.main() proxmox_backup.main()
def test_create_backup_check_mode(self): def test_create_backup_check_mode(self):
set_module_args({"api_user": "root@pam", with set_module_args(
"api_password": "secret", {
"api_host": "127.0.0.1", "api_user": "root@pam",
"mode": "all", "api_password": "secret",
"storage": "backup", "api_host": "127.0.0.1",
"_ansible_check_mode": True, "mode": "all",
}) "storage": "backup",
with pytest.raises(AnsibleExitJson) as exc_info: "_ansible_check_mode": True,
proxmox_backup.main() }
):
with pytest.raises(AnsibleExitJson) as exc_info:
proxmox_backup.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
@ -272,14 +275,15 @@ class TestProxmoxBackup(ModuleTestCase):
assert self.mock_post_vzdump.call_count == 0 assert self.mock_post_vzdump.call_count == 0
def test_create_backup_all_mode(self): def test_create_backup_all_mode(self):
set_module_args({"api_user": "root@pam", with set_module_args({
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"mode": "all", "api_host": "127.0.0.1",
"storage": "backup", "mode": "all",
}) "storage": "backup",
with pytest.raises(AnsibleExitJson) as exc_info: }):
proxmox_backup.main() with pytest.raises(AnsibleExitJson) as exc_info:
proxmox_backup.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["changed"] is True assert result["changed"] is True
@ -291,17 +295,18 @@ class TestProxmoxBackup(ModuleTestCase):
assert self.mock_post_vzdump.call_count == 3 assert self.mock_post_vzdump.call_count == 3
def test_create_backup_include_mode_with_wait(self): def test_create_backup_include_mode_with_wait(self):
set_module_args({"api_user": "root@pam", with set_module_args({
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"mode": "include", "api_host": "127.0.0.1",
"node": "node1", "mode": "include",
"storage": "backup", "node": "node1",
"vmids": [100], "storage": "backup",
"wait": True "vmids": [100],
}) "wait": True
with pytest.raises(AnsibleExitJson) as exc_info: }):
proxmox_backup.main() with pytest.raises(AnsibleExitJson) as exc_info:
proxmox_backup.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["changed"] is True assert result["changed"] is True
@ -313,17 +318,18 @@ class TestProxmoxBackup(ModuleTestCase):
assert self.mock_post_vzdump.call_count == 1 assert self.mock_post_vzdump.call_count == 1
def test_fail_insufficient_permissions(self): def test_fail_insufficient_permissions(self):
set_module_args({"api_user": "root@pam", with set_module_args({
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"mode": "include", "api_host": "127.0.0.1",
"storage": "backup", "mode": "include",
"performance_tweaks": "max-workers=2", "storage": "backup",
"vmids": [100], "performance_tweaks": "max-workers=2",
"wait": True "vmids": [100],
}) "wait": True
with pytest.raises(AnsibleFailJson) as exc_info: }):
proxmox_backup.main() with pytest.raises(AnsibleFailJson) as exc_info:
proxmox_backup.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["msg"] == "Insufficient permission: Performance_tweaks and bandwidth require 'Sys.Modify' permission for '/'" assert result["msg"] == "Insufficient permission: Performance_tweaks and bandwidth require 'Sys.Modify' permission for '/'"
@ -331,17 +337,18 @@ class TestProxmoxBackup(ModuleTestCase):
assert self.mock_post_vzdump.call_count == 0 assert self.mock_post_vzdump.call_count == 0
def test_fail_missing_node(self): def test_fail_missing_node(self):
set_module_args({"api_user": "root@pam", with set_module_args({
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"mode": "include", "api_host": "127.0.0.1",
"storage": "backup", "mode": "include",
"node": "nonexistingnode", "storage": "backup",
"vmids": [100], "node": "nonexistingnode",
"wait": True "vmids": [100],
}) "wait": True
with pytest.raises(AnsibleFailJson) as exc_info: }):
proxmox_backup.main() with pytest.raises(AnsibleFailJson) as exc_info:
proxmox_backup.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["msg"] == "Node nonexistingnode was specified, but does not exist on the cluster" assert result["msg"] == "Node nonexistingnode was specified, but does not exist on the cluster"
@ -349,16 +356,17 @@ class TestProxmoxBackup(ModuleTestCase):
assert self.mock_post_vzdump.call_count == 0 assert self.mock_post_vzdump.call_count == 0
def test_fail_missing_storage(self): def test_fail_missing_storage(self):
set_module_args({"api_user": "root@pam", with set_module_args({
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"mode": "include", "api_host": "127.0.0.1",
"storage": "nonexistingstorage", "mode": "include",
"vmids": [100], "storage": "nonexistingstorage",
"wait": True "vmids": [100],
}) "wait": True
with pytest.raises(AnsibleFailJson) as exc_info: }):
proxmox_backup.main() with pytest.raises(AnsibleFailJson) as exc_info:
proxmox_backup.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["msg"] == "Storage nonexistingstorage does not exist in the cluster" assert result["msg"] == "Storage nonexistingstorage does not exist in the cluster"

28
tests/unit/plugins/modules/test_proxmox_backup_info.py
View file

@ -207,20 +207,20 @@ class TestProxmoxBackupInfoModule(ModuleTestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["msg"] == "missing required arguments: api_host, api_user" assert result["msg"] == "missing required arguments: api_host, api_user"
def test_get_all_backups_information(self): def test_get_all_backups_information(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
set_module_args({ with set_module_args({
'api_host': 'proxmoxhost', 'api_host': 'proxmoxhost',
'api_user': 'root@pam', 'api_user': 'root@pam',
'api_password': 'supersecret' 'api_password': 'supersecret'
}) }):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["backup_info"] == EXPECTED_BACKUP_OUTPUT assert result["backup_info"] == EXPECTED_BACKUP_OUTPUT
@ -231,13 +231,13 @@ class TestProxmoxBackupInfoModule(ModuleTestCase):
expected_output = [ expected_output = [
backup for backup in EXPECTED_BACKUP_OUTPUT if backup["vm_name"] == vmname backup for backup in EXPECTED_BACKUP_OUTPUT if backup["vm_name"] == vmname
] ]
set_module_args({ with set_module_args({
'api_host': 'proxmoxhost', 'api_host': 'proxmoxhost',
'api_user': 'root@pam', 'api_user': 'root@pam',
'api_password': 'supersecret', 'api_password': 'supersecret',
'vm_name': vmname 'vm_name': vmname
}) }):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["backup_info"] == expected_output assert result["backup_info"] == expected_output
@ -249,13 +249,13 @@ class TestProxmoxBackupInfoModule(ModuleTestCase):
expected_output = [ expected_output = [
backup for backup in EXPECTED_BACKUP_OUTPUT if backup["vmid"] == vmid backup for backup in EXPECTED_BACKUP_OUTPUT if backup["vmid"] == vmid
] ]
set_module_args({ with set_module_args({
'api_host': 'proxmoxhost', 'api_host': 'proxmoxhost',
'api_user': 'root@pam', 'api_user': 'root@pam',
'api_password': 'supersecret', 'api_password': 'supersecret',
'vm_id': vmid 'vm_id': vmid
}) }):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["backup_info"] == expected_output assert result["backup_info"] == expected_output
assert len(result["backup_info"]) == 1 assert len(result["backup_info"]) == 1
@ -263,13 +263,13 @@ class TestProxmoxBackupInfoModule(ModuleTestCase):
def test_get_specific_backup_information_by_backupjobs(self): def test_get_specific_backup_information_by_backupjobs(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
backupjobs = True backupjobs = True
set_module_args({ with set_module_args({
'api_host': 'proxmoxhost', 'api_host': 'proxmoxhost',
'api_user': 'root@pam', 'api_user': 'root@pam',
'api_password': 'supersecret', 'api_password': 'supersecret',
'backup_jobs': backupjobs 'backup_jobs': backupjobs
}) }):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["backup_info"] == EXPECTED_BACKUP_JOBS_OUTPUT assert result["backup_info"] == EXPECTED_BACKUP_JOBS_OUTPUT

62
tests/unit/plugins/modules/test_proxmox_kvm.py
View file

@ -57,11 +57,11 @@ class TestProxmoxKvmModule(ModuleTestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_module_exits_unchaged_when_provided_vmid_exists(self): def test_module_exits_unchaged_when_provided_vmid_exists(self):
set_module_args( with set_module_args(
{ {
"api_host": "host", "api_host": "host",
"api_user": "user", "api_user": "user",
@ -69,10 +69,10 @@ class TestProxmoxKvmModule(ModuleTestCase):
"vmid": "100", "vmid": "100",
"node": "pve", "node": "pve",
} }
) ):
self.get_vm_mock.return_value = [{"vmid": "100"}] self.get_vm_mock.return_value = [{"vmid": "100"}]
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
self.module.main() self.module.main()
assert self.get_vm_mock.call_count == 1 assert self.get_vm_mock.call_count == 1
result = exc_info.value.args[0] result = exc_info.value.args[0]
@ -80,7 +80,7 @@ class TestProxmoxKvmModule(ModuleTestCase):
assert result["msg"] == "VM with vmid <100> already exists" assert result["msg"] == "VM with vmid <100> already exists"
def test_vm_created_when_vmid_not_exist_but_name_already_exist(self): def test_vm_created_when_vmid_not_exist_but_name_already_exist(self):
set_module_args( with set_module_args(
{ {
"api_host": "host", "api_host": "host",
"api_user": "user", "api_user": "user",
@ -89,10 +89,10 @@ class TestProxmoxKvmModule(ModuleTestCase):
"name": "existing.vm.local", "name": "existing.vm.local",
"node": "pve", "node": "pve",
} }
) ):
self.get_vm_mock.return_value = None self.get_vm_mock.return_value = None
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
self.module.main() self.module.main()
assert self.get_vm_mock.call_count == 1 assert self.get_vm_mock.call_count == 1
assert self.get_node_mock.call_count == 1 assert self.get_node_mock.call_count == 1
@ -101,7 +101,7 @@ class TestProxmoxKvmModule(ModuleTestCase):
assert result["msg"] == "VM existing.vm.local with vmid 100 deployed" assert result["msg"] == "VM existing.vm.local with vmid 100 deployed"
def test_vm_not_created_when_name_already_exist_and_vmid_not_set(self): def test_vm_not_created_when_name_already_exist_and_vmid_not_set(self):
set_module_args( with set_module_args(
{ {
"api_host": "host", "api_host": "host",
"api_user": "user", "api_user": "user",
@ -109,21 +109,21 @@ class TestProxmoxKvmModule(ModuleTestCase):
"name": "existing.vm.local", "name": "existing.vm.local",
"node": "pve", "node": "pve",
} }
) ):
with patch.object(proxmox_utils.ProxmoxAnsible, "get_vmid") as get_vmid_mock: with patch.object(proxmox_utils.ProxmoxAnsible, "get_vmid") as get_vmid_mock:
get_vmid_mock.return_value = { get_vmid_mock.return_value = {
"vmid": 100, "vmid": 100,
"name": "existing.vm.local", "name": "existing.vm.local",
} }
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
self.module.main() self.module.main()
assert get_vmid_mock.call_count == 1 assert get_vmid_mock.call_count == 1
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["changed"] is False assert result["changed"] is False
def test_vm_created_when_name_doesnt_exist_and_vmid_not_set(self): def test_vm_created_when_name_doesnt_exist_and_vmid_not_set(self):
set_module_args( with set_module_args(
{ {
"api_host": "host", "api_host": "host",
"api_user": "user", "api_user": "user",
@ -131,15 +131,15 @@ class TestProxmoxKvmModule(ModuleTestCase):
"name": "existing.vm.local", "name": "existing.vm.local",
"node": "pve", "node": "pve",
} }
) ):
self.get_vm_mock.return_value = None self.get_vm_mock.return_value = None
with patch.multiple( with patch.multiple(
proxmox_utils.ProxmoxAnsible, get_vmid=DEFAULT, get_nextvmid=DEFAULT proxmox_utils.ProxmoxAnsible, get_vmid=DEFAULT, get_nextvmid=DEFAULT
) as utils_mock: ) as utils_mock:
utils_mock["get_vmid"].return_value = None utils_mock["get_vmid"].return_value = None
utils_mock["get_nextvmid"].return_value = 101 utils_mock["get_nextvmid"].return_value = 101
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
self.module.main() self.module.main()
assert utils_mock["get_vmid"].call_count == 1 assert utils_mock["get_vmid"].call_count == 1
assert utils_mock["get_nextvmid"].call_count == 1 assert utils_mock["get_nextvmid"].call_count == 1

90
tests/unit/plugins/modules/test_proxmox_snap.py
View file

@ -51,9 +51,9 @@ def fake_api(mocker):
def test_proxmox_snap_without_argument(capfd): def test_proxmox_snap_without_argument(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
proxmox_snap.main() proxmox_snap.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
@ -62,19 +62,21 @@ def test_proxmox_snap_without_argument(capfd):
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_create_snapshot_check_mode(connect_mock, capfd, mocker): def test_create_snapshot_check_mode(connect_mock, capfd, mocker):
set_module_args({"hostname": "test-lxc", with set_module_args({
"api_user": "root@pam", "hostname": "test-lxc",
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"state": "present", "api_host": "127.0.0.1",
"snapname": "test", "state": "present",
"timeout": "1", "snapname": "test",
"force": True, "timeout": "1",
"_ansible_check_mode": True}) "force": True,
proxmox_utils.HAS_PROXMOXER = True "_ansible_check_mode": True
connect_mock.side_effect = lambda: fake_api(mocker) }):
with pytest.raises(SystemExit) as results: proxmox_utils.HAS_PROXMOXER = True
proxmox_snap.main() connect_mock.side_effect = lambda: fake_api(mocker)
with pytest.raises(SystemExit) as results:
proxmox_snap.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
@ -83,19 +85,21 @@ def test_create_snapshot_check_mode(connect_mock, capfd, mocker):
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_remove_snapshot_check_mode(connect_mock, capfd, mocker): def test_remove_snapshot_check_mode(connect_mock, capfd, mocker):
set_module_args({"hostname": "test-lxc", with set_module_args({
"api_user": "root@pam", "hostname": "test-lxc",
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"state": "absent", "api_host": "127.0.0.1",
"snapname": "test", "state": "absent",
"timeout": "1", "snapname": "test",
"force": True, "timeout": "1",
"_ansible_check_mode": True}) "force": True,
proxmox_utils.HAS_PROXMOXER = True "_ansible_check_mode": True
connect_mock.side_effect = lambda: fake_api(mocker) }):
with pytest.raises(SystemExit) as results: proxmox_utils.HAS_PROXMOXER = True
proxmox_snap.main() connect_mock.side_effect = lambda: fake_api(mocker)
with pytest.raises(SystemExit) as results:
proxmox_snap.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
@ -104,19 +108,21 @@ def test_remove_snapshot_check_mode(connect_mock, capfd, mocker):
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_rollback_snapshot_check_mode(connect_mock, capfd, mocker): def test_rollback_snapshot_check_mode(connect_mock, capfd, mocker):
set_module_args({"hostname": "test-lxc", with set_module_args({
"api_user": "root@pam", "hostname": "test-lxc",
"api_password": "secret", "api_user": "root@pam",
"api_host": "127.0.0.1", "api_password": "secret",
"state": "rollback", "api_host": "127.0.0.1",
"snapname": "test", "state": "rollback",
"timeout": "1", "snapname": "test",
"force": True, "timeout": "1",
"_ansible_check_mode": True}) "force": True,
proxmox_utils.HAS_PROXMOXER = True "_ansible_check_mode": True
connect_mock.side_effect = lambda: fake_api(mocker) }):
with pytest.raises(SystemExit) as results: proxmox_utils.HAS_PROXMOXER = True
proxmox_snap.main() connect_mock.side_effect = lambda: fake_api(mocker)
with pytest.raises(SystemExit) as results:
proxmox_snap.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err

10
tests/unit/plugins/modules/test_proxmox_storage_contents_info.py
View file

@ -76,14 +76,14 @@ class TestProxmoxStorageContentsInfo(ModuleTestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_storage_contents_info(self): def test_storage_contents_info(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
set_module_args(get_module_args(node=NODE1, storage="datastore")) with set_module_args(get_module_args(node=NODE1, storage="datastore")):
expected_output = {} expected_output = {}
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert not result["changed"] assert not result["changed"]

67
tests/unit/plugins/modules/test_proxmox_tasks_info.py
View file

@ -127,9 +127,9 @@ EXPECTED_SINGLE_TASK = [
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_without_required_parameters(connect_mock, capfd, mocker): def test_without_required_parameters(connect_mock, capfd, mocker):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
proxmox_tasks_info.main() proxmox_tasks_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert json.loads(out)['failed'] assert json.loads(out)['failed']
@ -145,16 +145,17 @@ def mock_api_tasks_response(mocker):
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_get_tasks(connect_mock, capfd, mocker): def test_get_tasks(connect_mock, capfd, mocker):
set_module_args({'api_host': 'proxmoxhost', with set_module_args({
'api_user': 'root@pam', 'api_host': 'proxmoxhost',
'api_password': 'supersecret', 'api_user': 'root@pam',
'node': NODE}) 'api_password': 'supersecret',
'node': NODE
}):
connect_mock.side_effect = lambda: mock_api_tasks_response(mocker)
proxmox_utils.HAS_PROXMOXER = True
connect_mock.side_effect = lambda: mock_api_tasks_response(mocker) with pytest.raises(SystemExit):
proxmox_utils.HAS_PROXMOXER = True proxmox_tasks_info.main()
with pytest.raises(SystemExit):
proxmox_tasks_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert len(json.loads(out)['proxmox_tasks']) != 0 assert len(json.loads(out)['proxmox_tasks']) != 0
@ -163,17 +164,18 @@ def test_get_tasks(connect_mock, capfd, mocker):
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_get_single_task(connect_mock, capfd, mocker): def test_get_single_task(connect_mock, capfd, mocker):
set_module_args({'api_host': 'proxmoxhost', with set_module_args({
'api_user': 'root@pam', 'api_host': 'proxmoxhost',
'api_password': 'supersecret', 'api_user': 'root@pam',
'node': NODE, 'api_password': 'supersecret',
'task': TASK_UPID}) 'node': NODE,
'task': TASK_UPID
}):
connect_mock.side_effect = lambda: mock_api_tasks_response(mocker)
proxmox_utils.HAS_PROXMOXER = True
connect_mock.side_effect = lambda: mock_api_tasks_response(mocker) with pytest.raises(SystemExit):
proxmox_utils.HAS_PROXMOXER = True proxmox_tasks_info.main()
with pytest.raises(SystemExit):
proxmox_tasks_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert len(json.loads(out)['proxmox_tasks']) == 1 assert len(json.loads(out)['proxmox_tasks']) == 1
@ -183,17 +185,18 @@ def test_get_single_task(connect_mock, capfd, mocker):
@patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect') @patch('ansible_collections.community.general.plugins.module_utils.proxmox.ProxmoxAnsible._connect')
def test_get_non_existent_task(connect_mock, capfd, mocker): def test_get_non_existent_task(connect_mock, capfd, mocker):
set_module_args({'api_host': 'proxmoxhost', with set_module_args({
'api_user': 'root@pam', 'api_host': 'proxmoxhost',
'api_password': 'supersecret', 'api_user': 'root@pam',
'node': NODE, 'api_password': 'supersecret',
'task': 'UPID:nonexistent'}) 'node': NODE,
'task': 'UPID:nonexistent'
}):
connect_mock.side_effect = lambda: mock_api_tasks_response(mocker)
proxmox_utils.HAS_PROXMOXER = True
connect_mock.side_effect = lambda: mock_api_tasks_response(mocker) with pytest.raises(SystemExit):
proxmox_utils.HAS_PROXMOXER = True proxmox_tasks_info.main()
with pytest.raises(SystemExit):
proxmox_tasks_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert json.loads(out)['failed'] assert json.loads(out)['failed']

8
tests/unit/plugins/modules/test_proxmox_template.py
View file

@ -48,7 +48,7 @@ class TestProxmoxTemplateModule(ModuleTestCase):
def test_module_fail_when_toolbelt_not_installed_and_file_size_is_big(self, mock_stat): def test_module_fail_when_toolbelt_not_installed_and_file_size_is_big(self, mock_stat):
self.module.HAS_REQUESTS_TOOLBELT = False self.module.HAS_REQUESTS_TOOLBELT = False
mock_stat.return_value.st_size = 268435460 mock_stat.return_value.st_size = 268435460
set_module_args( with set_module_args(
{ {
"api_host": "host", "api_host": "host",
"api_user": "user", "api_user": "user",
@ -57,9 +57,9 @@ class TestProxmoxTemplateModule(ModuleTestCase):
"src": "/tmp/mock.iso", "src": "/tmp/mock.iso",
"content_type": "iso" "content_type": "iso"
} }
) ):
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["failed"] is True assert result["failed"] is True

96
tests/unit/plugins/modules/test_proxmox_vm_info.py
View file

@ -452,17 +452,17 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["msg"] == "missing required arguments: api_host, api_user" assert result["msg"] == "missing required arguments: api_host, api_user"
def test_get_lxc_vms_information(self): def test_get_lxc_vms_information(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
set_module_args(get_module_args(type="lxc")) with set_module_args(get_module_args(type="lxc")):
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["type"] == "lxc"] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["type"] == "lxc"]
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["changed"] is False assert result["changed"] is False
@ -470,25 +470,25 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
def test_get_qemu_vms_information(self): def test_get_qemu_vms_information(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
set_module_args(get_module_args(type="qemu")) with set_module_args(get_module_args(type="qemu")):
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["type"] == "qemu"] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["type"] == "qemu"]
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
def test_get_all_vms_information(self): def test_get_all_vms_information(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
set_module_args(get_module_args()) with set_module_args(get_module_args()):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == EXPECTED_VMS_OUTPUT assert result["proxmox_vms"] == EXPECTED_VMS_OUTPUT
def test_vmid_is_converted_to_int(self): def test_vmid_is_converted_to_int(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
set_module_args(get_module_args(type="lxc")) with set_module_args(get_module_args(type="lxc")):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert isinstance(result["proxmox_vms"][0]["vmid"], int) assert isinstance(result["proxmox_vms"][0]["vmid"], int)
@ -501,8 +501,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
for vm in EXPECTED_VMS_OUTPUT for vm in EXPECTED_VMS_OUTPUT
if vm["vmid"] == vmid and vm["type"] == "lxc" if vm["vmid"] == vmid and vm["type"] == "lxc"
] ]
set_module_args(get_module_args(type="lxc", vmid=vmid)) with set_module_args(get_module_args(type="lxc", vmid=vmid)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -516,8 +516,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
for vm in EXPECTED_VMS_OUTPUT for vm in EXPECTED_VMS_OUTPUT
if vm["vmid"] == vmid and vm["type"] == "qemu" if vm["vmid"] == vmid and vm["type"] == "qemu"
] ]
set_module_args(get_module_args(type="qemu", vmid=vmid)) with set_module_args(get_module_args(type="qemu", vmid=vmid)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -527,8 +527,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
vmid = 100 vmid = 100
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["vmid"] == vmid] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["vmid"] == vmid]
set_module_args(get_module_args(type="all", vmid=vmid)) with set_module_args(get_module_args(type="all", vmid=vmid)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -542,8 +542,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["name"] == name] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["name"] == name]
set_module_args(get_module_args(type="all", name=name)) with set_module_args(get_module_args(type="all", name=name)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -558,8 +558,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["name"] == name] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["name"] == name]
set_module_args(get_module_args(type="all", name=name)) with set_module_args(get_module_args(type="all", name=name)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -573,8 +573,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["name"] == name] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["name"] == name]
set_module_args(get_module_args(type="all", name=name)) with set_module_args(get_module_args(type="all", name=name)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -587,8 +587,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
for vm in EXPECTED_VMS_OUTPUT for vm in EXPECTED_VMS_OUTPUT
if vm["node"] == NODE1 and vm["type"] == "lxc" if vm["node"] == NODE1 and vm["type"] == "lxc"
] ]
set_module_args(get_module_args(type="lxc", node=NODE1)) with set_module_args(get_module_args(type="lxc", node=NODE1)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -601,8 +601,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
for vm in EXPECTED_VMS_OUTPUT for vm in EXPECTED_VMS_OUTPUT
if vm["node"] == NODE1 and vm["type"] == "qemu" if vm["node"] == NODE1 and vm["type"] == "qemu"
] ]
set_module_args(get_module_args(type="qemu", node=NODE1)) with set_module_args(get_module_args(type="qemu", node=NODE1)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -611,8 +611,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
def test_get_all_vms_from_specific_node(self): def test_get_all_vms_from_specific_node(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["node"] == NODE1] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["node"] == NODE1]
set_module_args(get_module_args(node=NODE1)) with set_module_args(get_module_args(node=NODE1)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output
@ -621,8 +621,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
def test_module_returns_empty_list_when_vm_does_not_exist(self): def test_module_returns_empty_list_when_vm_does_not_exist(self):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
vmid = 200 vmid = 200
set_module_args(get_module_args(type="all", vmid=vmid)) with set_module_args(get_module_args(type="all", vmid=vmid)):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == [] assert result["proxmox_vms"] == []
@ -632,8 +632,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
"Some mocked connection error." "Some mocked connection error."
) )
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args(get_module_args(type="qemu")) with set_module_args(get_module_args(type="qemu")):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert "Failed to retrieve QEMU VMs information:" in result["msg"] assert "Failed to retrieve QEMU VMs information:" in result["msg"]
@ -643,8 +643,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
"Some mocked connection error." "Some mocked connection error."
) )
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args(get_module_args(type="lxc")) with set_module_args(get_module_args(type="lxc")):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert "Failed to retrieve LXC VMs information:" in result["msg"] assert "Failed to retrieve LXC VMs information:" in result["msg"]
@ -654,8 +654,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
"Some mocked connection error." "Some mocked connection error."
) )
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args(get_module_args()) with set_module_args(get_module_args()):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert ( assert (
@ -665,8 +665,8 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
def test_module_fail_when_node_does_not_exist(self): def test_module_fail_when_node_does_not_exist(self):
with pytest.raises(AnsibleFailJson) as exc_info: with pytest.raises(AnsibleFailJson) as exc_info:
set_module_args(get_module_args(type="all", node="NODE3")) with set_module_args(get_module_args(type="all", node="NODE3")):
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["msg"] == "Node NODE3 doesn't exist in PVE cluster" assert result["msg"] == "Node NODE3 doesn't exist in PVE cluster"
@ -677,10 +677,10 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
) as get_vmid_mock: ) as get_vmid_mock:
with pytest.raises(AnsibleExitJson): with pytest.raises(AnsibleExitJson):
vmid = 100 vmid = 100
set_module_args( with set_module_args(
get_module_args(type="all", vmid=vmid, name="something") get_module_args(type="all", vmid=vmid, name="something")
) ):
self.module.main() self.module.main()
assert get_vmid_mock.call_count == 0 assert get_vmid_mock.call_count == 0
@ -701,14 +701,14 @@ class TestProxmoxVmInfoModule(ModuleTestCase):
with pytest.raises(AnsibleExitJson) as exc_info: with pytest.raises(AnsibleExitJson) as exc_info:
vmid = 101 vmid = 101
set_module_args(get_module_args( with set_module_args(get_module_args(
type="qemu", type="qemu",
vmid=vmid, vmid=vmid,
config="current", config="current",
)) )):
expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["vmid"] == vmid] expected_output = [vm for vm in EXPECTED_VMS_OUTPUT if vm["vmid"] == vmid]
expected_output[0]["config"] = config_vm_value expected_output[0]["config"] = config_vm_value
self.module.main() self.module.main()
result = exc_info.value.args[0] result = exc_info.value.args[0]
assert result["proxmox_vms"] == expected_output assert result["proxmox_vms"] == expected_output

248
tests/unit/plugins/modules/test_redis_data.py
View file

@ -21,9 +21,9 @@ if tuple(map(int, __version__.split('.'))) < (3, 4, 0):
def test_redis_data_without_arguments(capfd): def test_redis_data_without_arguments(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert json.loads(out)['failed'] assert json.loads(out)['failed']
@ -31,16 +31,16 @@ def test_redis_data_without_arguments(capfd):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_key(capfd, mocker): def test_redis_data_key(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'value': 'baz', 'value': 'baz',
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
mocker.patch('redis.Redis.set', return_value=True) mocker.patch('redis.Redis.set', return_value=True)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -52,17 +52,17 @@ def test_redis_data_key(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_existing_key_nx(capfd, mocker): def test_redis_data_existing_key_nx(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'value': 'baz', 'value': 'baz',
'non_existing': True, 'non_existing': True,
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
mocker.patch('redis.Redis.set', return_value=None) mocker.patch('redis.Redis.set', return_value=None)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -76,17 +76,17 @@ def test_redis_data_existing_key_nx(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_non_existing_key_xx(capfd, mocker): def test_redis_data_non_existing_key_xx(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'value': 'baz', 'value': 'baz',
'existing': True, 'existing': True,
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
mocker.patch('redis.Redis.get', return_value=None) mocker.patch('redis.Redis.get', return_value=None)
mocker.patch('redis.Redis.set', return_value=None) mocker.patch('redis.Redis.set', return_value=None)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -100,15 +100,15 @@ def test_redis_data_non_existing_key_xx(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_delete_present_key(capfd, mocker): def test_redis_data_delete_present_key(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'absent'}) 'state': 'absent'}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
mocker.patch('redis.Redis.delete', return_value=1) mocker.patch('redis.Redis.delete', return_value=1)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -118,15 +118,15 @@ def test_redis_data_delete_present_key(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_delete_absent_key(capfd, mocker): def test_redis_data_delete_absent_key(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'absent'}) 'state': 'absent'}):
mocker.patch('redis.Redis.delete', return_value=0) mocker.patch('redis.Redis.delete', return_value=0)
mocker.patch('redis.Redis.get', return_value=None) mocker.patch('redis.Redis.get', return_value=None)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -136,14 +136,14 @@ def test_redis_data_delete_absent_key(capfd, mocker):
@pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0") @pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0")
def test_redis_data_fail_username(capfd, mocker): def test_redis_data_fail_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'value': 'baz', 'value': 'baz',
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -153,15 +153,15 @@ def test_redis_data_fail_username(capfd, mocker):
def test_redis_data_key_no_username(capfd, mocker): def test_redis_data_key_no_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'value': 'baz', 'value': 'baz',
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
mocker.patch('redis.Redis.set', return_value=True) mocker.patch('redis.Redis.set', return_value=True)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -172,15 +172,15 @@ def test_redis_data_key_no_username(capfd, mocker):
def test_redis_delete_key_no_username(capfd, mocker): def test_redis_delete_key_no_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
mocker.patch('redis.Redis.delete', return_value=1) mocker.patch('redis.Redis.delete', return_value=1)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -189,15 +189,15 @@ def test_redis_delete_key_no_username(capfd, mocker):
def test_redis_delete_key_non_existent_key(capfd, mocker): def test_redis_delete_key_non_existent_key(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'absent', 'state': 'absent',
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
mocker.patch('redis.Redis.get', return_value=None) mocker.patch('redis.Redis.get', return_value=None)
mocker.patch('redis.Redis.delete', return_value=0) mocker.patch('redis.Redis.delete', return_value=0)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -206,15 +206,15 @@ def test_redis_delete_key_non_existent_key(capfd, mocker):
def test_redis_set_key_check_mode_nochange(capfd, mocker): def test_redis_set_key_check_mode_nochange(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'present', 'state': 'present',
'value': 'bar', 'value': 'bar',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -225,15 +225,15 @@ def test_redis_set_key_check_mode_nochange(capfd, mocker):
def test_redis_set_key_check_mode_delete_nx(capfd, mocker): def test_redis_set_key_check_mode_delete_nx(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'present', 'state': 'present',
'value': 'baz', 'value': 'baz',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
mocker.patch('redis.Redis.get', return_value=None) mocker.patch('redis.Redis.get', return_value=None)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -243,15 +243,15 @@ def test_redis_set_key_check_mode_delete_nx(capfd, mocker):
def test_redis_set_key_check_mode_delete(capfd, mocker): def test_redis_set_key_check_mode_delete(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'present', 'state': 'present',
'value': 'baz', 'value': 'baz',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -261,15 +261,15 @@ def test_redis_set_key_check_mode_delete(capfd, mocker):
def test_redis_set_key_check_mode(capfd, mocker): def test_redis_set_key_check_mode(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'state': 'present', 'state': 'present',
'value': 'baz', 'value': 'baz',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data.main() redis_data.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err

152
tests/unit/plugins/modules/test_redis_data_incr.py
View file

@ -25,9 +25,9 @@ if HAS_REDIS_USERNAME_OPTION:
def test_redis_data_incr_without_arguments(capfd): def test_redis_data_incr_without_arguments(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert json.loads(out)['failed'] assert json.loads(out)['failed']
@ -35,13 +35,13 @@ def test_redis_data_incr_without_arguments(capfd):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_incr(capfd, mocker): def test_redis_data_incr(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', }) 'key': 'foo', }):
mocker.patch('redis.Redis.incr', return_value=57) mocker.patch('redis.Redis.incr', return_value=57)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -53,14 +53,14 @@ def test_redis_data_incr(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_incr_int(capfd, mocker): def test_redis_data_incr_int(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'increment_int': 10}) 'increment_int': 10}):
mocker.patch('redis.Redis.incrby', return_value=57) mocker.patch('redis.Redis.incrby', return_value=57)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -72,14 +72,14 @@ def test_redis_data_incr_int(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_inc_float(capfd, mocker): def test_redis_data_inc_float(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'increment_float': '5.5'}) 'increment_float': '5.5'}):
mocker.patch('redis.Redis.incrbyfloat', return_value=57.45) mocker.patch('redis.Redis.incrbyfloat', return_value=57.45)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -91,13 +91,15 @@ def test_redis_data_inc_float(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_incr_float_wrong_value(capfd): def test_redis_data_incr_float_wrong_value(capfd):
set_module_args({'login_host': 'localhost', with set_module_args({
'login_user': 'root', 'login_host': 'localhost',
'login_password': 'secret', 'login_user': 'root',
'key': 'foo', 'login_password': 'secret',
'increment_float': 'not_a_number'}) 'key': 'foo',
with pytest.raises(SystemExit): 'increment_float': 'not_a_number'
redis_data_incr.main() }):
with pytest.raises(SystemExit):
redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -106,13 +108,13 @@ def test_redis_data_incr_float_wrong_value(capfd):
@pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0") @pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0")
def test_redis_data_incr_fail_username(capfd, mocker): def test_redis_data_incr_fail_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_user': 'root', 'login_user': 'root',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'_ansible_check_mode': False}) '_ansible_check_mode': False}):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -122,12 +124,12 @@ def test_redis_data_incr_fail_username(capfd, mocker):
def test_redis_data_incr_no_username(capfd, mocker): def test_redis_data_incr_no_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', }) 'key': 'foo', }):
mocker.patch('redis.Redis.incr', return_value=57) mocker.patch('redis.Redis.incr', return_value=57)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -138,13 +140,13 @@ def test_redis_data_incr_no_username(capfd, mocker):
def test_redis_data_incr_float_no_username(capfd, mocker): def test_redis_data_incr_float_no_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'increment_float': '5.5'}) 'increment_float': '5.5'}):
mocker.patch('redis.Redis.incrbyfloat', return_value=57.45) mocker.patch('redis.Redis.incrbyfloat', return_value=57.45)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -155,13 +157,13 @@ def test_redis_data_incr_float_no_username(capfd, mocker):
def test_redis_data_incr_check_mode(capfd, mocker): def test_redis_data_incr_check_mode(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
mocker.patch('redis.Redis.get', return_value=10) mocker.patch('redis.Redis.get', return_value=10)
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -171,13 +173,13 @@ def test_redis_data_incr_check_mode(capfd, mocker):
def test_redis_data_incr_check_mode_not_incrementable(capfd, mocker): def test_redis_data_incr_check_mode_not_incrementable(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
mocker.patch('redis.Redis.get', return_value='bar') mocker.patch('redis.Redis.get', return_value='bar')
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -190,14 +192,14 @@ def test_redis_data_incr_check_mode_not_incrementable(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_incr_check_mode_permissions(capfd, mocker): def test_redis_data_incr_check_mode_permissions(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({'login_host': 'localhost',
'login_password': 'secret', 'login_password': 'secret',
'key': 'foo', 'key': 'foo',
'_ansible_check_mode': True}) '_ansible_check_mode': True}):
redis.Redis.get = mocker.Mock(side_effect=NoPermissionError( redis.Redis.get = mocker.Mock(side_effect=NoPermissionError(
"this user has no permissions to run the 'get' command or its subcommand")) "this user has no permissions to run the 'get' command or its subcommand"))
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_incr.main() redis_data_incr.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err

90
tests/unit/plugins/modules/test_redis_data_info.py
View file

@ -23,9 +23,9 @@ if tuple(map(int, __version__.split('.'))) < (3, 4, 0):
def test_redis_data_info_without_arguments(capfd): def test_redis_data_info_without_arguments(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
redis_data_info.main() redis_data_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
assert json.loads(out)['failed'] assert json.loads(out)['failed']
@ -33,14 +33,16 @@ def test_redis_data_info_without_arguments(capfd):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_info_existing_key(capfd, mocker): def test_redis_data_info_existing_key(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({
'login_user': 'root', 'login_host': 'localhost',
'login_password': 'secret', 'login_user': 'root',
'key': 'foo', 'login_password': 'secret',
'_ansible_check_mode': False}) 'key': 'foo',
mocker.patch('redis.Redis.get', return_value='bar') '_ansible_check_mode': False
with pytest.raises(SystemExit): }):
redis_data_info.main() mocker.patch('redis.Redis.get', return_value='bar')
with pytest.raises(SystemExit):
redis_data_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -50,14 +52,16 @@ def test_redis_data_info_existing_key(capfd, mocker):
@pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0") @pytest.mark.skipif(not HAS_REDIS_USERNAME_OPTION, reason="Redis version < 3.4.0")
def test_redis_data_info_absent_key(capfd, mocker): def test_redis_data_info_absent_key(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({
'login_user': 'root', 'login_host': 'localhost',
'login_password': 'secret', 'login_user': 'root',
'key': 'foo', 'login_password': 'secret',
'_ansible_check_mode': False}) 'key': 'foo',
mocker.patch('redis.Redis.get', return_value=None) '_ansible_check_mode': False
with pytest.raises(SystemExit): }):
redis_data_info.main() mocker.patch('redis.Redis.get', return_value=None)
with pytest.raises(SystemExit):
redis_data_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -67,13 +71,15 @@ def test_redis_data_info_absent_key(capfd, mocker):
@pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0") @pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0")
def test_redis_data_fail_username(capfd, mocker): def test_redis_data_fail_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({
'login_user': 'root', 'login_host': 'localhost',
'login_password': 'secret', 'login_user': 'root',
'key': 'foo', 'login_password': 'secret',
'_ansible_check_mode': False}) 'key': 'foo',
with pytest.raises(SystemExit): '_ansible_check_mode': False
redis_data_info.main() }):
with pytest.raises(SystemExit):
redis_data_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -84,13 +90,15 @@ def test_redis_data_fail_username(capfd, mocker):
@pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0") @pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0")
def test_redis_data_info_absent_key_no_username(capfd, mocker): def test_redis_data_info_absent_key_no_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({
'login_password': 'secret', 'login_host': 'localhost',
'key': 'foo', 'login_password': 'secret',
'_ansible_check_mode': False}) 'key': 'foo',
mocker.patch('redis.Redis.get', return_value=None) '_ansible_check_mode': False
with pytest.raises(SystemExit): }):
redis_data_info.main() mocker.patch('redis.Redis.get', return_value=None)
with pytest.raises(SystemExit):
redis_data_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err
@ -100,13 +108,15 @@ def test_redis_data_info_absent_key_no_username(capfd, mocker):
@pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0") @pytest.mark.skipif(HAS_REDIS_USERNAME_OPTION, reason="Redis version > 3.4.0")
def test_redis_data_info_existing_key_no_username(capfd, mocker): def test_redis_data_info_existing_key_no_username(capfd, mocker):
set_module_args({'login_host': 'localhost', with set_module_args({
'login_password': 'secret', 'login_host': 'localhost',
'key': 'foo', 'login_password': 'secret',
'_ansible_check_mode': False}) 'key': 'foo',
mocker.patch('redis.Redis.get', return_value='bar') '_ansible_check_mode': False
with pytest.raises(SystemExit): }):
redis_data_info.main() mocker.patch('redis.Redis.get', return_value='bar')
with pytest.raises(SystemExit):
redis_data_info.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
print(out) print(out)
assert not err assert not err

20
tests/unit/plugins/modules/test_redis_info.py
View file

@ -47,8 +47,8 @@ class TestRedisInfoModule(ModuleTestCase):
"""Test without parameters""" """Test without parameters"""
with self.patch_redis_client(side_effect=FakeRedisClient) as redis_client: with self.patch_redis_client(side_effect=FakeRedisClient) as redis_client:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
self.assertEqual(redis_client.call_count, 1) self.assertEqual(redis_client.call_count, 1)
self.assertEqual(redis_client.call_args, ({'host': 'localhost', self.assertEqual(redis_client.call_args, ({'host': 'localhost',
'port': 6379, 'port': 6379,
@ -64,12 +64,12 @@ class TestRedisInfoModule(ModuleTestCase):
"""Test with all parameters""" """Test with all parameters"""
with self.patch_redis_client(side_effect=FakeRedisClient) as redis_client: with self.patch_redis_client(side_effect=FakeRedisClient) as redis_client:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({ with set_module_args({
'login_host': 'test', 'login_host': 'test',
'login_port': 1234, 'login_port': 1234,
'login_password': 'PASS' 'login_password': 'PASS'
}) }):
self.module.main() self.module.main()
self.assertEqual(redis_client.call_count, 1) self.assertEqual(redis_client.call_count, 1)
self.assertEqual(redis_client.call_args, ({'host': 'test', self.assertEqual(redis_client.call_args, ({'host': 'test',
'port': 1234, 'port': 1234,
@ -85,7 +85,7 @@ class TestRedisInfoModule(ModuleTestCase):
"""Test with tls parameters""" """Test with tls parameters"""
with self.patch_redis_client(side_effect=FakeRedisClient) as redis_client: with self.patch_redis_client(side_effect=FakeRedisClient) as redis_client:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({ with set_module_args({
'login_host': 'test', 'login_host': 'test',
'login_port': 1234, 'login_port': 1234,
'login_password': 'PASS', 'login_password': 'PASS',
@ -94,8 +94,8 @@ class TestRedisInfoModule(ModuleTestCase):
'client_cert_file': '/etc/ssl/client.pem', 'client_cert_file': '/etc/ssl/client.pem',
'client_key_file': '/etc/ssl/client.key', 'client_key_file': '/etc/ssl/client.key',
'validate_certs': False 'validate_certs': False
}) }):
self.module.main() self.module.main()
self.assertEqual(redis_client.call_count, 1) self.assertEqual(redis_client.call_count, 1)
self.assertEqual(redis_client.call_args, ({'host': 'test', self.assertEqual(redis_client.call_args, ({'host': 'test',
'port': 1234, 'port': 1234,
@ -111,7 +111,7 @@ class TestRedisInfoModule(ModuleTestCase):
"""Test failure message""" """Test failure message"""
with self.patch_redis_client(side_effect=FakeRedisClientFail) as redis_client: with self.patch_redis_client(side_effect=FakeRedisClientFail) as redis_client:
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
self.assertEqual(redis_client.call_count, 1) self.assertEqual(redis_client.call_count, 1)
self.assertEqual(result.exception.args[0]['msg'], 'unable to connect to database: Test Error') self.assertEqual(result.exception.args[0]['msg'], 'unable to connect to database: Test Error')

61
tests/unit/plugins/modules/test_rhsm_release.py
View file

@ -52,15 +52,15 @@ class RhsmRepositoryReleaseModuleTestCase(ModuleTestCase):
def test_release_set(self): def test_release_set(self):
# test that the module attempts to change the release when the current # test that the module attempts to change the release when the current
# release is not the same as the user-specific target release # release is not the same as the user-specific target release
set_module_args({'release': '7.5'}) with set_module_args({'release': '7.5'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
# first call, get_release: returns different version so set_release is called # first call, get_release: returns different version so set_release is called
(0, '7.4', ''), (0, '7.4', ''),
# second call, set_release: just needs to exit with 0 rc # second call, set_release: just needs to exit with 0 rc
(0, '', ''), (0, '', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.assertEqual('7.5', result['current_release']) self.assertEqual('7.5', result['current_release'])
@ -72,13 +72,13 @@ class RhsmRepositoryReleaseModuleTestCase(ModuleTestCase):
def test_release_set_idempotent(self): def test_release_set_idempotent(self):
# test that the module does not attempt to change the release when # test that the module does not attempt to change the release when
# the current release matches the user-specified target release # the current release matches the user-specified target release
set_module_args({'release': '7.5'}) with set_module_args({'release': '7.5'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
# first call, get_release: returns same version, set_release is not called # first call, get_release: returns same version, set_release is not called
(0, '7.5', ''), (0, '7.5', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
self.assertEqual('7.5', result['current_release']) self.assertEqual('7.5', result['current_release'])
@ -89,15 +89,15 @@ class RhsmRepositoryReleaseModuleTestCase(ModuleTestCase):
def test_release_unset(self): def test_release_unset(self):
# test that the module attempts to change the release when the current # test that the module attempts to change the release when the current
# release is not the same as the user-specific target release # release is not the same as the user-specific target release
set_module_args({'release': None}) with set_module_args({'release': None}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
# first call, get_release: returns version so set_release is called # first call, get_release: returns version so set_release is called
(0, '7.5', ''), (0, '7.5', ''),
# second call, set_release: just needs to exit with 0 rc # second call, set_release: just needs to exit with 0 rc
(0, '', ''), (0, '', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.assertIsNone(result['current_release']) self.assertIsNone(result['current_release'])
@ -109,13 +109,13 @@ class RhsmRepositoryReleaseModuleTestCase(ModuleTestCase):
def test_release_unset_idempotent(self): def test_release_unset_idempotent(self):
# test that the module attempts to change the release when the current # test that the module attempts to change the release when the current
# release is not the same as the user-specific target release # release is not the same as the user-specific target release
set_module_args({'release': None}) with set_module_args({'release': None}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
# first call, get_release: returns no version, set_release is not called # first call, get_release: returns no version, set_release is not called
(0, 'Release not set', ''), (0, 'Release not set', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
self.assertIsNone(result['current_release']) self.assertIsNone(result['current_release'])
@ -126,9 +126,8 @@ class RhsmRepositoryReleaseModuleTestCase(ModuleTestCase):
def test_release_insane(self): def test_release_insane(self):
# test that insane values for release trigger fail_json # test that insane values for release trigger fail_json
insane_value = 'this is an insane release value' insane_value = 'this is an insane release value'
set_module_args({'release': insane_value}) with set_module_args({'release': insane_value}):
result = self.module_main(AnsibleFailJson)
result = self.module_main(AnsibleFailJson)
# also ensure that the fail msg includes the insane value # also ensure that the fail msg includes the insane value
self.assertIn(insane_value, result['msg']) self.assertIn(insane_value, result['msg'])

50
tests/unit/plugins/modules/test_rpm_ostree_pkg.py
View file

@ -35,12 +35,12 @@ class RpmOSTreeModuleTestCase(ModuleTestCase):
return exc.exception.args[0] return exc.exception.args[0]
def test_present(self): def test_present(self):
set_module_args({'name': 'nfs-utils', 'state': 'present'}) with set_module_args({'name': 'nfs-utils', 'state': 'present'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '', ''), (0, '', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.assertEqual(['nfs-utils'], result['packages']) self.assertEqual(['nfs-utils'], result['packages'])
@ -49,12 +49,12 @@ class RpmOSTreeModuleTestCase(ModuleTestCase):
]) ])
def test_present_unchanged(self): def test_present_unchanged(self):
set_module_args({'name': 'nfs-utils', 'state': 'present'}) with set_module_args({'name': 'nfs-utils', 'state': 'present'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(77, '', ''), (77, '', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
self.assertEqual(0, result['rc']) self.assertEqual(0, result['rc'])
@ -64,12 +64,12 @@ class RpmOSTreeModuleTestCase(ModuleTestCase):
]) ])
def test_present_failed(self): def test_present_failed(self):
set_module_args({'name': 'nfs-utils', 'state': 'present'}) with set_module_args({'name': 'nfs-utils', 'state': 'present'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(1, '', ''), (1, '', ''),
] ]
result = self.module_main(AnsibleFailJson) result = self.module_main(AnsibleFailJson)
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
self.assertEqual(1, result['rc']) self.assertEqual(1, result['rc'])
@ -79,12 +79,12 @@ class RpmOSTreeModuleTestCase(ModuleTestCase):
]) ])
def test_absent(self): def test_absent(self):
set_module_args({'name': 'nfs-utils', 'state': 'absent'}) with set_module_args({'name': 'nfs-utils', 'state': 'absent'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(0, '', ''), (0, '', ''),
] ]
result = self.module_main(AnsibleExitJson) result = self.module_main(AnsibleExitJson)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])
self.assertEqual(['nfs-utils'], result['packages']) self.assertEqual(['nfs-utils'], result['packages'])
@ -93,12 +93,12 @@ class RpmOSTreeModuleTestCase(ModuleTestCase):
]) ])
def test_absent_failed(self): def test_absent_failed(self):
set_module_args({'name': 'nfs-utils', 'state': 'absent'}) with set_module_args({'name': 'nfs-utils', 'state': 'absent'}):
self.module_main_command.side_effect = [ self.module_main_command.side_effect = [
(1, '', ''), (1, '', ''),
] ]
result = self.module_main(AnsibleFailJson) result = self.module_main(AnsibleFailJson)
self.assertFalse(result['changed']) self.assertFalse(result['changed'])
self.assertEqual(1, result['rc']) self.assertEqual(1, result['rc'])

110
tests/unit/plugins/modules/test_scaleway_compute_private_network.py
View file

@ -62,9 +62,9 @@ def response_remove_nics():
def test_scaleway_private_network_without_arguments(capfd): def test_scaleway_private_network_without_arguments(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_compute_private_network.main() scaleway_compute_private_network.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
@ -77,21 +77,22 @@ def test_scaleway_add_nic(capfd):
cid = 'c004b4cd-ef5g-678h-90i1-jk2345678l90' cid = 'c004b4cd-ef5g-678h-90i1-jk2345678l90'
url = 'servers/' + cid + '/private_nics' url = 'servers/' + cid + '/private_nics'
set_module_args({"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", with set_module_args({
"state": "present", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"region": "par1", "state": "present",
"compute_id": cid, "region": "par1",
"private_network_id": pnid "compute_id": cid,
}) "private_network_id": pnid
}):
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_without_nics() mock_scw_get.return_value = response_without_nics()
with patch.object(Scaleway, 'post') as mock_scw_post: with patch.object(Scaleway, 'post') as mock_scw_post:
mock_scw_post.return_value = response_when_add_nics() mock_scw_post.return_value = response_when_add_nics()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_compute_private_network.main() scaleway_compute_private_network.main()
mock_scw_post.assert_any_call(path=url, data={"private_network_id": pnid}) mock_scw_post.assert_any_call(path=url, data={"private_network_id": pnid})
mock_scw_get.assert_any_call(url) mock_scw_get.assert_any_call(url)
out, err = capfd.readouterr() out, err = capfd.readouterr()
del os.environ['SCW_API_TOKEN'] del os.environ['SCW_API_TOKEN']
@ -105,18 +106,19 @@ def test_scaleway_add_existing_nic(capfd):
cid = 'c004b4cd-ef5g-678h-90i1-jk2345678l90' cid = 'c004b4cd-ef5g-678h-90i1-jk2345678l90'
url = 'servers/' + cid + '/private_nics' url = 'servers/' + cid + '/private_nics'
set_module_args({"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", with set_module_args({
"state": "present", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"region": "par1", "state": "present",
"compute_id": cid, "region": "par1",
"private_network_id": pnid "compute_id": cid,
}) "private_network_id": pnid
}):
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_nics() mock_scw_get.return_value = response_with_nics()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_compute_private_network.main() scaleway_compute_private_network.main()
mock_scw_get.assert_any_call(url) mock_scw_get.assert_any_call(url)
out, err = capfd.readouterr() out, err = capfd.readouterr()
del os.environ['SCW_API_TOKEN'] del os.environ['SCW_API_TOKEN']
@ -132,21 +134,22 @@ def test_scaleway_remove_existing_nic(capfd):
url = 'servers/' + cid + '/private_nics' url = 'servers/' + cid + '/private_nics'
urlremove = 'servers/' + cid + '/private_nics/' + nicid urlremove = 'servers/' + cid + '/private_nics/' + nicid
set_module_args({"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", with set_module_args({
"state": "absent", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"region": "par1", "state": "absent",
"compute_id": cid, "region": "par1",
"private_network_id": pnid "compute_id": cid,
}) "private_network_id": pnid
}):
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_nics() mock_scw_get.return_value = response_with_nics()
with patch.object(Scaleway, 'delete') as mock_scw_delete: with patch.object(Scaleway, 'delete') as mock_scw_delete:
mock_scw_delete.return_value = response_remove_nics() mock_scw_delete.return_value = response_remove_nics()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_compute_private_network.main() scaleway_compute_private_network.main()
mock_scw_delete.assert_any_call(urlremove) mock_scw_delete.assert_any_call(urlremove)
mock_scw_get.assert_any_call(url) mock_scw_get.assert_any_call(url)
out, err = capfd.readouterr() out, err = capfd.readouterr()
@ -161,18 +164,19 @@ def test_scaleway_remove_absent_nic(capfd):
cid = 'c004b4cd-ef5g-678h-90i1-jk2345678l90' cid = 'c004b4cd-ef5g-678h-90i1-jk2345678l90'
url = 'servers/' + cid + '/private_nics' url = 'servers/' + cid + '/private_nics'
set_module_args({"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", with set_module_args({
"state": "absent", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"region": "par1", "state": "absent",
"compute_id": cid, "region": "par1",
"private_network_id": pnid "compute_id": cid,
}) "private_network_id": pnid
}):
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_without_nics() mock_scw_get.return_value = response_without_nics()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_compute_private_network.main() scaleway_compute_private_network.main()
mock_scw_get.assert_any_call(url) mock_scw_get.assert_any_call(url)
out, err = capfd.readouterr() out, err = capfd.readouterr()
del os.environ['SCW_API_TOKEN'] del os.environ['SCW_API_TOKEN']

133
tests/unit/plugins/modules/test_scaleway_private_network.py
View file

@ -71,9 +71,9 @@ def response_delete():
def test_scaleway_private_network_without_arguments(capfd): def test_scaleway_private_network_without_arguments(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_private_network.main() scaleway_private_network.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err
@ -81,20 +81,21 @@ def test_scaleway_private_network_without_arguments(capfd):
def test_scaleway_create_pn(capfd): def test_scaleway_create_pn(capfd):
set_module_args({"state": "present", with set_module_args({
"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", "state": "present",
"region": "par2", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"name": "new_network_name", "region": "par2",
"tags": ["tag1"] "name": "new_network_name",
}) "tags": ["tag1"]
}):
os.environ['SCW_API_TOKEN'] = 'notrealtoken' os.environ['SCW_API_TOKEN'] = 'notrealtoken'
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_zero_network() mock_scw_get.return_value = response_with_zero_network()
with patch.object(Scaleway, 'post') as mock_scw_post: with patch.object(Scaleway, 'post') as mock_scw_post:
mock_scw_post.return_value = response_create_new() mock_scw_post.return_value = response_create_new()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_private_network.main() scaleway_private_network.main()
mock_scw_post.assert_any_call(path='private-networks/', data={'name': 'new_network_name', mock_scw_post.assert_any_call(path='private-networks/', data={'name': 'new_network_name',
'project_id': 'a123b4cd-ef5g-678h-90i1-jk2345678l90', 'project_id': 'a123b4cd-ef5g-678h-90i1-jk2345678l90',
'tags': ['tag1']}) 'tags': ['tag1']})
@ -105,18 +106,19 @@ def test_scaleway_create_pn(capfd):
def test_scaleway_existing_pn(capfd): def test_scaleway_existing_pn(capfd):
set_module_args({"state": "present", with set_module_args({
"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", "state": "present",
"region": "par2", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"name": "new_network_name", "region": "par2",
"tags": ["tag1"] "name": "new_network_name",
}) "tags": ["tag1"]
}):
os.environ['SCW_API_TOKEN'] = 'notrealtoken' os.environ['SCW_API_TOKEN'] = 'notrealtoken'
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_new_network() mock_scw_get.return_value = response_with_new_network()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_private_network.main() scaleway_private_network.main()
mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10}) mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10})
out, err = capfd.readouterr() out, err = capfd.readouterr()
@ -127,20 +129,21 @@ def test_scaleway_existing_pn(capfd):
def test_scaleway_add_tag_pn(capfd): def test_scaleway_add_tag_pn(capfd):
set_module_args({"state": "present", with set_module_args({
"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", "state": "present",
"region": "par2", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"name": "new_network_name", "region": "par2",
"tags": ["newtag"] "name": "new_network_name",
}) "tags": ["newtag"]
}):
os.environ['SCW_API_TOKEN'] = 'notrealtoken' os.environ['SCW_API_TOKEN'] = 'notrealtoken'
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_new_network() mock_scw_get.return_value = response_with_new_network()
with patch.object(Scaleway, 'patch') as mock_scw_patch: with patch.object(Scaleway, 'patch') as mock_scw_patch:
mock_scw_patch.return_value = response_create_new_newtag() mock_scw_patch.return_value = response_create_new_newtag()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_private_network.main() scaleway_private_network.main()
mock_scw_patch.assert_any_call(path='private-networks/c123b4cd-ef5g-678h-90i1-jk2345678l90', data={'name': 'new_network_name', 'tags': ['newtag']}) mock_scw_patch.assert_any_call(path='private-networks/c123b4cd-ef5g-678h-90i1-jk2345678l90', data={'name': 'new_network_name', 'tags': ['newtag']})
mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10}) mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10})
@ -152,20 +155,21 @@ def test_scaleway_add_tag_pn(capfd):
def test_scaleway_remove_pn(capfd): def test_scaleway_remove_pn(capfd):
set_module_args({"state": "absent", with set_module_args({
"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", "state": "absent",
"region": "par2", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"name": "new_network_name", "region": "par2",
"tags": ["newtag"] "name": "new_network_name",
}) "tags": ["newtag"]
}):
os.environ['SCW_API_TOKEN'] = 'notrealtoken' os.environ['SCW_API_TOKEN'] = 'notrealtoken'
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_new_network() mock_scw_get.return_value = response_with_new_network()
with patch.object(Scaleway, 'delete') as mock_scw_delete: with patch.object(Scaleway, 'delete') as mock_scw_delete:
mock_scw_delete.return_value = response_delete() mock_scw_delete.return_value = response_delete()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_private_network.main() scaleway_private_network.main()
mock_scw_delete.assert_any_call('private-networks/c123b4cd-ef5g-678h-90i1-jk2345678l90') mock_scw_delete.assert_any_call('private-networks/c123b4cd-ef5g-678h-90i1-jk2345678l90')
mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10}) mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10})
@ -177,18 +181,19 @@ def test_scaleway_remove_pn(capfd):
def test_scaleway_absent_pn_not_exists(capfd): def test_scaleway_absent_pn_not_exists(capfd):
set_module_args({"state": "absent", with set_module_args({
"project": "a123b4cd-ef5g-678h-90i1-jk2345678l90", "state": "absent",
"region": "par2", "project": "a123b4cd-ef5g-678h-90i1-jk2345678l90",
"name": "new_network_name", "region": "par2",
"tags": ["newtag"] "name": "new_network_name",
}) "tags": ["newtag"]
}):
os.environ['SCW_API_TOKEN'] = 'notrealtoken' os.environ['SCW_API_TOKEN'] = 'notrealtoken'
with patch.object(Scaleway, 'get') as mock_scw_get: with patch.object(Scaleway, 'get') as mock_scw_get:
mock_scw_get.return_value = response_with_zero_network() mock_scw_get.return_value = response_with_zero_network()
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
scaleway_private_network.main() scaleway_private_network.main()
mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10}) mock_scw_get.assert_any_call('private-networks', params={'name': 'new_network_name', 'order_by': 'name_asc', 'page': 1, 'page_size': 10})
out, err = capfd.readouterr() out, err = capfd.readouterr()

96
tests/unit/plugins/modules/test_simpleinit_msb.py
View file

@ -91,110 +91,112 @@ class TestSimpleinitMSB(ModuleTestCase):
def tearDown(self): def tearDown(self):
super(TestSimpleinitMSB, self).tearDown() super(TestSimpleinitMSB, self).tearDown()
def init_module(self, args):
set_module_args(args)
return SimpleinitMSB(build_module())
@patch('os.path.exists', return_value=True) @patch('os.path.exists', return_value=True)
@patch('ansible.module_utils.basic.AnsibleModule.get_bin_path', return_value="/sbin/telinit") @patch('ansible.module_utils.basic.AnsibleModule.get_bin_path', return_value="/sbin/telinit")
def test_get_service_tools(self, *args, **kwargs): def test_get_service_tools(self, *args, **kwargs):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'smgl-suspend-single', 'name': 'smgl-suspend-single',
'state': 'running', 'state': 'running',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
simpleinit_msb.get_service_tools() simpleinit_msb.get_service_tools()
self.assertEqual(simpleinit_msb.telinit_cmd, "/sbin/telinit") self.assertEqual(simpleinit_msb.telinit_cmd, "/sbin/telinit")
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command')
def test_service_exists(self, execute_command): def test_service_exists(self, execute_command):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'smgl-suspend-single', 'name': 'smgl-suspend-single',
'state': 'running', 'state': 'running',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
execute_command.return_value = (0, _TELINIT_LIST, "") execute_command.return_value = (0, _TELINIT_LIST, "")
simpleinit_msb.service_exists() simpleinit_msb.service_exists()
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command')
def test_service_exists_not(self, execute_command): def test_service_exists_not(self, execute_command):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'ntp', 'name': 'ntp',
'state': 'running', 'state': 'running',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
execute_command.return_value = (0, _TELINIT_LIST, "") execute_command.return_value = (0, _TELINIT_LIST, "")
with self.assertRaises(AnsibleFailJson) as context: with self.assertRaises(AnsibleFailJson) as context:
simpleinit_msb.service_exists() simpleinit_msb.service_exists()
self.assertEqual("telinit could not find the requested service: ntp", context.exception.args[0]["msg"]) self.assertEqual("telinit could not find the requested service: ntp", context.exception.args[0]["msg"])
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_exists') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_exists')
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command')
def test_check_service_enabled(self, execute_command, service_exists): def test_check_service_enabled(self, execute_command, service_exists):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'nscd', 'name': 'nscd',
'state': 'running', 'state': 'running',
'enabled': 'true', 'enabled': 'true',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
service_exists.return_value = True service_exists.return_value = True
execute_command.return_value = (0, _TELINIT_LIST_ENABLED, "") execute_command.return_value = (0, _TELINIT_LIST_ENABLED, "")
self.assertTrue(simpleinit_msb.service_enabled()) self.assertTrue(simpleinit_msb.service_enabled())
# Race condition check # Race condition check
with patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_enabled', return_value=False): with patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_enabled', return_value=False):
execute_command.return_value = (0, "", _TELINIT_ALREADY_ENABLED) execute_command.return_value = (0, "", _TELINIT_ALREADY_ENABLED)
simpleinit_msb.service_enable() simpleinit_msb.service_enable()
self.assertFalse(simpleinit_msb.changed) self.assertFalse(simpleinit_msb.changed)
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_exists') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_exists')
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.execute_command')
def test_check_service_disabled(self, execute_command, service_exists): def test_check_service_disabled(self, execute_command, service_exists):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'sysstat', 'name': 'sysstat',
'state': 'stopped', 'state': 'stopped',
'enabled': 'false', 'enabled': 'false',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
service_exists.return_value = True service_exists.return_value = True
execute_command.return_value = (0, _TELINIT_LIST_DISABLED, "") execute_command.return_value = (0, _TELINIT_LIST_DISABLED, "")
self.assertFalse(simpleinit_msb.service_enabled()) self.assertFalse(simpleinit_msb.service_enabled())
# Race condition check # Race condition check
with patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_enabled', return_value=True): with patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_enabled', return_value=True):
execute_command.return_value = (0, "", _TELINIT_ALREADY_DISABLED) execute_command.return_value = (0, "", _TELINIT_ALREADY_DISABLED)
simpleinit_msb.service_enable() simpleinit_msb.service_enable()
self.assertFalse(simpleinit_msb.changed) self.assertFalse(simpleinit_msb.changed)
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_control') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_control')
def test_check_service_running(self, service_control): def test_check_service_running(self, service_control):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'sshd', 'name': 'sshd',
'state': 'running', 'state': 'running',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
service_control.return_value = (0, _TELINIT_STATUS_RUNNING, "") service_control.return_value = (0, _TELINIT_STATUS_RUNNING, "")
self.assertFalse(simpleinit_msb.get_service_status()) self.assertFalse(simpleinit_msb.get_service_status())
@patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_control') @patch('ansible_collections.community.general.plugins.modules.simpleinit_msb.SimpleinitMSB.service_control')
def test_check_service_running_not(self, service_control): def test_check_service_running_not(self, service_control):
simpleinit_msb = self.init_module({ with set_module_args({
'name': 'smgl-metalog', 'name': 'smgl-metalog',
'state': 'running', 'state': 'running',
}) }):
simpleinit_msb = SimpleinitMSB(build_module())
service_control.return_value = (0, _TELINIT_STATUS_RUNNING_NOT, "") service_control.return_value = (0, _TELINIT_STATUS_RUNNING_NOT, "")
self.assertFalse(simpleinit_msb.get_service_status()) self.assertFalse(simpleinit_msb.get_service_status())

156
tests/unit/plugins/modules/test_slack.py
View file

@ -28,110 +28,105 @@ class TestSlackModule(ModuleTestCase):
def test_without_required_parameters(self): def test_without_required_parameters(self):
"""Failure must occurs when all parameters are missing""" """Failure must occurs when all parameters are missing"""
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_invalid_old_token(self): def test_invalid_old_token(self):
"""Failure if there is an old style token""" """Failure if there is an old style token"""
set_module_args({ with set_module_args({
'token': 'test', 'token': 'test',
}) }):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
self.module.main() self.module.main()
def test_successful_message(self): def test_successful_message(self):
"""tests sending a message. This is example 1 from the docs""" """tests sending a message. This is example 1 from the docs"""
set_module_args({ with set_module_args({
'token': 'XXXX/YYYY/ZZZZ', 'token': 'XXXX/YYYY/ZZZZ',
'msg': 'test' 'msg': 'test'
}) }):
with patch.object(slack, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(slack, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 1)
fetch_url_mock.return_value = (None, {"status": 200}) call_data = json.loads(fetch_url_mock.call_args[1]['data'])
with self.assertRaises(AnsibleExitJson): assert call_data['username'] == "Ansible"
self.module.main() assert call_data['text'] == "test"
assert fetch_url_mock.call_args[1]['url'] == "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
self.assertTrue(fetch_url_mock.call_count, 1)
call_data = json.loads(fetch_url_mock.call_args[1]['data'])
assert call_data['username'] == "Ansible"
assert call_data['text'] == "test"
assert fetch_url_mock.call_args[1]['url'] == "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
def test_failed_message(self): def test_failed_message(self):
"""tests failing to send a message""" """tests failing to send a message"""
set_module_args({ with set_module_args({
'token': 'XXXX/YYYY/ZZZZ', 'token': 'XXXX/YYYY/ZZZZ',
'msg': 'test' 'msg': 'test'
}) }):
with patch.object(slack, "fetch_url") as fetch_url_mock:
with patch.object(slack, "fetch_url") as fetch_url_mock: fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'test'})
fetch_url_mock.return_value = (None, {"status": 404, 'msg': 'test'}) with self.assertRaises(AnsibleFailJson):
with self.assertRaises(AnsibleFailJson): self.module.main()
self.module.main()
def test_message_with_thread(self): def test_message_with_thread(self):
"""tests sending a message with a thread""" """tests sending a message with a thread"""
set_module_args({ with set_module_args({
'token': 'XXXX/YYYY/ZZZZ', 'token': 'XXXX/YYYY/ZZZZ',
'msg': 'test', 'msg': 'test',
'thread_id': '100.00' 'thread_id': '100.00'
}) }):
with patch.object(slack, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(slack, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 1)
fetch_url_mock.return_value = (None, {"status": 200}) call_data = json.loads(fetch_url_mock.call_args[1]['data'])
with self.assertRaises(AnsibleExitJson): assert call_data['username'] == "Ansible"
self.module.main() assert call_data['text'] == "test"
assert call_data['thread_ts'] == '100.00'
self.assertTrue(fetch_url_mock.call_count, 1) assert fetch_url_mock.call_args[1]['url'] == "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
call_data = json.loads(fetch_url_mock.call_args[1]['data'])
assert call_data['username'] == "Ansible"
assert call_data['text'] == "test"
assert call_data['thread_ts'] == '100.00'
assert fetch_url_mock.call_args[1]['url'] == "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
# https://github.com/ansible-collections/community.general/issues/1097 # https://github.com/ansible-collections/community.general/issues/1097
def test_ts_in_message_does_not_cause_edit(self): def test_ts_in_message_does_not_cause_edit(self):
set_module_args({ with set_module_args({
'token': 'xoxa-123456789abcdef', 'token': 'xoxa-123456789abcdef',
'msg': 'test with ts' 'msg': 'test with ts'
}) }):
with patch.object(slack, "fetch_url") as fetch_url_mock:
mock_response = Mock()
mock_response.read.return_value = '{"fake":"data"}'
fetch_url_mock.return_value = (mock_response, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(slack, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 1)
mock_response = Mock() self.assertEqual(fetch_url_mock.call_args[1]['url'], "https://slack.com/api/chat.postMessage")
mock_response.read.return_value = '{"fake":"data"}'
fetch_url_mock.return_value = (mock_response, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
self.assertTrue(fetch_url_mock.call_count, 1)
self.assertEqual(fetch_url_mock.call_args[1]['url'], "https://slack.com/api/chat.postMessage")
def test_edit_message(self): def test_edit_message(self):
set_module_args({ with set_module_args({
'token': 'xoxa-123456789abcdef', 'token': 'xoxa-123456789abcdef',
'msg': 'test2', 'msg': 'test2',
'message_id': '12345' 'message_id': '12345'
}) }):
with patch.object(slack, "fetch_url") as fetch_url_mock:
mock_response = Mock()
mock_response.read.return_value = '{"messages":[{"ts":"12345","msg":"test1"}]}'
fetch_url_mock.side_effect = [
(mock_response, {"status": 200}),
(mock_response, {"status": 200}),
]
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(slack, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 2)
mock_response = Mock() self.assertEqual(fetch_url_mock.call_args[1]['url'], "https://slack.com/api/chat.update")
mock_response.read.return_value = '{"messages":[{"ts":"12345","msg":"test1"}]}' call_data = json.loads(fetch_url_mock.call_args[1]['data'])
fetch_url_mock.side_effect = [ self.assertEqual(call_data['ts'], "12345")
(mock_response, {"status": 200}),
(mock_response, {"status": 200}),
]
with self.assertRaises(AnsibleExitJson):
self.module.main()
self.assertTrue(fetch_url_mock.call_count, 2)
self.assertEqual(fetch_url_mock.call_args[1]['url'], "https://slack.com/api/chat.update")
call_data = json.loads(fetch_url_mock.call_args[1]['data'])
self.assertEqual(call_data['ts'], "12345")
def test_message_with_blocks(self): def test_message_with_blocks(self):
"""tests sending a message with blocks""" """tests sending a message with blocks"""
set_module_args({ with set_module_args({
'token': 'XXXX/YYYY/ZZZZ', 'token': 'XXXX/YYYY/ZZZZ',
'msg': 'test', 'msg': 'test',
'blocks': [{ 'blocks': [{
@ -153,28 +148,27 @@ class TestSlackModule(ModuleTestCase):
'emoji': True 'emoji': True
} }
}] }]
}) }):
with patch.object(slack, "fetch_url") as fetch_url_mock:
fetch_url_mock.return_value = (None, {"status": 200})
with self.assertRaises(AnsibleExitJson):
self.module.main()
with patch.object(slack, "fetch_url") as fetch_url_mock: self.assertTrue(fetch_url_mock.call_count, 1)
fetch_url_mock.return_value = (None, {"status": 200}) call_data = json.loads(fetch_url_mock.call_args[1]['data'])
with self.assertRaises(AnsibleExitJson): assert call_data['username'] == "Ansible"
self.module.main() assert call_data['blocks'][1]['text']['text'] == "test"
assert fetch_url_mock.call_args[1]['url'] == "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
self.assertTrue(fetch_url_mock.call_count, 1)
call_data = json.loads(fetch_url_mock.call_args[1]['data'])
assert call_data['username'] == "Ansible"
assert call_data['blocks'][1]['text']['text'] == "test"
assert fetch_url_mock.call_args[1]['url'] == "https://hooks.slack.com/services/XXXX/YYYY/ZZZZ"
def test_message_with_invalid_color(self): def test_message_with_invalid_color(self):
"""tests sending invalid color value to module""" """tests sending invalid color value to module"""
set_module_args({ with set_module_args({
'token': 'XXXX/YYYY/ZZZZ', 'token': 'XXXX/YYYY/ZZZZ',
'msg': 'test', 'msg': 'test',
'color': 'aa', 'color': 'aa',
}) }):
with self.assertRaises(AnsibleFailJson) as exec_info: with self.assertRaises(AnsibleFailJson) as exec_info:
self.module.main() self.module.main()
msg = "Color value specified should be either one of" \ msg = "Color value specified should be either one of" \
" ['normal', 'good', 'warning', 'danger'] or any valid" \ " ['normal', 'good', 'warning', 'danger'] or any valid" \

24
tests/unit/plugins/modules/test_solaris_zone.py
View file

@ -54,16 +54,16 @@ def test_zone_create(mocked_zone_create, capfd):
""" """
test zone creation test zone creation
""" """
set_module_args( with set_module_args(
{ {
"name": "z1", "name": "z1",
"state": "installed", "state": "installed",
"path": "/zones/z1", "path": "/zones/z1",
"_ansible_check_mode": False, "_ansible_check_mode": False,
} }
) ):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
solaris_zone.main() solaris_zone.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -75,16 +75,16 @@ def test_zone_delete(mocked_zone_delete, capfd):
""" """
test zone deletion test zone deletion
""" """
set_module_args( with set_module_args(
{ {
"name": "z1", "name": "z1",
"state": "absent", "state": "absent",
"path": "/zones/z1", "path": "/zones/z1",
"_ansible_check_mode": False, "_ansible_check_mode": False,
} }
) ):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
solaris_zone.main() solaris_zone.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)
@ -100,16 +100,16 @@ def test_zone_create_invalid_names(mocked_zone_create, capfd):
# 2. Zone name > 64 characters. # 2. Zone name > 64 characters.
# 3. Zone name beginning with non-alphanumeric character. # 3. Zone name beginning with non-alphanumeric character.
for invalid_name in ('foo!bar', 'z' * 65, '_zone'): for invalid_name in ('foo!bar', 'z' * 65, '_zone'):
set_module_args( with set_module_args(
{ {
"name": invalid_name, "name": invalid_name,
"state": "installed", "state": "installed",
"path": "/zones/" + invalid_name, "path": "/zones/" + invalid_name,
"_ansible_check_mode": False, "_ansible_check_mode": False,
} }
) ):
with pytest.raises(SystemExit): with pytest.raises(SystemExit):
solaris_zone.main() solaris_zone.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
results = json.loads(out) results = json.loads(out)

32
tests/unit/plugins/modules/test_statsd.py
View file

@ -42,36 +42,36 @@ class TestStatsDModule(ModuleTestCase):
"""Test udp without parameters""" """Test udp without parameters"""
with self.patch_udp_statsd_client(side_effect=FakeStatsD) as fake_statsd: with self.patch_udp_statsd_client(side_effect=FakeStatsD) as fake_statsd:
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_tcp_without_parameters(self): def test_tcp_without_parameters(self):
"""Test tcp without parameters""" """Test tcp without parameters"""
with self.patch_tcp_statsd_client(side_effect=FakeStatsD) as fake_statsd: with self.patch_tcp_statsd_client(side_effect=FakeStatsD) as fake_statsd:
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
set_module_args({}) with set_module_args({}):
self.module.main() self.module.main()
def test_udp_with_parameters(self): def test_udp_with_parameters(self):
"""Test udp with parameters""" """Test udp with parameters"""
with self.patch_udp_statsd_client(side_effect=FakeStatsD) as fake_statsd: with self.patch_udp_statsd_client(side_effect=FakeStatsD) as fake_statsd:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({ with set_module_args({
'metric': 'my_counter', 'metric': 'my_counter',
'metric_type': 'counter', 'metric_type': 'counter',
'value': 1, 'value': 1,
}) }):
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], 'Sent counter my_counter -> 1 to StatsD') self.assertEqual(result.exception.args[0]['msg'], 'Sent counter my_counter -> 1 to StatsD')
self.assertEqual(result.exception.args[0]['changed'], True) self.assertEqual(result.exception.args[0]['changed'], True)
with self.patch_udp_statsd_client(side_effect=FakeStatsD) as fake_statsd: with self.patch_udp_statsd_client(side_effect=FakeStatsD) as fake_statsd:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({ with set_module_args({
'metric': 'my_gauge', 'metric': 'my_gauge',
'metric_type': 'gauge', 'metric_type': 'gauge',
'value': 3, 'value': 3,
}) }):
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], 'Sent gauge my_gauge -> 3 (delta=False) to StatsD') self.assertEqual(result.exception.args[0]['msg'], 'Sent gauge my_gauge -> 3 (delta=False) to StatsD')
self.assertEqual(result.exception.args[0]['changed'], True) self.assertEqual(result.exception.args[0]['changed'], True)
@ -79,23 +79,23 @@ class TestStatsDModule(ModuleTestCase):
"""Test tcp with parameters""" """Test tcp with parameters"""
with self.patch_tcp_statsd_client(side_effect=FakeStatsD) as fake_statsd: with self.patch_tcp_statsd_client(side_effect=FakeStatsD) as fake_statsd:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({ with set_module_args({
'protocol': 'tcp', 'protocol': 'tcp',
'metric': 'my_counter', 'metric': 'my_counter',
'metric_type': 'counter', 'metric_type': 'counter',
'value': 1, 'value': 1,
}) }):
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], 'Sent counter my_counter -> 1 to StatsD') self.assertEqual(result.exception.args[0]['msg'], 'Sent counter my_counter -> 1 to StatsD')
self.assertEqual(result.exception.args[0]['changed'], True) self.assertEqual(result.exception.args[0]['changed'], True)
with self.patch_tcp_statsd_client(side_effect=FakeStatsD) as fake_statsd: with self.patch_tcp_statsd_client(side_effect=FakeStatsD) as fake_statsd:
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({ with set_module_args({
'protocol': 'tcp', 'protocol': 'tcp',
'metric': 'my_gauge', 'metric': 'my_gauge',
'metric_type': 'gauge', 'metric_type': 'gauge',
'value': 3, 'value': 3,
}) }):
self.module.main() self.module.main()
self.assertEqual(result.exception.args[0]['msg'], 'Sent gauge my_gauge -> 3 (delta=False) to StatsD') self.assertEqual(result.exception.args[0]['msg'], 'Sent gauge my_gauge -> 3 (delta=False) to StatsD')
self.assertEqual(result.exception.args[0]['changed'], True) self.assertEqual(result.exception.args[0]['changed'], True)

26
tests/unit/plugins/modules/test_sysupgrade.py
View file

@ -7,7 +7,7 @@ __metaclass__ = type
from ansible.module_utils import basic from ansible.module_utils import basic
from ansible_collections.community.general.tests.unit.compat.mock import patch from ansible_collections.community.general.tests.unit.compat.mock import patch
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, ModuleTestCase from ansible_collections.community.general.tests.unit.plugins.modules.utils import set_module_args, AnsibleExitJson, AnsibleFailJson, ModuleTestCase
from ansible_collections.community.general.plugins.modules import sysupgrade from ansible_collections.community.general.plugins.modules import sysupgrade
@ -48,11 +48,12 @@ class TestSysupgradeModule(ModuleTestCase):
""" """
stderr = "" stderr = ""
with patch.object(basic.AnsibleModule, "run_command") as run_command: with set_module_args({}):
run_command.return_value = (rc, stdout, stderr) with patch.object(basic.AnsibleModule, "run_command") as run_command:
with self.assertRaises(AnsibleExitJson) as result: run_command.return_value = (rc, stdout, stderr)
self.module.main() with self.assertRaises(AnsibleExitJson) as result:
self.assertTrue(result.exception.args[0]['changed']) self.module.main()
self.assertTrue(result.exception.args[0]['changed'])
def test_upgrade_failed(self): def test_upgrade_failed(self):
""" Upgrade failed """ """ Upgrade failed """
@ -61,9 +62,10 @@ class TestSysupgradeModule(ModuleTestCase):
stdout = "" stdout = ""
stderr = "sysupgrade: need root privileges" stderr = "sysupgrade: need root privileges"
with patch.object(basic.AnsibleModule, "run_command") as run_command_mock: with set_module_args({}):
run_command_mock.return_value = (rc, stdout, stderr) with patch.object(basic.AnsibleModule, "run_command") as run_command_mock:
with self.assertRaises(AnsibleFailJson) as result: run_command_mock.return_value = (rc, stdout, stderr)
self.module.main() with self.assertRaises(AnsibleFailJson) as result:
self.assertTrue(result.exception.args[0]['failed']) self.module.main()
self.assertIn('need root', result.exception.args[0]['msg']) self.assertTrue(result.exception.args[0]['failed'])
self.assertIn('need root', result.exception.args[0]['msg'])

6
tests/unit/plugins/modules/test_terraform.py
View file

@ -13,9 +13,9 @@ from ansible_collections.community.general.tests.unit.plugins.modules.utils impo
def test_terraform_without_argument(capfd): def test_terraform_without_argument(capfd):
set_module_args({}) with set_module_args({}):
with pytest.raises(SystemExit) as results: with pytest.raises(SystemExit) as results:
terraform.main() terraform.main()
out, err = capfd.readouterr() out, err = capfd.readouterr()
assert not err assert not err

204
tests/unit/plugins/modules/test_ufw.py
View file

@ -7,10 +7,8 @@ __metaclass__ = type
from ansible_collections.community.general.tests.unit.compat import unittest from ansible_collections.community.general.tests.unit.compat import unittest
from ansible_collections.community.general.tests.unit.compat.mock import patch from ansible_collections.community.general.tests.unit.compat.mock import patch
from ansible.module_utils import basic from ansible.module_utils import basic
from ansible.module_utils.common.text.converters import to_bytes
import ansible_collections.community.general.plugins.modules.ufw as module import ansible_collections.community.general.plugins.modules.ufw as module
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, AnsibleFailJson, set_module_args, exit_json, fail_json
import json
# mock ufw messages # mock ufw messages
@ -104,35 +102,6 @@ def do_nothing_func_port_7000(*args, **kwarg):
return 0, dry_mode_cmd_with_port_700[args[0]], "" return 0, dry_mode_cmd_with_port_700[args[0]], ""
def set_module_args(args):
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
"""prepare arguments so that they will be picked up during module creation"""
basic._ANSIBLE_ARGS = to_bytes(args)
class AnsibleExitJson(Exception):
"""Exception class to be raised by module.exit_json and caught by the test case"""
pass
class AnsibleFailJson(Exception):
"""Exception class to be raised by module.fail_json and caught by the test case"""
pass
def exit_json(*args, **kwargs):
"""function to patch over exit_json; package return data into an exception"""
if 'changed' not in kwargs:
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
def fail_json(*args, **kwargs):
"""function to patch over fail_json; package return data into an exception"""
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
def get_bin_path(self, arg, required=False): def get_bin_path(self, arg, required=False):
"""Mock AnsibleModule.get_bin_path""" """Mock AnsibleModule.get_bin_path"""
return arg return arg
@ -171,28 +140,28 @@ class TestUFW(unittest.TestCase):
self.assertTrue(reg.match("::") is not None) self.assertTrue(reg.match("::") is not None)
def test_check_mode_add_rules(self): def test_check_mode_add_rules(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7000', 'port': '7000',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertFalse(result.exception.args[0]['changed']) self.assertFalse(result.exception.args[0]['changed'])
def test_check_mode_add_insert_rules(self): def test_check_mode_add_insert_rules(self):
set_module_args({ with set_module_args({
'insert': '1', 'insert': '1',
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7000', 'port': '7000',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertFalse(result.exception.args[0]['changed']) self.assertFalse(result.exception.args[0]['changed'])
def test_check_mode_add_detailed_route(self): def test_check_mode_add_detailed_route(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'route': 'yes', 'route': 'yes',
'interface_in': 'foo', 'interface_in': 'foo',
@ -203,13 +172,12 @@ class TestUFW(unittest.TestCase):
'from_port': '7000', 'from_port': '7000',
'to_port': '7001', 'to_port': '7001',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000)
result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_add_ambiguous_route(self): def test_check_mode_add_ambiguous_route(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'route': 'yes', 'route': 'yes',
'interface_in': 'foo', 'interface_in': 'foo',
@ -217,68 +185,66 @@ class TestUFW(unittest.TestCase):
'direction': 'in', 'direction': 'in',
'interface': 'baz', 'interface': 'baz',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
with self.assertRaises(AnsibleFailJson) as result:
with self.assertRaises(AnsibleFailJson) as result: self.__getResult(do_nothing_func_port_7000)
self.__getResult(do_nothing_func_port_7000)
exc = result.exception.args[0] exc = result.exception.args[0]
self.assertTrue(exc['failed']) self.assertTrue(exc['failed'])
self.assertIn('mutually exclusive', exc['msg']) self.assertIn('mutually exclusive', exc['msg'])
def test_check_mode_add_interface_in(self): def test_check_mode_add_interface_in(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7003', 'port': '7003',
'interface_in': 'foo', 'interface_in': 'foo',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_add_interface_out(self): def test_check_mode_add_interface_out(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7004', 'port': '7004',
'interface_out': 'foo', 'interface_out': 'foo',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_add_non_route_interface_both(self): def test_check_mode_add_non_route_interface_both(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7004', 'port': '7004',
'interface_in': 'foo', 'interface_in': 'foo',
'interface_out': 'bar', 'interface_out': 'bar',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
with self.assertRaises(AnsibleFailJson) as result:
with self.assertRaises(AnsibleFailJson) as result: self.__getResult(do_nothing_func_port_7000)
self.__getResult(do_nothing_func_port_7000)
exc = result.exception.args[0] exc = result.exception.args[0]
self.assertTrue(exc['failed']) self.assertTrue(exc['failed'])
self.assertIn('combine', exc['msg']) self.assertIn('combine', exc['msg'])
def test_check_mode_add_direction_in(self): def test_check_mode_add_direction_in(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7003', 'port': '7003',
'direction': 'in', 'direction': 'in',
'interface': 'foo', 'interface': 'foo',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_add_direction_in_with_ip(self): def test_check_mode_add_direction_in_with_ip(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'from_ip': '1.1.1.1', 'from_ip': '1.1.1.1',
@ -288,24 +254,24 @@ class TestUFW(unittest.TestCase):
'direction': 'in', 'direction': 'in',
'interface': 'foo', 'interface': 'foo',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_add_direction_out(self): def test_check_mode_add_direction_out(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7004', 'port': '7004',
'direction': 'out', 'direction': 'out',
'interface': 'foo', 'interface': 'foo',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_add_direction_out_with_ip(self): def test_check_mode_add_direction_out_with_ip(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'from_ip': '1.1.1.1', 'from_ip': '1.1.1.1',
@ -315,157 +281,149 @@ class TestUFW(unittest.TestCase):
'direction': 'out', 'direction': 'out',
'interface': 'foo', 'interface': 'foo',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
result = self.__getResult(do_nothing_func_port_7000) result = self.__getResult(do_nothing_func_port_7000)
self.assertTrue(result.exception.args[0]['changed']) self.assertTrue(result.exception.args[0]['changed'])
def test_check_mode_delete_existing_rules(self): def test_check_mode_delete_existing_rules(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7000', 'port': '7000',
'delete': 'yes', 'delete': 'yes',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_check_mode_delete_existing_insert_rules(self): def test_check_mode_delete_existing_insert_rules(self):
set_module_args({ with set_module_args({
'insert': '1', 'insert': '1',
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7000', 'port': '7000',
'delete': 'yes', 'delete': 'yes',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_check_mode_delete_not_existing_rules(self): def test_check_mode_delete_not_existing_rules(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7001', 'port': '7001',
'delete': 'yes', 'delete': 'yes',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_check_mode_delete_not_existing_insert_rules(self): def test_check_mode_delete_not_existing_insert_rules(self):
set_module_args({ with set_module_args({
'insert': '1', 'insert': '1',
'rule': 'allow', 'rule': 'allow',
'proto': 'tcp', 'proto': 'tcp',
'port': '7001', 'port': '7001',
'delete': 'yes', 'delete': 'yes',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_enable_mode(self): def test_enable_mode(self):
set_module_args({ with set_module_args({
'state': 'enabled', 'state': 'enabled',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_disable_mode(self): def test_disable_mode(self):
set_module_args({ with set_module_args({
'state': 'disabled', 'state': 'disabled',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_logging_off(self): def test_logging_off(self):
set_module_args({ with set_module_args({
'logging': 'off', 'logging': 'off',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_logging_on(self): def test_logging_on(self):
set_module_args({ with set_module_args({
'logging': 'on', 'logging': 'on',
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_default_changed(self): def test_default_changed(self):
set_module_args({ with set_module_args({
'default': 'allow', 'default': 'allow',
"direction": "incoming", "direction": "incoming",
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed']) self.assertTrue(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_default_not_changed(self): def test_default_not_changed(self):
set_module_args({ with set_module_args({
'default': 'deny', 'default': 'deny',
"direction": "incoming", "direction": "incoming",
'_ansible_check_mode': True '_ansible_check_mode': True
}) }):
self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed']) self.assertFalse(self.__getResult(do_nothing_func_port_7000).exception.args[0]['changed'])
def test_ipv6_remove(self): def test_ipv6_remove(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'udp', 'proto': 'udp',
'port': '5353', 'port': '5353',
'from': 'ff02::fb', 'from': 'ff02::fb',
'delete': 'yes', 'delete': 'yes',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertTrue(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed']) self.assertTrue(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed'])
def test_ipv6_add_existing(self): def test_ipv6_add_existing(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'udp', 'proto': 'udp',
'port': '5353', 'port': '5353',
'from': 'ff02::fb', 'from': 'ff02::fb',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertFalse(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed']) self.assertFalse(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed'])
def test_add_not_existing_ipv4_submask(self): def test_add_not_existing_ipv4_submask(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'udp', 'proto': 'udp',
'port': '1577', 'port': '1577',
'from': '10.0.0.0/24', 'from': '10.0.0.0/24',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertTrue(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed']) self.assertTrue(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed'])
def test_ipv4_add_with_existing_ipv6(self): def test_ipv4_add_with_existing_ipv6(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'proto': 'udp', 'proto': 'udp',
'port': '5353', 'port': '5353',
'from': '224.0.0.252', 'from': '224.0.0.252',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
self.assertTrue(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed']) self.assertTrue(self.__getResult(do_nothing_func_ipv6).exception.args[0]['changed'])
def test_ipv6_add_from_nothing(self): def test_ipv6_add_from_nothing(self):
set_module_args({ with set_module_args({
'rule': 'allow', 'rule': 'allow',
'port': '23', 'port': '23',
'to': '::', 'to': '::',
'_ansible_check_mode': True, '_ansible_check_mode': True,
}) }):
result = self.__getResult(do_nothing_func_nothing).exception.args[0] result = self.__getResult(do_nothing_func_nothing).exception.args[0]
print(result) print(result)
self.assertTrue(result['changed']) self.assertTrue(result['changed'])

41
tests/unit/plugins/modules/test_usb_facts.py
View file

@ -5,42 +5,11 @@
from __future__ import (absolute_import, division, print_function) from __future__ import (absolute_import, division, print_function)
__metaclass__ = type __metaclass__ = type
import json
from ansible_collections.community.general.tests.unit.compat import mock from ansible_collections.community.general.tests.unit.compat import mock
from ansible_collections.community.general.tests.unit.compat import unittest from ansible_collections.community.general.tests.unit.compat import unittest
from ansible.module_utils import basic from ansible.module_utils import basic
from ansible.module_utils.common.text.converters import to_bytes
from ansible_collections.community.general.plugins.modules import usb_facts from ansible_collections.community.general.plugins.modules import usb_facts
from ansible_collections.community.general.tests.unit.plugins.modules.utils import AnsibleExitJson, set_module_args, exit_json, fail_json
def set_module_args(args):
"""prepare arguments so that they will be picked up during module creation"""
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
class AnsibleExitJson(Exception):
"""Exception class to be raised by module.exit_json and caught by the test case"""
pass
class AnsibleFailJson(Exception):
"""Exception class to be raised by module.fail_json and caught by the test case"""
pass
def exit_json(*args, **kwargs):
"""function to patch over exit_json; package return data into an exception"""
if 'changed' not in kwargs:
kwargs['changed'] = False
raise AnsibleExitJson(kwargs)
def fail_json(*args, **kwargs):
"""function to patch over fail_json; package return data into an exception"""
kwargs['failed'] = True
raise AnsibleFailJson(kwargs)
def get_bin_path(self, arg, required=False): def get_bin_path(self, arg, required=False):
@ -85,8 +54,8 @@ class TestUsbFacts(unittest.TestCase):
command_output = data["input"] command_output = data["input"]
mock_run_command.return_value = 0, command_output, None mock_run_command.return_value = 0, command_output, None
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({}) with set_module_args({}):
usb_facts.main() usb_facts.main()
for output_field in self.output_fields: for output_field in self.output_fields:
self.assertEqual(result.exception.args[0]["ansible_facts"]["usb_devices"][0][output_field], data[output_field]) self.assertEqual(result.exception.args[0]["ansible_facts"]["usb_devices"][0][output_field], data[output_field])
@ -97,8 +66,8 @@ class TestUsbFacts(unittest.TestCase):
with mock.patch.object(basic.AnsibleModule, 'run_command') as mock_run_command: with mock.patch.object(basic.AnsibleModule, 'run_command') as mock_run_command:
mock_run_command.return_value = 0, input, None mock_run_command.return_value = 0, input, None
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
set_module_args({}) with set_module_args({}):
usb_facts.main() usb_facts.main()
for index in range(0, len(self.testing_data)): for index in range(0, len(self.testing_data)):
for output_field in self.output_fields: for output_field in self.output_fields:
self.assertEqual(result.exception.args[0]["ansible_facts"]["usb_devices"][index][output_field], self.assertEqual(result.exception.args[0]["ansible_facts"]["usb_devices"][index][output_field],

570
tests/unit/plugins/modules/test_wdc_redfish_command.py
View file

@ -309,30 +309,30 @@ class TestWdcRedfishCommand(unittest.TestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
module.main() module.main()
def test_module_fail_when_unknown_category(self): def test_module_fail_when_unknown_category(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'unknown', 'category': 'unknown',
'command': 'FWActivate', 'command': 'FWActivate',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': [], 'ioms': [],
}) }):
module.main() module.main()
def test_module_fail_when_unknown_command(self): def test_module_fail_when_unknown_command(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'unknown', 'command': 'unknown',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': [], 'ioms': [],
}) }):
module.main() module.main()
def test_module_chassis_power_mode_low(self): def test_module_chassis_power_mode_low(self):
"""Test setting chassis power mode to low (happy path).""" """Test setting chassis power mode to low (happy path)."""
@ -344,15 +344,15 @@ class TestWdcRedfishCommand(unittest.TestCase):
'resource_id': 'Enclosure', 'resource_id': 'Enclosure',
'baseuri': 'example.com' 'baseuri': 'example.com'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
get_request=mock_get_request, get_request=mock_get_request,
post_request=mock_post_request): post_request=mock_post_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE,
get_exception_message(ansible_exit_json)) get_exception_message(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
def test_module_chassis_power_mode_normal_when_already_normal(self): def test_module_chassis_power_mode_normal_when_already_normal(self):
"""Test setting chassis power mode to normal when it already is. Verify we get changed=False.""" """Test setting chassis power mode to normal when it already is. Verify we get changed=False."""
@ -364,14 +364,14 @@ class TestWdcRedfishCommand(unittest.TestCase):
'resource_id': 'Enclosure', 'resource_id': 'Enclosure',
'baseuri': 'example.com' 'baseuri': 'example.com'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
get_request=mock_get_request): get_request=mock_get_request):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE,
get_exception_message(ansible_exit_json)) get_exception_message(ansible_exit_json))
self.assertFalse(is_changed(ansible_exit_json)) self.assertFalse(is_changed(ansible_exit_json))
def test_module_chassis_power_mode_invalid_command(self): def test_module_chassis_power_mode_invalid_command(self):
"""Test that we get an error when issuing an invalid PowerMode command.""" """Test that we get an error when issuing an invalid PowerMode command."""
@ -383,14 +383,14 @@ class TestWdcRedfishCommand(unittest.TestCase):
'resource_id': 'Enclosure', 'resource_id': 'Enclosure',
'baseuri': 'example.com' 'baseuri': 'example.com'
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
get_request=mock_get_request): get_request=mock_get_request):
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
module.main() module.main()
expected_error_message = "Invalid Command 'PowerModeExtraHigh'" expected_error_message = "Invalid Command 'PowerModeExtraHigh'"
self.assertIn(expected_error_message, self.assertIn(expected_error_message,
get_exception_message(ansible_fail_json)) get_exception_message(ansible_fail_json))
def test_module_enclosure_led_indicator_on(self): def test_module_enclosure_led_indicator_on(self):
"""Test turning on a valid LED indicator (in this case we use the Enclosure resource).""" """Test turning on a valid LED indicator (in this case we use the Enclosure resource)."""
@ -402,16 +402,15 @@ class TestWdcRedfishCommand(unittest.TestCase):
"resource_id": "Enclosure", "resource_id": "Enclosure",
"baseuri": "example.com" "baseuri": "example.com"
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", get_request=mock_get_request,
get_request=mock_get_request, post_request=mock_post_request):
post_request=mock_post_request): with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: module.main()
module.main() self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE,
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json))
get_exception_message(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json))
def test_module_invalid_resource_led_indicator_on(self): def test_module_invalid_resource_led_indicator_on(self):
"""Test turning LED on for an invalid resource id.""" """Test turning LED on for an invalid resource id."""
@ -423,16 +422,15 @@ class TestWdcRedfishCommand(unittest.TestCase):
"resource_id": "Disk99", "resource_id": "Disk99",
"baseuri": "example.com" "baseuri": "example.com"
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", get_request=mock_get_request,
get_request=mock_get_request, post_request=mock_post_request):
post_request=mock_post_request): with self.assertRaises(AnsibleFailJson) as ansible_fail_json:
with self.assertRaises(AnsibleFailJson) as ansible_fail_json: module.main()
module.main() expected_error_message = "Chassis resource Disk99 not found"
expected_error_message = "Chassis resource Disk99 not found" self.assertEqual(expected_error_message,
self.assertEqual(expected_error_message, get_exception_message(ansible_fail_json))
get_exception_message(ansible_fail_json))
def test_module_enclosure_led_off_already_off(self): def test_module_enclosure_led_off_already_off(self):
"""Test turning LED indicator off when it's already off. Confirm changed is False and no POST occurs.""" """Test turning LED indicator off when it's already off. Confirm changed is False and no POST occurs."""
@ -444,15 +442,14 @@ class TestWdcRedfishCommand(unittest.TestCase):
"resource_id": "Enclosure", "resource_id": "Enclosure",
"baseuri": "example.com" "baseuri": "example.com"
} }
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", get_request=mock_get_request):
get_request=mock_get_request): with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: module.main()
module.main() self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE,
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json))
get_exception_message(ansible_exit_json)) self.assertFalse(is_changed(ansible_exit_json))
self.assertFalse(is_changed(ansible_exit_json))
def test_module_fw_activate_first_iom_unavailable(self): def test_module_fw_activate_first_iom_unavailable(self):
"""Test that if the first IOM is not available, the 2nd one is used.""" """Test that if the first IOM is not available, the 2nd one is used."""
@ -467,26 +464,26 @@ class TestWdcRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': ioms 'ioms': ioms
} }
set_module_args(module_args) with set_module_args(module_args):
def mock_get_request(*args, **kwargs): def mock_get_request(*args, **kwargs):
"""Mock for get_request that will fail on the 'bad' IOM.""" """Mock for get_request that will fail on the 'bad' IOM."""
if "bad.example.com" in args[1]: if "bad.example.com" in args[1]:
return MOCK_URL_ERROR return MOCK_URL_ERROR
else: else:
return mock_get_request_enclosure_single_tenant(*args, **kwargs) return mock_get_request_enclosure_single_tenant(*args, **kwargs)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
_firmware_activate_uri=mock_fw_activate_url, _firmware_activate_uri=mock_fw_activate_url,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return, _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request, get_request=mock_get_request,
post_request=mock_post_request): post_request=mock_post_request):
with self.assertRaises(AnsibleExitJson) as cm: with self.assertRaises(AnsibleExitJson) as cm:
module.main() module.main()
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE,
get_exception_message(cm)) get_exception_message(cm))
def test_module_fw_activate_pass(self): def test_module_fw_activate_pass(self):
"""Test the FW Activate command in a passing scenario.""" """Test the FW Activate command in a passing scenario."""
@ -508,69 +505,68 @@ class TestWdcRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
} }
module_args.update(uri_specifier) module_args.update(uri_specifier)
set_module_args(module_args) with set_module_args(module_args):
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", _firmware_activate_uri=mock_fw_activate_url,
_firmware_activate_uri=mock_fw_activate_url, _update_uri=mock_update_url,
_update_uri=mock_update_url, _find_updateservice_resource=empty_return,
_find_updateservice_resource=empty_return, _find_updateservice_additional_uris=empty_return,
_find_updateservice_additional_uris=empty_return, get_request=mock_get_request_enclosure_single_tenant,
get_request=mock_get_request_enclosure_single_tenant, post_request=mock_post_request):
post_request=mock_post_request): with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: module.main()
module.main() self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE,
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json))
get_exception_message(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
self.assertTrue(is_changed(ansible_exit_json))
def test_module_fw_activate_service_does_not_support_fw_activate(self): def test_module_fw_activate_service_does_not_support_fw_activate(self):
"""Test FW Activate when it is not supported.""" """Test FW Activate when it is not supported."""
expected_error_message = "Service does not support FWActivate" expected_error_message = "Service does not support FWActivate"
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'FWActivate', 'command': 'FWActivate',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"] 'ioms': ["example1.example.com"]
}) }):
def mock_update_uri_response(*args, **kwargs): def mock_update_uri_response(*args, **kwargs):
return { return {
"ret": True, "ret": True,
"data": {} # No Actions "data": {} # No Actions
} }
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return, _find_updateservice_additional_uris=empty_return,
get_request=mock_update_uri_response): get_request=mock_update_uri_response):
with self.assertRaises(AnsibleFailJson) as cm: with self.assertRaises(AnsibleFailJson) as cm:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(cm)) get_exception_message(cm))
def test_module_update_and_activate_image_uri_not_http(self): def test_module_update_and_activate_image_uri_not_http(self):
"""Test Update and Activate when URI is not http(s)""" """Test Update and Activate when URI is not http(s)"""
expected_error_message = "Bundle URI must be HTTP or HTTPS" expected_error_message = "Bundle URI must be HTTP or HTTPS"
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"], 'ioms': ["example1.example.com"],
'update_image_uri': "ftp://example.com/image" 'update_image_uri': "ftp://example.com/image"
}) }):
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return): _find_updateservice_additional_uris=empty_return):
with self.assertRaises(AnsibleFailJson) as cm: with self.assertRaises(AnsibleFailJson) as cm:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(cm)) get_exception_message(cm))
def test_module_update_and_activate_target_not_ready_for_fw_update(self): def test_module_update_and_activate_target_not_ready_for_fw_update(self):
"""Test Update and Activate when target is not in the correct state.""" """Test Update and Activate when target is not in the correct state."""
@ -580,38 +576,38 @@ class TestWdcRedfishCommand(unittest.TestCase):
mock_status_code, mock_status_code,
mock_status_description mock_status_description
) )
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"], 'ioms': ["example1.example.com"],
'update_image_uri': "http://example.com/image" 'update_image_uri': "http://example.com/image"
}) }):
with patch.object(module.WdcRedfishUtils, "get_simple_update_status") as mock_get_simple_update_status: with patch.object(module.WdcRedfishUtils, "get_simple_update_status") as mock_get_simple_update_status:
mock_get_simple_update_status.return_value = { mock_get_simple_update_status.return_value = {
"ret": True, "ret": True,
"entries": { "entries": {
"StatusCode": mock_status_code, "StatusCode": mock_status_code,
"Description": mock_status_description "Description": mock_status_description
}
} }
}
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return): _find_updateservice_additional_uris=empty_return):
with self.assertRaises(AnsibleFailJson) as cm: with self.assertRaises(AnsibleFailJson) as cm:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(cm)) get_exception_message(cm))
def test_module_update_and_activate_bundle_not_a_tarfile(self): def test_module_update_and_activate_bundle_not_a_tarfile(self):
"""Test Update and Activate when bundle is not a tarfile""" """Test Update and Activate when bundle is not a tarfile"""
mock_filename = os.path.abspath(__file__) mock_filename = os.path.abspath(__file__)
expected_error_message = ERROR_MESSAGE_UNABLE_TO_EXTRACT_BUNDLE_VERSION expected_error_message = ERROR_MESSAGE_UNABLE_TO_EXTRACT_BUNDLE_VERSION
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -622,24 +618,24 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = mock_filename mock_fetch_file.return_value = mock_filename
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update, get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return): _find_updateservice_additional_uris=empty_return):
with self.assertRaises(AnsibleFailJson) as cm: with self.assertRaises(AnsibleFailJson) as cm:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(cm)) get_exception_message(cm))
def test_module_update_and_activate_bundle_contains_no_firmware_version(self): def test_module_update_and_activate_bundle_contains_no_firmware_version(self):
"""Test Update and Activate when bundle contains no firmware version""" """Test Update and Activate when bundle contains no firmware version"""
expected_error_message = ERROR_MESSAGE_UNABLE_TO_EXTRACT_BUNDLE_VERSION expected_error_message = ERROR_MESSAGE_UNABLE_TO_EXTRACT_BUNDLE_VERSION
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -650,29 +646,29 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = "empty_tarfile{0}.tar".format(uuid.uuid4()) tar_name = "empty_tarfile{0}.tar".format(uuid.uuid4())
empty_tarfile = tarfile.open(os.path.join(self.tempdir, tar_name), "w") empty_tarfile = tarfile.open(os.path.join(self.tempdir, tar_name), "w")
empty_tarfile.close() empty_tarfile.close()
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update, get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return): _find_updateservice_additional_uris=empty_return):
with self.assertRaises(AnsibleFailJson) as cm: with self.assertRaises(AnsibleFailJson) as cm:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(cm)) get_exception_message(cm))
def test_module_update_and_activate_version_already_installed(self): def test_module_update_and_activate_version_already_installed(self):
"""Test Update and Activate when the bundle version is already installed""" """Test Update and Activate when the bundle version is already installed"""
mock_firmware_version = "1.2.3" mock_firmware_version = "1.2.3"
expected_error_message = ACTION_WAS_SUCCESSFUL_MESSAGE expected_error_message = ACTION_WAS_SUCCESSFUL_MESSAGE
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -683,31 +679,31 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version, tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version,
is_multi_tenant=False) is_multi_tenant=False)
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3, get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3,
get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update, get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return, _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request_enclosure_single_tenant): get_request=mock_get_request_enclosure_single_tenant):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(result)) get_exception_message(result))
self.assertFalse(is_changed(result)) self.assertFalse(is_changed(result))
def test_module_update_and_activate_version_already_installed_multi_tenant(self): def test_module_update_and_activate_version_already_installed_multi_tenant(self):
"""Test Update and Activate on multi-tenant when version is already installed""" """Test Update and Activate on multi-tenant when version is already installed"""
mock_firmware_version = "1.2.3" mock_firmware_version = "1.2.3"
expected_error_message = ACTION_WAS_SUCCESSFUL_MESSAGE expected_error_message = ACTION_WAS_SUCCESSFUL_MESSAGE
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -718,30 +714,30 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version, tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version,
is_multi_tenant=True) is_multi_tenant=True)
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3, get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3,
get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update, get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return, _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request_enclosure_multi_tenant): get_request=mock_get_request_enclosure_multi_tenant):
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(result)) get_exception_message(result))
self.assertFalse(is_changed(result)) self.assertFalse(is_changed(result))
def test_module_update_and_activate_pass(self): def test_module_update_and_activate_pass(self):
"""Test Update and Activate (happy path)""" """Test Update and Activate (happy path)"""
mock_firmware_version = "1.2.2" mock_firmware_version = "1.2.2"
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -752,34 +748,34 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version, tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version,
is_multi_tenant=False) is_multi_tenant=False)
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils", with patch.multiple("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils",
get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3, get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3,
simple_update=mock_simple_update, simple_update=mock_simple_update,
_simple_update_status_uri=mocked_url_response, _simple_update_status_uri=mocked_url_response,
# _find_updateservice_resource=empty_return, # _find_updateservice_resource=empty_return,
# _find_updateservice_additional_uris=empty_return, # _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request_enclosure_single_tenant, get_request=mock_get_request_enclosure_single_tenant,
post_request=mock_post_request): post_request=mock_post_request):
with patch("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils.get_simple_update_status" with patch("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils.get_simple_update_status"
) as mock_get_simple_update_status: ) as mock_get_simple_update_status:
mock_get_simple_update_status.side_effect = MOCK_SIMPLE_UPDATE_STATUS_LIST mock_get_simple_update_status.side_effect = MOCK_SIMPLE_UPDATE_STATUS_LIST
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
module.main() module.main()
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json))
def test_module_update_and_activate_pass_multi_tenant(self): def test_module_update_and_activate_pass_multi_tenant(self):
"""Test Update and Activate with multi-tenant (happy path)""" """Test Update and Activate with multi-tenant (happy path)"""
mock_firmware_version = "1.2.2" mock_firmware_version = "1.2.2"
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -790,34 +786,34 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version, tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version,
is_multi_tenant=True) is_multi_tenant=True)
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3, get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3,
simple_update=mock_simple_update, simple_update=mock_simple_update,
_simple_update_status_uri=mocked_url_response, _simple_update_status_uri=mocked_url_response,
# _find_updateservice_resource=empty_return, # _find_updateservice_resource=empty_return,
# _find_updateservice_additional_uris=empty_return, # _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request_enclosure_multi_tenant, get_request=mock_get_request_enclosure_multi_tenant,
post_request=mock_post_request): post_request=mock_post_request):
with patch("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils.get_simple_update_status" with patch("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils.get_simple_update_status"
) as mock_get_simple_update_status: ) as mock_get_simple_update_status:
mock_get_simple_update_status.side_effect = MOCK_SIMPLE_UPDATE_STATUS_LIST mock_get_simple_update_status.side_effect = MOCK_SIMPLE_UPDATE_STATUS_LIST
with self.assertRaises(AnsibleExitJson) as ansible_exit_json: with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
module.main() module.main()
self.assertTrue(is_changed(ansible_exit_json)) self.assertTrue(is_changed(ansible_exit_json))
self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json)) self.assertEqual(ACTION_WAS_SUCCESSFUL_MESSAGE, get_exception_message(ansible_exit_json))
def test_module_fw_update_multi_tenant_firmware_single_tenant_enclosure(self): def test_module_fw_update_multi_tenant_firmware_single_tenant_enclosure(self):
"""Test Update and Activate using multi-tenant bundle on single-tenant enclosure""" """Test Update and Activate using multi-tenant bundle on single-tenant enclosure"""
mock_firmware_version = "1.1.1" mock_firmware_version = "1.1.1"
expected_error_message = "Enclosure multi-tenant is False but bundle multi-tenant is True" expected_error_message = "Enclosure multi-tenant is False but bundle multi-tenant is True"
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -828,30 +824,30 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version, tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version,
is_multi_tenant=True) is_multi_tenant=True)
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3(), get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3(),
get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update, get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return, _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request_enclosure_single_tenant): get_request=mock_get_request_enclosure_single_tenant):
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(result)) get_exception_message(result))
def test_module_fw_update_single_tentant_firmware_multi_tenant_enclosure(self): def test_module_fw_update_single_tentant_firmware_multi_tenant_enclosure(self):
"""Test Update and Activate using singe-tenant bundle on multi-tenant enclosure""" """Test Update and Activate using singe-tenant bundle on multi-tenant enclosure"""
mock_firmware_version = "1.1.1" mock_firmware_version = "1.1.1"
expected_error_message = "Enclosure multi-tenant is True but bundle multi-tenant is False" expected_error_message = "Enclosure multi-tenant is True but bundle multi-tenant is False"
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'UpdateAndActivate', 'command': 'UpdateAndActivate',
'username': 'USERID', 'username': 'USERID',
@ -862,24 +858,24 @@ class TestWdcRedfishCommand(unittest.TestCase):
"username": "image_user", "username": "image_user",
"password": "image_password" "password": "image_password"
} }
}) }):
tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version, tar_name = self.generate_temp_bundlefile(mock_firmware_version=mock_firmware_version,
is_multi_tenant=False) is_multi_tenant=False)
with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file: with patch('ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.fetch_file') as mock_fetch_file:
mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name) mock_fetch_file.return_value = os.path.join(self.tempdir, tar_name)
with patch.multiple(module.WdcRedfishUtils, with patch.multiple(module.WdcRedfishUtils,
get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3(), get_firmware_inventory=mock_get_firmware_inventory_version_1_2_3(),
get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update, get_simple_update_status=mock_get_simple_update_status_ready_for_fw_update,
_firmware_activate_uri=mocked_url_response, _firmware_activate_uri=mocked_url_response,
_update_uri=mock_update_url, _update_uri=mock_update_url,
_find_updateservice_resource=empty_return, _find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return, _find_updateservice_additional_uris=empty_return,
get_request=mock_get_request_enclosure_multi_tenant): get_request=mock_get_request_enclosure_multi_tenant):
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
self.assertEqual(expected_error_message, self.assertEqual(expected_error_message,
get_exception_message(result)) get_exception_message(result))
def generate_temp_bundlefile(self, def generate_temp_bundlefile(self,
mock_firmware_version, mock_firmware_version,

198
tests/unit/plugins/modules/test_wdc_redfish_info.py
View file

@ -77,140 +77,140 @@ class TestWdcRedfishInfo(unittest.TestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
module.main() module.main()
def test_module_fail_when_unknown_category(self): def test_module_fail_when_unknown_category(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'unknown', 'category': 'unknown',
'command': 'SimpleUpdateStatus', 'command': 'SimpleUpdateStatus',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': [], 'ioms': [],
}) }):
module.main() module.main()
def test_module_fail_when_unknown_command(self): def test_module_fail_when_unknown_command(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'unknown', 'command': 'unknown',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': [], 'ioms': [],
}) }):
module.main() module.main()
def test_module_simple_update_status_pass(self): def test_module_simple_update_status_pass(self):
set_module_args({ with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'SimpleUpdateStatus', 'command': 'SimpleUpdateStatus',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"], 'ioms': ["example1.example.com"],
}) }):
def mock_simple_update_status(*args, **kwargs): def mock_simple_update_status(*args, **kwargs):
return {
"ret": True,
"data": {
"Description": "Ready for FW update",
"ErrorCode": 0,
"EstimatedRemainingMinutes": 0,
"StatusCode": 0
}
}
def mocked_string_response(*args, **kwargs):
return "mockedUrl"
def empty_return(*args, **kwargs):
return {"ret": True}
with patch.multiple(module.WdcRedfishUtils,
_simple_update_status_uri=mocked_string_response,
_find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return,
get_request=mock_simple_update_status):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
module.main()
redfish_facts = get_redfish_facts(ansible_exit_json)
self.assertEqual(mock_simple_update_status()["data"],
redfish_facts["simple_update_status"]["entries"])
def test_module_simple_update_status_updateservice_resource_not_found(self):
set_module_args({
'category': 'Update',
'command': 'SimpleUpdateStatus',
'username': 'USERID',
'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"],
})
with patch.object(module.WdcRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {
"ret": True,
"data": {} # Missing UpdateService property
}
with self.assertRaises(AnsibleFailJson) as ansible_exit_json:
module.main()
self.assertEqual("UpdateService resource not found",
get_exception_message(ansible_exit_json))
def test_module_simple_update_status_service_does_not_support_simple_update(self):
set_module_args({
'category': 'Update',
'command': 'SimpleUpdateStatus',
'username': 'USERID',
'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"],
})
def mock_get_request_function(uri):
mock_url_string = "mockURL"
if mock_url_string in uri:
return { return {
"ret": True, "ret": True,
"data": { "data": {
"Actions": { # No #UpdateService.SimpleUpdate "Description": "Ready for FW update",
} "ErrorCode": 0,
"EstimatedRemainingMinutes": 0,
"StatusCode": 0
} }
} }
else:
return {
"ret": True,
"data": mock_url_string
}
with patch.object(module.WdcRedfishUtils, 'get_request') as mock_get_request: def mocked_string_response(*args, **kwargs):
mock_get_request.side_effect = mock_get_request_function return "mockedUrl"
with self.assertRaises(AnsibleFailJson) as ansible_exit_json:
module.main()
self.assertEqual("UpdateService resource not found",
get_exception_message(ansible_exit_json))
def test_module_simple_update_status_service_does_not_support_fw_activate(self): def empty_return(*args, **kwargs):
set_module_args({ return {"ret": True}
with patch.multiple(module.WdcRedfishUtils,
_simple_update_status_uri=mocked_string_response,
_find_updateservice_resource=empty_return,
_find_updateservice_additional_uris=empty_return,
get_request=mock_simple_update_status):
with self.assertRaises(AnsibleExitJson) as ansible_exit_json:
module.main()
redfish_facts = get_redfish_facts(ansible_exit_json)
self.assertEqual(mock_simple_update_status()["data"],
redfish_facts["simple_update_status"]["entries"])
def test_module_simple_update_status_updateservice_resource_not_found(self):
with set_module_args({
'category': 'Update', 'category': 'Update',
'command': 'SimpleUpdateStatus', 'command': 'SimpleUpdateStatus',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"], 'ioms': ["example1.example.com"],
}) }):
with patch.object(module.WdcRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {
"ret": True,
"data": {} # Missing UpdateService property
}
with self.assertRaises(AnsibleFailJson) as ansible_exit_json:
module.main()
self.assertEqual("UpdateService resource not found",
get_exception_message(ansible_exit_json))
def mock_get_request_function(uri): def test_module_simple_update_status_service_does_not_support_simple_update(self):
if uri.endswith("/redfish/v1") or uri.endswith("/redfish/v1/"): with set_module_args({
return MOCK_SUCCESSFUL_RESPONSE_WITH_UPDATE_SERVICE_RESOURCE 'category': 'Update',
elif uri.endswith("/mockedUrl"): 'command': 'SimpleUpdateStatus',
return MOCK_SUCCESSFUL_HTTP_EMPTY_RESPONSE 'username': 'USERID',
elif uri.endswith("/UpdateService"): 'password': 'PASSW0RD=21',
return MOCK_SUCCESSFUL_RESPONSE_WITH_SIMPLE_UPDATE_BUT_NO_FW_ACTIVATE 'ioms': ["example1.example.com"],
else: }):
raise RuntimeError("Illegal call to get_request in test: " + uri)
with patch("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils.get_request") as mock_get_request: def mock_get_request_function(uri):
mock_get_request.side_effect = mock_get_request_function mock_url_string = "mockURL"
with self.assertRaises(AnsibleFailJson) as ansible_exit_json: if mock_url_string in uri:
module.main() return {
self.assertEqual("Service does not support FWActivate", "ret": True,
get_exception_message(ansible_exit_json)) "data": {
"Actions": { # No #UpdateService.SimpleUpdate
}
}
}
else:
return {
"ret": True,
"data": mock_url_string
}
with patch.object(module.WdcRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.side_effect = mock_get_request_function
with self.assertRaises(AnsibleFailJson) as ansible_exit_json:
module.main()
self.assertEqual("UpdateService resource not found",
get_exception_message(ansible_exit_json))
def test_module_simple_update_status_service_does_not_support_fw_activate(self):
with set_module_args({
'category': 'Update',
'command': 'SimpleUpdateStatus',
'username': 'USERID',
'password': 'PASSW0RD=21',
'ioms': ["example1.example.com"],
}):
def mock_get_request_function(uri):
if uri.endswith("/redfish/v1") or uri.endswith("/redfish/v1/"):
return MOCK_SUCCESSFUL_RESPONSE_WITH_UPDATE_SERVICE_RESOURCE
elif uri.endswith("/mockedUrl"):
return MOCK_SUCCESSFUL_HTTP_EMPTY_RESPONSE
elif uri.endswith("/UpdateService"):
return MOCK_SUCCESSFUL_RESPONSE_WITH_SIMPLE_UPDATE_BUT_NO_FW_ACTIVATE
else:
raise RuntimeError("Illegal call to get_request in test: " + uri)
with patch("ansible_collections.community.general.plugins.module_utils.wdc_redfish_utils.WdcRedfishUtils.get_request") as mock_get_request:
mock_get_request.side_effect = mock_get_request_function
with self.assertRaises(AnsibleFailJson) as ansible_exit_json:
module.main()
self.assertEqual("Service does not support FWActivate",
get_exception_message(ansible_exit_json))

627
tests/unit/plugins/modules/test_xcc_redfish_command.py
View file

@ -30,33 +30,33 @@ class TestXCCRedfishCommand(unittest.TestCase):
def test_module_fail_when_required_args_missing(self): def test_module_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({}) with set_module_args({}):
module.main() module.main()
def test_module_fail_when_unknown_category(self): def test_module_fail_when_unknown_category(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'unknown', 'category': 'unknown',
'command': 'VirtualMediaEject', 'command': 'VirtualMediaEject',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
module.main() module.main()
def test_module_fail_when_unknown_command(self): def test_module_fail_when_unknown_command(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'Manager', 'category': 'Manager',
'command': 'unknown', 'command': 'unknown',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
module.main() module.main()
def test_module_command_VirtualMediaInsert_pass(self): def test_module_command_VirtualMediaInsert_pass(self):
set_module_args({ with set_module_args({
'category': 'Manager', 'category': 'Manager',
'command': 'VirtualMediaInsert', 'command': 'VirtualMediaInsert',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -70,20 +70,20 @@ class TestXCCRedfishCommand(unittest.TestCase):
'write_protected': True, 'write_protected': True,
'transfer_protocol_type': 'NFS' 'transfer_protocol_type': 'NFS'
} }
}) }):
with patch.object(module.XCCRedfishUtils, '_find_systems_resource') as mock__find_systems_resource: with patch.object(module.XCCRedfishUtils, '_find_systems_resource') as mock__find_systems_resource:
mock__find_systems_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'} mock__find_systems_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'}
with patch.object(module.XCCRedfishUtils, '_find_managers_resource') as mock__find_managers_resource: with patch.object(module.XCCRedfishUtils, '_find_managers_resource') as mock__find_managers_resource:
mock__find_managers_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'} mock__find_managers_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'}
with patch.object(module.XCCRedfishUtils, 'virtual_media_insert') as mock_virtual_media_insert: with patch.object(module.XCCRedfishUtils, 'virtual_media_insert') as mock_virtual_media_insert:
mock_virtual_media_insert.return_value = {'ret': True, 'changed': True, 'msg': 'success'} mock_virtual_media_insert.return_value = {'ret': True, 'changed': True, 'msg': 'success'}
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
module.main() module.main()
def test_module_command_VirtualMediaEject_pass(self): def test_module_command_VirtualMediaEject_pass(self):
set_module_args({ with set_module_args({
'category': 'Manager', 'category': 'Manager',
'command': 'VirtualMediaEject', 'command': 'VirtualMediaEject',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -93,194 +93,184 @@ class TestXCCRedfishCommand(unittest.TestCase):
'virtual_media': { 'virtual_media': {
'image_url': "nfs://10.245.52.18:/home/nfs/bootable-sr635-20210111-autorun.iso", 'image_url': "nfs://10.245.52.18:/home/nfs/bootable-sr635-20210111-autorun.iso",
} }
}) }):
with patch.object(module.XCCRedfishUtils, '_find_systems_resource') as mock__find_systems_resource: with patch.object(module.XCCRedfishUtils, '_find_systems_resource') as mock__find_systems_resource:
mock__find_systems_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'} mock__find_systems_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'}
with patch.object(module.XCCRedfishUtils, '_find_managers_resource') as mock__find_managers_resource: with patch.object(module.XCCRedfishUtils, '_find_managers_resource') as mock__find_managers_resource:
mock__find_managers_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'} mock__find_managers_resource.return_value = {'ret': True, 'changed': True, 'msg': 'success'}
with patch.object(module.XCCRedfishUtils, 'virtual_media_eject') as mock_virtual_media_eject: with patch.object(module.XCCRedfishUtils, 'virtual_media_eject') as mock_virtual_media_eject:
mock_virtual_media_eject.return_value = {'ret': True, 'changed': True, 'msg': 'success'} mock_virtual_media_eject.return_value = {'ret': True, 'changed': True, 'msg': 'success'}
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
module.main() module.main()
def test_module_command_VirtualMediaEject_fail_when_required_args_missing(self): def test_module_command_VirtualMediaEject_fail_when_required_args_missing(self):
with self.assertRaises(AnsibleFailJson): with self.assertRaises(AnsibleFailJson):
set_module_args({ with set_module_args({
'category': 'Manager', 'category': 'Manager',
'command': 'VirtualMediaEject', 'command': 'VirtualMediaEject',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
module.main() module.main()
def test_module_command_GetResource_fail_when_required_args_missing(self): def test_module_command_GetResource_fail_when_required_args_missing(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetResource', 'command': 'GetResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleFailJson) as result:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_GetResource_fail_when_get_return_false(self): def test_module_command_GetResource_fail_when_get_return_false(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetResource', 'command': 'GetResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': False, 'msg': '404 error'}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleFailJson) as result:
mock_get_request.return_value = {'ret': False, 'msg': '404 error'} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_GetResource_pass(self): def test_module_command_GetResource_pass(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetResource', 'command': 'GetResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleExitJson) as result:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleExitJson) as result:
module.main()
def test_module_command_GetCollectionResource_fail_when_required_args_missing(self): def test_module_command_GetCollectionResource_fail_when_required_args_missing(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetCollectionResource', 'command': 'GetCollectionResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleFailJson) as result:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_GetCollectionResource_fail_when_get_return_false(self): def test_module_command_GetCollectionResource_fail_when_get_return_false(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetCollectionResource', 'command': 'GetCollectionResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': False, 'msg': '404 error'}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleFailJson) as result:
mock_get_request.return_value = {'ret': False, 'msg': '404 error'} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_GetCollectionResource_fail_when_get_not_colection(self): def test_module_command_GetCollectionResource_fail_when_get_not_colection(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetCollectionResource', 'command': 'GetCollectionResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleFailJson) as result:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_GetCollectionResource_pass_when_get_empty_collection(self): def test_module_command_GetCollectionResource_pass_when_get_empty_collection(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetCollectionResource', 'command': 'GetCollectionResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'Members': [], 'Members@odata.count': 0}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleExitJson) as result:
mock_get_request.return_value = {'ret': True, 'data': {'Members': [], 'Members@odata.count': 0}} module.main()
with self.assertRaises(AnsibleExitJson) as result:
module.main()
def test_module_command_GetCollectionResource_pass_when_get_collection(self): def test_module_command_GetCollectionResource_pass_when_get_collection(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'GetCollectionResource', 'command': 'GetCollectionResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'Members': [{'@odata.id': '/redfish/v1/testuri/1'}], 'Members@odata.count': 1}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with self.assertRaises(AnsibleExitJson) as result:
mock_get_request.return_value = {'ret': True, 'data': {'Members': [{'@odata.id': '/redfish/v1/testuri/1'}], 'Members@odata.count': 1}} module.main()
with self.assertRaises(AnsibleExitJson) as result:
module.main()
def test_module_command_PatchResource_fail_when_required_args_missing(self): def test_module_command_PatchResource_fail_when_required_args_missing(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PatchResource', 'command': 'PatchResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}} mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request: with self.assertRaises(AnsibleFailJson) as result:
mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_PatchResource_fail_when_required_args_missing_no_requestbody(self): def test_module_command_PatchResource_fail_when_required_args_missing_no_requestbody(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PatchResource', 'command': 'PatchResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}} mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request: with self.assertRaises(AnsibleFailJson) as result:
mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_PatchResource_fail_when_noexisting_property_in_requestbody(self): def test_module_command_PatchResource_fail_when_noexisting_property_in_requestbody(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PatchResource', 'command': 'PatchResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -288,19 +278,18 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
'request_body': {'teststr': 'yyyy', 'otherkey': 'unknownkey'} 'request_body': {'teststr': 'yyyy', 'otherkey': 'unknownkey'}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}} mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}}
with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request: with self.assertRaises(AnsibleFailJson) as result:
mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx'}} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_PatchResource_fail_when_get_return_false(self): def test_module_command_PatchResource_fail_when_get_return_false(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PatchResource', 'command': 'PatchResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -308,19 +297,18 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
'request_body': {'teststr': 'yyyy'} 'request_body': {'teststr': 'yyyy'}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}} mock_patch_request.return_value = {'ret': False, 'msg': '500 internal error'}
with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request: with self.assertRaises(AnsibleFailJson) as result:
mock_patch_request.return_value = {'ret': False, 'msg': '500 internal error'} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_PatchResource_pass(self): def test_module_command_PatchResource_pass(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PatchResource', 'command': 'PatchResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -328,170 +316,165 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
'request_body': {'teststr': 'yyyy'} 'request_body': {'teststr': 'yyyy'}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request:
mock_get_request.return_value = {'ret': True, 'data': {'teststr': 'xxxx', '@odata.etag': '27f6eb13fa1c28a2711'}} mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'yyyy', '@odata.etag': '322e0d45d9572723c98'}}
with patch.object(module.XCCRedfishUtils, 'patch_request') as mock_patch_request: with self.assertRaises(AnsibleExitJson) as result:
mock_patch_request.return_value = {'ret': True, 'data': {'teststr': 'yyyy', '@odata.etag': '322e0d45d9572723c98'}} module.main()
with self.assertRaises(AnsibleExitJson) as result:
module.main()
def test_module_command_PostResource_fail_when_required_args_missing(self): def test_module_command_PostResource_fail_when_required_args_missing(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': True} mock_post_request.return_value = {'ret': True}
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
def test_module_command_PostResource_fail_when_invalid_resourceuri(self): def test_module_command_PostResource_fail_when_invalid_resourceuri(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/testuri', 'resource_uri': '/redfish/v1/testuri',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': True} mock_post_request.return_value = {'ret': True}
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
def test_module_command_PostResource_fail_when_no_requestbody(self): def test_module_command_PostResource_fail_when_no_requestbody(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword', 'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': True} mock_post_request.return_value = {'ret': True}
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
def test_module_command_PostResource_fail_when_no_requestbody(self): def test_module_command_PostResource_fail_when_no_requestbody(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
'username': 'USERID', 'username': 'USERID',
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword', 'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword',
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': True} mock_post_request.return_value = {'ret': True}
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
def test_module_command_PostResource_fail_when_requestbody_mismatch_with_data_from_actioninfo_uri(self): def test_module_command_PostResource_fail_when_requestbody_mismatch_with_data_from_actioninfo_uri(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -499,39 +482,38 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword', 'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword',
'request_body': {'PasswordName': 'UefiAdminPassword', 'NewPassword': 'PASSW0RD=='} 'request_body': {'PasswordName': 'UefiAdminPassword', 'NewPassword': 'PASSW0RD=='}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Parameters': [],
'Parameters': [], 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': True} mock_post_request.return_value = {'ret': True}
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
def test_module_command_PostResource_fail_when_get_return_false(self): def test_module_command_PostResource_fail_when_get_return_false(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -539,19 +521,18 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword', 'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword',
'request_body': {'PasswordName': 'UefiAdminPassword', 'NewPassword': 'PASSW0RD=='} 'request_body': {'PasswordName': 'UefiAdminPassword', 'NewPassword': 'PASSW0RD=='}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
mock_get_request.return_value = {'ret': False, 'msg': '404 error'}
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_get_request.return_value = {'ret': False, 'msg': '404 error'} mock_post_request.return_value = {'ret': True}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with self.assertRaises(AnsibleFailJson) as result:
mock_post_request.return_value = {'ret': True} module.main()
with self.assertRaises(AnsibleFailJson) as result:
module.main()
def test_module_command_PostResource_fail_when_post_return_false(self): def test_module_command_PostResource_fail_when_post_return_false(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -559,38 +540,37 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios', 'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios',
'request_body': {} 'request_body': {}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': False, 'msg': '500 internal error'} mock_post_request.return_value = {'ret': False, 'msg': '500 internal error'}
with self.assertRaises(AnsibleFailJson) as result: with self.assertRaises(AnsibleFailJson) as result:
module.main() module.main()
def test_module_command_PostResource_pass(self): def test_module_command_PostResource_pass(self):
set_module_args({ with set_module_args({
'category': 'Raw', 'category': 'Raw',
'command': 'PostResource', 'command': 'PostResource',
'baseuri': '10.245.39.251', 'baseuri': '10.245.39.251',
@ -598,32 +578,31 @@ class TestXCCRedfishCommand(unittest.TestCase):
'password': 'PASSW0RD=21', 'password': 'PASSW0RD=21',
'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios', 'resource_uri': '/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios',
'request_body': {} 'request_body': {}
}) }):
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request:
with patch.object(module.XCCRedfishUtils, 'get_request') as mock_get_request: mock_get_request.return_value = {
mock_get_request.return_value = { 'ret': True,
'ret': True, 'data': {
'data': { 'Actions': {
'Actions': { '#Bios.ChangePassword': {
'#Bios.ChangePassword': { '@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo",
'@Redfish.ActionInfo': "/redfish/v1/Systems/1/Bios/ChangePasswordActionInfo", 'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ChangePassword", 'title': "ChangePassword",
'title': "ChangePassword", 'PasswordName@Redfish.AllowableValues': [
'PasswordName@Redfish.AllowableValues': [ "UefiAdminPassword",
"UefiAdminPassword", "UefiPowerOnPassword"
"UefiPowerOnPassword" ]
] },
'#Bios.ResetBios': {
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
}, },
'#Bios.ResetBios': { }
'title': "ResetBios",
'target': "/redfish/v1/Systems/1/Bios/Actions/Bios.ResetBios"
}
},
} }
}
with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request: with patch.object(module.XCCRedfishUtils, 'post_request') as mock_post_request:
mock_post_request.return_value = {'ret': True, 'msg': 'post success'} mock_post_request.return_value = {'ret': True, 'msg': 'post success'}
with self.assertRaises(AnsibleExitJson) as result: with self.assertRaises(AnsibleExitJson) as result:
module.main() module.main()

7
tests/unit/plugins/modules/utils.py
View file

@ -5,6 +5,7 @@
from __future__ import (absolute_import, division, print_function) from __future__ import (absolute_import, division, print_function)
__metaclass__ = type __metaclass__ = type
import contextlib as _contextlib
import json import json
from ansible_collections.community.general.tests.unit.compat import unittest from ansible_collections.community.general.tests.unit.compat import unittest
@ -13,14 +14,16 @@ from ansible.module_utils import basic
from ansible.module_utils.common.text.converters import to_bytes from ansible.module_utils.common.text.converters import to_bytes
@_contextlib.contextmanager
def set_module_args(args): def set_module_args(args):
if '_ansible_remote_tmp' not in args: if '_ansible_remote_tmp' not in args:
args['_ansible_remote_tmp'] = '/tmp' args['_ansible_remote_tmp'] = '/tmp'
if '_ansible_keep_remote_files' not in args: if '_ansible_keep_remote_files' not in args:
args['_ansible_keep_remote_files'] = False args['_ansible_keep_remote_files'] = False
args = json.dumps({'ANSIBLE_MODULE_ARGS': args}) serialized_args = to_bytes(json.dumps({'ANSIBLE_MODULE_ARGS': args}))
basic._ANSIBLE_ARGS = to_bytes(args) with patch.object(basic, '_ANSIBLE_ARGS', serialized_args):
yield
class AnsibleExitJson(Exception): class AnsibleExitJson(Exception):