added X-Forwarded-Protocol, X-Forwarded-Ssl, X-Url-Scheme improve more coverage on identifying request scheme

Author: jeevatkm

ahttp.go

@@ -96,24 +96,35 @@ func WrapGzipWriter(w io.Writer) ResponseWriter {
 	return gr
 }
 
-// IdentifyScheme method is to identify value of protocol value. It's is derived
+// Scheme method is to identify value of protocol value. It's is derived
 // one, Go language doesn't provide directly.
-//  - `X-Forwarded-Proto` is not empty return value as is
-//  - `http.Request.TLS` is not nil value is `https`
-//  - `http.Request.TLS` is nil value is `http`
-func IdentifyScheme(r *http.Request) string {
-	scheme := r.Header.Get("X-Forwarded-Proto")
-	if scheme == "" {
-		if r.TLS == nil {
-			return "http"
-		}
+//  - `X-Forwarded-Proto` is not empty, returns as-is
+//  - `X-Forwarded-Protocol` is not empty, returns as-is
+//  - `http.Request.TLS` is not nil or `X-Forwarded-Ssl == on` returns `https`
+//  - `X-Url-Scheme` is not empty, returns as-is
+//  - returns `http`
+func Scheme(r *http.Request) string {
+	if scheme := r.Header.Get(HeaderXForwardedProto); scheme != "" {
+		return scheme
+	}
+
+	if scheme := r.Header.Get(HeaderXForwardedProtocol); scheme != "" {
+		return scheme
+	}
+
+	if r.TLS != nil || r.Header.Get(HeaderXForwardedSsl) == "on" {
 		return "https"
 	}
-	return scheme
+
+	if scheme := r.Header.Get(HeaderXUrlScheme); scheme != "" {
+		return scheme
+	}
+
+	return "http"
 }
 
-// IdentifyHost method is to correct Hosyt source value from HTTP request.
-func IdentifyHost(r *http.Request) string {
+// Host method is to correct Hosyt source value from HTTP request.
+func Host(r *http.Request) string {
 	if r.URL.Host == "" {
 		return r.Host
 	}

content_type_test.go

@@ -6,6 +6,7 @@ package ahttp
 
 import (
 	"net/url"
+	"runtime"
 	"testing"
 
 	"aahframework.org/essentials.v0"
@@ -41,8 +42,11 @@ func TestHTTPNegotiateContentType(t *testing.T) {
 	req := createRawHTTPRequest(HeaderAccept, "application/json")
 	req.URL, _ = url.Parse("http://localhost:8080/testpath.json")
 	contentType = NegotiateContentType(req)
-	assert.True(t, contentType.IsEqual("application/json"))
-	assert.Equal(t, ".json", contentType.Exts[0])
+	if runtime.GOOS != "windows" { // due to mime types not exists
+		assert.NotNil(t, contentType)
+		assert.True(t, contentType.IsEqual("application/json"))
+		assert.Equal(t, ".json", contentType.Exts[0])
+	}
 
 	req = createRawHTTPRequest(HeaderAccept, "application/json")
 	req.URL, _ = url.Parse("http://localhost:8080/testpath.html")

header.go

@@ -79,6 +79,9 @@ const (
 	HeaderXForwardedHost                  = "X-Forwarded-Host"
 	HeaderXForwardedPort                  = "X-Forwarded-Port"
 	HeaderXForwardedProto                 = "X-Forwarded-Proto"
+	HeaderXForwardedProtocol              = "X-Forwarded-Protocol"
+	HeaderXForwardedSsl                   = "X-Forwarded-Ssl"
+	HeaderXUrlScheme                      = "X-Url-Scheme"
 	HeaderXForwardedServer                = "X-Forwarded-Server"
 	HeaderXFrameOptions                   = "X-Frame-Options"
 	HeaderXHTTPMethodOverride             = "X-HTTP-Method-Override"

request.go

@@ -33,8 +33,8 @@ var requestPool = &sync.Pool{New: func() interface{} { return &Request{} }}
 // ParseRequest method populates the given aah framework `ahttp.Request`
 // instance from Go HTTP request.
 func ParseRequest(r *http.Request, req *Request) *Request {
-	req.Scheme = IdentifyScheme(r)
-	req.Host = IdentifyHost(r)
+	req.Scheme = Scheme(r)
+	req.Host = Host(r)
 	req.Proto = r.Proto
 	req.Method = r.Method
 	req.Path = r.URL.Path

request_test.go

@@ -158,7 +158,7 @@ func TestHTTPRequestParams(t *testing.T) {
 	f, fh, err := aahReq3.FormFile("testfile.txt")
 	assert.Nil(t, f)
 	assert.Equal(t, "testfile.txt", fh.Filename)
-	assert.Equal(t, "open : no such file or directory", err.Error())
+	assert.True(t, strings.HasPrefix(err.Error(), "open :"))
 	ReleaseRequest(aahReq3)
 }
 
@@ -185,20 +185,25 @@ func TestHTTPRequestCookies(t *testing.T) {
 
 func TestRequestSchemeDerived(t *testing.T) {
 	req := httptest.NewRequest("GET", "http://127.0.0.1:8080/welcome.html", nil)
-	scheme1 := IdentifyScheme(req)
-	assert.Equal(t, "http", scheme1)
+	assert.Equal(t, "http", Scheme(req))
+
+	req.Header.Set(HeaderXUrlScheme, "http")
+	assert.Equal(t, "http", Scheme(req))
+
+	req.Header.Set(HeaderXForwardedSsl, "on")
+	assert.Equal(t, "https", Scheme(req))
 
 	req.TLS = &tls.ConnectionState{}
-	scheme2 := IdentifyScheme(req)
-	assert.Equal(t, "https", scheme2)
+	assert.Equal(t, "https", Scheme(req))
+
+	req.Header.Set(HeaderXForwardedProtocol, "https")
+	assert.Equal(t, "https", Scheme(req))
 
 	req.Header.Set(HeaderXForwardedProto, "https")
-	scheme3 := IdentifyScheme(req)
-	assert.Equal(t, "https", scheme3)
+	assert.Equal(t, "https", Scheme(req))
 
 	req.Header.Set(HeaderXForwardedProto, "http")
-	scheme4 := IdentifyScheme(req)
-	assert.Equal(t, "http", scheme4)
+	assert.Equal(t, "http", Scheme(req))
 }
 
 func TestRequestSaveFile(t *testing.T) {
@@ -298,7 +303,7 @@ func TestRequestSaveFileForExistingFile(t *testing.T) {
 
 	size, err := saveFile(&buf, "testdata/file1.txt")
 	assert.NotNil(t, err)
-	assert.Equal(t, "ahttp: open testdata/file1.txt: file exists", err.Error())
+	assert.True(t, strings.HasPrefix(err.Error(), "ahttp: open testdata/file1.txt:"))
 	assert.Equal(t, int64(0), size)
 }