1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
package api
import (
"fmt"
"io"
"net/http"
"net/http/httptest"
"net/url"
"regexp"
"testing"
"github.com/stretchr/testify/require"
"gitlab.com/gitlab-org/gitlab/workhorse/internal/helper"
"gitlab.com/gitlab-org/gitlab/workhorse/internal/secret"
"gitlab.com/gitlab-org/gitlab/workhorse/internal/testhelper"
"gitlab.com/gitlab-org/gitlab/workhorse/internal/upstream/roundtripper"
)
func TestGetGeoProxyDataForResponses(t *testing.T) {
testCases := []struct {
desc string
json string
expectedError bool
expectedURL string
expectedExtraData string
}{
{"when Geo secondary", `{"geo_proxy_url":"http://primary","geo_proxy_extra_data":"geo-data"}`, false, "http://primary", "geo-data"},
{"when Geo secondary with explicit null data", `{"geo_proxy_url":"http://primary","geo_proxy_extra_data":null}`, false, "http://primary", ""},
{"when Geo secondary without extra data", `{"geo_proxy_url":"http://primary"}`, false, "http://primary", ""},
{"when Geo primary or no node", `{}`, false, "", ""},
{"for malformed request", `non-json`, true, "", ""},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
geoProxyData, err := getGeoProxyDataGivenResponse(t, tc.json)
if tc.expectedError {
require.Error(t, err)
} else {
require.NoError(t, err)
require.Equal(t, tc.expectedURL, geoProxyData.GeoProxyURL.String())
require.Equal(t, tc.expectedExtraData, geoProxyData.GeoProxyExtraData)
}
})
}
}
func TestPreAuthorizeFixedPath_OK(t *testing.T) {
var (
upstreamHeaders http.Header
upstreamQuery url.Values
)
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/my/api/path" {
return
}
upstreamHeaders = r.Header
upstreamQuery = r.URL.Query()
w.Header().Set("Content-Type", ResponseContentType)
io.WriteString(w, `{"TempPath":"HELLO!!"}`)
}))
defer ts.Close()
req, err := http.NewRequest("GET", "/original/request/path?q1=Q1&q2=Q2", nil)
require.NoError(t, err)
req.Header.Set("key1", "value1")
api := NewAPI(helper.URLMustParse(ts.URL), "123", http.DefaultTransport)
resp, err := api.PreAuthorizeFixedPath(req, "POST", "/my/api/path")
require.NoError(t, err)
require.Equal(t, "value1", upstreamHeaders.Get("key1"), "original headers must propagate")
require.Equal(t, url.Values{"q1": []string{"Q1"}, "q2": []string{"Q2"}}, upstreamQuery,
"original query must propagate")
require.Equal(t, "HELLO!!", resp.TempPath, "sanity check: successful API call")
}
func TestPreAuthorizeFixedPath_Unauthorized(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/my/api/path" {
return
}
w.WriteHeader(http.StatusUnauthorized)
}))
defer ts.Close()
req, err := http.NewRequest("GET", "/original/request/path?q1=Q1&q2=Q2", nil)
require.NoError(t, err)
api := NewAPI(helper.URLMustParse(ts.URL), "123", http.DefaultTransport)
resp, err := api.PreAuthorizeFixedPath(req, "POST", "/my/api/path")
require.Nil(t, resp)
preAuthError := &PreAuthorizeFixedPathError{StatusCode: 401, Status: "Unauthorized 401"}
require.ErrorAs(t, err, &preAuthError)
}
func getGeoProxyDataGivenResponse(t *testing.T, givenInternalApiResponse string) (*GeoProxyData, error) {
t.Helper()
ts := testRailsServer(regexp.MustCompile(`/api/v4/geo/proxy`), 200, givenInternalApiResponse)
defer ts.Close()
backend := helper.URLMustParse(ts.URL)
version := "123"
rt := roundtripper.NewTestBackendRoundTripper(backend)
testhelper.ConfigureSecret()
apiClient := NewAPI(backend, version, rt)
geoProxyData, err := apiClient.GetGeoProxyData()
return geoProxyData, err
}
func testRailsServer(url *regexp.Regexp, code int, body string) *httptest.Server {
return testhelper.TestServerWithHandlerWithGeoPolling(url, func(w http.ResponseWriter, r *http.Request) {
// return a 204 No Content response if we don't receive the JWT header
if r.Header.Get(secret.RequestHeader) == "" {
w.WriteHeader(204)
return
}
w.Header().Set("Content-Type", ResponseContentType)
w.WriteHeader(code)
fmt.Fprint(w, body)
})
}
|
