Mise à jour de votre mot de passe

1. Vue d’ensemble

Dans cet article rapide, nous allons implémenter une fonctionnalité simple «Changer mon propre mot de passe» disponible pour l’utilisateur après s’être inscrit et connecté.

2. Côté client - Modifier ma page de mot de passe

Jetons un coup d’œil à la très simple page côté client:

<html>
<body>
<div id="errormsg" style="display:none"></div>
<div>
    <input id="oldpass" name="oldpassword" type="password"/>
    <input id="pass" name="password" type="password"/>
    <input id="passConfirm" type="password"/>
    <span id="error" style="display:none">Password mismatch</span>

   <button type="submit" onclick="savePass()">Change Password</button>
</div>

<script src="jquery.min.js"></script>
<script type="text/javascript">

var serverContext =[[@{/}]];
function savePass(){
    var pass = $("#pass").val();
    var valid = pass == $("#passConfirm").val();
    if(!valid) {
      $("#error").show();
      return;
    }
    $.post(serverContext + "user/updatePassword",
      {password: pass, oldpassword: $("#oldpass").val()} ,function(data){
        window.location.href = serverContext +"/home.html?message="+data.message;
    })
    .fail(function(data) {
        $("#errormsg").show().html(data.responseJSON.message);
    });
}
</script>
</body>
</html>

3. Mettre à jour le mot de passe de l’utilisateur

Maintenant, implémentons aussi le fonctionnement côté serveur:

@RequestMapping(value = "/user/updatePassword", method = RequestMethod.POST)
@PreAuthorize("hasRole('READ__PRIVILEGE')")
@ResponseBody
public GenericResponse changeUserPassword(Locale locale,
  @RequestParam("password") String password,
  @RequestParam("oldpassword") String oldPassword) {
    User user = userService.findUserByEmail(
      SecurityContextHolder.getContext().getAuthentication().getName());

    if (!userService.checkIfValidOldPassword(user, oldPassword)) {
        throw new InvalidOldPasswordException();
    }
    userService.changeUserPassword(user, password);
    return new GenericResponse(messages.getMessage("message.updatePasswordSuc", null, locale));
}

Remarquez comment la méthode est sécurisée via l’annotation @ PreAuthorize , car elle ne devrait être accessible qu’aux utilisateurs connectés .

4. Tests d’API

Enfin, consommons l’API avec certains tests d’API pour s’assurer que tout fonctionne bien; Commençons par la configuration simple du test et l’initialisation des données:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
  classes = { ConfigTest.class, PersistenceJPAConfig.class },
  loader = AnnotationConfigContextLoader.class)
public class ChangePasswordApiTest {
    private final String URL__PREFIX = "http://localhost:8080/";
    private final String URL = URL__PREFIX + "/user/updatePassword";

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    FormAuthConfig formConfig = new FormAuthConfig(
      URL__PREFIX + "/login", "username", "password");

    @Before
    public void init() {
        User user = userRepository.findByEmail("[email protected]");
        if (user == null) {
            user = new User();
            user.setFirstName("Test");
            user.setLastName("Test");
            user.setPassword(passwordEncoder.encode("test"));
            user.setEmail("[email protected]");
            user.setEnabled(true);
            userRepository.save(user);
        } else {
            user.setPassword(passwordEncoder.encode("test"));
            userRepository.save(user);
        }
    }
}

Maintenant, essayons de changer le mot de passe pour un utilisateur connecté :

@Test
public void givenLoggedInUser__whenChangingPassword__thenCorrect() {
    RequestSpecification request = RestAssured.given().auth()
      .form("[email protected]", "test", formConfig);

    Map<String, String> params = new HashMap<String, String>();
    params.put("oldpassword", "test");
    params.put("password", "newtest");

    Response response = request.with().params(params).post(URL);

    assertEquals(200, response.statusCode());
    assertTrue(response.body().asString().contains("Password updated successfully"));
}

Suivant - essayons de changer le mot de passe si l’ancien mot de passe est incorrect :

@Test
public void givenWrongOldPassword__whenChangingPassword__thenBadRequest() {
    RequestSpecification request = RestAssured.given().auth()
      .form("[email protected]", "test", formConfig);

    Map<String, String> params = new HashMap<String, String>();
    params.put("oldpassword", "abc");
    params.put("password", "newtest");

    Response response = request.with().params(params).post(URL);

    assertEquals(400, response.statusCode());
    assertTrue(response.body().asString().contains("Invalid Old Password"));
}

Enfin, essayons de changer le mot de passe sans authentification :

@Test
public void givenNotAuthenticatedUser__whenChangingPassword__thenRedirect() {
    Map<String, String> params = new HashMap<String, String>();
    params.put("oldpassword", "abc");
    params.put("password", "xyz");

    Response response = RestAssured.with().params(params).post(URL);

    assertEquals(302, response.statusCode());
    assertFalse(response.body().asString().contains("Password updated successfully"));
}

Notez que, pour chaque test, nous fournissons un FormAuthConfig pour gérer l’authentification.

Nous réinitialisons également le mot de passe via init () pour nous assurer que nous utilisons le mot de passe correct avant le test.

5. Conclusion

C’est un moyen simple, qui permet à l’utilisateur de modifier son propre mot de passe après l’enregistrement et la connexion à l’application.

La mise en œuvre complète de ce tutoriel est disponible à l’adresse le projet github - il s’agit d’un projet basé sur Eclipse. il est.

"** Précédent

Enregistrement - Force du mot de passe et règles

TOC