def setUp(self):
super(TestLogutil, self).setUp()
self.rhsm_config = stubs.StubConfig()
rhsm_patcher = mock.patch('rhsm.config')
self.rhsm_config_mock = rhsm_patcher.start()
self.rhsm_config_mock.initConfig.return_value = self.rhsm_config
self.addCleanup(rhsm_patcher.stop)
def test_network_cfg_write_values_no_port(self):
self.nc = networkConfig.NetworkConfigDialog()
self.stubConfig = stubs.StubConfig()
self.nc.cfg = self.stubConfig
self.nc.enableProxyButton.set_active(True)
self.nc.proxyEntry.set_text("example.com")
self.nc.write_values()
def test_network_config_write_values(self):
nc = networkConfig.NetworkConfigDialog()
stubConfig = stubs.StubConfig()
nc.cfg = stubConfig
nc.xml.get_widget("enableProxyButton").set_active(True)
nc.xml.get_widget("proxyEntry").set_text("example.com:10000")
nc.write_values()
def test_network_cfg_save_change_values(self):
self.nc = networkConfig.NetworkConfigDialog()
self.stubConfig = stubs.StubConfig()
self.nc.cfg = self.stubConfig
self.nc.enableProxyButton.set_active(True)
self.nc.proxyEntry.set_text("example.com:10000")
self.expected = {}
self.nc.on_save_clicked(self.nc.saveButton)
self.assertNotEquals(self.expected, self.nc.cfg.store)
def test_network_cfg_ok_change_values(self):
self.nc = networkConfig.NetworkConfigDialog()
self.stubConfig = stubs.StubConfig()
self.nc.cfg = self.stubConfig
self.nc.xml.get_widget("enableProxyButton").set_active(True)
self.nc.xml.get_widget("proxyEntry").set_text("example.com:10000")
self.expected = {}
self.nc.on_ok_clicked(self.nc.xml.get_widget("okButton"))
self.assertNotEquals(self.expected, self.nc.cfg.store)
def test_network_cfg_write_values_with_auth(self):
self.nc = networkConfig.NetworkConfigDialog()
self.stubConfig = stubs.StubConfig()
self.nc.cfg = self.stubConfig
self.nc.enableProxyButton.set_active(True)
self.nc.proxyEntry.set_text("example.com:10000")
self.nc.enableProxyAuthButton.set_active(True)
self.nc.proxyUserEntry.set_text("redhatUser")
self.nc.proxyPasswordEntry.set_text("redhatPass")
self.nc.write_values()
actual_user = self.nc.cfg.store['server']['proxy_user']
actual_password = self.nc.cfg.store['server']['proxy_password']
self.assertTrue(actual_user == "redhatUser")
self.assertTrue(actual_password == "redhatPass")
def test_network_cfg_set_initial_values(self):
self.stubConfig = stubs.StubConfig()
self.nc.set_initial_values()
def setUp(self):
SubManFixture.setUp(self)
self.nc = networkConfig.NetworkConfigDialog()
self.stubConfig = stubs.StubConfig()
def test_network_cfg_write_fail(self):
self.nc = networkConfig.NetworkConfigDialog()
self.stubConfig = stubs.StubConfig()
self.stubConfig.raise_io = True
self.nc.cfg = self.stubConfig
self.nc.write_values()
def setUp(self):
SubManFixture.setUp(self)
self.stubConfig = stubs.StubConfig()
def test_network_config_write_fail(self):
nc = networkConfig.NetworkConfigDialog()
stubConfig = stubs.StubConfig()
stubConfig.raise_io = True
nc.cfg = stubConfig
nc.write_values()
def setUp(self):
# No matter what, stop all patching (even if we have a failure in setUp itself)
self.addCleanup(patch.stopall)
# Never attempt to use the actual managercli.cfg which points to a
# real file in etc.
self.mock_cfg_parser = stubs.StubConfig()
original_conf = subscription_manager.managercli.conf
def unstub_conf():
subscription_manager.managercli.conf = original_conf
# Mock makes it damn near impossible to mock a module attribute (which we shouldn't be using
# in the first place because it's terrible) so we monkey-patch it ourselves.
# TODO Fix this idiocy by not reading the damn config on module import
subscription_manager.managercli.conf = config.Config(
self.mock_cfg_parser)
self.addCleanup(unstub_conf)
facts_host_patcher = patch('rhsmlib.dbus.facts.FactsClient',
auto_spec=True)
self.mock_facts_host = facts_host_patcher.start()
self.mock_facts_host.return_value.GetFacts.return_value = self.set_facts(
)
# By default mock that we are registered. Individual test cases
# can override if they are testing disconnected scenario.
id_mock = NonCallableMock(name='FixtureIdentityMock')
id_mock.exists_and_valid = Mock(return_value=True)
id_mock.uuid = 'fixture_identity_mock_uuid'
id_mock.name = 'fixture_identity_mock_name'
id_mock.cert_dir_path = "/not/a/real/path/to/pki/consumer/"
id_mock.keypath.return_value = "/not/a/real/key/path"
id_mock.certpath.return_value = "/not/a/real/cert/path"
# Don't really care about date ranges here:
self.mock_calc = NonCallableMock()
self.mock_calc.calculate.return_value = None
# Avoid trying to read real /etc/yum.repos.d/redhat.repo
self.mock_repofile_path_exists_patcher = patch(
'subscription_manager.repolib.RepoFile.path_exists')
mock_repofile_path_exists = self.mock_repofile_path_exists_patcher.start(
)
mock_repofile_path_exists.return_value = True
inj.provide(inj.IDENTITY, id_mock)
inj.provide(inj.PRODUCT_DATE_RANGE_CALCULATOR, self.mock_calc)
inj.provide(inj.ENTITLEMENT_STATUS_CACHE,
stubs.StubEntitlementStatusCache())
inj.provide(inj.PROD_STATUS_CACHE, stubs.StubProductStatusCache())
inj.provide(inj.OVERRIDE_STATUS_CACHE, stubs.StubOverrideStatusCache())
inj.provide(inj.RELEASE_STATUS_CACHE, stubs.StubReleaseStatusCache())
inj.provide(inj.PROFILE_MANAGER, stubs.StubProfileManager())
# By default set up an empty stub entitlement and product dir.
# Tests need to modify or create their own but nothing should hit
# the system.
self.ent_dir = stubs.StubEntitlementDirectory()
inj.provide(inj.ENT_DIR, self.ent_dir)
self.prod_dir = stubs.StubProductDirectory()
inj.provide(inj.PROD_DIR, self.prod_dir)
# Installed products manager needs PROD_DIR injected first
inj.provide(inj.INSTALLED_PRODUCTS_MANAGER,
stubs.StubInstalledProductsManager())
self.stub_cp_provider = stubs.StubCPProvider()
self._release_versions = []
self.stub_cp_provider.content_connection.get_versions = self._get_release_versions
inj.provide(inj.CP_PROVIDER, self.stub_cp_provider)
inj.provide(inj.CERT_SORTER, stubs.StubCertSorter())
# setup and mock the plugin_manager
plugin_manager_mock = MagicMock(name='FixturePluginManagerMock')
plugin_manager_mock.runiter.return_value = iter([])
inj.provide(inj.PLUGIN_MANAGER, plugin_manager_mock)
inj.provide(inj.DBUS_IFACE, Mock(name='FixtureDbusIfaceMock'))
pooltype_cache = Mock()
inj.provide(inj.POOLTYPE_CACHE, pooltype_cache)
# don't use file based locks for tests
inj.provide(inj.ACTION_LOCK, RLock)
self.stub_facts = stubs.StubFacts()
inj.provide(inj.FACTS, self.stub_facts)
content_access_cache_mock = MagicMock(name='ContentAccessCacheMock')
inj.provide(inj.CONTENT_ACCESS_CACHE, content_access_cache_mock)
self.dbus_patcher = patch(
'subscription_manager.managercli.CliCommand._request_validity_check'
)
self.dbus_patcher.start()
# No tests should be trying to connect to any configure or test server
# so really, everything needs this mock. May need to be in __init__, or
# better, all test classes need to use SubManFixture
self.is_valid_server_patcher = patch(
"subscription_manager.managercli.is_valid_server_info")
is_valid_server_mock = self.is_valid_server_patcher.start()
is_valid_server_mock.return_value = True
# No tests should be trying to test the proxy connection
# so really, everything needs this mock. May need to be in __init__, or
# better, all test classes need to use SubManFixture
self.test_proxy_connection_patcher = patch(
"subscription_manager.managercli.CliCommand.test_proxy_connection")
test_proxy_connection_mock = self.test_proxy_connection_patcher.start()
test_proxy_connection_mock.return_value = True
self.files_to_cleanup = []
