loginsrv

Unnamed repository; edit this file 'description' to name the repository.
git clone git@jamesshield.xyz:repos/loginsrv.git
Log | Files | Refs | README | LICENSE

gitlab_test.go (8405B)


      1 package oauth2
      2 
      3 import (
      4 	"net/http"
      5 	"net/http/httptest"
      6 	"regexp"
      7 	"testing"
      8 
      9 	. "github.com/stretchr/testify/assert"
     10 	"github.com/tarent/loginsrv/model"
     11 )
     12 
     13 var gitlabTestUserResponse = `{
     14 	"id": 1,
     15 	"username": "john_smith",
     16 	"email": "john@example.com",
     17 	"name": "John Smith",
     18 	"state": "active",
     19 	"avatar_url": "http://localhost:3000/uploads/user/avatar/1/index.jpg",
     20 	"web_url": "http://localhost:3000/john_smith",
     21 	"created_at": "2012-05-23T08:00:58Z",
     22 	"bio": null,
     23 	"location": null,
     24 	"public_email": "john@example.com",
     25 	"skype": "",
     26 	"linkedin": "",
     27 	"twitter": "",
     28 	"website_url": "",
     29 	"organization": "",
     30 	"last_sign_in_at": "2012-06-01T11:41:01Z",
     31 	"confirmed_at": "2012-05-23T09:05:22Z",
     32 	"theme_id": 1,
     33 	"last_activity_on": "2012-05-23",
     34 	"color_scheme_id": 2,
     35 	"projects_limit": 100,
     36 	"current_sign_in_at": "2012-06-02T06:36:55Z",
     37 	"identities": [
     38 	  {"provider": "github", "extern_uid": "2435223452345"},
     39 	  {"provider": "bitbucket", "extern_uid": "john_smith"},
     40 	  {"provider": "google_oauth2", "extern_uid": "8776128412476123468721346"}
     41 	],
     42 	"can_create_group": true,
     43 	"can_create_project": true,
     44 	"two_factor_enabled": true,
     45 	"external": false,
     46 	"private_profile": false
     47   }`
     48 
     49 var gitlabTestGroupsResponse = `[
     50 	{
     51 	  "id": 1,
     52 	  "web_url": "https://gitlab.com/groups/example",
     53 	  "name": "example",
     54 	  "path": "example",
     55 	  "description": "",
     56 	  "visibility": "private",
     57 	  "lfs_enabled": true,
     58 	  "avatar_url": null,
     59 	  "request_access_enabled": true,
     60 	  "full_name": "example",
     61 	  "full_path": "example",
     62 	  "parent_id": null,
     63 	  "ldap_cn": null,
     64 	  "ldap_access": null
     65 	},
     66 	{
     67 		"id": 2,
     68 		"web_url": "https://gitlab.com/groups/example/subgroup",
     69 		"name": "subgroup",
     70 		"path": "subgroup",
     71 		"description": "",
     72 		"visibility": "private",
     73 		"lfs_enabled": true,
     74 		"avatar_url": null,
     75 		"request_access_enabled": true,
     76 		"full_name": "example / subgroup",
     77 		"full_path": "example/subgroup",
     78 		"parent_id": null,
     79 		"ldap_cn": null,
     80 		"ldap_access": null
     81 	}
     82 ]`
     83 
     84 func Test_Gitlab_getUserInfo(t *testing.T) {
     85 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
     86 		if r.URL.Path == "/user" {
     87 			Equal(t, "secret", r.FormValue("access_token"))
     88 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
     89 			w.Write([]byte(gitlabTestUserResponse))
     90 		} else if r.URL.Path == "/groups" {
     91 			Equal(t, "secret", r.FormValue("access_token"))
     92 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
     93 			w.Write([]byte(gitlabTestGroupsResponse))
     94 		}
     95 	}))
     96 	defer server.Close()
     97 
     98 	gitlabAPI = server.URL
     99 
    100 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    101 	NoError(t, err)
    102 	Equal(t, "john_smith", u.Sub)
    103 	Equal(t, "john@example.com", u.Email)
    104 	Equal(t, "John Smith", u.Name)
    105 	Equal(t, []string{"example", "example/subgroup"}, u.Groups)
    106 	Equal(t, `{"user":`+gitlabTestUserResponse+`,"groups":`+gitlabTestGroupsResponse+`}`, rawJSON)
    107 }
    108 
    109 func Test_Gitlab_getUserInfo_NoServer(t *testing.T) {
    110 	gitlabAPI = "http://localhost"
    111 
    112 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    113 	Equal(t, model.UserInfo{}, u)
    114 	Empty(t, rawJSON)
    115 	Error(t, err)
    116 	Regexp(t, regexp.MustCompile(`connection refused$`), err.Error())
    117 }
    118 
    119 func Test_Gitlab_getUserInfo_UserContentTypeNegative(t *testing.T) {
    120 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    121 		if r.URL.Path == "/user" {
    122 			Equal(t, "secret", r.FormValue("access_token"))
    123 			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    124 			w.Write([]byte(gitlabTestUserResponse))
    125 		} else if r.URL.Path == "/groups" {
    126 			Equal(t, "secret", r.FormValue("access_token"))
    127 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    128 			w.Write([]byte(gitlabTestGroupsResponse))
    129 		}
    130 	}))
    131 	defer server.Close()
    132 
    133 	gitlabAPI = server.URL
    134 
    135 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    136 	Equal(t, model.UserInfo{}, u)
    137 	Empty(t, rawJSON)
    138 	Error(t, err)
    139 	Regexp(t, regexp.MustCompile(`^wrong content-type on gitlab get user info`), err.Error())
    140 }
    141 
    142 func Test_Gitlab_getUserInfo_GroupsContentTypeNegative(t *testing.T) {
    143 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    144 		if r.URL.Path == "/user" {
    145 			Equal(t, "secret", r.FormValue("access_token"))
    146 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    147 			w.Write([]byte(gitlabTestUserResponse))
    148 		} else if r.URL.Path == "/groups" {
    149 			Equal(t, "secret", r.FormValue("access_token"))
    150 			w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    151 			w.Write([]byte(gitlabTestGroupsResponse))
    152 		}
    153 	}))
    154 	defer server.Close()
    155 
    156 	gitlabAPI = server.URL
    157 
    158 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    159 	Equal(t, model.UserInfo{}, u)
    160 	Empty(t, rawJSON)
    161 	Error(t, err)
    162 	Regexp(t, regexp.MustCompile(`^wrong content-type on gitlab get groups info`), err.Error())
    163 }
    164 
    165 func Test_Gitlab_getUserInfo_UserStatusCodeNegative(t *testing.T) {
    166 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    167 		if r.URL.Path == "/user" {
    168 			Equal(t, "secret", r.FormValue("access_token"))
    169 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    170 			w.WriteHeader(http.StatusInternalServerError)
    171 			w.Write([]byte(gitlabTestUserResponse))
    172 		} else if r.URL.Path == "/groups" {
    173 			Equal(t, "secret", r.FormValue("access_token"))
    174 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    175 			w.Write([]byte(gitlabTestGroupsResponse))
    176 		}
    177 	}))
    178 	defer server.Close()
    179 
    180 	gitlabAPI = server.URL
    181 
    182 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    183 	Equal(t, model.UserInfo{}, u)
    184 	Empty(t, rawJSON)
    185 	Error(t, err)
    186 	Regexp(t, regexp.MustCompile(`^got http status [0-9]{3} on gitlab get user info`), err.Error())
    187 }
    188 
    189 func Test_Gitlab_getUserInfo_GroupsStatusCodeNegative(t *testing.T) {
    190 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    191 		if r.URL.Path == "/user" {
    192 			Equal(t, "secret", r.FormValue("access_token"))
    193 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    194 			w.Write([]byte(gitlabTestUserResponse))
    195 		} else if r.URL.Path == "/groups" {
    196 			Equal(t, "secret", r.FormValue("access_token"))
    197 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    198 			w.WriteHeader(http.StatusInternalServerError)
    199 			w.Write([]byte(gitlabTestGroupsResponse))
    200 		}
    201 	}))
    202 	defer server.Close()
    203 
    204 	gitlabAPI = server.URL
    205 
    206 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    207 	Equal(t, model.UserInfo{}, u)
    208 	Empty(t, rawJSON)
    209 	Error(t, err)
    210 	Regexp(t, regexp.MustCompile(`^got http status [0-9]{3} on gitlab get groups info`), err.Error())
    211 }
    212 
    213 func Test_Gitlab_getUserInfo_UserJSONNegative(t *testing.T) {
    214 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    215 		if r.URL.Path == "/user" {
    216 			Equal(t, "secret", r.FormValue("access_token"))
    217 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    218 			w.Write([]byte("[]"))
    219 		} else if r.URL.Path == "/groups" {
    220 			Equal(t, "secret", r.FormValue("access_token"))
    221 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    222 			w.Write([]byte(gitlabTestGroupsResponse))
    223 		}
    224 	}))
    225 	defer server.Close()
    226 
    227 	gitlabAPI = server.URL
    228 
    229 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    230 	Equal(t, model.UserInfo{}, u)
    231 	Empty(t, rawJSON)
    232 	Error(t, err)
    233 	Regexp(t, regexp.MustCompile(`^error parsing gitlab get user info`), err.Error())
    234 }
    235 
    236 func Test_Gitlab_getUserInfo_GroupsJSONNegative(t *testing.T) {
    237 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    238 		if r.URL.Path == "/user" {
    239 			Equal(t, "secret", r.FormValue("access_token"))
    240 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    241 			w.Write([]byte(gitlabTestUserResponse))
    242 		} else if r.URL.Path == "/groups" {
    243 			Equal(t, "secret", r.FormValue("access_token"))
    244 			w.Header().Set("Content-Type", "application/json; charset=utf-8")
    245 			w.Write([]byte("{}"))
    246 		}
    247 	}))
    248 	defer server.Close()
    249 
    250 	gitlabAPI = server.URL
    251 
    252 	u, rawJSON, err := providerGitlab.GetUserInfo(TokenInfo{AccessToken: "secret"})
    253 	Equal(t, model.UserInfo{}, u)
    254 	Empty(t, rawJSON)
    255 	Error(t, err)
    256 	Regexp(t, regexp.MustCompile(`^error parsing gitlab get groups info`), err.Error())
    257 }