Added individual request proxy support

Signed-off-by: Levi Gross <[email protected]>

Author: levigross

base_get_test.go

@@ -6,6 +6,8 @@ import (
 	"encoding/xml"
 	"io"
 	"net/http"
+	"net/http/httptest"
+	"net/url"
 	"os"
 	"testing"
 )
@@ -94,6 +96,54 @@ func TestGetNoOptions(t *testing.T) {
 	verifyOkResponse(<-GetAsync("http://httpbin.org/get", nil), t)
 }
 
+func TestGetProxy(t *testing.T) {
+	ch := make(chan string, 1)
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ch <- "real server"
+	}))
+
+	defer ts.Close()
+
+	proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ch <- "proxy for " + r.URL.String()
+	}))
+
+	defer proxy.Close()
+
+	pu, err := url.Parse(proxy.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := Head(ts.URL, &RequestOptions{Proxies: map[string]*url.URL{pu.Scheme: pu}})
+
+	defer http.DefaultTransport.(*http.Transport).CloseIdleConnections()
+
+	if err != nil {
+		t.Error("Unable to make request: ", err)
+	}
+
+	if resp.Ok != true {
+		t.Error("Response is not OK for some reason: ", resp.StatusCode)
+	}
+
+	got := <-ch
+	want := "proxy for " + ts.URL + "/"
+	if got != want {
+		t.Errorf("want %q, got %q", want, got)
+	}
+}
+
+func TestGetSyncInvalidProxyScheme(t *testing.T) {
+	resp, err := Get("http://httpbin.org/get", &RequestOptions{Proxies: map[string]*url.URL{"gopher": nil}})
+	if err != nil {
+		t.Error("Request failed: ", err)
+	}
+
+	verifyOkResponse(resp, t)
+}
+
 func TestGetSyncNoOptions(t *testing.T) {
 	resp, err := Get("http://httpbin.org/get", nil)
 	if err != nil {

request.go

@@ -58,6 +58,9 @@ type RequestOptions struct {
 
 	// Cookies is an array of `http.Cookie` that allows you to attach cookies to your request
 	Cookies []http.Cookie
+
+	// Proxies is a map in the following format *protocol* => proxy address e.g http => http://127.0.0.1:8080
+	Proxies map[string]*url.URL
 }
 
 func doRequest(requestVerb, url string, ro *RequestOptions) (*Response, error) {
@@ -133,9 +136,13 @@ func createFileUploadRequest(httpMethod, userURL string, ro *RequestOptions) (*h
 		return createMultiPartPostRequest(httpMethod, userURL, ro)
 	}
 
-	// This may be a PUT or PATCH request so we will just put the raw io.ReadCloser in the request body
+	// This may be a PUT or PATCH request so we will just put the raw
+	// io.ReadCloser in the request body
 	// and guess the MIME type from the file name
 
+	// At the moment, we will only support 1 file upload as a time
+	// when uploading using PUT or PATCH
+
 	req, err := http.NewRequest(httpMethod, userURL, ro.File.FileContents)
 
 	if err != nil {
@@ -246,16 +253,46 @@ func encodePostValues(postValues map[string]string) string {
 	return urlValues.Encode() // This will sort all of the string values
 }
 
+// proxySettings will default to the default proxy settings if none are provided
+// if settings are provided – they will override the environment variables
+func (ro RequestOptions) proxySettings(req *http.Request) (*url.URL, error) {
+	// No proxies – lets use the default
+	if len(ro.Proxies) == 0 {
+		return http.ProxyFromEnvironment(req)
+	}
+
+	// There was a proxy specified – do we support the protocol?
+	if _, ok := ro.Proxies[req.URL.Scheme]; ok {
+		return ro.Proxies[req.URL.Scheme], nil
+	}
+
+	// Proxies were specified but not for any protocol that we use
+	return http.ProxyFromEnvironment(req)
+
+}
+
+// useDefaultClient will tell the "client creator" if a custom client is needed
+// it checks the following items (and will create a custom client of these are)
+// true
+// 1. Do we want to accept invalid SSL certificates?
+// 2. Do we want to disable compression?
+// 3. Do we want a custom proxy?
+func (ro RequestOptions) dontUseDefaultClient() bool {
+	return ro.InsecureSkipVerify == true ||
+		ro.DisableCompression == true ||
+		len(ro.Proxies) != 0
+}
+
 func buildHTTPClient(ro *RequestOptions) *http.Client {
 	// Does the user want to change the defaults?
-	if ro.InsecureSkipVerify != true && ro.DisableCompression != true {
+	if !ro.dontUseDefaultClient() {
 		return http.DefaultClient
 	}
 
 	return &http.Client{
 		Transport: &http.Transport{
 			// These are borrowed from the default transporter
-			Proxy: http.ProxyFromEnvironment,
+			Proxy: ro.proxySettings,
 			Dial: (&net.Dialer{
 				Timeout:   30 * time.Second,
 				KeepAlive: 30 * time.Second,

response_test.go

@@ -1,7 +1,6 @@
 package grequests
 
 import (
-	"net/http"
 	"strconv"
 	"testing"
 )
@@ -15,7 +14,7 @@ func TestResponseOk(t *testing.T) {
 
 func verifyResponseOkForStatus(status int, t *testing.T) {
 	url := "http://httpbin.org/status/" + strconv.Itoa(status)
-	resp, err := buildResponse(http.Get(url))
+	resp, err := Get(url, nil)
 
 	if err != nil {
 		t.Error("Unable to make request", err)