def test_04_proxy_uri(self): """Verify that a ProxyURI object can be created, copied, modified, and used as expected.""" pobj = publisher.ProxyURI("http://example.com") self.assertTrue(pobj.uri == "http://example.com") tcert = os.path.join(self.test_root, "test.cert") tkey = os.path.join(self.test_root, "test.key") # check that we can't set several RepositoryURI attributes bad_props = { "priority": 1, "ssl_cert": tcert, "ssl_key": tkey, "trailing_slash": False } pobj = publisher.ProxyURI("http://example.com") for prop in bad_props: self.assertRaises(ValueError, setattr, pobj, prop, bad_props[prop]) # check bad values for system self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, pobj, "system", "Carrots") self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, pobj, "system", None) # check that we can set URI values that RespositoryURI would # choke on uri = "http://*****:*****@server" pobj.uri = uri self.assertTrue(pobj.uri == uri) # check that setting system results in uri being overridden pobj.system = True self.assertTrue(pobj.system == True) self.assertTrue(pobj.uri == publisher.SYSREPO_PROXY) # check that clearing system also clears uri pobj.system = False self.assertTrue(pobj.system == False) self.assertTrue(pobj.uri == None)
def transform_urls(urls): res = [] for val in urls: # If the URI contains <sysrepo> then it's served # directly by the system-repository. if val.startswith("http://{0}".format(publisher.SYSREPO_PROXY)): scheme, netloc, path, params, query, fragment =\ urlparse(val) r = publisher.RepositoryURI( urlunparse( (scheme, proxy_host, path, params, query, fragment))) else: # This URI needs to be proxied through the # system-repository, so we assign it a special # ProxyURI, which gets replaced by the actual # URI of the system-repository in # imageconfig.BlendedConfig.__merge_publishers r = publisher.RepositoryURI(val) r.proxies = [publisher.ProxyURI(None, system=True)] res.append(r) return res
def test_01_repository_uri(self): """Verify that a RepositoryURI object can be created, copied, modified, and used as expected.""" nsfile = os.path.join(self.test_root, "nosuchfile") tcert = os.path.join(self.test_root, "test.cert") tkey = os.path.join(self.test_root, "test.key") uprops = { "priority": 1, "ssl_cert": tcert, "ssl_key": tkey, "trailing_slash": False, } # Check that all properties can be set at construction time. uobj = publisher.RepositoryURI("https://example.com", **uprops) # Verify that all properties provided at construction time were # set as expected. self.assertEqual(uobj.uri, "https://example.com") for p in uprops: self.assertEqual(uprops[p], getattr(uobj, p)) # Verify that scheme matches provided URI. self.assertEqual(uobj.scheme, "https") # Verify that a copy matches its original. cuobj = copy.copy(uobj) self.assertEqual(uobj.uri, cuobj.uri) for p in uprops: self.assertEqual(getattr(uobj, p), getattr(cuobj, p)) cuobj = None # Verify that setting invalid property values raises the # expected exception. self.assertRaises(api_errors.BadRepositoryURI, setattr, uobj, "uri", None) self.assertRaises(api_errors.UnsupportedRepositoryURI, setattr, uobj, "uri", ":/notvalid") # this value is valid only for ProxyURI objects, not # RepositoryURI objects self.assertRaises(api_errors.BadRepositoryURI, setattr, uobj, "uri", "http://*****:*****@server") self.assertRaises(api_errors.BadRepositoryURIPriority, setattr, uobj, "priority", "foo") self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, uobj, "ssl_cert", -1) self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, uobj, "ssl_key", -1) # Verify that changing the URI scheme will null properties that # no longer apply. uobj.uri = "http://example.com" self.assertEqual(uobj.ssl_cert, None) self.assertEqual(uobj.ssl_key, None) # Verify that scheme matches provided URI. self.assertEqual(uobj.scheme, "http") # Verify that attempting to set properties not valid for the # current URI scheme raises the expected exception. self.assertRaises(api_errors.UnsupportedRepositoryURIAttribute, setattr, uobj, "ssl_cert", tcert) self.assertRaises(api_errors.UnsupportedRepositoryURIAttribute, setattr, uobj, "ssl_key", tkey) # Verify that individual properties can be set. uobj = publisher.RepositoryURI("https://example.com/") for p in uprops: setattr(uobj, p, uprops[p]) self.assertEqual(getattr(uobj, p), uprops[p]) # Finally, verify all properties (except URI and trailing_slash) # can be set to None. for p in ("priority", "ssl_cert", "ssl_key"): setattr(uobj, p, None) self.assertEqual(getattr(uobj, p), None) # Verify that proxies are set properly uobj = publisher.RepositoryURI("https://example.com", proxies=[]) uobj = publisher.RepositoryURI("https://example.com", proxies=[publisher.ProxyURI("http://foo.com")]) self.assertTrue(uobj.proxies == [publisher.ProxyURI( "http://foo.com")]) uobj.proxies = [] self.assertTrue(uobj.proxies == []) # Verify that proxies and proxy are linked uobj.proxies = [publisher.ProxyURI("http://foo.com")] self.assertTrue(uobj.proxy == "http://foo.com") uobj.proxy = "http://bar" self.assertTrue(uobj.proxies == [publisher.ProxyURI("http://bar")]) try: raised = False publisher.RepositoryURI("http://foo", proxies=[ publisher.ProxyURI("http://bar")], proxy="http://foo") except api_errors.PublisherError: raised = True finally: self.assertTrue(raised, "No exception raised when " "creating a RepositoryURI obj with proxies & proxy") # Check that we detect bad values for proxies self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, uobj, "proxies", "foo") self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, uobj, "proxies", [None]) # we only support a single proxy per RepositoryURI self.assertRaises(api_errors.BadRepositoryAttributeValue, setattr, uobj, "proxies", [ publisher.ProxyURI("http://foo.com"), publisher.ProxyURI("http://bar.com")])