Activitats

Modificar les dades d'un usuari

L’objectiu d’aquesta activitat és escriure un test que comprovi que el codi té la capacitat de modificar les dades d’un usuari correctament.

Com podeu veure a la classe UserServiceImpl, el mètode de l’especificació JPA que s’utilitza per modificar dades és merge. Aquesta és la documentació:

    /**
     * Merge the state of the given entity into the
     * current persistence context.
     * @param entity  entity instance
     * @return the managed instance that the state was merged to
     * @throws IllegalArgumentException if instance is not an
     *         entity or is a removed entity
     * @throws TransactionRequiredException if there is no transaction when
     *         invoked on a container-managed entity manager of that is of type 
     *         <code>PersistenceContextType.TRANSACTION

public <T> T merge(T entity); </code>

Com podeu veure, el mètode retorna l’objecte modificat. A partir del següent

codi ( 7.9 KB )

, modifiqueu el mètode edit de la interfície UserService, la seva implementació i afegiu el test editUser al test UserServiceTest, que comprovi que les dades es modifiquen correctament.

public interface UserService {
    public void create(User user);
    public User edit(User user);
    public void remove(User user);
    public User findUserByUsername(String username);
}

@Stateless
public class UserServiceImpl implements UserService {
    @PersistenceContext
    private EntityManager entityManager;
 
    @Override
    public User edit(User user) {
       return entityManager.merge(user);
    }
}

La resta del codi que no ha canviat no hi està inclòs.

Test a afegir a UserServiceTest.

   @Test
    public void editUser() {
      User user = new User();
      user.setActive(true);
      user.setCreatedOn(new Timestamp(new Date().getTime()));
      user.setEmail("user1@test.com");
      user.setName("John");
      user.setPassword("secret");
      user.setRank(100);
      user.setUsername("user1");
      userService.create(user);
 
      Assert.assertNotNull(user.getUserId());
 
      String newEmail = "user1@gmail-test.com";
      user.setEmail(newEmail);
 
      User modifiedUser = userService.edit(user);
      Assert.assertEquals("user1@gmail-test.com", modifiedUser.getEmail());
  }

Eliminar un usuari

L’objectiu d’aquesta activitat és escriure un test que comprovi que el codi té la capacitat d’eliminar un usuari de la base de dades.

A partir del següent

codi ( 7.9 KB )

, afegiu el test removeUser al test UserServiceTest, que comprovi que un usuari s’esborra correctament.

Quan escriviu el codi us trobareu dos problemes. El primer és que quan s’intenti esborrar l’usuari hi haurà el següent error:

Caused by: java.lang.IllegalArgumentException: Entity must be managed to call remove: org.ioc.daw.user.User@59655457, try merging the detached and try the remove again.

Una pista: el problema és que per poder esborrar una entitat ha de ser part de la sessió, i això s’aconsegueix amb el mètode merge.

Un cop solucioneu això us trobareu un altre problema: en executar el test es llançarà una excepció:

Caused by: javax.persistence.NoResultException: getSingleResult() did not retrieve any entities.

Aquí teniu la documentació del mètode getSingleResult.

  /**
   * Execute a SELECT query that returns a single untyped result.
   * @return the result
   * @throws NoResultException if there is no result
   * @throws NonUniqueResultException if more than one result
   * @throws IllegalStateException if called for a Java
   *         Persistence query language UPDATE or DELETE statement
   * @throws QueryTimeoutException if the query execution exceeds
   *         the query timeout value set and only the statement is
   *         rolled back
   * @throws TransactionRequiredException if a lock mode other than
   *         <code>NONE</code > has been set and there is no transaction
   *         or the persistence context has not been joined to the transaction
   * @throws PessimisticLockException if pessimistic locking
   *         fails and the transaction is rolled back
   * @throws LockTimeoutException if pessimistic locking
   *         fails and only the statement is rolled back
   * @throws PersistenceException if the query execution exceeds 
   *         the query timeout value set and the transaction 
   *         is rolled back 
   */
  Object getSingleResult();

Modifiqueu el mètode findUserByUsername perquè retorni null si no troba cap resultat a la base de dades.

@Stateless
public class UserServiceImpl implements UserService {
 
    @Override
    public void remove(User user) {
        user = entityManager.merge(user);
        entityManager.remove(user);
    }
 
    @Override
    public User findUserByUsername(String username) {
      try{
      return (User) entityManager.createQuery("select object(o) from User o " +
                "where o.username = :username")
                .setParameter("username", username)
                .getSingleResult();
      } catch(NoResultException e){
          return null;
      }
    }
}

La resta del codi que no ha canviat no hi està inclòs.

Test que comprova que un usuari s’esborra correctament.

  @Test
  public void removeUser() {
      User user = new User();
      user.setActive(true);
      user.setCreatedOn(new Timestamp(new Date().getTime()));
      user.setEmail("user2@test.com");
      user.setName("John");
      user.setPassword("secret");
      user.setRank(1);
      user.setUsername("user2");
      userService.create(user);
      Assert.assertNotNull(user.getUserId());
 
      userService.remove(user);
 
      User removedUser = userService.findUserByUsername("user1");
      Assert.assertNull(removedUser);
  }

Trobar els usuaris actius

L’objectiu d’aquesta activitat és escriure el codi i un test que permeti trobar els usuaris actius.

Modifiqueu UserService i UserServiceImpl i afegiu-hi un test.

public interface UserService {
    public List<User> findActiveUsers();
}

@Stateless
public class UserServiceImpl implements UserService {
  @Override
  public List<User> findActiveUsers() {
      try{
          return (List<User>) entityManager.createQuery("select object(o) from User o " +
                  "where o.active= true")
                  .getResultList();
      } catch(NoResultException e){
          return null;
      }
 
  }
}

I el test:

@Test
public void findActiveUsers() {
    String username = "jdoe";
    User user = new User();
    user.setActive(true);
    user.setCreatedOn(new Timestamp(new Date().getTime()));
    user.setEmail("test@test.com");
    user.setName("Jane");
    user.setPassword("password");
    user.setRank(100);
    user.setUsername(username);
    User user1 = new User();
    user1.setActive(false);
    user1.setCreatedOn(new Timestamp(new Date().getTime()));
    user1.setEmail("test1@test.com");
    user1.setName("Joe");
    user1.setPassword("password");
    user1.setRank(100);
    user1.setUsername("joeTest");
 
    userService.create(user);
    userService.create(user1);
 
    List<User> activeUsers= userService.findActiveUsers();
    Assert.assertNotNull(activeUsers);
    Assert.assertEquals(1, activeUsers.size());
}

'Rank' d'un usuari

L’objectiu d’aquesta activitat és escriure el codi i un test que permeti trobar l’usuari amb el rank més gran.

Modifiqueu UserService i UserServiceImpl i afegiu-hi un test.

public interface UserService {
  public User findUserWithHighestRank();
}

@Stateless
public class UserServiceImpl implements UserService {
  @Override
  public User findUserWithHighestRank() {
      try {
          return (User) entityManager.createQuery("select object(o) from User o order by o.rank DESC")
                  .setMaxResults(1)
                  .getSingleResult();
      } catch (NoResultException e) {
          return null;
      }
  }
}

I el test:

@Test
public void findUserWithHighestRank() {
    String username = "jdoe";
    User user = new User();
    user.setActive(true);
    user.setCreatedOn(new Timestamp(new Date().getTime()));
    user.setEmail("test@test.com");
    user.setName("Jane");
    user.setPassword("password");
    user.setRank(50);
    user.setUsername(username);
    User user1 = new User();
    user1.setActive(false);
    user1.setCreatedOn(new Timestamp(new Date().getTime()));
    user1.setEmail("test1@test.com");
    user1.setName("Joe");
    user1.setPassword("password");
    user1.setRank(100);
    user1.setUsername("joeTest");
 
    userService.create(user);
    userService.create(user1);
 
    User highestRankUser = userService.findUserWithHighestRank();
    Assert.assertEquals("joeTest", highestRankUser.getUsername());
}