Utilisation de REST-assuré pour tester des exemples de flux OAuth 2.0

OAuth 2.0 fournit quatre flux différents, mais l'objectif principal de chaque flux est de obtenir un access_token et utilisez-le pour accéder aux ressources protégées.

Les quatre flux différents sont:

  • Octroi de code d'autorisation
  • Flux de subvention implicite
  • Informations d'identification du client
  • Flux d'octroi de mot de passe

Ce didacticiel fournit des exemples de code utilisant la technologie REST pour tester les flux OAuth 2.0, l'octroi de code d'autorisation et les flux d'informations d'identification du client.




Flux d'octroi de code d'autorisation

Il s'agit du flux le plus courant où un code est émis et utilisé pour obtenir le jeton d'accès . Ce code est poussé vers une application frontale (sur le navigateur) après la connexion de l'utilisateur. Le access_token est émis côté serveur, authentifiant le client avec son mot de passe et le code obtenu.

Processus en trois étapes:


  • 1 - Obtenir le code d'authentification
  • 2 - Obtenez un jeton d'accès
  • 3 - Utiliser un jeton d'accès (pour accéder aux ressources protégées)

Obtenir le code d'authentification

La première étape consiste à obtenir le code:

import io.restassured.RestAssured; import io.restassured.http.ContentType; import io.restassured.response.Response; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import static io.restassured.RestAssured.given; import java.util.Base64; public class RestAssuredOAuth2 {
public static String clientId = 'some_client_id';
public static String redirectUri = 'some_redirect_uri';
public static String scope = 'some_scope';
public static String username = 'some_email';
public static String password = 'some_password';
public static String encode(String str1, String str2) {
return new String(Base64.getEncoder().encode((str1 + ':' + str2).getBytes()));
}
public static Response getCode() {
String authorization = encode(username, password);

return


given()




.header('authorization', 'Basic ' + authorization)




.contentType(ContentType.URLENC)




.formParam('response_type', 'code')




.queryParam('client_id', clientId)




.queryParam('redirect_uri', redirectUri)




.queryParam('scope', scope)




.post('/oauth2/authorize')




.then()




.statusCode(200)




.extract()




.response();
}
public static String parseForOAuth2Code(Response response) {
return response.jsonPath().getString('code');
}
@BeforeAll
public static void setup() {
RestAssured.baseURI = 'https://some-url.com';
}
@Test
public void iShouldGetCode() {
Response response = getCode();
String code = parseForOAuth2Code(response);

Assertions.assertNotNull(code);
} }

Obtenir un jeton d'accès

Une fois que nous avons obtenu le code d'autorisation, nous pouvons alors demander access_token:

public static Response getToken(String authCode) {
String authorization = encode(username, password);
return
given()

.header('authorization', 'Basic ' + authorization)

.contentType(ContentType.URLENC)

.queryParam('code', authCode)

.queryParam('redirect_uri', redirectUri)

.queryParam('grant_type', grantType)

.post('/oauth2/token')

.then()

.statusCode(200)

.extract()

.response();
}
public static String parseForAccessToken(Response loginResponse) {
return loginResponse.jsonPath().getString('access_token');
}
@Test
public void iShouldGetToken() {
Response tokenResponse = getToken(code);
String accessToken = parseForAccessToken(tokenResponse);
Assertions.assertNotNull(accessToken);
}

Utilisation du jeton d'accès

Enfin, lorsque nous avons un access_token valide, nous pouvons alors faire des requêtes aux ressources protégées:

public static void getUsers() {
given().auth()
.oauth2(accessToken)
.when()
.get('/users')
.then()
.statusCode(200); }

Nous pouvons également envoyer le jeton d'accès en tant que Authorization Header avec le Bearer préfixe:


Par example:

public static void getUsers() {
given()
.header('Authorization', 'Bearer ' + accessToken)
.when()
.get('/users')
.then()
.statusCode(200); }


Flux d'informations d'identification du client

Le flux d'informations d'identification du client n'a pas d'interface utilisateur (navigateur) impliquée et est principalement utilisé pour l'autorisation de machine à machine.

En mode REST assuré, cela ressemblera à:

import io.restassured.RestAssured; import io.restassured.http.ContentType; import io.restassured.response.Response; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import static io.restassured.RestAssured.given; import static io.restassured.RestAssured.requestSpecification; public class RestAssuredOAuth2 {
public static Response response;
private String userAdminClientId = System.getenv('M2M_USER_ADMIN_CLIENT_ID');
private String userAdminClientSecret = System.getenv('M2M_USER_ADMIN_CLIENT_SECRET');
private String oauth2Payload = '{ ' +

' 'client_id': '' + userAdminClientId + '', ' +

' 'client_secret': '' + userAdminClientSecret + '', ' +

' 'audience': 'https://some-url.com/user', ' +

' 'grant_type': 'client_credentials', ' +

' 'scope': 'user:admin' }';
private static String createUserPayload = '{ ' +

' 'username': 'api-user', ' +

' 'email': 'api-user@putsbox.com', ' +

' 'password': 'Passw0rd123!', ' +

' 'firstName': 'my-first-name', ' +

' 'lastName': 'my-last-name', ' +

' 'roles': ['read'] }';
public void userAdminConfigSetup() {
requestSpecification = given().auth().oauth2(getAccessToken(oauth2Payload))


.header('Accept', ContentType.JSON.getAcceptHeader())


.contentType(ContentType.JSON);
}
public String getAccessToken(String payload) {
return given()


.contentType(ContentType.JSON)


.body(payload)


.post('/token')


.then().extract().response()


.jsonPath().getString('access_token');
}
@BeforeAll
public static void setup() {
RestAssured.baseURI = 'https://some-url.com';
}
@Test
public void createUser() {
userAdminConfigSetup();
response = given(requestSpecification)


.body(createUserPayload)


.post('/user')


.then().extract().response();

Assertions.assertEquals(201, response.statusCode());
} }


Conclusion

Ici, nous avons fourni des exemples de code avec la garantie REST sur la façon d'obtenir access_token en utilisant les flux OAuth 2.0. Une fois que nous obtenons le access_token nous pouvons alors faire des requêtes aux ressources protégées.


J'espère que vous avez trouvé ce qui précède utile.