func TestIssueAccessToken(t *testing.T) {
ctrl := gomock.NewController(t)
areq := &fosite.AccessRequest{}
aresp := &fosite.AccessResponse{Extra: map[string]interface{}{}}
accessStrat := internal.NewMockAccessTokenStrategy(ctrl)
accessStore := internal.NewMockAccessTokenStorage(ctrl)
httpReq := &http.Request{}
defer ctrl.Finish()
helper := HandleHelper{
AccessTokenStorage: accessStore,
AccessTokenStrategy: accessStrat,
AccessTokenLifespan: time.Hour,
}
areq.Session = &fosite.DefaultSession{}
for k, c := range []struct {
mock func()
err error
}{
{
mock: func() {
accessStrat.EXPECT().GenerateAccessToken(nil, areq).Return("", "", errors.New(""))
},
err: errors.New(""),
},
{
mock: func() {
accessStrat.EXPECT().GenerateAccessToken(nil, areq).Return("token", "signature", nil)
accessStore.EXPECT().CreateAccessTokenSession(nil, "signature", areq).Return(errors.New(""))
},
err: errors.New(""),
},
{
mock: func() {
accessStrat.EXPECT().GenerateAccessToken(nil, areq).Return("token", "signature", nil)
accessStore.EXPECT().CreateAccessTokenSession(nil, "signature", areq).Return(nil)
},
err: nil,
},
} {
c.mock()
err := helper.IssueAccessToken(nil, httpReq, areq, aresp)
require.Equal(t, err == nil, c.err == nil)
if c.err != nil {
assert.EqualError(t, err, c.err.Error(), "Case %d", k)
}
}
}
func TestAuthorizeImplicit_EndpointHandler(t *testing.T) {
ctrl := gomock.NewController(t)
store := internal.NewMockAccessTokenStorage(ctrl)
chgen := internal.NewMockAccessTokenStrategy(ctrl)
aresp := internal.NewMockAuthorizeResponder(ctrl)
defer ctrl.Finish()
areq := fosite.NewAuthorizeRequest()
httpreq := &http.Request{Form: url.Values{}}
areq.Session = new(fosite.DefaultSession)
h := AuthorizeImplicitGrantTypeHandler{
AccessTokenStorage: store,
AccessTokenStrategy: chgen,
AccessTokenLifespan: time.Hour,
ScopeStrategy: fosite.HierarchicScopeStrategy,
}
for k, c := range []struct {
description string
setup func()
expectErr error
}{
{
description: "should pass because not responsible for handling the response type",
setup: func() {
areq.ResponseTypes = fosite.Arguments{"a"}
},
},
{
description: "should fail because access token generation failed",
setup: func() {
areq.ResponseTypes = fosite.Arguments{"token"}
areq.Client = &fosite.DefaultClient{
GrantTypes: fosite.Arguments{"implicit"},
ResponseTypes: fosite.Arguments{"token"},
}
chgen.EXPECT().GenerateAccessToken(nil, areq).Return("", "", errors.New(""))
},
expectErr: fosite.ErrServerError,
},
{
description: "should fail because persistance failed",
setup: func() {
chgen.EXPECT().GenerateAccessToken(nil, areq).AnyTimes().Return("access.ats", "ats", nil)
store.EXPECT().CreateAccessTokenSession(nil, "ats", areq).Return(errors.New(""))
},
expectErr: fosite.ErrServerError,
},
{
description: "should pass",
setup: func() {
areq.State = "state"
areq.GrantedScopes = fosite.Arguments{"scope"}
store.EXPECT().CreateAccessTokenSession(nil, "ats", areq).AnyTimes().Return(nil)
aresp.EXPECT().AddFragment("access_token", "access.ats")
aresp.EXPECT().AddFragment("expires_in", gomock.Any())
aresp.EXPECT().AddFragment("token_type", "bearer")
aresp.EXPECT().AddFragment("state", "state")
aresp.EXPECT().AddFragment("scope", "scope")
},
expectErr: nil,
},
} {
c.setup()
err := h.HandleAuthorizeEndpointRequest(nil, httpreq, areq, aresp)
assert.True(t, errors.Cause(err) == c.expectErr, "(%d) %s\n%s\n%s", k, c.description, err, c.expectErr)
t.Logf("Passed test case %d", k)
}
}
