def testDefaultWelcomeMessageHttpToHttpCheckReturnCode(self):
     "Test redirecting http to http and verify its return code"
     self.cfg['serverURL'] = "http://SECRET_URL/XMLRPC-REDIRECT-NOSSL"
     s = rpcServer.getServer()
     s.registration.welcome_message()
     status = s.get_response_status()
     self.assertEqual(status, 200)

 def testGetServerRedirectServer(self):
     "Verify that getServer works when talking to a server that redirects"
     self.cfg['serverURL'] = "%s-REDIRECT" % self.cfg['serverURL']
     try:
         s = rpcServer.getServer()
     except:
         self.fail("Got an expection calling rpcServer.getServer")

 def testGetServerRedirectServer(self):
     "Verify that getServer works when talking to a server that redirects"
     self.cfg['serverURL'] = "https://rhn.redhat.com/XMLRPC-REDIRECT"
     try:
         s = rpcServer.getServer()
     except:
         self.fail("Got an expection calling rpcServer.getServer")

 def testDefaulWelcomeMessageNoRedirectCheckRedirect(self):
     "Test a non redirecting connection and see if redirected() is set"
     self.cfg['serverURL'] = "http://SECRET_URL/XMLRPC"
     s = rpcServer.getServer()
     s.registration.welcome_message()
     ret = s.redirected()
     self.assertEqual(ret, None)

 def testDefaultWelcomeMessageHttpToHttpsCheckRedirect(self):
     "Test redirecting http to https and verify redirect()"
     self.cfg['serverURL'] = "%s/XMLRPC-REDIRECT" % self.defaultServer
     s = rpcServer.getServer()
     s.registration.welcome_message()
     ret = s.redirected()
     self.assertEqual(ret, "%s/XMLRPC") % self.defaultServer

 def testDefaultWelcomeMessageHttpsToHttpsCheckReturnCode(self):
     "Test redirecting https to https and verify its return code"
     self.cfg['serverURL'] = "%s/XMLRPC-REDIRECT" % self.defaultServer
     s = rpcServer.getServer()
     s.registration.welcome_message()
     status  = s.get_response_status()
     self.assertEqual(status, 200)

 def __init__(self, serverOverride=None, timeout=None, rpcServerOverride=None):
     if rpcServerOverride is None:
         self._server = rpcServer.getServer(serverOverride=serverOverride,
                 timeout=timeout)
     else:
         self._server = rpcServerOverride
     self._capabilities = None

 def testDefaultWelcomeMessageHttpToHttpCheckRedirect(self):
     "Test redirecting http to http and verify redirect()"
     self.cfg['serverURL'] = "http://SECRET_URL/XMLRPC-REDIRECT-NOSSL"
     s = rpcServer.getServer()
     s.registration.welcome_message()
     ret = s.redirected()
     self.assertEqual(ret, "http://SECRET_URL/XMLRPC")

def updateHardware():
    s = rpcServer.getServer()


    hardwareList = hardware.Hardware()
    s.registration.refresh_hw_profile(up2dateAuth.getSystemId(),
                                          hardwareList)

    def testGetServerMultipleCaCert(self):
        "getServer with a multiple CA certs"
        rpcServer.rhns_ca_certs = ["/usr/share/rhn/RHNS-CA-CERT", "/usr/share/rhn/RHNS-CA-CERT"]

        try:
            s = rpcServer.getServer()
        except:
            self.fail("Got an %s expection" % sys.exc_type)

 def testGetServerAuthProxyNoEnableAuthProxy(self):
     "getServer with httpProxy set, but no enableAuthProxy"
     sys.path.append("/etc/sysconfig/rhn/")
     proxyUrl = testConfig.authProxyUrl
     self.cfg['httpProxy'] = testConfig.authProxyUrl
     try:
         s = rpcServer.getServer()
     except:
         self.fail("Got an expection calling rpcServer.getServer")

 def testGetServerProxy(self):
     "Verify that getServer Works when specifying a proxy"
     sys.path.append("/etc/sysconfig/rhn/")
     proxyUrl = testConfig.anonProxyUrl
     self.cfg['httpProxy'] = proxyUrl
     try:
         s = rpcServer.getServer()
     except:
         self.fail("Got an expection calling rpcServer.getServer")

 def testDefaultWelcomeMessageHttpsToHttp(self):
     "Test redirecting https to http"
     self.cfg['serverURL'] = "https://SECRET_URL/XMLRPC-REDIRECT-NOSSL"
     s = rpcServer.getServer()
     try:
         s.registration.welcome_message()
     except rpclib.InvalidRedirectionError:
         pass
     else:
         self.fail("IOError expected here but didnt get it")

 def testGetServerNoCaCert(self):
     "getServer with a missing CA cert"
     self.cfg['sslCACert'] =  ["/var/not/likely/to/exist/I/hope/SSL-CA-Cert"]
     try:
         s = rpcServer.getServer()
         write(s)
     except SystemExit:
         pass
     else:
         self.fail("Expected to get an SSLCertificateFileNotFound error")

 def testGetServerAuthProxyNoUsername(self):
     "Verify that getSerer works when specifying an an auth proxy and no username"
     sys.path.append("/etc/sysconfig/rhn/")
     proxyUrl = testConfig.authProxyUrl
     self.cfg['httpProxy'] = testConfig.authProxyUrl
     self.cfg['enableAuthProxy'] = 1
     try:
         s = rpcServer.getServer()
     except:
         self.fail("Got an expection calling rpcServer.getServer")

 def testDefaultWelcomeMessageHttpToHttpRedirectsOff(self):
     "Test redirecting http to http and verify if tails with allow_redirect off"
     self.cfg['serverURL'] = "http://SECRET_URL/XMLRPC-REDIRECT-NOSSL"
     s = rpcServer.getServer()
     s.allow_redirect(0)
     try:
         s.registration.welcome_message()
     except rpclib.InvalidRedirectionError:
         pass
     else:
         self.fail("InvalidRedirectionError expected here but didnt get it")

 def testDefaultWelcomeMessageHttpsToHttpsRedirectsOff(self):
     "Test redirecting https to https and verify it fails with allow_redirect off"
     self.cfg['serverURL'] = "%s/XMLRPC-REDIRECT" % self.defaultServer
     s = rpcServer.getServer()
     s.allow_redirect(0)
     try:
         s.registration.welcome_message()
     except  rpclib.InvalidRedirectionError:
         pass
     else:
         self.fail("InvalidRedirectionError expected here but didnt get it")

    def testGetServerNoCaCert(self):
        "getServer with a missing CA cert"
        self.cfg['sslCACert'] =  ["/var/not/likely/to/exist/I/hope/SSL-CA-Cert"]
#        rpcServer.rhns_ca_certs = ["/var/not/likely/to/exist/I/hope/SSL-CA-Cert"]
        try:
            s = rpcServer.getServer()
            write(s)
        except SystemExit:
            pass
        else:
            self.fail("Expected to get a sys.exit(1)")

    def __get_server():
        """ Initialize a server connection and set up capability info. """
        server = rpcServer.getServer()

        # load the new client caps if they exist
        clientCaps.loadLocalCaps()

        headerlist = clientCaps.caps.headerFormat()
        for (headerName, value) in headerlist:
            server.add_header(headerName, value)

        return server

 def getSolutions(self, unknowns, progressCallback = None, msgCallback = None):
     s = rpcServer.getServer(refreshCallback=self.refreshCallback)
     try:
         tmpRetList = rpcServer.doCall(s.up2date.solveDependencies,
                                         up2dateAuth.getSystemId(),
                                         unknowns)
     except rpclib.Fault, f:
         if f.faultCode == -26:
             #raise RpmError(f.faultString + _(", depended on by %s") % unknowns)
             raise up2dateErrors.RpmError(f.faultString)
         else:
              raise up2dateErrors.CommunicationError(f.faultString)