def testInvalidConfig(self): with open(os.path.join(self.config_dir, "test.conf"), "w") as f: f.write(""" Malformed configuration file """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 0)
def test_one_source_to_many_dests(self): # This tests that there can be one source that specifies # information for different destinations and that the correct mapping # is created. config_1 = combine_dicts(TestReadingConfigs.source_options_1, TestReadingConfigs.dest_options_1) # NOTE: virt-who today does not support config sections having the same # name. Hence the only way to have one source go to multiple # destinations (without new config options) is to have two sections # with the same information but different section names config_options_2 = TestReadingConfigs.source_options_1.copy() config_options_2['name'] = 'test2' config_2 = combine_dicts(config_options_2, TestReadingConfigs.dest_options_2) expected_dest_1 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_1) expected_dest_2 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_2) expected_mapping = { expected_dest_1: [config_1['name']], expected_dest_2: [config_2['name']] # config_2['name'] == # config_1['name'] } with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write( TestReadingConfigs.dict_to_ini(config_1) + TestReadingConfigs.dict_to_ini(config_2)) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(manager.dest_to_sources_map, expected_mapping)
def test_read_hypervisor(self): with open(self.hypervisor_file, "w") as f: f.write(HYPERVISOR_JSON) with open(self.config_file, "w") as f: f.write(""" [test] type=fake is_hypervisor=true file=%s """ % self.hypervisor_file) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(len(manager.configs), 1) virt = Virt.fromConfig(self.logger, manager.configs[0]) self.assertEquals(type(virt), FakeVirt) mapping = virt.getHostGuestMapping() self.assertTrue("hypervisors" in mapping) hypervisors = mapping["hypervisors"] self.assertEquals(len(hypervisors), 1) hypervisor = hypervisors[0] self.assertEquals(type(hypervisor), Hypervisor) self.assertEquals(hypervisor.hypervisorId, "60527517-6284-7593-6AAB-75BF2A6375EF") self.assertEquals(len(hypervisor.guestIds), 1) guest = hypervisor.guestIds[0] self.assertEquals(guest.uuid, "07ED8178-95D5-4244-BC7D-582A54A48FF8") self.assertEquals(guest.state, 1)
def test_many_sources_to_one_dest(self): # This tests that there can be multiple configs that specify to # report to the same destination config_1 = combine_dicts(TestReadingConfigs.source_options_1, TestReadingConfigs.dest_options_1) config_2 = combine_dicts(TestReadingConfigs.source_options_2, TestReadingConfigs.dest_options_1) expected_dest = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_1) expected_mapping = { expected_dest: [config_1['name'], config_2['name']] } with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write( TestReadingConfigs.dict_to_ini(config_1) + TestReadingConfigs.dict_to_ini(config_2)) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(manager.dests, set([expected_dest])) self.assertEqual(manager.sources, set([config_1['name'], config_2['name']])) self.assertEquals(manager.dest_to_sources_map, expected_mapping)
def testBasicConfig(self): with open(os.path.join(self.config_dir, "test.conf"), "w") as f: f.write(TestReadingConfigs.dict_to_ini(default_config_values)) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertConfigEqualsDefault(config)
def test_one_source_to_one_dest(self): config_1 = combine_dicts(TestReadingConfigs.source_options_1, TestReadingConfigs.dest_options_1) expected_dest_1 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_1) expected_mapping = {expected_dest_1: [config_1['name']]} with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(TestReadingConfigs.dict_to_ini(config_1)) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(manager.dest_to_sources_map, expected_mapping)
def test_sm_config_override(self, initConfig, HTTPSConnection, RhsmProxyHTTPSConnection): '''Test if overriding options from rhsm.conf works.''' conn = MagicMock() conn.getresponse.return_value.status = 200 conn.getresponse.return_value.read.return_value = '{"result": "ok"}' HTTPSConnection.return_value = conn RhsmProxyHTTPSConnection.return_value = conn def config_get(section, key): return { 'server/proxy_hostname': 'proxy.server.test', 'rhsm/consumerCertDir': '', 'server/hostname': 'server.test', 'server/port': '8081', 'server/prefix': 'old_prefix', }.get('%s/%s' % (section, key), None) initConfig.return_value.get.side_effect = config_get config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt rhsm_hostname=host rhsm_port=8080 rhsm_prefix=/prefix rhsm_proxy_hostname= rhsm_proxy_port=8443 rhsm_insecure=1 rhsm_username=user rhsm_password=passwd """) config_manager = ConfigManager(self.logger, config_dir) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, Mock(), config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config.rhsm_hostname, 'host') self.assertEqual(config.rhsm_port, '8080') manager._connect(config) self.assertFalse(RhsmProxyHTTPSConnection.called, "It shouldn't use proxy") self.assertTrue(HTTPSConnection.called) conn.request.assert_called_with( 'GET', '/prefix/status/', body=ANY, headers=ANY)
def testInvisibleConfigFile(self): with open(os.path.join(self.config_dir, ".test1.conf"), "w") as f: f.write(""" [test1] type=libvirt server=1.2.3.4 username=admin password=password owner=root env=staging """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 0, "Hidden config file shouldn't be read")
def testUnreadableConfig(self): filename = os.path.join(self.config_dir, "test.conf") with open(filename, "w") as f: f.write(""" [test] type=esx server=1.2.3.4 username=admin password=password owner=root env=staging """) os.chmod(filename, 0) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 0)
def testFilterHostNew(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=esx server=1.2.3.4 username=admin password=password owner=root env=staging filter_hosts=12345 """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) self.assertEqual(manager.configs[0].filter_hosts, ['12345'])
def testEsxDisableSimplifiedVim(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=esx server=1.2.3.4 username=admin password=password owner=root env=staging simplified_vim=false """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertFalse(config.simplified_vim)
def test_satellite_config_file(self): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt sat_server=sat.example.com """) config_manager = ConfigManager(self.logger, config_dir) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, MagicMock(), config) self.assertTrue(isinstance(manager, Satellite)) self.assertEqual(config.sat_server, 'sat.example.com')
def testMultipleConfigsInFile(self): config_1 = combine_dicts(TestReadingConfigs.source_options_1, TestReadingConfigs.dest_options_1) config_2 = combine_dicts(TestReadingConfigs.source_options_2, TestReadingConfigs.dest_options_2) with open(os.path.join(self.config_dir, "test.conf"), "w") as f: f.write( TestReadingConfigs.dict_to_ini(config_1) + TestReadingConfigs.dict_to_ini(config_2)) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 2) config = manager.configs[0] self.assert_config_contains_all(config, config_1) config = manager.configs[1] self.assert_config_contains_all(config, config_2)
def test_read_non_hypervisor_from_hypervisor(self): with open(self.hypervisor_file, "w") as f: f.write(HYPERVISOR_JSON) with open(self.config_file, "w") as f: f.write(""" [test] type=fake is_hypervisor=false file=%s """ % self.hypervisor_file) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(len(manager.configs), 1) virt = Virt.fromConfig(self.logger, manager.configs[0]) self.assertEquals(type(virt), FakeVirt) self.assertRaises(VirtError, virt.listDomains)
def test_read_hypervisor_from_non_hypervisor(self): with open(self.hypervisor_file, "w") as f: f.write(NON_HYPERVISOR_JSON) with open(self.config_file, "w") as f: f.write(""" [test] type=fake is_hypervisor=true file=%s """ % self.hypervisor_file) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(len(manager.configs), 1) virt = Virt.from_config(self.logger, manager.configs[0], None) self.assertEquals(type(virt), FakeVirt) self.assertRaises(VirtError, virt.getHostGuestMapping)
def testBasicConfig(self): with open(os.path.join(self.config_dir, "test.conf"), "w") as f: f.write(""" [test] type=esx server=1.2.3.4 username=admin password=password owner=root env=staging rhsm_username=admin rhsm_password=password rhsm_hostname=host rhsm_port=1234 rhsm_prefix=prefix rhsm_proxy_hostname=proxy host rhsm_proxy_port=4321 rhsm_proxy_user=proxyuser rhsm_proxy_password=proxypass rhsm_insecure=1 """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertEqual(config.name, "test") self.assertEqual(config.type, "esx") self.assertEqual(config.server, "1.2.3.4") self.assertEqual(config.username, "admin") self.assertEqual(config.password, "password") self.assertEqual(config.owner, "root") self.assertEqual(config.env, "staging") self.assertEqual(config.rhsm_username, 'admin') self.assertEqual(config.rhsm_password, 'password') self.assertEqual(config.rhsm_hostname, 'host') self.assertEqual(config.rhsm_port, '1234') self.assertEqual(config.rhsm_prefix, 'prefix') self.assertEqual(config.rhsm_proxy_hostname, 'proxy host') self.assertEqual(config.rhsm_proxy_port, '4321') self.assertEqual(config.rhsm_proxy_user, 'proxyuser') self.assertEqual(config.rhsm_proxy_password, 'proxypass') self.assertEqual(config.rhsm_insecure, '1') self.assertEqual(config.simplified_vim, True)
def test_many_sources_to_many_dests(self): config_1 = combine_dicts(TestReadingConfigs.source_options_1, TestReadingConfigs.dest_options_1) config_2 = combine_dicts(TestReadingConfigs.source_options_2, TestReadingConfigs.dest_options_2) # Create another source config that is slightly different source_3_options = TestReadingConfigs.source_options_2.copy() source_3_options['name'] = 'test3' source_4_options = TestReadingConfigs.source_options_1.copy() source_4_options['name'] = 'test4' # Create another dest config that is slightly different dest_options_3 = TestReadingConfigs.dest_options_2.copy() dest_options_3['owner'] = 'some_cool_owner_person' config_3 = combine_dicts(source_3_options, TestReadingConfigs.dest_options_2) config_4 = combine_dicts(source_4_options, dest_options_3) expected_dest_1 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_1) expected_dest_2 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_2) expected_dest_3 = Satellite6DestinationInfo(**dest_options_3) expected_mapping = { expected_dest_1: [config_1['name']], expected_dest_2: [config_2['name'], config_3['name']], expected_dest_3: [config_4['name']] } with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write( TestReadingConfigs.dict_to_ini(config_1) + TestReadingConfigs.dict_to_ini(config_2) + TestReadingConfigs.dict_to_ini(config_3) + TestReadingConfigs.dict_to_ini(config_4)) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(manager.dest_to_sources_map, expected_mapping)
def testCryptedPassword(self, password): password.return_value = (hexlify(Password._generate_key()), hexlify(Password._generate_key())) passwd = "TestSecretPassword!" crypted = hexlify(Password.encrypt(passwd)) filename = os.path.join(self.config_dir, "test.conf") with open(filename, "w") as f: f.write(""" [test] type=esx server=1.2.3.4 username=admin encrypted_password=%s owner=root env=staging """ % crypted) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) self.assertEqual(manager.configs[0].password, passwd)
def __init__(self, logger, options, config_dir=None): """ Executor class provides bridge between virtualization supervisor and Subscription Manager. logger - logger instance options - options for virt-who, parsed from command line arguments """ self.logger = logger self.options = options self.terminate_event = Event() self.virts = [] # Queue for getting events from virt backends self.queue = None # Dictionary with mapping between config names and report hashes, # used for checking if the report changed from last time self.last_reports_hash = {} # How long should we wait between reports sent to server self.retry_after = MinimumSendInterval # This counts the number of responses of http code 429 # received between successfully sent reports self._429_count = 0 self.reloading = False # Reports that are queued for sending self.queued_reports = OrderedDict() # Name of configs that wasn't reported in oneshot mode self.oneshot_remaining = set() # Reports that are currently processed by server self.reports_in_progress = [] self.configManager = ConfigManager(self.logger, config_dir) for config in self.configManager.configs: logger.debug("Using config named '%s'" % config.name) self.send_after = time.time()
def testQuotesInConfig(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=esx server="1.2.3.4" username='******' password=p"asswor'd owner=" root " env='"staging"' """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertEqual(config.name, "test1") self.assertEqual(config.type, "esx") self.assertEqual(config.server, "1.2.3.4") self.assertEqual(config.username, "admin") self.assertEqual(config.password, "p\"asswor'd") self.assertEqual(config.owner, " root ") self.assertEqual(config.env, '"staging"')
def testLibvirtConfig(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=libvirt server=1.2.3.4 username=admin password=password owner=root env=staging """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertEqual(config.name, "test1") self.assertEqual(config.type, "libvirt") self.assertEqual(config.server, "1.2.3.4") self.assertEqual(config.username, "admin") self.assertEqual(config.password, "password") self.assertEqual(config.owner, "root") self.assertEqual(config.env, "staging")
def test_read_non_hypervisor(self): with open(self.hypervisor_file, "w") as f: f.write(NON_HYPERVISOR_JSON) with open(self.config_file, "w") as f: f.write(""" [test] type=fake is_hypervisor=false file=%s """ % self.hypervisor_file) manager = ConfigManager(self.logger, self.config_dir) self.assertEquals(len(manager.configs), 1) virt = Virt.fromConfig(self.logger, manager.configs[0]) self.assertEquals(type(virt), FakeVirt) guests = virt.listDomains() self.assertEquals(len(guests), 1) guest = guests[0] self.assertEquals(guest.uuid, "9f06a84d-5f56-4e7e-be0c-937b3c1924d7") self.assertEquals(guest.state, 1)
def test_sm_config_file(self, rhsmconnection): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt rhsm_hostname=host rhsm_port=8080 rhsm_prefix=prefix rhsm_proxy_hostname=proxy_host rhsm_proxy_port=9090 rhsm_proxy_user=proxy_user rhsm_proxy_password=proxy_password rhsm_insecure=1 rhsm_username=user rhsm_password=passwd """) config_manager = ConfigManager(self.logger, config_dir) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, Mock(), config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config.rhsm_hostname, 'host') self.assertEqual(config.rhsm_port, '8080') manager._connect(config) rhsmconnection.assert_called_with( username='******', password='******', host='host', ssl_port=8080, handler='prefix', proxy_hostname='proxy_host', proxy_port='9090', proxy_user='******', proxy_password='******', insecure='1')
def testUnicode(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=esx server=žluťoučký servřík username=username password=password owner=здравствуйте env=العَرَبِيَّة """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertEqual(config.name, "test1") self.assertEqual(config.type, "esx") self.assertEqual(config.server, "žluťoučký servřík") # Username and password can't be unicode, they has to be latin1 for HTTP Basic auth self.assertEqual(config.username, "username") self.assertEqual(config.password, "password") self.assertEqual(config.owner, "здравствуйте") self.assertEqual(config.env, 'العَرَبِيَّة')
def filter_hosts(self, config): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=esx server=does.not.exist username=username password=password owner=owner env=env {config} """.format(config=config)) config_manager = ConfigManager(self.logger, config_dir) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] included_hypervisor = Hypervisor('12345', guestIds=[ Guest('guest-2', xvirt, Guest.STATE_RUNNING), ]) excluded_hypervisor = Hypervisor('00000', guestIds=[ Guest('guest-1', xvirt, Guest.STATE_RUNNING), ]) assoc = { 'hypervisors': [ excluded_hypervisor, included_hypervisor, ] } report = HostGuestAssociationReport(config, assoc) assert report.association == {'hypervisors': [included_hypervisor]}
def testMultipleConfigFiles(self): config_1 = combine_dicts(TestReadingConfigs.source_options_1, TestReadingConfigs.dest_options_1) config_2 = combine_dicts(TestReadingConfigs.source_options_2, TestReadingConfigs.dest_options_2) with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(TestReadingConfigs.dict_to_ini(config_1)) with open(os.path.join(self.config_dir, "test2.conf"), "w") as f: f.write(TestReadingConfigs.dict_to_ini(config_2)) expected_dest_1 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_1) expected_dest_2 = Satellite6DestinationInfo( **TestReadingConfigs.dest_options_2) expected_mapping = { expected_dest_1: [config_1['name']], expected_dest_2: [config_2['name']] } manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 2) self.assertEqual(manager.dest_to_sources_map, expected_mapping) self.assertEqual(manager.dests, set([expected_dest_1, expected_dest_2])) self.assertEqual(manager.sources, set([config_1['name'], config_2['name']])) result2, result1 = manager.configs self.assertIn(result1.name, ("test1", "test2")) if result1.name == "test2": result2, result1 = result1, result2 self.assert_config_contains_all(result1, config_1) self.assert_config_contains_all(result2, config_2)
def testMultipleConfigFiles(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=esx server=1.2.3.4 username=admin password=password owner=root env=staging rhsm_username=rhsm_admin1 rhsm_password=rhsm_password1 rhsm_hostname=host1 rhsm_port=12341 rhsm_prefix=prefix1 rhsm_proxy_hostname=proxyhost1 rhsm_proxy_port=43211 rhsm_proxy_user=proxyuser1 rhsm_proxy_password=proxypass1 rhsm_insecure=1 """) with open(os.path.join(self.config_dir, "test2.conf"), "w") as f: f.write(""" [test2] type=hyperv server=1.2.3.5 username=admin password=password owner=root env=staging rhsm_username=rhsm_admin2 rhsm_password=rhsm_password2 rhsm_hostname=host2 rhsm_port=12342 rhsm_prefix=prefix2 rhsm_proxy_hostname=proxyhost2 rhsm_proxy_port=43212 rhsm_proxy_user=proxyuser2 rhsm_proxy_password=proxypass2 rhsm_insecure=2 """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 2) config2, config1 = manager.configs self.assertIn(config1.name, ("test1", "test2")) if config1.name == "test2": config2, config1 = config1, config2 self.assertEqual(config1.name, "test1") self.assertEqual(config1.type, "esx") self.assertEqual(config1.server, "1.2.3.4") self.assertEqual(config1.username, "admin") self.assertEqual(config1.password, "password") self.assertEqual(config1.owner, "root") self.assertEqual(config1.env, "staging") self.assertEqual(config1.rhsm_username, 'rhsm_admin1') self.assertEqual(config1.rhsm_password, 'rhsm_password1') self.assertEqual(config1.rhsm_hostname, 'host1') self.assertEqual(config1.rhsm_port, '12341') self.assertEqual(config1.rhsm_prefix, 'prefix1') self.assertEqual(config1.rhsm_proxy_hostname, 'proxyhost1') self.assertEqual(config1.rhsm_proxy_port, '43211') self.assertEqual(config1.rhsm_proxy_user, 'proxyuser1') self.assertEqual(config1.rhsm_proxy_password, 'proxypass1') self.assertEqual(config1.rhsm_insecure, '1') self.assertEqual(config2.name, "test2") self.assertEqual(config2.type, "hyperv") self.assertEqual(config2.server, "1.2.3.5") self.assertEqual(config2.username, "admin") self.assertEqual(config2.password, "password") self.assertEqual(config2.owner, "root") self.assertEqual(config2.env, "staging") self.assertEqual(config2.rhsm_username, 'rhsm_admin2') self.assertEqual(config2.rhsm_password, 'rhsm_password2') self.assertEqual(config2.rhsm_hostname, 'host2') self.assertEqual(config2.rhsm_port, '12342') self.assertEqual(config2.rhsm_prefix, 'prefix2') self.assertEqual(config2.rhsm_proxy_hostname, 'proxyhost2') self.assertEqual(config2.rhsm_proxy_port, '43212') self.assertEqual(config2.rhsm_proxy_user, 'proxyuser2') self.assertEqual(config2.rhsm_proxy_password, 'proxypass2') self.assertEqual(config2.rhsm_insecure, '2')
def testConfigFileExtensions(self): with open(os.path.join(self.config_dir, "test1.conf"), "w") as f: f.write(""" [test1] type=esx server=1.2.3.4 username=admin password=password owner=root env=staging rhsm_username=rhsm_admin1 rhsm_password=rhsm_password1 rhsm_hostname=host1 rhsm_port=12341 rhsm_prefix=prefix1 rhsm_proxy_hostname=proxyhost1 rhsm_proxy_port=43211 rhsm_proxy_user=proxyuser1 rhsm_proxy_password=proxypass1 rhsm_insecure=1 """) with open(os.path.join(self.config_dir, "test2.conf.bk"), "w") as f: f.write(""" [test2] type=hyperv server=1.2.3.5 username=admin password=password owner=root env=staging rhsm_username=rhsm_admin2 rhsm_password=rhsm_password2 rhsm_hostname=host2 rhsm_port=12342 rhsm_prefix=prefix2 rhsm_proxy_hostname=proxyhost2 rhsm_proxy_port=43212 rhsm_proxy_user=proxyuser2 rhsm_proxy_password=proxypass2 rhsm_insecure=2 """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 1) config = manager.configs[0] self.assertEqual(config.name, "test1") self.assertEqual(config.type, "esx") self.assertEqual(config.server, "1.2.3.4") self.assertEqual(config.username, "admin") self.assertEqual(config.password, "password") self.assertEqual(config.owner, "root") self.assertEqual(config.env, "staging") self.assertEqual(config.rhsm_username, 'rhsm_admin1') self.assertEqual(config.rhsm_password, 'rhsm_password1') self.assertEqual(config.rhsm_hostname, 'host1') self.assertEqual(config.rhsm_port, '12341') self.assertEqual(config.rhsm_prefix, 'prefix1') self.assertEqual(config.rhsm_proxy_hostname, 'proxyhost1') self.assertEqual(config.rhsm_proxy_port, '43211') self.assertEqual(config.rhsm_proxy_user, 'proxyuser1') self.assertEqual(config.rhsm_proxy_password, 'proxypass1') self.assertEqual(config.rhsm_insecure, '1')
def testMultipleConfigsInFile(self): with open(os.path.join(self.config_dir, "test.conf"), "w") as f: f.write(""" [test1] type=esx server=1.2.3.4 username=admin password=password owner=root1 env=staging1 rhsm_username=rhsm_admin1 rhsm_password=rhsm_password1 rhsm_hostname=host1 rhsm_port=12341 rhsm_prefix=prefix1 rhsm_proxy_hostname=proxyhost1 rhsm_proxy_port=43211 rhsm_proxy_user=proxyuser1 rhsm_proxy_password=proxypass1 rhsm_insecure=1 [test2] type=hyperv server=1.2.3.5 username=admin password=password owner=root2 env=staging2 rhsm_username=rhsm_admin2 rhsm_password=rhsm_password2 rhsm_hostname=host2 rhsm_port=12342 rhsm_prefix=prefix2 rhsm_proxy_hostname=proxyhost2 rhsm_proxy_port=43212 rhsm_proxy_user=proxyuser2 rhsm_proxy_password=proxypass2 rhsm_insecure=2 """) manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 2) config = manager.configs[0] self.assertEqual(config.name, "test1") self.assertEqual(config.type, "esx") self.assertEqual(config.server, "1.2.3.4") self.assertEqual(config.username, "admin") self.assertEqual(config.password, "password") self.assertEqual(config.owner, "root1") self.assertEqual(config.env, "staging1") self.assertEqual(config.rhsm_username, 'rhsm_admin1') self.assertEqual(config.rhsm_password, 'rhsm_password1') self.assertEqual(config.rhsm_hostname, 'host1') self.assertEqual(config.rhsm_port, '12341') self.assertEqual(config.rhsm_prefix, 'prefix1') self.assertEqual(config.rhsm_proxy_hostname, 'proxyhost1') self.assertEqual(config.rhsm_proxy_port, '43211') self.assertEqual(config.rhsm_proxy_user, 'proxyuser1') self.assertEqual(config.rhsm_proxy_password, 'proxypass1') self.assertEqual(config.rhsm_insecure, '1') config = manager.configs[1] self.assertEqual(config.name, "test2") self.assertEqual(config.type, "hyperv") self.assertEqual(config.username, "admin") self.assertEqual(config.server, "1.2.3.5") self.assertEqual(config.password, "password") self.assertEqual(config.owner, "root2") self.assertEqual(config.env, "staging2") self.assertEqual(config.rhsm_username, 'rhsm_admin2') self.assertEqual(config.rhsm_password, 'rhsm_password2') self.assertEqual(config.rhsm_hostname, 'host2') self.assertEqual(config.rhsm_port, '12342') self.assertEqual(config.rhsm_prefix, 'prefix2') self.assertEqual(config.rhsm_proxy_hostname, 'proxyhost2') self.assertEqual(config.rhsm_proxy_port, '43212') self.assertEqual(config.rhsm_proxy_user, 'proxyuser2') self.assertEqual(config.rhsm_proxy_password, 'proxypass2') self.assertEqual(config.rhsm_insecure, '2')
def testEmptyConfig(self): manager = ConfigManager(self.logger, self.config_dir) self.assertEqual(len(manager.configs), 0)