git.iko.soy/typeable/oauth2-proxy
on 3155ada help sign in
typeable/oauth2-proxy/providers/github_test.go
186 lines 5.6 kB history raw
1package providers
3import (
4 "net/http"
5 "net/http/httptest"
6 "net/url"
7 "testing"
9 "github.com/pusher/oauth2_proxy/pkg/apis/sessions"
10 "github.com/stretchr/testify/assert"
13func testGitHubProvider(hostname string) *GitHubProvider {
14 p := NewGitHubProvider(
15 &ProviderData{
16 ProviderName: "",
17 LoginURL: &url.URL{},
18 RedeemURL: &url.URL{},
19 ProfileURL: &url.URL{},
20 ValidateURL: &url.URL{},
21 Scope: ""})
22 if hostname != "" {
23 updateURL(p.Data().LoginURL, hostname)
24 updateURL(p.Data().RedeemURL, hostname)
25 updateURL(p.Data().ProfileURL, hostname)
26 updateURL(p.Data().ValidateURL, hostname)
27 }
28 return p
31func testGitHubBackend(payload []string) *httptest.Server {
32 pathToQueryMap := map[string][]string{
33 "/user": {""},
34 "/user/emails": {""},
35 "/user/orgs": {"limit=200&page=1", "limit=200&page=2", "limit=200&page=3"},
36 }
38 return httptest.NewServer(http.HandlerFunc(
39 func(w http.ResponseWriter, r *http.Request) {
40 query, ok := pathToQueryMap[r.URL.Path]
41 validQuery := false
42 index := 0
43 for i, q := range query {
44 if q == r.URL.RawQuery {
45 validQuery = true
46 index = i
47 }
48 }
49 if !ok {
50 w.WriteHeader(404)
51 } else if !validQuery {
52 w.WriteHeader(404)
53 } else {
54 w.WriteHeader(200)
55 w.Write([]byte(payload[index]))
56 }
57 }))
60func TestGitHubProviderDefaults(t *testing.T) {
61 p := testGitHubProvider("")
62 assert.NotEqual(t, nil, p)
63 assert.Equal(t, "GitHub", p.Data().ProviderName)
64 assert.Equal(t, "https://github.com/login/oauth/authorize",
65 p.Data().LoginURL.String())
66 assert.Equal(t, "https://github.com/login/oauth/access_token",
67 p.Data().RedeemURL.String())
68 assert.Equal(t, "https://api.github.com/",
69 p.Data().ValidateURL.String())
70 assert.Equal(t, "user:email", p.Data().Scope)
73func TestGitHubProviderOverrides(t *testing.T) {
74 p := NewGitHubProvider(
75 &ProviderData{
76 LoginURL: &url.URL{
77 Scheme: "https",
78 Host: "example.com",
79 Path: "/login/oauth/authorize"},
80 RedeemURL: &url.URL{
81 Scheme: "https",
82 Host: "example.com",
83 Path: "/login/oauth/access_token"},
84 ValidateURL: &url.URL{
85 Scheme: "https",
86 Host: "api.example.com",
87 Path: "/"},
88 Scope: "profile"})
89 assert.NotEqual(t, nil, p)
90 assert.Equal(t, "GitHub", p.Data().ProviderName)
91 assert.Equal(t, "https://example.com/login/oauth/authorize",
92 p.Data().LoginURL.String())
93 assert.Equal(t, "https://example.com/login/oauth/access_token",
94 p.Data().RedeemURL.String())
95 assert.Equal(t, "https://api.example.com/",
96 p.Data().ValidateURL.String())
97 assert.Equal(t, "profile", p.Data().Scope)
100func TestGitHubProviderGetEmailAddress(t *testing.T) {
101 b := testGitHubBackend([]string{`[ {"email": "michael.bland@gsa.gov", "verified": true, "primary": true} ]`})
102 defer b.Close()
104 bURL, _ := url.Parse(b.URL)
105 p := testGitHubProvider(bURL.Host)
107 session := &sessions.SessionState{AccessToken: "imaginary_access_token"}
108 email, err := p.GetEmailAddress(session)
109 assert.Equal(t, nil, err)
110 assert.Equal(t, "michael.bland@gsa.gov", email)
113func TestGitHubProviderGetEmailAddressNotVerified(t *testing.T) {
114 b := testGitHubBackend([]string{`[ {"email": "michael.bland@gsa.gov", "verified": false, "primary": true} ]`})
115 defer b.Close()
117 bURL, _ := url.Parse(b.URL)
118 p := testGitHubProvider(bURL.Host)
120 session := &sessions.SessionState{AccessToken: "imaginary_access_token"}
121 email, err := p.GetEmailAddress(session)
122 assert.Equal(t, nil, err)
123 assert.Empty(t, "", email)
126func TestGitHubProviderGetEmailAddressWithOrg(t *testing.T) {
127 b := testGitHubBackend([]string{
128 `[ {"email": "michael.bland@gsa.gov", "primary": true, "verified": true, "login":"testorg"} ]`,
129 `[ {"email": "michael.bland1@gsa.gov", "primary": true, "verified": true, "login":"testorg1"} ]`,
130 `[ ]`,
131 })
132 defer b.Close()
134 bURL, _ := url.Parse(b.URL)
135 p := testGitHubProvider(bURL.Host)
136 p.Org = "testorg1"
138 session := &sessions.SessionState{AccessToken: "imaginary_access_token"}
139 email, err := p.GetEmailAddress(session)
140 assert.Equal(t, nil, err)
141 assert.Equal(t, "michael.bland@gsa.gov", email)
144// Note that trying to trigger the "failed building request" case is not
145// practical, since the only way it can fail is if the URL fails to parse.
146func TestGitHubProviderGetEmailAddressFailedRequest(t *testing.T) {
147 b := testGitHubBackend([]string{"unused payload"})
148 defer b.Close()
150 bURL, _ := url.Parse(b.URL)
151 p := testGitHubProvider(bURL.Host)
153 // We'll trigger a request failure by using an unexpected access
154 // token. Alternatively, we could allow the parsing of the payload as
155 // JSON to fail.
156 session := &sessions.SessionState{AccessToken: "unexpected_access_token"}
157 email, err := p.GetEmailAddress(session)
158 assert.NotEqual(t, nil, err)
159 assert.Equal(t, "", email)
162func TestGitHubProviderGetEmailAddressEmailNotPresentInPayload(t *testing.T) {
163 b := testGitHubBackend([]string{"{\"foo\": \"bar\"}"})
164 defer b.Close()
166 bURL, _ := url.Parse(b.URL)
167 p := testGitHubProvider(bURL.Host)
169 session := &sessions.SessionState{AccessToken: "imaginary_access_token"}
170 email, err := p.GetEmailAddress(session)
171 assert.NotEqual(t, nil, err)
172 assert.Equal(t, "", email)
175func TestGitHubProviderGetUserName(t *testing.T) {
176 b := testGitHubBackend([]string{`{"email": "michael.bland@gsa.gov", "login": "mbland"}`})
177 defer b.Close()
179 bURL, _ := url.Parse(b.URL)
180 p := testGitHubProvider(bURL.Host)
182 session := &sessions.SessionState{AccessToken: "imaginary_access_token"}
183 email, err := p.GetUserName(session)
184 assert.Equal(t, nil, err)
185 assert.Equal(t, "mbland", email)