/**
   * Verifica la possibilità di recuperare i dati di un utente dal database disponendo di una
   * stringa che può comparire come sottostringa del nome, del cognome oppure del nome utente. In
   * particolare, il test assicura che il risultato sia uguale alle attese (in base a come è stato
   * configurato il mock di GetUserDataUtil), e verifica inoltre il corretto utilizzo dei mock. In
   * particolare, verifica che sia eseguita ESATTAMENTE la query impostata nella variabile 'query' e
   * che la UtilFactory sia utilizzata per procurarsi la corretta istanza di GetUtil.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetUserDataGeneric() {
    String mail = "*****@*****.**";
    String name = "paperino";
    String surname = "de paperoni";
    String query =
        "from UserData as u where u.mail like '%"
            + mail
            + "%' or u.name like '%"
            + name
            + "%' or u.surname like '%"
            + surname
            + "%'";
    // configura il comportamento dei mock
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    List<IUserData> result = tester.getUserDatas(mail, name, surname);

    // verifica l'output
    assertNotNull(result);
    assertEquals(list, result);

    // verifica il corretto utilizzo dei mock
    verify(factory).getUserDataUtil(manager);
    verify(getter).execute(query);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare il prossimo
   * id disponibile per un inserimento nella tabella Messages del database ma avviene un errore nel
   * sistema di persistenza dei dati e il sottotipo di {@GetUtil} che effettua l'operazione di
   * SELECT, invece di una collezione di transfer object, restituisce un riferimento nullo. Il test
   * verifica che in questo caso anche la chiamata di metodo getGroup restituisca un riferimento
   * nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetMessageNewKeyWithNoMessages() {
    // query da eseguire
    String query = "select max(message.id) from Message message";
    // impedisce l'esecuzione di uniqueResult
    when(getter.uniqueResult(query)).thenReturn(null);

    // invoca il metodo da testare
    Long result = tester.getMessageNewKey();
    assertEquals(result, (Object) 1L);

    // verifica il corretto utilizzo dei mock
    verify(getter).uniqueResult(query);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare tutti i
   * messaggi della segreteria di un determinato utente ma avviene un errore nel sistema di
   * persistenza dei dati e il sottotipo di {@GetUtil} che effettua l'operazione di SELECT, invece
   * di una collezione di transfer object, restituisce un riferimento nullo. Il test verifica che in
   * questo caso anche la chiamata di metodo getGroup restituisca un riferimento nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetMessagesNoCollection() {
    // query da eseguire
    String query = "from Message as m where m.receiver.id = " + userId;
    // impedisce il recupero della collezione
    when(getter.execute(query)).thenReturn(null);

    // invoca il metodo da testare
    List<IMessage> result = tester.getMessages(user);
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verifyZeroInteractions(list);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare dal sistema
   * di persistenza una lista di messaggi della segreteria a partire da un utente che non ha alcun
   * messaggio nella propria segreteria telefonica. In particolare, il test verifica che il
   * risultato dell'invocazione del metodo sia, come desiderato <code>null</code>. Si controlla
   * inoltre che il metodo execute di {@link GetUtil} sia richiamato passando come parametro
   * esattamente la stringa HQL necessaria al recupero dei dati.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetMessagesEmpty() {
    // query da eseguire
    String query = "from Message as m where m.receiver.id = " + userId;
    // comportamento dei mock
    when(getter.execute(query)).thenReturn(list);
    when(list.isEmpty()).thenReturn(true);

    // invoca il metodo da testare
    List<IMessage> result = tester.getMessages(user);
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verify(list).isEmpty();
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare la lista di
   * gruppi della rubrica che hanno come proprietario un determinato utente. In particolare, il test
   * verifica che nel caso in cui la collezione di gruppi sia vuota il valore ritornato sia
   * effettivamente <code>null</code> e che sia effettivamente invocato il metodo execute passando
   * la query HQL corretta per interrogare il database.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetGroupIUserDataEmpty() {
    // query che deve essere eseguita
    String query = "from Group as g where g.owner.id = " + userId;
    // comportamento dei mock
    when(list.isEmpty()).thenReturn(true);
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    List<IGroup> result = tester.getGroup(user);
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verify(list).isEmpty();
  }
  /**
   * Verifica la possibilità di recuperare il più piccolo id libero per il prossimo inserimento
   * nella tabella dei messaggi in segreteria del database. In particolare, il test controlla che il
   * risultato sia conforme alle aspettative e che cioè il valore sia superiore di un'unità rispetto
   * a quanto restituito dal metodo getUniqueResult dal {@link GetUtil} e che questo metodo sia
   * invocato correttamente.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetMessageNewKey() {
    // id dell'ultimo inserimento in Messages
    Long lastId = 1L;
    // query da eseguire
    String query = "select max(message.id) from Message message";
    // ignoriamo il metodo-portoghese
    when(getter.uniqueResult(query)).thenReturn(lastId);

    // invoca il metodo da testare
    Long result = tester.getMessageNewKey();
    assertNotNull(result);
    assertTrue(result == lastId + 1);

    // verifica il corretto utilizzo dei mock
    verify(getter).uniqueResult(query);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare un gruppo
   * della rubrica sulla base del proprietario di quest'ultimo ma avviene un errore nel sistema di
   * persistenza dei dati e il sottotipo di {@GetUtil} che effettua l'operazione di SELECT, invece
   * di una collezione di transfer object, restituisce un riferimento nullo. Il test verifica che in
   * questo caso anche la chiamata di metodo getGroup restituisca un riferimento nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetGroupIUserDataNoCollection() {
    // query che deve essere eseguita
    String query = "from Group as g where g.owner.id = " + userId;
    // impedisce il recupero della collezione
    when(getter.execute(query)).thenReturn(null);

    // invoca il metodo da testare
    List<IGroup> result = tester.getGroup(user);

    // verifica il risultato ottenuto
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verifyZeroInteractions(list);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare un
   * messaggio della segreteria sulla base del numero identificativo di quest'ultimo ma avviene un
   * errore nel sistema di persistenza dei dati e il sottotipo di {@GetUtil} che effettua
   * l'operazione di SELECT, invece di una collezione di transfer object, restituisce un riferimento
   * nullo. Il test verifica che in questo caso anche la chiamata di metodo getGroup restituisca un
   * riferimento nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetMessageNoCollection() {
    // identificativo di prova
    Long id = 1L;
    // query che deve essere eseguita
    String query = "from Message as m where m.id = " + "'" + id + "'";
    // impedisce il recupero della lista
    when(getter.execute(query)).thenReturn(null);

    // invoca il metodo da testare
    IMessage result = tester.getMessage(id);

    // verifica l'output
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verifyZeroInteractions(list);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare un gruppo
   * della rubrica sulla base del numero identificativo di quest'ultimo ma avviene un errore nel
   * sistema di persistenza dei dati e il sottotipo di {@GetUtil} che effettua l'operazione di
   * SELECT, invece di una collezione di transfer object, restituisce un riferimento nullo. Il test
   * verifica che in questo caso anche la chiamata di metodo getGroup restituisca un riferimento
   * nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetGroupLongNoCollection() {
    // id del gruppo
    Long groupId = 1L;
    // query che deve essere eseguita
    String query = "from Group as g where g.id = " + "'" + groupId + "'";
    // impedisce il recupero della collezione
    when(getter.execute(query)).thenReturn(null);

    // invoca il metodo da testare
    IGroup result = tester.getGroup(groupId);

    // verifica il risultato ottenuto
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verifyZeroInteractions(list);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare una
   * chiamata sulla base del numero identificativo di quest'ultimo ma avviene un errore nel sistema
   * di persistenza dei dati e il sottotipo di {@GetUtil} che effettua l'operazione di SELECT,
   * invece di una collezione di transfer object, restituisce un riferimento nullo. Il test verifica
   * che in questo caso anche la chiamata di metodo getGroup restituisca un riferimento nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetCallNoCollection() {
    // identificativo di prova
    Long id = 1L;
    // query che deve essere eseguita
    String query = "from Call as c where c.id = " + id;
    // impedisce il recupero della collezione
    when(getter.execute(query)).thenReturn(null);

    // invoca il metodo da testare
    ICall result = tester.getCall(id);

    // verifica il risultato ottenuto
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(factory).getCallUtil(manager);
    verify(getter).execute(query);
    verifyZeroInteractions(list);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare uno degli
   * utenti del sistema sulla base dell'indirizzo email impostato in fase di registrazione ma
   * avviene un errore nel sistema di persistenza dei dati e il sottotipo di {@GetUtil} che effettua
   * l'operazione di SELECT, invece di una collezione di transfer object, restituisce un riferimento
   * nullo. Il test verifica che in questo caso anche la chiamata di metodo getGroup restituisca un
   * riferimento nullo.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetUserDataByEmailNoCollection() {
    // indirizzo email di prova
    String mail = "ThisIsNotAnEmailAddress";
    // query che deve essere eseguita
    String query = "from UserData as u where u.mail = " + "'" + mail + "'";
    // configura il comportamento dei mock
    when(getter.execute(query)).thenReturn(null);

    // invoca il metodo da testare
    IUserData result = tester.getUserData(mail);

    // verifica il risultato ottenuto
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(factory).getUserDataUtil(manager);
    verify(getter).execute(query);
    verifyZeroInteractions(list);
  }
  /**
   * Verifica la possibilità di recuperare una chiamata dal database disponendo del relativo numero
   * identificativo. In particolare, il test assicura che il risultato sia uguale alle attese (in
   * base a come è stato configurato il mock di GetUserDataUtil), e verifica inoltre il corretto
   * utilizzo dei mock. In particolare, verifica che sia eseguita ESATTAMENTE la query impostata
   * nella variabile 'query' e il fatto che dalla collezione di oggetti ritornata dalla execute del
   * GetUtil sia estratto il primo elemento e che non sia MAI invocato get con argomenti superiori
   * allo zero, che la lista sia scorsa solo se non è vuota e che la UtilFactory sia utilizzata per
   * procurarsi la corretta istanza di GetUtil.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetCall() {
    Long id = 1L;
    String query = "from Call as c where c.id = " + id;
    // configura il comportamento dei mock
    when(list.get(0)).thenReturn(call);
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    ICall result = tester.getCall(id);

    // verifica l'output
    assertNotNull(result);
    assertEquals(call, result);

    // verifica il corretto utilizzo dei mock
    verify(factory).getCallUtil(manager);
    verify(getter).execute(query);
    verify(list).isEmpty();
    verify(list).get(0);
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare dal sistema
   * di persistenza un messaggio della segreteria a partire da un campo numerico identificativo che
   * non corrisponde ad alcuno dei messaggi presenti. In particolare, il test verifica che il
   * risultato dell'invocazione del metodo sia, come desiderato <code>null</code> e che non siano
   * effettuate operazioni di estrazione dalla lista restituita dal metodo execute del {@link
   * GetUtil} dal momento che quest'ultima è vuota. si controlla inoltre che quest'ultimo metodo sia
   * richiamato passando come parametro esattamente la stringa HQL necessaria al recupero dei dati.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetMessageEmpty() {
    // identificativo di prova
    Long id = 1L;
    // query che deve essere eseguita
    String query = "from Message as m where m.id = " + "'" + id + "'";
    // comportamento dei mock
    when(list.isEmpty()).thenReturn(true);
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    IMessage result = tester.getMessage(id);

    // verifica l'output
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verify(list).isEmpty();
    verify(list, never()).get(anyInt());
  }
  /**
   * Verifica il comportamento della classe nel momento in cui è richiesto di recuperare dal sistema
   * di persistenza un gruppo a partire da un campo numerico identificativo che non corrisponde ad
   * alcuno dei gruppi presenti nel sistema. In particolare, il test verifica che il risultato
   * dell'invocazione del metodo sia, come desiderato <code>null</code> e che non siano effettuate
   * operazioni di estrazione dalla lista restituita dal metodo execute del {@link GetUtil} dal
   * momento che quest'ultima è vuota. si controlla inoltre che quest'ultimo metodo sia richiamato
   * passando come parametro esattamente la stringa HQL necessaria al recupero dei dati.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetGroupLongEmpty() {
    // id del gruppo
    Long groupId = 1L;
    // query che deve essere eseguita
    String query = "from Group as g where g.id = " + "'" + groupId + "'";
    // comportamento dei mock
    when(list.isEmpty()).thenReturn(true);
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    IGroup result = tester.getGroup(groupId);

    // verifica il risultato ottenuto
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(getter).execute(query);
    verify(list, never()).get(anyInt());
    verify(list).isEmpty();
  }
  /**
   * Verifica il comportamento della classe nel momento in cui si tenta di recuperare una chiamata
   * con un id inesistente (cioè la query restituisce un insieme vuoto). Il test assicura che in
   * questo caso la collezione restituita sia, come atteso, il riferimento nullo. Inoltre il test
   * verifica il corretto utilizzo dei mock, cioè che sia utilizzata la classe factory per ottenere
   * il GetUtil corretto, che il metodo execute di quest'ultimo sia invocato ESATTAMENTE con la
   * stringa impostata nella variabile query, che si controlli se la collezione restituita è vuota
   * e, dal momento che appare come tale, che non sia MAI invocato il metodo get su quest'ultima con
   * un parametro intero.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetCallEmpty() {
    // identificativo di prova
    Long id = 1L;
    // query che deve essere eseguita
    String query = "from Call as c where c.id = " + id;
    // configura il comportamento dei mock
    when(list.isEmpty()).thenReturn(true);
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    ICall result = tester.getCall(id);

    // verifica il risultato ottenuto
    assertNull(result);

    // verifica il corretto utilizzo dei mock
    verify(factory).getCallUtil(manager);
    verify(getter).execute(query);
    verify(list).isEmpty();
    verify(list, never()).get(anyInt());
  }
  /**
   * Verifica la possibilità di recuperare i dati di un utente dal database disponendo del relativo
   * numero identificativo. In particolare, il test assicura che il risultato sia uguale alle attese
   * (in base a come è stato configurato il mock di GetUserDataUtil), e verifica inoltre il corretto
   * utilizzo dei mock. In particolare, verifica che sia eseguita ESATTAMENTE la query impostata
   * nella variabile 'query' e il fatto che dalla collezione di oggetti ritornata dalla execute del
   * GetUtil sia estratto il primo elemento e che non sia MAI invocato get con argomenti superiori
   * allo zero, che la lista sia scorsa solo se non è vuota e che la UtilFactory sia utilizzata per
   * procurarsi la corretta istanza di GetUtil.
   *
   * @author Diego Beraldin
   * @version 2.0
   */
  @Test
  public void testGetUserDataById() {
    // identificativo di prova
    Long id = 1L;
    // query che deve essere eseguita
    String query = "from UserData as u where u.id = " + id;
    // configura il comportamento dei mock
    when(list.get(0)).thenReturn(user);
    when(getter.execute(query)).thenReturn(list);

    // invoca il metodo da testare
    IUserData result = tester.getUserData(id);

    // verifica il risultato ottenuto
    assertNotNull(result);
    assertEquals(user, result);

    // verifica il corretto utilizzo dei mock
    verify(factory).getUserDataUtil(manager);
    verify(getter).execute(query);
    verify(list).isEmpty();
    verify(list).get(0);
  }