def setUp(self): logger = logging.getLogger('hyclops.connector.base') logger.addHandler(logging.NullHandler()) self.patcher = patch('hyclops.connector.base.ZabbixAPI', new=MockZabbixAPI) self.patcher.start() config_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "test.conf") self.config = configobj.ConfigObj(config_path, file_error=True) self.connector = BaseConnector(config=self.config) self.connector.zabbix_api = MockZabbixAPI() self._create_zabbix_mock()
def test_init(self): self.assertIsInstance(self.connector.config, configobj.ConfigObj) self.assertIsInstance(self.connector.logger, logging.Logger) self.assertEqual(self.connector.zabbix_server, '127.0.0.1') self.assertEqual(self.connector.zabbix_port, '10051') self.assertEqual(self.connector.zabbix_sender_path, '/usr/bin/zabbix_sender') self.assertIsInstance(self.connector.zabbix_api, MockZabbixAPI) with self.assertRaises(KeyError): connector = BaseConnector(config=configobj.ConfigObj("wrong_path")) with patch('hyclops.connector.base.ZabbixAPI.login') as m: m.side_effect = ZabbixAPIException() with self.assertRaises(ZabbixAPIException): connector = BaseConnector(config=self.config) m.side_effect = Exception() with self.assertRaises(Exception): connector = BaseConnector(config=self.config)
def setUp(self): logger = logging.getLogger('hyclops.connector.base') logger.addHandler(logging.NullHandler()) self.patcher = patch('hyclops.connector.base.ZabbixAPI', new=MockZabbixAPI) self.patcher.start() config_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "test.conf") self.config = configobj.ConfigObj(config_path, file_error=True) self.connector = BaseConnector(config=self.config) self.connector.zabbix_api = MockZabbixAPI() self._create_zabbix_mock()
class TestBaseConnector(unittest.TestCase): def setUp(self): logger = logging.getLogger('hyclops.connector.base') # logger.addHandler(logging.NullHandler()) logger.addHandler(logging.FileHandler("/tmp/hyclops_test.log")) self.patcher = patch('hyclops.connector.base.ZabbixAPI', new=MockZabbixAPI) self.patcher.start() config_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "test.conf") self.config = configobj.ConfigObj(config_path, file_error=True) self.connector = BaseConnector(config=self.config) self.connector.zabbix_api = MockZabbixAPI() self._create_zabbix_mock() def tearDown(self): self.patcher.stop() def _create_zabbix_mock(self): zabbix_api = self.connector.zabbix_api # create AWSAccount Group response = zabbix_api.hostgroup.create({ "name": "AWSAccount" }) groupid_aws_account = response["groupids"][0] # create AmazonEC2 Group response = zabbix_api.hostgroup.create({ "name": "AmazonEC2" }) groupid_amazon_ec2 = response["groupids"][0] # create AWSAccount Template response = zabbix_api.template.create({ "host": "AWSAccount", "groups": [{"groupid": groupid_aws_account}], "macros": [ {"macro": "{$VM_GROUPS}", "value": "AmazonEC2"}, {"macro": "{$REQUIRED_TEMPLATES}", "value": "AmazonEC2"}, {"macro": "{$VM_TEMPLATES}", "value": "Template App Zabbix Agent"}, {"macro": "{$VM_TEMPLATES_LINUX}", "value": "Template OS Linux"}, {"macro": "{$VM_TEMPLATES_WINDOWS}", "value": "Template OS Windows"}, ] }) templateid_aws_account = response["templateids"][0] # create AmazonEC2 Template response = zabbix_api.template.create({ "host": "AmazonEC2", "groups": [{"groupid": groupid_amazon_ec2}], }) templateid_amazon_ec2 = response["templateids"][0] # create Template OS Linux response = zabbix_api.template.create({ "host": "Template OS Linux", "groups": [], }) # create Template OS Windows response = zabbix_api.template.create({ "host": "Template OS Windows", "groups": [], }) # create Template App Zabbix Agent response = zabbix_api.template.create({ "host": "Template App Zabbix Agent", "groups": [], }) # create AWS Host zabbix_api.host.create({ "host": "AWS", "interfaces": [ {"interfaceid": 1, "type": 1, "main": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050}, ], "groups": [{"groupid": groupid_aws_account}], "parentTemplates": [{"templateid": templateid_aws_account}], "inventory": [], "macros": { "1": {"macro": "{$KEY}", "value": "key"}, "2": {"macro": "{$SECRET}", "value": "secret"}, }, }) # create EC2Instance(i-aaaaaaaa) Host zabbix_api.host.create({ "host": "i-aaaaaaaa", "name": "AWS_EC2Instance", "interfaces": [ {"interfaceid": 1, "type": 1, "main": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050}, {"interfaceid": 2, "type": 2, "main": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161}, ], "groups": [{"groupid": groupid_amazon_ec2}], "parentTemplates": [{"templateid": templateid_amazon_ec2}], "inventory": { "name": "EC2Instance", "type": "ec2", "tag": "AWS", "location": "us-east-1", "serialno_a": "i-aaaaaaaa", }, "macros": [], }) # create Global Macro zabbix_api.usermacro.create({ "globalmacro": True, "macro": "{$GLOBAL}", "value": "global macro", }) zabbix_api.usermacro.create({ "globalmacro": True, "macro": "{$GLOBAL2}", "value": "global macro 2", }) def test_init(self): self.assertIsInstance(self.connector.config, configobj.ConfigObj) self.assertIsInstance(self.connector.logger, logging.Logger) self.assertEqual(self.connector.zabbix_server, '127.0.0.1') self.assertEqual(self.connector.zabbix_port, '10051') self.assertEqual(self.connector.zabbix_sender_path, '/usr/bin/zabbix_sender') self.assertIsInstance(self.connector.zabbix_api, MockZabbixAPI) with self.assertRaises(KeyError): connector = BaseConnector(config=configobj.ConfigObj("wrong_path")) with patch('hyclops.connector.base.ZabbixAPI.login') as m: m.side_effect = ZabbixAPIException() with self.assertRaises(ZabbixAPIException): connector = BaseConnector(config=self.config) m.side_effect = Exception() with self.assertRaises(Exception): connector = BaseConnector(config=self.config) def test_call(self): with self.assertRaises(NotImplementedError): self.connector("hostname", {}) def test_escape_shell_args(self): test_data = ["'", None, "string", [], [None], ["str1", "str2"], ("str1",), (None, None), ("cat", "'; echo 'command injection'; '",)] for data in test_data: escaped_args = self.connector.escape_shell_args(data) self.assertIsInstance(escaped_args, tuple) for arg in escaped_args: self.assertIsInstance(arg, str) self.assertTrue(re.match(r'^\'(.*)\'$', str(arg))) def test_zabbix_sender(self): test_data = [ {"zabbix_hostname": None, "key": None, "value": None}, {"zabbix_hostname": [], "key": {}, "value": (None,)}, {"zabbix_hostname": "TestHost", "key": "item.key", "value": None}, {"zabbix_hostname": "TestHost", "key": "item.key", "value": 0}, {"zabbix_hostname": "TestHost", "key": "item.key", "value": "string"}, {"zabbix_hostname": "TestHost", "key": "item.key", "value": ["array", None]}, {"zabbix_hostname": "TestHost", "key": "item.key", "value": {"dict": "string", "none": None}}, ] with patch('os.system') as m: m.return_value = 0 for data in test_data: try: self.connector.zabbix_sender(**data) except: self.fail("Unexpected Error") m.return_value = 1 for data in test_data: with self.assertRaises(Exception): self.connector.zabbix_sender(**data) def test_addresses_to_interfaces(self): test_data = [ # one addresses {"params": {"addresses": ["127.0.0.1"]}, "expect": [{"type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 1}, {"type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 1}]}, # two addresses {"params": {"addresses": ["127.0.0.1", "localhost.localdomain"]}, "expect": [{"type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 0}, {"type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 0}, {"type": 1, "useip": 0, "ip": "", "dns": "localhost.localdomain", "port": 10050, "main": 1}, {"type": 2, "useip": 0, "ip": "", "dns": "localhost.localdomain", "port": 161, "main": 1}]}, # one address with interface_types {"params": {"addresses": ["127.0.0.1"], "interface_types": [1]}, "expect": [{"type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 1}]}, # one address with main flag {"params": {"addresses": ["127.0.0.1"], "main": False}, "expect": [{"type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 0}, {"type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 0}]}, # not list {"params": {"addresses": "127.0.0.1"}, "expect": [{"type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 1}, {"type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 1}]}, # empty addresses {"params": {"addresses": [], "interface_types": [1]}, "expect": [{"type": 1, "useip": 0, "ip": "", "dns": "dummy-interface.invalid", "port": 10050, "main": 1}]}, # invalid addresses {"params": {"addresses": [None, ""], "interface_types": [1]}, "expect": [{"type": 1, "useip": 0, "ip": "", "dns": "dummy-interface.invalid", "port": 10050, "main": 1}]}, ] for data in test_data: interfaces = self.connector.addresses_to_interfaces(**data["params"]) self.assertListEqual(interfaces, data["expect"]) def test_interfaces_to_addresses(self): test_data = [ # not list {"params": {"interfaces": {"interfaceid": 1, "hostid": 10002, "dns": "", "ip": "127.0.0.1", "main": 1, "type": 1, "useip": 1, "port": 10050}}, "expect": ["127.0.0.1"]}, # two interfaces {"params": {"interfaces": [{"interfaceid": 1, "hostid": 10002, "dns": "", "ip": "127.0.0.1", "main": 1, "type": 1, "useip": 1, "port": 10050}, {"interfaceid": 2, "hostid": 10002, "dns": "localhost.localdomain", "ip": "", "main": 0, "type": 1, "useip": 0, "port": 10050}]}, "expect": ["127.0.0.1", "localhost.localdomain"]}, # not dict {"params": {"interfaces": ["127.0.0.1"]}, "expect": []}, # invalid dict {"params": {"interfaces": [{"aaa": "bbb"}]}, "expect": []}, ] for data in test_data: addresses = self.connector.interfaces_to_addresses(**data["params"]) self.assertListEqual(addresses, data["expect"]) def test_get_zabbix_host(self): result = self.connector.get_zabbix_host("i-aaaaaaaa") self.assertIsInstance(result, dict) self.assertEqual(result["host"], "i-aaaaaaaa") def test_get_zabbix_interfaces(self): # host exist result = self.connector.get_zabbix_interfaces("AWS", interface_type=1, main=True) self.assertListEqual(result, [{"interfaceid": 1, "hostid": 10006, "dns": "", "ip": "127.0.0.1", "main": 1, "type": 1, "useip": 1, "port": 10050}]) # host does not exist result = self.connector.get_zabbix_interfaces("not exist") self.assertListEqual(result, []) def test_get_user_macro(self): test_data = [ {"params": {"hostname": "AWS", "key": "{$KEY}"}, "expect": "key"}, {"params": {"hostname": "AWS", "key": "{$SECRET}"}, "expect": "secret"}, {"params": {"hostname": "AWS", "key": "{$VM_TEMPLATES_LINUX}"}, "expect": "Template OS Linux"}, {"params": {"hostname": "AWS", "key": "{$GLOBAL}"}, "expect": "global macro"}, {"params": {"hostname": "AWS", "key": "not found"}, "expect": None}, {"params": {"hostname": "not found", "key": "not found"}, "expect": None}, {"params": {"hostname": "AWS", "key": None}, "expect": None}, ] for data in test_data: result = self.connector.get_user_macro(**data["params"]) self.assertEqual(result, data["expect"]) def test_get_group_ids(self): test_data = [ {"params": {"owner_hostname": "AWS", "key": "{$VM_GROUPS}"}, "expect": [{"groupid": 2}]}, {"params": {"owner_hostname": "AWS", "key": "{$NOT_EXIST}"}, "expect": []}, {"params": {"owner_hostname": "AWS", "key": "{$GLOBAL}"}, "expect": [{"groupid": 3}]}, ] for data in test_data: result = self.connector.get_group_ids(**data["params"]) self.assertEqual(result, data["expect"]) self.connector.zabbix_api.hostgroup.create = Mock(side_effect=ZabbixAPIException()) result = self.connector.get_group_ids("AWS", "{$GLOBAL2}") self.assertListEqual(result, []) def test_get_template_ids(self): test_data = [ {"params": {"owner_hostname": "AWS", "key": "{$REQUIRED_TEMPLATES}"}, "expect": [{"templateid": 10002}]}, {"params": {"owner_hostname": "AWS", "key": ""}, "expect": [{"templateid": 10002}]}, {"params": {"owner_hostname": "AWS", "key": "{$GLOBAL}"}, "expect": []}, {"params": {"owner_hostname": "AWS", "key": "{$NOT_EXIST}"}, "expect": []}, {"params": {"owner_hostname": "NotExist", "key": ""}, "expect": []}, ] for data in test_data: result = self.connector.get_template_ids(**data["params"]) self.assertEqual(result, data["expect"]) def test_get_user_template_ids(self): test_data = [ {"params": {"owner_hostname": "AWS", "node": Mock(extra={"platform": None})}, "expect": [{"templateid": 10005}, {"templateid": 10003}]}, {"params": {"owner_hostname": "AWS", "node": Mock(extra={"platform": "windows"})}, "expect": [{"templateid": 10005}, {"templateid": 10004}]}, {"params": {"owner_hostname": "AWS", "node": Mock(extra={"platform": "Red Hat Enterprise Linux 6 (64bit)"})}, "expect": [{"templateid": 10005}, {"templateid": 10003}]}, {"params": {"owner_hostname": "AWS", "node": Mock(extra={"platform": "CentOS 4/5/6 (64bit)"})}, "expect": [{"templateid": 10005}, {"templateid": 10003}]}, {"params": {"owner_hostname": "AWS", "node": Mock(extra={"platform": "Microsoft Windows Server 2008 R2 (64bit)"})}, "expect": [{"templateid": 10005}, {"templateid": 10004}]}, ] for data in test_data: result = self.connector.get_user_template_ids(**data["params"]) self.assertListEqual(result, data["expect"]) def test_adjust_string_length(self): test_data = [ {"params": {"base_string": "1234567890", "suffix": "i-123456", "max_length": 64}, "expect": "1234567890_i-123456"}, {"params": {"base_string": "1234567890", "suffix": "i-123456", "max_length": 15}, "expect": "1234.._i-123456"}, {"params": {"base_string": "1234567890", "suffix": "", "max_length": 64}, "expect": "1234567890"}, {"params": {"base_string": "1234567890", "suffix": "", "max_length": 9}, "expect": "1234567.."}, {"params": {"base_string": "1234567890", "suffix": "i-1234567890", "max_length": 10}, "expect": "..34567890"} ] for data in test_data: result = self.connector.adjust_string_length(data["params"]["base_string"], data["params"]["suffix"], data["params"]["max_length"]) self.assertEqual(result, data["expect"])
class TestBaseConnector(unittest.TestCase): def setUp(self): logger = logging.getLogger('hyclops.connector.base') logger.addHandler(logging.NullHandler()) self.patcher = patch('hyclops.connector.base.ZabbixAPI', new=MockZabbixAPI) self.patcher.start() config_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), "test.conf") self.config = configobj.ConfigObj(config_path, file_error=True) self.connector = BaseConnector(config=self.config) self.connector.zabbix_api = MockZabbixAPI() self._create_zabbix_mock() def tearDown(self): self.patcher.stop() def _create_zabbix_mock(self): zabbix_api = self.connector.zabbix_api # create AWSAccount Group response = zabbix_api.hostgroup.create({"name": "AWSAccount"}) groupid_aws_account = response["groupids"][0] # create AmazonEC2 Group response = zabbix_api.hostgroup.create({"name": "AmazonEC2"}) groupid_amazon_ec2 = response["groupids"][0] # create AWSAccount Template response = zabbix_api.template.create({ "host": "AWSAccount", "groups": [{ "groupid": groupid_aws_account }], "macros": [ { "macro": "{$VM_GROUPS}", "value": "AmazonEC2" }, { "macro": "{$REQUIRED_TEMPLATES}", "value": "AmazonEC2" }, { "macro": "{$VM_TEMPLATES}", "value": "Template App Zabbix Agent" }, { "macro": "{$VM_TEMPLATES_LINUX}", "value": "Template OS Linux" }, { "macro": "{$VM_TEMPLATES_WINDOWS}", "value": "Template OS Windows" }, ] }) templateid_aws_account = response["templateids"][0] # create AmazonEC2 Template response = zabbix_api.template.create({ "host": "AmazonEC2", "groups": [{ "groupid": groupid_amazon_ec2 }], }) templateid_amazon_ec2 = response["templateids"][0] # create Template OS Linux response = zabbix_api.template.create({ "host": "Template OS Linux", "groups": [], }) # create Template OS Windows response = zabbix_api.template.create({ "host": "Template OS Windows", "groups": [], }) # create Template App Zabbix Agent response = zabbix_api.template.create({ "host": "Template App Zabbix Agent", "groups": [], }) # create AWS Host zabbix_api.host.create({ "host": "AWS", "interfaces": [ { "interfaceid": 1, "type": 1, "main": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050 }, ], "groups": [{ "groupid": groupid_aws_account }], "parentTemplates": [{ "templateid": templateid_aws_account }], "inventory": [], "macros": { "1": { "macro": "{$KEY}", "value": "key" }, "2": { "macro": "{$SECRET}", "value": "secret" }, }, }) # create EC2Instance(i-aaaaaaaa) Host zabbix_api.host.create({ "host": "i-aaaaaaaa", "name": "AWS_EC2Instance", "interfaces": [ { "interfaceid": 1, "type": 1, "main": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050 }, { "interfaceid": 2, "type": 2, "main": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161 }, ], "groups": [{ "groupid": groupid_amazon_ec2 }], "parentTemplates": [{ "templateid": templateid_amazon_ec2 }], "inventory": { "name": "EC2Instance", "type": "ec2", "tag": "AWS", "location": "us-east-1", "serialno_a": "i-aaaaaaaa", }, "macros": [], }) # create Global Macro zabbix_api.usermacro.create({ "globalmacro": True, "macro": "{$GLOBAL}", "value": "global macro", }) zabbix_api.usermacro.create({ "globalmacro": True, "macro": "{$GLOBAL2}", "value": "global macro 2", }) def test_init(self): self.assertIsInstance(self.connector.config, configobj.ConfigObj) self.assertIsInstance(self.connector.logger, logging.Logger) self.assertEqual(self.connector.zabbix_server, '127.0.0.1') self.assertEqual(self.connector.zabbix_port, '10051') self.assertEqual(self.connector.zabbix_sender_path, '/usr/bin/zabbix_sender') self.assertIsInstance(self.connector.zabbix_api, MockZabbixAPI) with self.assertRaises(KeyError): connector = BaseConnector(config=configobj.ConfigObj("wrong_path")) with patch('hyclops.connector.base.ZabbixAPI.login') as m: m.side_effect = ZabbixAPIException() with self.assertRaises(ZabbixAPIException): connector = BaseConnector(config=self.config) m.side_effect = Exception() with self.assertRaises(Exception): connector = BaseConnector(config=self.config) def test_call(self): with self.assertRaises(NotImplementedError): self.connector("hostname", {}) def test_escape_shell_args(self): test_data = [ "'", None, "string", [], [None], ["str1", "str2"], ("str1", ), (None, None), ( "cat", "'; echo 'command injection'; '", ) ] for data in test_data: escaped_args = self.connector.escape_shell_args(data) self.assertIsInstance(escaped_args, tuple) for arg in escaped_args: self.assertIsInstance(arg, str) self.assertTrue(re.match(r'^\'(.*)\'$', str(arg))) def test_zabbix_sender(self): test_data = [ { "zabbix_hostname": None, "key": None, "value": None }, { "zabbix_hostname": [], "key": {}, "value": (None, ) }, { "zabbix_hostname": "TestHost", "key": "item.key", "value": None }, { "zabbix_hostname": "TestHost", "key": "item.key", "value": 0 }, { "zabbix_hostname": "TestHost", "key": "item.key", "value": "string" }, { "zabbix_hostname": "TestHost", "key": "item.key", "value": ["array", None] }, { "zabbix_hostname": "TestHost", "key": "item.key", "value": { "dict": "string", "none": None } }, ] with patch('os.system') as m: m.return_value = 0 for data in test_data: try: self.connector.zabbix_sender(**data) except: self.fail("Unexpected Error") m.return_value = 1 for data in test_data: with self.assertRaises(Exception): self.connector.zabbix_sender(**data) def test_addresses_to_interfaces(self): test_data = [ # one addresses { "params": { "addresses": ["127.0.0.1"] }, "expect": [{ "type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 1 }, { "type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 1 }] }, # two addresses { "params": { "addresses": ["127.0.0.1", "localhost.localdomain"] }, "expect": [{ "type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 0 }, { "type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 0 }, { "type": 1, "useip": 0, "ip": "", "dns": "localhost.localdomain", "port": 10050, "main": 1 }, { "type": 2, "useip": 0, "ip": "", "dns": "localhost.localdomain", "port": 161, "main": 1 }] }, # one address with interface_types { "params": { "addresses": ["127.0.0.1"], "interface_types": [1] }, "expect": [{ "type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 1 }] }, # one address with main flag { "params": { "addresses": ["127.0.0.1"], "main": False }, "expect": [{ "type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 0 }, { "type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 0 }] }, # not list { "params": { "addresses": "127.0.0.1" }, "expect": [{ "type": 1, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 10050, "main": 1 }, { "type": 2, "useip": 1, "ip": "127.0.0.1", "dns": "", "port": 161, "main": 1 }] }, # empty addresses { "params": { "addresses": [], "interface_types": [1] }, "expect": [{ "type": 1, "useip": 0, "ip": "", "dns": "dummy-interface.invalid", "port": 10050, "main": 1 }] }, # invalid addresses { "params": { "addresses": [None, ""], "interface_types": [1] }, "expect": [{ "type": 1, "useip": 0, "ip": "", "dns": "dummy-interface.invalid", "port": 10050, "main": 1 }] }, ] for data in test_data: interfaces = self.connector.addresses_to_interfaces( **data["params"]) self.assertListEqual(interfaces, data["expect"]) def test_interfaces_to_addresses(self): test_data = [ # not list { "params": { "interfaces": { "interfaceid": 1, "hostid": 10002, "dns": "", "ip": "127.0.0.1", "main": 1, "type": 1, "useip": 1, "port": 10050 } }, "expect": ["127.0.0.1"] }, # two interfaces { "params": { "interfaces": [{ "interfaceid": 1, "hostid": 10002, "dns": "", "ip": "127.0.0.1", "main": 1, "type": 1, "useip": 1, "port": 10050 }, { "interfaceid": 2, "hostid": 10002, "dns": "localhost.localdomain", "ip": "", "main": 0, "type": 1, "useip": 0, "port": 10050 }] }, "expect": ["127.0.0.1", "localhost.localdomain"] }, # not dict { "params": { "interfaces": ["127.0.0.1"] }, "expect": [] }, # invalid dict { "params": { "interfaces": [{ "aaa": "bbb" }] }, "expect": [] }, ] for data in test_data: addresses = self.connector.interfaces_to_addresses( **data["params"]) self.assertListEqual(addresses, data["expect"]) def test_get_zabbix_host(self): result = self.connector.get_zabbix_host("i-aaaaaaaa") self.assertIsInstance(result, dict) self.assertEqual(result["host"], "i-aaaaaaaa") def test_get_zabbix_interfaces(self): # host exist result = self.connector.get_zabbix_interfaces("AWS", interface_type=1, main=True) self.assertListEqual(result, [{ "interfaceid": 1, "hostid": 10006, "dns": "", "ip": "127.0.0.1", "main": 1, "type": 1, "useip": 1, "port": 10050 }]) # host does not exist result = self.connector.get_zabbix_interfaces("not exist") self.assertListEqual(result, []) def test_get_user_macro(self): test_data = [ { "params": { "hostname": "AWS", "key": "{$KEY}" }, "expect": "key" }, { "params": { "hostname": "AWS", "key": "{$SECRET}" }, "expect": "secret" }, { "params": { "hostname": "AWS", "key": "{$VM_TEMPLATES_LINUX}" }, "expect": "Template OS Linux" }, { "params": { "hostname": "AWS", "key": "{$GLOBAL}" }, "expect": "global macro" }, { "params": { "hostname": "AWS", "key": "not found" }, "expect": None }, { "params": { "hostname": "not found", "key": "not found" }, "expect": None }, { "params": { "hostname": "AWS", "key": None }, "expect": None }, ] for data in test_data: result = self.connector.get_user_macro(**data["params"]) self.assertEqual(result, data["expect"]) def test_get_group_ids(self): test_data = [ { "params": { "owner_hostname": "AWS", "key": "{$VM_GROUPS}" }, "expect": [{ "groupid": 2 }] }, { "params": { "owner_hostname": "AWS", "key": "{$NOT_EXIST}" }, "expect": [] }, { "params": { "owner_hostname": "AWS", "key": "{$GLOBAL}" }, "expect": [{ "groupid": 3 }] }, ] for data in test_data: result = self.connector.get_group_ids(**data["params"]) self.assertEqual(result, data["expect"]) self.connector.zabbix_api.hostgroup.create = Mock( side_effect=ZabbixAPIException()) result = self.connector.get_group_ids("AWS", "{$GLOBAL2}") self.assertListEqual(result, []) def test_get_template_ids(self): test_data = [ { "params": { "owner_hostname": "AWS", "key": "{$REQUIRED_TEMPLATES}" }, "expect": [{ "templateid": 10002 }] }, { "params": { "owner_hostname": "AWS", "key": "" }, "expect": [{ "templateid": 10002 }] }, { "params": { "owner_hostname": "AWS", "key": "{$GLOBAL}" }, "expect": [] }, { "params": { "owner_hostname": "AWS", "key": "{$NOT_EXIST}" }, "expect": [] }, { "params": { "owner_hostname": "NotExist", "key": "" }, "expect": [] }, ] for data in test_data: result = self.connector.get_template_ids(**data["params"]) self.assertEqual(result, data["expect"]) def test_get_user_template_ids(self): test_data = [ { "params": { "owner_hostname": "AWS", "node": Mock(extra={"platform": None}) }, "expect": [{ "templateid": 10005 }, { "templateid": 10003 }] }, { "params": { "owner_hostname": "AWS", "node": Mock(extra={"platform": "windows"}) }, "expect": [{ "templateid": 10005 }, { "templateid": 10004 }] }, { "params": { "owner_hostname": "AWS", "node": Mock(extra={ "platform": "Red Hat Enterprise Linux 6 (64bit)" }) }, "expect": [{ "templateid": 10005 }, { "templateid": 10003 }] }, { "params": { "owner_hostname": "AWS", "node": Mock(extra={"platform": "CentOS 4/5/6 (64bit)"}) }, "expect": [{ "templateid": 10005 }, { "templateid": 10003 }] }, { "params": { "owner_hostname": "AWS", "node": Mock(extra={ "platform": "Microsoft Windows Server 2008 R2 (64bit)" }) }, "expect": [{ "templateid": 10005 }, { "templateid": 10004 }] }, ] for data in test_data: result = self.connector.get_user_template_ids(**data["params"]) self.assertListEqual(result, data["expect"]) def test_adjust_string_length(self): test_data = [{ "params": { "base_string": "1234567890", "suffix": "i-123456", "max_length": 64 }, "expect": "1234567890_i-123456" }, { "params": { "base_string": "1234567890", "suffix": "i-123456", "max_length": 15 }, "expect": "1234.._i-123456" }, { "params": { "base_string": "1234567890", "suffix": "", "max_length": 64 }, "expect": "1234567890" }, { "params": { "base_string": "1234567890", "suffix": "", "max_length": 9 }, "expect": "1234567.." }, { "params": { "base_string": "1234567890", "suffix": "i-1234567890", "max_length": 10 }, "expect": "..34567890" }] for data in test_data: result = self.connector.adjust_string_length( data["params"]["base_string"], data["params"]["suffix"], data["params"]["max_length"]) self.assertEqual(result, data["expect"])