/**
* 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);
}
