| #!/usr/bin/python | |
| # | |
| # Copyright 2008 Google Inc. All Rights Reserved. | |
| """Test for host.""" | |
| # pylint: disable=missing-docstring | |
| import sys | |
| import unittest | |
| import mock | |
| import common | |
| from autotest_lib.cli import cli_mock, host | |
| from autotest_lib.client.common_lib import control_data | |
| from autotest_lib.server import hosts | |
| CLIENT = control_data.CONTROL_TYPE_NAMES.CLIENT | |
| SERVER = control_data.CONTROL_TYPE_NAMES.SERVER | |
| class host_ut(cli_mock.cli_unittest): | |
| def test_parse_lock_options_both_set(self): | |
| hh = host.host() | |
| class opt(object): | |
| lock = True | |
| unlock = True | |
| options = opt() | |
| self.usage = "unused" | |
| sys.exit.expect_call(1).and_raises(cli_mock.ExitException) | |
| self.god.mock_io() | |
| self.assertRaises(cli_mock.ExitException, | |
| hh._parse_lock_options, options) | |
| self.god.unmock_io() | |
| def test_cleanup_labels_with_platform(self): | |
| labels = ['l0', 'l1', 'l2', 'p0', 'l3'] | |
| hh = host.host() | |
| self.assertEqual(['l0', 'l1', 'l2', 'l3'], | |
| hh._cleanup_labels(labels, 'p0')) | |
| def test_cleanup_labels_no_platform(self): | |
| labels = ['l0', 'l1', 'l2', 'l3'] | |
| hh = host.host() | |
| self.assertEqual(['l0', 'l1', 'l2', 'l3'], | |
| hh._cleanup_labels(labels)) | |
| def test_cleanup_labels_with_non_avail_platform(self): | |
| labels = ['l0', 'l1', 'l2', 'l3'] | |
| hh = host.host() | |
| self.assertEqual(['l0', 'l1', 'l2', 'l3'], | |
| hh._cleanup_labels(labels, 'p0')) | |
| class host_list_unittest(cli_mock.cli_unittest): | |
| def test_parse_host_not_required(self): | |
| hl = host.host_list() | |
| sys.argv = ['atest'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqual([], hl.hosts) | |
| self.assertEqual([], leftover) | |
| def test_parse_with_hosts(self): | |
| hl = host.host_list() | |
| mfile = cli_mock.create_file('host0\nhost3\nhost4\n') | |
| sys.argv = ['atest', 'host1', '--mlist', mfile.name, 'host3'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqualNoOrder(['host0', 'host1','host3', 'host4'], | |
| hl.hosts) | |
| self.assertEqual(leftover, []) | |
| mfile.clean() | |
| def test_parse_with_labels(self): | |
| hl = host.host_list() | |
| sys.argv = ['atest', '--label', 'label0'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqual(['label0'], hl.labels) | |
| self.assertEqual(leftover, []) | |
| def test_parse_with_multi_labels(self): | |
| hl = host.host_list() | |
| sys.argv = ['atest', '--label', 'label0,label2'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqualNoOrder(['label0', 'label2'], hl.labels) | |
| self.assertEqual(leftover, []) | |
| def test_parse_with_escaped_commas_label(self): | |
| hl = host.host_list() | |
| sys.argv = ['atest', '--label', 'label\\,0'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqual(['label,0'], hl.labels) | |
| self.assertEqual(leftover, []) | |
| def test_parse_with_escaped_commas_multi_labels(self): | |
| hl = host.host_list() | |
| sys.argv = ['atest', '--label', 'label\\,0,label\\,2'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqualNoOrder(['label,0', 'label,2'], hl.labels) | |
| self.assertEqual(leftover, []) | |
| def test_parse_with_both(self): | |
| hl = host.host_list() | |
| mfile = cli_mock.create_file('host0\nhost3\nhost4\n') | |
| sys.argv = ['atest', 'host1', '--mlist', mfile.name, 'host3', | |
| '--label', 'label0'] | |
| (options, leftover) = hl.parse() | |
| self.assertEqualNoOrder(['host0', 'host1','host3', 'host4'], | |
| hl.hosts) | |
| self.assertEqual(['label0'], hl.labels) | |
| self.assertEqual(leftover, []) | |
| mfile.clean() | |
| def test_execute_list_all_no_labels(self): | |
| self.run_cmd(argv=['atest', 'host', 'list'], | |
| rpcs=[('get_hosts', {}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [], | |
| u'invalid': False, | |
| u'platform': None, | |
| u'shard': None, | |
| u'id': 1}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}])], | |
| out_words_ok=['host0', 'host1', 'Ready', | |
| 'plat1', 'False', 'True', 'None']) | |
| def test_execute_list_all_with_labels(self): | |
| self.run_cmd(argv=['atest', 'host', 'list'], | |
| rpcs=[('get_hosts', {}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label0', u'label1'], | |
| u'invalid': False, | |
| u'platform': None, | |
| u'shard': None, | |
| u'id': 1}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 2}])], | |
| out_words_ok=['host0', 'host1', 'Ready', 'plat1', | |
| 'label0', 'label1', 'label2', 'label3', | |
| 'False', 'True', 'None']) | |
| def test_execute_list_filter_one_host(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1'], | |
| rpcs=[('get_hosts', {'hostname__in': ['host1']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', 'None'], | |
| out_words_no=['host0', 'host2', | |
| 'label1', 'False']) | |
| def test_execute_list_filter_two_hosts(self): | |
| mfile = cli_mock.create_file('host2') | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '--mlist', mfile.name], | |
| # This is a bit fragile as the list order may change... | |
| rpcs=[('get_hosts', {'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'False']) | |
| mfile.clean() | |
| def test_execute_list_filter_two_hosts_one_not_found(self): | |
| mfile = cli_mock.create_file('host2') | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '--mlist', mfile.name], | |
| # This is a bit fragile as the list order may change... | |
| rpcs=[('get_hosts', {'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['Ready', 'plat1', | |
| 'label3', 'True', 'None'], | |
| out_words_no=['host1', 'False'], | |
| err_words_ok=['host1']) | |
| mfile.clean() | |
| def test_execute_list_filter_two_hosts_none_found(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| 'host1', 'host2'], | |
| # This is a bit fragile as the list order may change... | |
| rpcs=[('get_hosts', {'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [])], | |
| out_words_ok=[], | |
| out_words_no=['Hostname', 'Status'], | |
| err_words_ok=['Unknown', 'host1', 'host2']) | |
| def test_execute_list_filter_label(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '-b', 'label3'], | |
| rpcs=[('get_hosts', {'labels__name__in': ['label3']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'False']) | |
| def test_execute_list_filter_multi_labels(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '-b', 'label3,label2'], | |
| rpcs=[('get_hosts', {'multiple_labels': ['label2', | |
| 'label3']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat0'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat0', | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host3', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'label2', u'plat2'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat2', | |
| u'id': 4}])], | |
| out_words_ok=['host1', 'host3', 'Ready', 'plat0', | |
| 'label2', 'label3', 'plat2', 'None'], | |
| out_words_no=['host2', 'False', 'plat1']) | |
| def test_execute_list_filter_three_labels(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '-b', 'label3,label2'], | |
| rpcs=[('get_hosts', {'multiple_labels': ['label2', | |
| 'label3']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'label2', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 3}])], | |
| out_words_ok=['host2', 'plat1', | |
| 'label2', 'label3', 'None'], | |
| out_words_no=['host1', 'host3']) | |
| def test_execute_list_filter_wild_labels(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '-b', 'label*'], | |
| rpcs=[('get_hosts', | |
| {'labels__name__startswith': 'label'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': 1, | |
| u'shard': None, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'label2', u'plat1'], | |
| u'invalid': 0, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host2', 'plat1', | |
| 'label2', 'label3', 'None'], | |
| out_words_no=['host1', 'host3']) | |
| def test_execute_list_filter_multi_labels_no_results(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '-b', 'label3,label2, '], | |
| rpcs=[('get_hosts', {'multiple_labels': ['label2', | |
| 'label3']}, | |
| True, | |
| [])], | |
| out_words_ok=[], | |
| out_words_no=['host1', 'host2', 'host3', | |
| 'label2', 'label3']) | |
| def test_execute_list_filter_label_and_hosts(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '-b', 'label3', 'host2'], | |
| rpcs=[('get_hosts', {'labels__name__in': ['label3'], | |
| 'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'lock_reason': u'', | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'False']) | |
| def test_execute_list_filter_label_and_hosts_none(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '-b', 'label3', 'host2'], | |
| rpcs=[('get_hosts', {'labels__name__in': ['label3'], | |
| 'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [])], | |
| out_words_ok=[], | |
| out_words_no=['Hostname', 'Status'], | |
| err_words_ok=['Unknown', 'host1', 'host2']) | |
| def test_execute_list_filter_status(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '-s', 'Ready'], | |
| rpcs=[('get_hosts', {'status__in': ['Ready']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'False']) | |
| def test_execute_list_filter_status_and_hosts(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '-s', 'Ready', 'host2'], | |
| rpcs=[('get_hosts', {'status__in': ['Ready'], | |
| 'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'False']) | |
| def test_execute_list_filter_status_and_hosts_none(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '--status', 'Repair', | |
| 'host2'], | |
| rpcs=[('get_hosts', {'status__in': ['Repair'], | |
| 'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [])], | |
| out_words_ok=[], | |
| out_words_no=['Hostname', 'Status'], | |
| err_words_ok=['Unknown', 'host2']) | |
| def test_execute_list_filter_statuses_and_hosts_none(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '--status', 'Repair', | |
| 'host2'], | |
| rpcs=[('get_hosts', {'status__in': ['Repair'], | |
| 'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [])], | |
| out_words_ok=[], | |
| out_words_no=['Hostname', 'Status'], | |
| err_words_ok=['Unknown', 'host2']) | |
| def test_execute_list_filter_locked(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', 'host1', | |
| '--locked', 'host2'], | |
| rpcs=[('get_hosts', {'locked': True, | |
| 'hostname__in': ['host2', 'host1']}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_reason': u'', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'shard': None, | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'lock_reason': u'', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'True', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'False']) | |
| def test_execute_list_filter_unlocked(self): | |
| self.run_cmd(argv=['atest', 'host', 'list', | |
| '--unlocked'], | |
| rpcs=[('get_hosts', {'locked': False}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label2', u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 2}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host2', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3}])], | |
| out_words_ok=['host1', 'Ready', 'plat1', | |
| 'label2', 'label3', 'False', | |
| 'host2', 'None'], | |
| out_words_no=['host0', 'label1', 'True']) | |
| class host_stat_unittest(cli_mock.cli_unittest): | |
| def test_execute_stat_two_hosts(self): | |
| # The order of RPCs between host1 and host0 could change... | |
| self.run_cmd(argv=['atest', 'host', 'stat', 'host0', 'host1'], | |
| rpcs=[('get_hosts', {'hostname': 'host1'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'locked_by': 'user0', | |
| u'lock_reason': u'', | |
| u'protection': 'No protection', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat1', | |
| u'id': 3, | |
| u'attributes': {}}]), | |
| ('get_hosts', {'hostname': 'host0'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'protection': u'No protection', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'shard': None, | |
| u'platform': u'plat0', | |
| u'id': 2, | |
| u'attributes': {}}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host1'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user2', u'debug_user', u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host1'}, | |
| True, | |
| [{u'id': 2, | |
| u'platform': 1, | |
| u'name': u'jme', | |
| u'invalid': False, | |
| u'kernel_config': u''}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host0'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user0', u'debug_user']}, | |
| {u'description': u'myacl0', | |
| u'hosts': [u'host0'], | |
| u'id': 2, | |
| u'name': u'acl0', | |
| u'users': [u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host0'}, | |
| True, | |
| [{u'id': 4, | |
| u'platform': 0, | |
| u'name': u'label0', | |
| u'invalid': False, | |
| u'kernel_config': u''}, | |
| {u'id': 5, | |
| u'platform': 1, | |
| u'name': u'plat0', | |
| u'invalid': False, | |
| u'kernel_config': u''}])], | |
| out_words_ok=['host0', 'host1', 'plat0', 'plat1', | |
| 'Everyone', 'acl0', 'label0']) | |
| def test_execute_stat_one_bad_host_verbose(self): | |
| self.run_cmd(argv=['atest', 'host', 'stat', 'host0', | |
| 'host1', '-v'], | |
| rpcs=[('get_hosts', {'hostname': 'host1'}, | |
| True, | |
| []), | |
| ('get_hosts', {'hostname': 'host0'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'protection': u'No protection', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'platform': u'plat0', | |
| u'id': 2, | |
| u'attributes': {}}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host0'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user0', u'debug_user']}, | |
| {u'description': u'myacl0', | |
| u'hosts': [u'host0'], | |
| u'id': 2, | |
| u'name': u'acl0', | |
| u'users': [u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host0'}, | |
| True, | |
| [{u'id': 4, | |
| u'platform': 0, | |
| u'name': u'label0', | |
| u'invalid': False, | |
| u'kernel_config': u''}, | |
| {u'id': 5, | |
| u'platform': 1, | |
| u'name': u'plat0', | |
| u'invalid': False, | |
| u'kernel_config': u''}])], | |
| out_words_ok=['host0', 'plat0', | |
| 'Everyone', 'acl0', 'label0'], | |
| out_words_no=['host1'], | |
| err_words_ok=['host1', 'Unknown host'], | |
| err_words_no=['host0']) | |
| def test_execute_stat_one_bad_host(self): | |
| self.run_cmd(argv=['atest', 'host', 'stat', 'host0', 'host1'], | |
| rpcs=[('get_hosts', {'hostname': 'host1'}, | |
| True, | |
| []), | |
| ('get_hosts', {'hostname': 'host0'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'protection': u'No protection', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'platform': u'plat0', | |
| u'id': 2, | |
| u'attributes': {}}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host0'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user0', u'debug_user']}, | |
| {u'description': u'myacl0', | |
| u'hosts': [u'host0'], | |
| u'id': 2, | |
| u'name': u'acl0', | |
| u'users': [u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host0'}, | |
| True, | |
| [{u'id': 4, | |
| u'platform': 0, | |
| u'name': u'label0', | |
| u'invalid': False, | |
| u'kernel_config': u''}, | |
| {u'id': 5, | |
| u'platform': 1, | |
| u'name': u'plat0', | |
| u'invalid': False, | |
| u'kernel_config': u''}])], | |
| out_words_ok=['host0', 'plat0', | |
| 'Everyone', 'acl0', 'label0'], | |
| out_words_no=['host1'], | |
| err_words_ok=['host1', 'Unknown host'], | |
| err_words_no=['host0']) | |
| def test_execute_stat_wildcard(self): | |
| # The order of RPCs between host1 and host0 could change... | |
| self.run_cmd(argv=['atest', 'host', 'stat', 'ho*'], | |
| rpcs=[('get_hosts', {'hostname__startswith': 'ho'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'locked_by': 'user0', | |
| u'lock_reason': u'', | |
| u'protection': 'No protection', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'id': 3, | |
| u'attributes': {}}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'protection': u'No protection', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'platform': u'plat0', | |
| u'id': 2, | |
| u'attributes': {}}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host1'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user2', u'debug_user', u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host1'}, | |
| True, | |
| [{u'id': 2, | |
| u'platform': 1, | |
| u'name': u'jme', | |
| u'invalid': False, | |
| u'kernel_config': u''}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host0'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user0', u'debug_user']}, | |
| {u'description': u'myacl0', | |
| u'hosts': [u'host0'], | |
| u'id': 2, | |
| u'name': u'acl0', | |
| u'users': [u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host0'}, | |
| True, | |
| [{u'id': 4, | |
| u'platform': 0, | |
| u'name': u'label0', | |
| u'invalid': False, | |
| u'kernel_config': u''}, | |
| {u'id': 5, | |
| u'platform': 1, | |
| u'name': u'plat0', | |
| u'invalid': False, | |
| u'kernel_config': u''}])], | |
| out_words_ok=['host0', 'host1', 'plat0', 'plat1', | |
| 'Everyone', 'acl0', 'label0']) | |
| def test_execute_stat_wildcard_and_host(self): | |
| # The order of RPCs between host1 and host0 could change... | |
| self.run_cmd(argv=['atest', 'host', 'stat', 'ho*', 'newhost0'], | |
| rpcs=[('get_hosts', {'hostname': 'newhost0'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'newhost0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'lock_reason': u'', | |
| u'protection': u'No protection', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'platform': u'plat0', | |
| u'id': 5, | |
| u'attributes': {}}]), | |
| ('get_hosts', {'hostname__startswith': 'ho'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'locked_by': 'user0', | |
| u'lock_reason': u'', | |
| u'protection': 'No protection', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'id': 3, | |
| u'attributes': {}}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_reason': u'', | |
| u'protection': 'No protection', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'platform': u'plat0', | |
| u'id': 2, | |
| u'attributes': {}}]), | |
| ('get_acl_groups', {'hosts__hostname': 'newhost0'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'newhost0', 'host1'], | |
| u'id': 42, | |
| u'name': u'my_acl', | |
| u'users': [u'user0', u'debug_user']}, | |
| {u'description': u'my favorite acl', | |
| u'hosts': [u'newhost0'], | |
| u'id': 2, | |
| u'name': u'acl10', | |
| u'users': [u'user0']}]), | |
| ('get_labels', {'host__hostname': 'newhost0'}, | |
| True, | |
| [{u'id': 4, | |
| u'platform': 0, | |
| u'name': u'label0', | |
| u'invalid': False, | |
| u'kernel_config': u''}, | |
| {u'id': 5, | |
| u'platform': 1, | |
| u'name': u'plat0', | |
| u'invalid': False, | |
| u'kernel_config': u''}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host1'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user2', u'debug_user', u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host1'}, | |
| True, | |
| [{u'id': 2, | |
| u'platform': 1, | |
| u'name': u'jme', | |
| u'invalid': False, | |
| u'kernel_config': u''}]), | |
| ('get_acl_groups', {'hosts__hostname': 'host0'}, | |
| True, | |
| [{u'description': u'', | |
| u'hosts': [u'host0', u'host1'], | |
| u'id': 1, | |
| u'name': u'Everyone', | |
| u'users': [u'user0', u'debug_user']}, | |
| {u'description': u'myacl0', | |
| u'hosts': [u'host0'], | |
| u'id': 2, | |
| u'name': u'acl0', | |
| u'users': [u'user0']}]), | |
| ('get_labels', {'host__hostname': 'host0'}, | |
| True, | |
| [{u'id': 4, | |
| u'platform': 0, | |
| u'name': u'label0', | |
| u'invalid': False, | |
| u'kernel_config': u''}, | |
| {u'id': 5, | |
| u'platform': 1, | |
| u'name': u'plat0', | |
| u'invalid': False, | |
| u'kernel_config': u''}])], | |
| out_words_ok=['host0', 'host1', 'newhost0', | |
| 'plat0', 'plat1', | |
| 'Everyone', 'acl10', 'label0']) | |
| class host_jobs_unittest(cli_mock.cli_unittest): | |
| def test_execute_jobs_one_host(self): | |
| self.run_cmd(argv=['atest', 'host', 'jobs', 'host0'], | |
| rpcs=[('get_host_queue_entries', | |
| {'host__hostname': 'host0', 'query_limit': 20, | |
| 'sort_by': ['-job__id']}, | |
| True, | |
| [{u'status': u'Failed', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host0', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': u'meta0', | |
| u'job': {u'control_file': | |
| (u"def step_init():\n" | |
| "\tjob.next_step([step_test])\n" | |
| "def step_test():\n" | |
| "\tjob.run_test('kernbench')\n\n"), | |
| u'name': u'kernel-smp-2.6.xyz.x86_64', | |
| u'control_type': CLIENT, | |
| u'synchronizing': None, | |
| u'priority': u'Low', | |
| u'owner': u'user0', | |
| u'created_on': u'2008-01-09 10:45:12', | |
| u'synch_count': None, | |
| u'id': 216}, | |
| u'active': 0, | |
| u'id': 2981}, | |
| {u'status': u'Aborted', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host0', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': None, | |
| u'job': {u'control_file': | |
| u"job.run_test('sleeptest')\n\n", | |
| u'name': u'testjob', | |
| u'control_type': CLIENT, | |
| u'synchronizing': 0, | |
| u'priority': u'Low', | |
| u'owner': u'user1', | |
| u'created_on': u'2008-01-17 15:04:53', | |
| u'synch_count': None, | |
| u'id': 289}, | |
| u'active': 0, | |
| u'id': 3167}])], | |
| out_words_ok=['216', 'user0', 'Failed', | |
| 'kernel-smp-2.6.xyz.x86_64', 'Aborted', | |
| '289', 'user1', 'Aborted', | |
| 'testjob']) | |
| def test_execute_jobs_wildcard(self): | |
| self.run_cmd(argv=['atest', 'host', 'jobs', 'ho*'], | |
| rpcs=[('get_hosts', {'hostname__startswith': 'ho'}, | |
| True, | |
| [{u'status': u'Ready', | |
| u'hostname': u'host1', | |
| u'locked': True, | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'locked_by': 'user0', | |
| u'labels': [u'label3', u'plat1'], | |
| u'invalid': False, | |
| u'platform': u'plat1', | |
| u'id': 3}, | |
| {u'status': u'Ready', | |
| u'hostname': u'host0', | |
| u'locked': False, | |
| u'locked_by': 'user0', | |
| u'lock_time': u'2008-07-23 12:54:15', | |
| u'labels': [u'label0', u'plat0'], | |
| u'invalid': False, | |
| u'platform': u'plat0', | |
| u'id': 2}]), | |
| ('get_host_queue_entries', | |
| {'host__hostname': 'host1', 'query_limit': 20, | |
| 'sort_by': ['-job__id']}, | |
| True, | |
| [{u'status': u'Failed', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host1', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': u'meta0', | |
| u'job': {u'control_file': | |
| (u"def step_init():\n" | |
| "\tjob.next_step([step_test])\n" | |
| "def step_test():\n" | |
| "\tjob.run_test('kernbench')\n\n"), | |
| u'name': u'kernel-smp-2.6.xyz.x86_64', | |
| u'control_type': CLIENT, | |
| u'synchronizing': None, | |
| u'priority': u'Low', | |
| u'owner': u'user0', | |
| u'created_on': u'2008-01-09 10:45:12', | |
| u'synch_count': None, | |
| u'id': 216}, | |
| u'active': 0, | |
| u'id': 2981}, | |
| {u'status': u'Aborted', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host1', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': None, | |
| u'job': {u'control_file': | |
| u"job.run_test('sleeptest')\n\n", | |
| u'name': u'testjob', | |
| u'control_type': CLIENT, | |
| u'synchronizing': 0, | |
| u'priority': u'Low', | |
| u'owner': u'user1', | |
| u'created_on': u'2008-01-17 15:04:53', | |
| u'synch_count': None, | |
| u'id': 289}, | |
| u'active': 0, | |
| u'id': 3167}]), | |
| ('get_host_queue_entries', | |
| {'host__hostname': 'host0', 'query_limit': 20, | |
| 'sort_by': ['-job__id']}, | |
| True, | |
| [{u'status': u'Failed', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host0', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': u'meta0', | |
| u'job': {u'control_file': | |
| (u"def step_init():\n" | |
| "\tjob.next_step([step_test])\n" | |
| "def step_test():\n" | |
| "\tjob.run_test('kernbench')\n\n"), | |
| u'name': u'kernel-smp-2.6.xyz.x86_64', | |
| u'control_type': CLIENT, | |
| u'synchronizing': None, | |
| u'priority': u'Low', | |
| u'owner': u'user0', | |
| u'created_on': u'2008-01-09 10:45:12', | |
| u'synch_count': None, | |
| u'id': 216}, | |
| u'active': 0, | |
| u'id': 2981}, | |
| {u'status': u'Aborted', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host0', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': None, | |
| u'job': {u'control_file': | |
| u"job.run_test('sleeptest')\n\n", | |
| u'name': u'testjob', | |
| u'control_type': CLIENT, | |
| u'synchronizing': 0, | |
| u'priority': u'Low', | |
| u'owner': u'user1', | |
| u'created_on': u'2008-01-17 15:04:53', | |
| u'synch_count': None, | |
| u'id': 289}, | |
| u'active': 0, | |
| u'id': 3167}])], | |
| out_words_ok=['216', 'user0', 'Failed', | |
| 'kernel-smp-2.6.xyz.x86_64', 'Aborted', | |
| '289', 'user1', 'Aborted', | |
| 'testjob']) | |
| def test_execute_jobs_one_host_limit(self): | |
| self.run_cmd(argv=['atest', 'host', 'jobs', 'host0', '-q', '10'], | |
| rpcs=[('get_host_queue_entries', | |
| {'host__hostname': 'host0', 'query_limit': 10, | |
| 'sort_by': ['-job__id']}, | |
| True, | |
| [{u'status': u'Failed', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host0', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': u'meta0', | |
| u'job': {u'control_file': | |
| (u"def step_init():\n" | |
| "\tjob.next_step([step_test])\n" | |
| "def step_test():\n" | |
| "\tjob.run_test('kernbench')\n\n"), | |
| u'name': u'kernel-smp-2.6.xyz.x86_64', | |
| u'control_type': CLIENT, | |
| u'synchronizing': None, | |
| u'priority': u'Low', | |
| u'owner': u'user0', | |
| u'created_on': u'2008-01-09 10:45:12', | |
| u'synch_count': None, | |
| u'id': 216}, | |
| u'active': 0, | |
| u'id': 2981}, | |
| {u'status': u'Aborted', | |
| u'complete': 1, | |
| u'host': {u'status': u'Ready', | |
| u'locked': True, | |
| u'locked_by': 'user0', | |
| u'hostname': u'host0', | |
| u'invalid': False, | |
| u'id': 3232}, | |
| u'priority': 0, | |
| u'meta_host': None, | |
| u'job': {u'control_file': | |
| u"job.run_test('sleeptest')\n\n", | |
| u'name': u'testjob', | |
| u'control_type': CLIENT, | |
| u'synchronizing': 0, | |
| u'priority': u'Low', | |
| u'owner': u'user1', | |
| u'created_on': u'2008-01-17 15:04:53', | |
| u'synch_count': None, | |
| u'id': 289}, | |
| u'active': 0, | |
| u'id': 3167}])], | |
| out_words_ok=['216', 'user0', 'Failed', | |
| 'kernel-smp-2.6.xyz.x86_64', 'Aborted', | |
| '289', 'user1', 'Aborted', | |
| 'testjob']) | |
| class host_mod_create_tests(object): | |
| def _gen_attributes_rpcs(self, host, attributes): | |
| """Generate RPCs expected to add attributes to host. | |
| @param host: hostname | |
| @param attributes: dict of attributes | |
| @return: list of rpcs to expect | |
| """ | |
| rpcs = [] | |
| for attr, val in attributes.iteritems(): | |
| rpcs.append(('set_host_attribute', | |
| { | |
| 'hostname': host, | |
| 'attribute': attr, | |
| 'value': val, | |
| }, | |
| True, None)) | |
| return rpcs | |
| def _gen_labels_rpcs(self, labels, platform=False, host_id=None): | |
| """Generate RPCS expected to add labels. | |
| @param labels: list of label names | |
| @param platform: labels are platform labels | |
| @param host_id: Host id old labels will be deleted from (if host exists) | |
| """ | |
| rpcs = [] | |
| if host_id: | |
| rpcs.append(('get_labels', {'host': host_id}, True, [])) | |
| for label in labels: | |
| rpcs += [ | |
| ('get_labels', {'name': label}, True, []), | |
| ('add_label', {'name': label}, True, None) | |
| ] | |
| if platform: | |
| rpcs[-1][1]['platform'] = True | |
| return rpcs | |
| def _gen_acls_rpcs(self, hosts, acls, host_ids=[]): | |
| """Generate RPCs expected to add acls. | |
| @param hosts: list of hostnames | |
| @param acls: list of acl names | |
| @param host_ids: List of host_ids if hosts already exist | |
| """ | |
| rpcs = [] | |
| for host_id in host_ids: | |
| rpcs.append(('get_acl_groups', {'hosts': host_id}, True, [])) | |
| for acl in acls: | |
| rpcs.append(('get_acl_groups', {'name': acl}, True, [])) | |
| rpcs.append(('add_acl_group', {'name': acl}, True, None)) | |
| for acl in acls: | |
| rpcs.append(( | |
| 'acl_group_add_hosts', | |
| { | |
| 'hosts': hosts, | |
| 'id': acl, | |
| }, | |
| True, | |
| None, | |
| )) | |
| return rpcs | |
| def test_lock_one_host(self): | |
| """Test locking host / creating host locked.""" | |
| lock_reason = 'Because' | |
| rpcs, out = self._gen_expectations(locked=True, lock_reason=lock_reason) | |
| self.run_cmd(argv=self._command_single + ['--lock', '--lock_reason', | |
| lock_reason], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_unlock_multiple_hosts(self): | |
| """Test unlocking host / creating host unlocked.""" | |
| rpcs, out = self._gen_expectations(hosts=self._hosts, locked=False) | |
| self.run_cmd(argv=self._command_multiple + ['--unlock'], rpcs=rpcs, | |
| out_words_ok=out) | |
| def test_machine_list(self): | |
| """Test action an machines from machine list file.""" | |
| mfile = cli_mock.create_file(','.join(self._hosts)) | |
| rpcs, out = self._gen_expectations(hosts=self._hosts, locked=False) | |
| try: | |
| self.run_cmd(argv=self._command_multiple + ['--unlock'], rpcs=rpcs, | |
| out_words_ok=out) | |
| finally: | |
| mfile.clean() | |
| def test_single_attributes(self): | |
| """Test applying one attribute to one host.""" | |
| attrs = {'foo': 'bar'} | |
| rpcs, out = self._gen_expectations(attributes=attrs) | |
| self.run_cmd(self._command_single + ['--attribute', 'foo=bar'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_attributes_comma(self): | |
| """Test setting an attribute with a comma in the value.""" | |
| attrs = {'foo': 'bar,zip'} | |
| rpcs, out = self._gen_expectations(attributes=attrs) | |
| self.run_cmd(self._command_single + ['--attribute', 'foo=bar,zip'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_multiple_attributes_comma(self): | |
| """Test setting attributes when one of the values contains a comma.""" | |
| attrs = {'foo': 'bar,zip', 'zang': 'poodle'} | |
| rpcs, out = self._gen_expectations(attributes=attrs) | |
| self.run_cmd(self._command_single + ['--attribute', 'foo=bar,zip', | |
| '--attribute', 'zang=poodle'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_multiple_attributes_multiple_hosts(self): | |
| """Test applying multiple attributes to multiple hosts.""" | |
| attrs = {'foo': 'bar', 'baz': 'zip'} | |
| rpcs, out = self._gen_expectations(hosts=self._hosts, attributes=attrs) | |
| self.run_cmd(self._command_multiple + ['--attribute', 'foo=bar', | |
| '--attribute', 'baz=zip'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_platform(self): | |
| """Test applying platform label.""" | |
| rpcs, out = self._gen_expectations(platform='some_platform') | |
| self.run_cmd(argv=self._command_single + ['--platform', | |
| 'some_platform'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_labels(self): | |
| """Test applying labels.""" | |
| labels = ['label0', 'label1'] | |
| rpcs, out = self._gen_expectations(labels=labels) | |
| self.run_cmd(argv=self._command_single + ['--labels', ','.join(labels)], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_labels_from_file(self): | |
| """Test applying labels from file.""" | |
| labels = ['label0', 'label1'] | |
| rpcs, out = self._gen_expectations(labels=labels) | |
| labelsf = cli_mock.create_file(','.join(labels)) | |
| try: | |
| self.run_cmd(argv=self._command_single + ['--blist', labelsf.name], | |
| rpcs=rpcs, out_words_ok=out) | |
| finally: | |
| labelsf.clean() | |
| def test_acls(self): | |
| """Test applying acls.""" | |
| acls = ['acl0', 'acl1'] | |
| rpcs, out = self._gen_expectations(acls=acls) | |
| self.run_cmd(argv=self._command_single + ['--acls', ','.join(acls)], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_acls_from_file(self): | |
| """Test applying acls from file.""" | |
| acls = ['acl0', 'acl1'] | |
| rpcs, out = self._gen_expectations(acls=acls) | |
| aclsf = cli_mock.create_file(','.join(acls)) | |
| try: | |
| self.run_cmd(argv=self._command_single + ['-A', aclsf.name], | |
| rpcs=rpcs, out_words_ok=out) | |
| finally: | |
| aclsf.clean() | |
| def test_protection(self): | |
| """Test applying host protection.""" | |
| protection = 'Do not repair' | |
| rpcs, out = self._gen_expectations(protection=protection) | |
| self.run_cmd(argv=self._command_single + ['--protection', protection], | |
| rpcs=rpcs,out_words_ok=out) | |
| def test_protection_invalid(self): | |
| """Test invalid protection causes failure.""" | |
| protection = 'Invalid protection' | |
| rpcs, out = self._gen_expectations(hosts=[]) | |
| self.run_cmd(argv=self._command_single + ['--protection', protection], | |
| exit_code=2, err_words_ok=['invalid', 'choice'] + | |
| protection.split()) | |
| def test_complex(self): | |
| """Test applying multiple modifications / creating a complex host.""" | |
| lock_reason = 'Because I said so.' | |
| platform = 'some_platform' | |
| labels = ['label0', 'label1'] | |
| acls = ['acl0', 'acl1'] | |
| protection = 'Do not verify' | |
| labelsf = cli_mock.create_file(labels[1]) | |
| aclsf = cli_mock.create_file(acls[1]) | |
| cmd_args = ['-l', '-r', lock_reason, '-t', platform, '-b', labels[0], | |
| '-B', labelsf.name, '-a', acls[0], '-A', aclsf.name, '-p', | |
| protection] | |
| rpcs, out = self._gen_expectations(locked=True, lock_reason=lock_reason, | |
| acls=acls, labels=labels, | |
| platform=platform, | |
| protection=protection) | |
| try: | |
| self.run_cmd(argv=self._command_single + cmd_args, rpcs=rpcs, | |
| out_words_ok=out) | |
| finally: | |
| labelsf.clean() | |
| aclsf.clean() | |
| class host_mod_unittest(host_mod_create_tests, cli_mock.cli_unittest): | |
| """Tests specific to the mod action and expectation generator for shared | |
| tests. | |
| """ | |
| _hosts = ['localhost', '127.0.0.1'] | |
| _host_ids = [1, 2] | |
| _command_base = ['atest', 'host', 'mod'] | |
| _command_single = _command_base + [_hosts[0]] | |
| _command_multiple = _command_base + _hosts | |
| def _gen_expectations(self, hosts=['localhost'], locked=None, | |
| lock_reason='', force_lock=False, protection=None, | |
| acls=[], labels=[], platform=None, attributes={}): | |
| rpcs = [] | |
| out = set() | |
| hosts = hosts[:] | |
| hosts.reverse() | |
| # Genarate result for get_hosts command to include all known hosts | |
| host_dicts = [] | |
| for h, h_id in zip(self._hosts, self._host_ids): | |
| host_dicts.append({'hostname': h, 'id': h_id}) | |
| rpcs.append(('get_hosts', {'hostname__in': hosts}, True, host_dicts)) | |
| # Expect actions only for known hosts | |
| host_ids = [] | |
| for host in hosts: | |
| if host not in self._hosts: | |
| continue | |
| host_id = self._host_ids[self._hosts.index(host)] | |
| host_ids.append(host_id) | |
| modify_args = {'id': host} | |
| if locked is not None: | |
| out.add('Locked' if locked else 'Unlocked') | |
| modify_args['locked'] = locked | |
| modify_args['lock_reason'] = lock_reason | |
| if force_lock: | |
| modify_args['force_modify_locking'] = True | |
| if protection: | |
| modify_args['protection'] = protection | |
| if len(modify_args.keys()) > 1: | |
| out.add(host) | |
| rpcs.append(('modify_host', modify_args, True, None)) | |
| if labels: | |
| rpcs += self._gen_labels_rpcs(labels, host_id=host_id) | |
| rpcs.append(('host_add_labels', {'id': host, 'labels': labels}, | |
| True, None)) | |
| if platform: | |
| rpcs += self._gen_labels_rpcs([platform], platform=True, | |
| host_id=host_id) | |
| rpcs.append(('host_add_labels', {'id': host, | |
| 'labels': [platform]}, | |
| True, None)) | |
| rpcs += self._gen_attributes_rpcs(host, attributes) | |
| if acls: | |
| rpcs += self._gen_acls_rpcs(hosts, acls, host_ids=host_ids) | |
| return rpcs, list(out) | |
| def test_mod_force_lock_one_host(self): | |
| """Test mod with forced locking.""" | |
| lock_reason = 'Because' | |
| rpcs, out = self._gen_expectations(locked=True, force_lock=True, | |
| lock_reason=lock_reason) | |
| self.run_cmd(argv=self._command_single + [ | |
| '--lock', '--force_modify_locking', '--lock_reason', | |
| lock_reason], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_mod_force_unlock_one_host(self): | |
| """Test mod forced unlocking.""" | |
| rpcs, out = self._gen_expectations(locked=False, force_lock=True) | |
| self.run_cmd(argv=self._command_single + ['--unlock', | |
| '--force_modify_locking'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_mod_fail_unknown_host(self): | |
| """Test mod fails with unknown host.""" | |
| rpcs, out = self._gen_expectations(hosts=['nope'], locked=True) | |
| self.run_cmd(argv=self._command_base + ['nope', '--lock'], | |
| rpcs=rpcs, err_words_ok=['Cannot', 'modify', 'nope']) | |
| class host_create_unittest(host_mod_create_tests, cli_mock.cli_unittest): | |
| """Test specific to create action and expectation generator for shared | |
| tests. | |
| """ | |
| _hosts = ['localhost', '127.0.0.1'] | |
| _command_base = ['atest', 'host', 'create'] | |
| _command_single = _command_base + [_hosts[0]] | |
| _command_multiple = _command_base + _hosts | |
| def setUp(self): | |
| """Mock out the create_host method. | |
| """ | |
| super(host_create_unittest, self).setUp() | |
| self._orig_create_host = hosts.create_host | |
| def tearDown(self): | |
| """Undo mock. | |
| """ | |
| super(host_create_unittest, self).tearDown() | |
| hosts.create_host = self._orig_create_host | |
| def _mock_host(self, platform=None, labels=[]): | |
| """Update the return values of the mocked host object. | |
| @param platform: return value of Host.get_platform() | |
| @param labels: return value of Host.get_labels() | |
| """ | |
| mock_host = mock.MagicMock() | |
| mock_host.get_platform.return_value = platform | |
| mock_host.get_labels.return_value = labels | |
| hosts.create_host = mock.MagicMock() | |
| hosts.create_host.return_value = mock_host | |
| def _gen_expectations(self, hosts=['localhost'], locked=False, | |
| lock_reason=None, platform=None, | |
| discovered_platform=None, labels=[], | |
| discovered_labels=[], acls=[], protection=None, | |
| attributes={}): | |
| """Build a list of expected RPC calls based on values to host command. | |
| @param hosts: list of hostname being created (default ['localhost']) | |
| @param locked: end state of host (bool) | |
| @param lock_reason: reason for host to be locked | |
| @param platform: platform label | |
| @param discovered_platform: platform discovered automatically by host | |
| @param labels: list of host labels (excluding platform) | |
| @param discovered_labels: list of labels discovered automatically | |
| @param acls: list of host acls | |
| @param protection: host protection level | |
| @return: list of expect rpc calls (each call is (op, args, success, | |
| result)) | |
| """ | |
| hosts = hosts[:] | |
| hosts.reverse() # No idea why | |
| lock_reason = lock_reason or 'Forced lock on device creation' | |
| acls = acls or [] | |
| rpcs = [] | |
| out = ['Added', 'host'] + hosts | |
| # Mock platform and label detection results | |
| self._mock_host(discovered_platform, discovered_labels) | |
| for host in hosts: | |
| add_args = { | |
| 'hostname': host, | |
| 'status': 'Ready', | |
| 'locked': True, | |
| 'lock_reason': lock_reason, | |
| } | |
| if protection: | |
| add_args['protection'] = protection | |
| rpcs.append(('add_host', add_args, True, None)) | |
| rpcs += self._gen_labels_rpcs(labels) | |
| if labels: | |
| rpcs.append(('host_add_labels', {'id': host, 'labels': labels}, | |
| True, None)) | |
| if platform: | |
| rpcs += self._gen_labels_rpcs([platform], platform=True) | |
| rpcs.append(('host_add_labels', {'id': host, | |
| 'labels': [platform]}, | |
| True, None)) | |
| rpcs += self._gen_attributes_rpcs(host, attributes) | |
| rpcs += self._gen_acls_rpcs(hosts, acls) | |
| if not locked: | |
| for host in hosts: | |
| rpcs.append(( | |
| 'modify_host', | |
| { | |
| 'id': host, | |
| 'locked': False, | |
| 'lock_reason': '', | |
| }, | |
| True, | |
| None, | |
| )) | |
| return rpcs, out | |
| def test_create_no_args(self): | |
| """Test simple creation with to arguments.""" | |
| rpcs, out = self._gen_expectations() | |
| self.run_cmd(argv=self._command_single, rpcs=rpcs, out_words_ok=out) | |
| def test_create_with_discovered_platform(self): | |
| """Test discovered platform is used when platform isn't specified.""" | |
| rpcs, out = self._gen_expectations(platform='some_platform', | |
| discovered_platform='some_platform') | |
| self.run_cmd(argv=self._command_single, rpcs=rpcs, out_words_ok=out) | |
| def test_create_specified_platform_overrides_discovered_platform(self): | |
| """Test that the specified platform overrides the discovered platform. | |
| """ | |
| rpcs, out = self._gen_expectations(platform='some_platform', | |
| discovered_platform='wrong_platform') | |
| self.run_cmd(argv=self._command_single + ['--platform', | |
| 'some_platform'], | |
| rpcs=rpcs, out_words_ok=out) | |
| def test_create_discovered_labels(self): | |
| """Test applying automatically discovered labels.""" | |
| labels = ['label0', 'label1'] | |
| rpcs, out = self._gen_expectations(labels=labels, | |
| discovered_labels=labels) | |
| self.run_cmd(argv=self._command_single, rpcs=rpcs, out_words_ok=out) | |
| def test_create_specified_discovered_labels_combine(self): | |
| """Test applying both discovered and specified labels.""" | |
| labels = ['label0', 'label1'] | |
| rpcs, out = self._gen_expectations(labels=labels, | |
| discovered_labels=[labels[0]]) | |
| self.run_cmd(argv=self._command_single + ['--labels', labels[1]], | |
| rpcs=rpcs, out_words_ok=out) | |
| if __name__ == '__main__': | |
| unittest.main() |