Could you add HTTPS support to the httplibrary?

[testipena]

Hello!

Could you add an elegant way to use HTTPS with the httplibrary?

I modified the livetest.py and __ init__.py in the following way and got https requests to work.

livetest.py

def __init__(self, host, scheme='http', relative_to=None):
    self.host = host
    self.relative_to = relative_to
    self.conn = {}
    self._load_conn(scheme)
    self.scheme = scheme
    self.extra_environ = {}
    self.reset()

def _do_httplib_request(self, req):
    "Convert WebOb Request to httplib request."
    headers = dict((name, val) for name, val in req.headers.iteritems())
    if req.scheme not in self.conn:
        self._load_conn(self.scheme)

    conn = self.conn[self.scheme]
    conn.request(req.method, req.path_qs, req.body, headers)

    webresp = conn.getresponse()
    res = webtest.TestResponse()
    res.status = '%s %s' % (webresp.status, webresp.reason)
    res.body = webresp.read()
    response_headers = []
    for headername in dict(webresp.getheaders()).keys():
        for headervalue in webresp.msg.getheaders(headername):
            response_headers.append((headername, headervalue))
    res.headerlist = response_headers
    res.errors = ''
    return res

and __ init.py __

    def __init__(self, http, scheme,  host=None):
        # daddy
        self._http = http

        # the livetest app
        if host:
            self.app = livetest.TestApp(host, scheme)
        else:
            self.app = None

        # the last request
        self.response = None

        # requirements for the next request
        # None -> no requirements
        # True -> request should succeed
        # False -> request should not succeed
        # string -> response status code should startwith(string)
        self.next_request_should = None

        # setup new http context
        self.post_process_request(None)


# internal
def __init__(self, scheme):
    self._contexts = [HTTP.Context(self, scheme)]

def create_http_context(self, scheme, host=None):
    """
    Sets the HTTP host to use for future requests. You must call this
    before issuing any HTTP requests.
    `scheme` is used to determine if the connection is made using http or https 
    `host` is the name of the host, optionally with port (e.g. 'google.com' or 'localhost:5984')
    """
    if host == None:
        host = self.context.app.host
    logger.info("Host for next HTTP request set to '%s'" % host)
    logger.info("Scheme for the next HTTP request is '%s'" % scheme)
    self._contexts.append(HTTP.Context(self, scheme, host))

There seems to be some issue when the modified library is taken into use in the Robot Framework the library needs an argument to work correctly.

BR. testipena

[peritus]

@testipena

yes, this library is intended to work with HTTPS as well.

I will probably not follow your proposal (Create HTTP Context <scheme> <host>) as it breaks backwards compatibility and forces a burden on people "just" using plain HTTP.

Also, for this to be merged I'd require a few tests to make sure it's working correctly.

Feel free to send a pull request, otherwise I'll leave this issue open as a reminder to get to it myself.

[peritus]

What do you think of

Create HTTP Context  <host>  <scheme [default:http]>

though ?

[testipena]

That sounds good if the arguments switch places as you suggest. The backward compatibility is good to keep in mind.

Create HTTP Context

other solution could be to add new Keyword

Create HTTPS Context

, but that would cause to use Run Keyword If -statements.

[peritus]

Yes, I also plan to add this to the GET keyword, so you can do

GET  https://my-ssl-host/file.txt

that is equivalent to

Create HTTP Context  my-ssl-host     https
GET                  /file.txt

[testipena]

That is good idea.

[stevejefferies]

I am also very keen to see HTTPS support included as I have implemented a very similar fix to that suggested here locally to allow our test system to support HTTPS. If I can put together a set of working test cases I will submit a pull request.

[peritus]

I have a half-working implementation here as well that waits for me to wrap it up. I'd be happy to accept a pull request with tests and docs.