github.com/wanliu/go-oauth2-server@v0.0.0-20180817021415-f928fa1580df/oauth/grant_type_refresh_token_test.go (about) 1 package oauth_test 2 3 import ( 4 "net/http" 5 "net/http/httptest" 6 "net/url" 7 "time" 8 9 "github.com/RichardKnop/uuid" 10 "github.com/stretchr/testify/assert" 11 "github.com/wanliu/go-oauth2-server/models" 12 "github.com/wanliu/go-oauth2-server/oauth" 13 "github.com/wanliu/go-oauth2-server/oauth/tokentypes" 14 "github.com/wanliu/go-oauth2-server/test-util" 15 ) 16 17 func (suite *OauthTestSuite) TestRefreshTokenGrantEmptyNotFound() { 18 // Prepare a request 19 r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil) 20 assert.NoError(suite.T(), err, "Request setup should not get an error") 21 r.SetBasicAuth("test_client_1", "test_secret") 22 r.PostForm = url.Values{ 23 "grant_type": {"refresh_token"}, 24 "refresh_token": {""}, 25 } 26 27 // Serve the request 28 w := httptest.NewRecorder() 29 suite.router.ServeHTTP(w, r) 30 31 // Check the response 32 testutil.TestResponseForError( 33 suite.T(), 34 w, 35 oauth.ErrRefreshTokenNotFound.Error(), 36 404, 37 ) 38 } 39 40 func (suite *OauthTestSuite) TestRefreshTokenGrantBogusNotFound() { 41 // Prepare a request 42 r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil) 43 assert.NoError(suite.T(), err, "Request setup should not get an error") 44 r.SetBasicAuth("test_client_1", "test_secret") 45 r.PostForm = url.Values{ 46 "grant_type": {"refresh_token"}, 47 "refresh_token": {"bogus_token"}, 48 } 49 50 // Serve the request 51 w := httptest.NewRecorder() 52 suite.router.ServeHTTP(w, r) 53 54 // Check the response 55 testutil.TestResponseForError( 56 suite.T(), 57 w, 58 oauth.ErrRefreshTokenNotFound.Error(), 59 404, 60 ) 61 } 62 63 func (suite *OauthTestSuite) TestRefreshTokenGrantExipired() { 64 // Insert a test refresh token 65 err := suite.db.Create(&models.OauthRefreshToken{ 66 MyGormModel: models.MyGormModel{ 67 ID: uuid.New(), 68 CreatedAt: time.Now().UTC(), 69 }, 70 Token: "test_token", 71 ExpiresAt: time.Now().UTC().Add(-10 * time.Second), 72 Client: suite.clients[0], 73 User: suite.users[0], 74 Scope: "read_write", 75 }).Error 76 assert.NoError(suite.T(), err, "Inserting test data failed") 77 78 // Prepare a request 79 r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil) 80 assert.NoError(suite.T(), err, "Request setup should not get an error") 81 r.SetBasicAuth("test_client_1", "test_secret") 82 r.PostForm = url.Values{ 83 "grant_type": {"refresh_token"}, 84 "refresh_token": {"test_token"}, 85 "scope": {"read read_write"}, 86 } 87 88 // Serve the request 89 w := httptest.NewRecorder() 90 suite.router.ServeHTTP(w, r) 91 92 // Check the response 93 testutil.TestResponseForError( 94 suite.T(), 95 w, 96 oauth.ErrRefreshTokenExpired.Error(), 97 400, 98 ) 99 } 100 101 func (suite *OauthTestSuite) TestRefreshTokenGrantScopeCannotBeGreater() { 102 // Insert a test refresh token 103 err := suite.db.Create(&models.OauthRefreshToken{ 104 MyGormModel: models.MyGormModel{ 105 ID: uuid.New(), 106 CreatedAt: time.Now().UTC(), 107 }, 108 Token: "test_token", 109 ExpiresAt: time.Now().UTC().Add(+10 * time.Second), 110 Client: suite.clients[0], 111 User: suite.users[0], 112 Scope: "read_write", 113 }).Error 114 assert.NoError(suite.T(), err, "Inserting test data failed") 115 116 // Prepare a request 117 r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil) 118 assert.NoError(suite.T(), err, "Request setup should not get an error") 119 r.SetBasicAuth("test_client_1", "test_secret") 120 r.PostForm = url.Values{ 121 "grant_type": {"refresh_token"}, 122 "refresh_token": {"test_token"}, 123 "scope": {"read read_write"}, 124 } 125 126 // Serve the request 127 w := httptest.NewRecorder() 128 suite.router.ServeHTTP(w, r) 129 130 // Check the response 131 testutil.TestResponseForError( 132 suite.T(), 133 w, 134 oauth.ErrRequestedScopeCannotBeGreater.Error(), 135 400, 136 ) 137 } 138 139 func (suite *OauthTestSuite) TestRefreshTokenGrantDefaultsToOriginalScope() { 140 // Insert a test refresh token 141 err := suite.db.Create(&models.OauthRefreshToken{ 142 MyGormModel: models.MyGormModel{ 143 ID: uuid.New(), 144 CreatedAt: time.Now().UTC(), 145 }, 146 Token: "test_token", 147 ExpiresAt: time.Now().UTC().Add(+10 * time.Second), 148 Client: suite.clients[0], 149 User: suite.users[0], 150 Scope: "read_write", 151 }).Error 152 assert.NoError(suite.T(), err, "Inserting test data failed") 153 154 // Make a request 155 r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil) 156 assert.NoError(suite.T(), err, "Request setup should not get an error") 157 r.SetBasicAuth("test_client_1", "test_secret") 158 r.PostForm = url.Values{ 159 "grant_type": {"refresh_token"}, 160 "refresh_token": {"test_token"}, 161 } 162 163 // Serve the request 164 w := httptest.NewRecorder() 165 suite.router.ServeHTTP(w, r) 166 167 // Fetch data 168 accessToken := new(models.OauthAccessToken) 169 assert.False(suite.T(), models.OauthAccessTokenPreload(suite.db). 170 Last(accessToken).RecordNotFound()) 171 172 // Check the response body 173 expected := &oauth.AccessTokenResponse{ 174 UserID: accessToken.User.MetaUserID, 175 AccessToken: accessToken.Token, 176 ExpiresIn: 3600, 177 TokenType: tokentypes.Bearer, 178 Scope: "read_write", 179 RefreshToken: "test_token", 180 } 181 testutil.TestResponseObject(suite.T(), w, expected, 200) 182 } 183 184 func (suite *OauthTestSuite) TestRefreshTokenGrant() { 185 // Insert a test refresh token 186 err := suite.db.Create(&models.OauthRefreshToken{ 187 MyGormModel: models.MyGormModel{ 188 ID: uuid.New(), 189 CreatedAt: time.Now().UTC(), 190 }, 191 Token: "test_token", 192 ExpiresAt: time.Now().UTC().Add(+10 * time.Second), 193 Client: suite.clients[0], 194 User: suite.users[0], 195 Scope: "read_write", 196 }).Error 197 assert.NoError(suite.T(), err, "Inserting test data failed") 198 199 // Make a request 200 r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil) 201 assert.NoError(suite.T(), err, "Request setup should not get an error") 202 r.SetBasicAuth("test_client_1", "test_secret") 203 r.PostForm = url.Values{ 204 "grant_type": {"refresh_token"}, 205 "refresh_token": {"test_token"}, 206 "scope": {"read_write"}, 207 } 208 209 // Serve the request 210 w := httptest.NewRecorder() 211 suite.router.ServeHTTP(w, r) 212 213 // Fetch data 214 accessToken := new(models.OauthAccessToken) 215 assert.False(suite.T(), models.OauthAccessTokenPreload(suite.db). 216 Last(accessToken).RecordNotFound()) 217 218 // Check the response 219 expected := &oauth.AccessTokenResponse{ 220 UserID: accessToken.User.MetaUserID, 221 AccessToken: accessToken.Token, 222 ExpiresIn: 3600, 223 TokenType: tokentypes.Bearer, 224 Scope: "read_write", 225 RefreshToken: "test_token", 226 } 227 testutil.TestResponseObject(suite.T(), w, expected, 200) 228 }