github.com/RichardKnop/Go-oauth2-server@v1.0.1/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/go-oauth2-server/models"
    10  	"github.com/RichardKnop/go-oauth2-server/oauth"
    11  	"github.com/RichardKnop/go-oauth2-server/oauth/tokentypes"
    12  	"github.com/RichardKnop/go-oauth2-server/test-util"
    13  	"github.com/RichardKnop/uuid"
    14  	"github.com/stretchr/testify/assert"
    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.UserID.String,
   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.UserID.String,
   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  }