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)
