database crud testing through ui with sample test cases
Cosa sono le operazioni CRUD e come eseguire test CRUD tramite l'interfaccia utente:
Gli esseri umani hanno iniziato a memorizzare le informazioni anche prima di diversi decenni! E a quei tempi, i database di file flat venivano utilizzati nella cronologia dei computer in cui tutti i dati erano memorizzati in un file.
Successivamente, all'inizio degli anni '70, IBM sviluppò il primo modello di database relazionale, che introduceva 'indici' per recuperare facilmente i dati.
Cosa imparerai:
- Panoramica delle operazioni CRUD
- Perché il test del database è importante?
- Le 4 funzionalità di base del database
- Definizione CRUD
- Test CRUD
- Come testare la funzionalità CRUD di un software?
- Conclusione
- Lettura consigliata
Panoramica delle operazioni CRUD
Attualmente, il sistema di archiviazione dati più comune è il Banca dati dove il software crea, legge, aggiorna ed elimina i dati tramite query. Il software per computer può rispondere alle esigenze degli utenti in modo più rapido ed efficace tramite database e query adeguatamente progettati.
Ciò implica che il test e la verifica del database è un fattore molto importante.
Le risposte dell'interfaccia utente grafica (GUI) come messaggi di errore, messaggi di successo ecc. Sono considerate molto importanti da quasi tutti i responsabili dei test. Questo perché la GUI sembra essere la parte visibile di un'applicazione, che gli utenti possono vedere. Tuttavia, il test del database è altrettanto importante.
In base alla mia esperienza, ho visto molti tester manuali che lo considerano un lavoro noioso, ma in realtà non lo è.
In questo tutorial, discuteremo il test della funzionalità del database della scatola nera tramite l'interfaccia utente e le query MySQL in modo semplice con semplici esempi.
Perché il test del database è importante?
I punti forniti di seguito spiegheranno l'importanza del test del database in un modo molto breve.
- I dati sono una risorsa importante e devono essere salvati e protetti.
- I database stanno diventando complessi con le nuove tecnologie e piattaforme. Pertanto, le possibilità di bug aumentano.
- Possono esserci funzionalità critiche associate ai valori memorizzati nel database.
- Problemi nel database o nelle query possono portare a problemi di funzionalità importanti.
- Per garantire che i dati siano mappati correttamente o meno.
Il test del database può essere eseguito come test unitario, test della scatola nera , test della scatola bianca e il testo della casella grigia.
Le 4 funzionalità di base del database
Il software basato su database ha generalmente quattro funzionalità principali che risulteranno chiare dagli esempi seguenti.
Esempio 1:
Facebook, il più famoso sito di social networking.
- Puoi creare un nuovo account
- Visualizza i dettagli del tuo account
- Modifica i dettagli dell'account
- Elimina l'account
- Puoi creare commenti
- Visualizzali
- Modificali
- Eliminali
Esempio 2:
LinkedIn, il famoso sito web di ricerca di lavoro:
come inizializzare un array generico in java
- Puoi creare il tuo profilo
- Visualizzalo
- Modificalo
- Cancellalo
- Puoi aggiungere post
- Visualizzali
- Modificali
- Eliminali
Hai notato una serie di attività comuni qui?
Sì! Hai ragione.
La maggior parte del software supporta queste funzionalità di creazione, visualizzazione, modifica ed eliminazione da cui il termine CRUDELE arriva.
Definizione CRUD
Nella programmazione del computer, CRUDELE sta per Crea, Leggi, Aggiorna ed Elimina. Queste sono le quattro funzioni principali e di base dell'archiviazione persistente. Questi vengono spesso eseguiti nelle applicazioni software tramite moduli.
- Creare - INSERISCI una voce nel database.
- Leggere oppure Recupera: SELEZIONA la voce dal database e visualizzala.
- Aggiornare - AGGIORNARE la voce completamente o parzialmente.
- Elimina o Distruggi - ELIMINA / ELIMINA la voce.
In base ai requisiti software, i cicli CRUD possono variare.
Per esempio: a volte, il venditore crea un account e l'utente lo visualizza. L'utente potrebbe non avere il privilegio di modificarlo o eliminarlo. D'altra parte, il requisito potrebbe essere: l'utente crea il suo account e il venditore lo verifica e lo approva. Questi cicli sono molto importanti dal punto di vista di un tester.
Per le funzionalità discusse sopra, c'è una query corrispondente in esecuzione nel database.
Di seguito sono riportati esempi di query MYSQL per ciascuna azione
Azione | Query di esempio |
---|---|
CREARE | INSERT INTO nome_tabella (colonna1, colonna2, colonna3, ...) VALORI (valore1, valore2, valore3, ...); |
LEGGERE | SELEZIONA * dalla tabella; |
AGGIORNARE | UPDATE nome_tabella SET colonna1 = valore11, colonna2 = valore22 WHERE condizione; |
ELIMINA | DELETE FROM TABLE nome_tabella dove colonna1 = 'valore11'; |
Tre varianti di CRUD sono PANE (Sfoglia, Leggi, Modifica, Aggiungi, Elimina), DAVE (Elimina, Aggiungi, Visualizza, Modifica) e UNA SCHIFEZZA (Crea, Replica, Aggiungi, Elabora).
Test CRUD
Il test CRUD è un test black box della funzionalità del database.
Come sappiamo, il test Black box considera il sistema software di test come una “scatola nera e i test vengono condotti tramite l'interfaccia utente.
Abbiamo capito che ogni azione di front-end come la registrazione dell'account, la modifica dei dettagli personali, la visualizzazione dei dettagli, l'eliminazione dell'account ecc. Ha un'azione CRUD corrispondente nel database. Il test CRUD viene eseguito per verificare se queste azioni si riflettono correttamente o meno nel database.
Il test CRUD è diverso dal comune test front-end della scatola nera in cui controlliamo i messaggi di successo come 'Account creato con successo' dopo la registrazione di un utente, ecc. Qui dobbiamo verificare se i dettagli dell'account vengono effettivamente inseriti nel database o meno.
Ci sono due modi in cui un tester manuale può farlo:
# 1) Esegui le query da solo- I tester con una buona conoscenza del linguaggio SQL e dei requisiti software possono eseguire le proprie query per testare il database. In questo modo tutti i casi possibili possono essere verificati con buone domande.
# 2) Esegui query con l'aiuto di uno sviluppatore- I tester possono iniziare con la verifica dell'interfaccia utente dell'applicazione e ottenere query dallo sviluppatore.
Le seguenti domande dovrebbero essere prese in considerazione durante la scrittura di casi di test per le operazioni CRUD:
- Che tipo di azione CRUD è valida e cosa non è valida per un'applicazione di test?
- Che tipo di relazione hanno / dovrebbero avere le azioni CRUD tra loro?
- Quando vengono eseguite le azioni CRUD?
- Chi accede alla funzionalità CRUD? Il sistema imposta privilegi diversi per utenti diversi?
Il processo di test generale per Test DB non è molto diverso dal solito test GUI manuale della scatola nera.
Piace,
Passo 1: Prepara l'ambiente di test.
Passo 2: Esegui i passaggi del test.
Passaggio 3: Controlla il risultato del test.
Passaggio 4: Convalida i risultati effettivi in base ai risultati attesi.
Passaggio 5: Segnala bug e altri risultati.
Per controllare il risultato del test, vengono utilizzati la risposta della GUI e il risultato della query. Per il test della scatola nera CRUD, abbiamo solo bisogno di una query, che è SELEZIONA.
Come tutti sappiamo, i database memorizzano i dati. Quando abbiamo bisogno di recuperare i dati, viene utilizzata la query SELECT. Nel test della scatola nera, dobbiamo solo usare questa query per vedere se le azioni tramite l'interfaccia utente mostrano o meno i riflessi corretti nel database.
'SELEZIONA' può essere utilizzato nei seguenti modi:
# 1) Se un tester desidera controllare e verificare tutti i dati, può utilizzare il simbolo di avvio (*) nella query SELECT. Questa è la forma più semplice di query SELECT.
SELECT * FROM table_name;
L'istruzione precedente seleziona tutti i campi da tutte le righe della tabella table_name.
# 2) In alcuni casi, il primo risultato della query può essere disordinato. Se un tester è interessato solo ad alcuni campi, è possibile utilizzare il seguente script.
casi di test di esempio di test white box
SELECT ‘field_1’, ‘field_2’, ‘field_3’ FROM table_name;
L'istruzione precedente seleziona i campi, 'campo_1', 'campo_2' e 'campo_3' da tutte le righe della tabella nome_tabella.
# 3) Se un tester desidera vedere i risultati in base a qualsiasi criterio, è possibile utilizzare la clausola WHERE.
SELECT ‘field_1’ FROM table_name WHERE field_2 = ‘success’;
L'istruzione precedente seleziona il campo, 'campo_1' da tutte le righe della tabella nome_tabella, dove 'campo2' è 'successo'.
Come testare la funzionalità CRUD di un software?
Considera quanto segue Esempio di un'interfaccia utente, che consente determinati privilegi utente per l'utilizzo del database MySQL per memorizzare i dati.
ESEMPIO | DETTAGLI DATABASE |
---|---|
1. Può CREARE un prodotto con tutti i dettagli inclusi, nome del prodotto, descrizione del prodotto, prezzo del prodotto utilizzando il modulo 'Aggiungi prodotto' | Database: Shopping_DB Tabella: prodotto Campi: nome_prodotto, dettagli_prodotto, prezzo_prodotto Crea una riga nella tabella 'prodotto' con i dettagli aggiunti nei campi corrispondenti |
2. Può LEGGERE i dettagli del nome del prodotto, la descrizione del prodotto, il prezzo del prodotto nella 'Pagina dei dettagli del prodotto'. | Database: Shopping_DB Tabella: prodotto Campi: nome_prodotto, dettagli_prodotto, prezzo_prodotto Seleziona tutti i dati o seleziona un dato particolare dalla tabella 'prodotti' |
3. Può AGGIORNARE il nome del prodotto, la descrizione del prodotto, il prezzo del prodotto utilizzando il modulo 'Modifica prodotto'. | Database: Shopping_DB Tabella: prodotto Campi: nome_prodotto, dettagli_prodotto, prezzo_prodotto Aggiorna tutti i dettagli o particolari in una determinata riga nella tabella 'prodotti' |
4. Può CANCELLARE il prodotto | Database: Shopping_DB Tabella: prodotto Campi: nome_prodotto, dettagli_prodotto, prezzo_prodotto Elimina tutti i dettagli nella tabella 'prodotti' trascinando la tabella o elimina una riga specifica da essa. |
Controlliamo come è possibile verificare la funzionalità CRUD per questo caso.
Nota :Condurre sempre test CRUD nei dump del database perché questo test può causare modifiche nel database. Il comando seguente può essere utilizzato per eseguire un dump dell'intero database.
$ mysqldump -u [uname] -p [pass] Shopping_DB> Shopping_DB_backup.sql
# 1) CREA funzionalità
Aggiungendo un nuovo articolo di prodotto, è possibile seguire i seguenti passaggi:
- Carica il modulo 'Aggiungi prodotto'.
- Immettere il nome del prodotto, dire 'nome del test'.
- Inserisci la descrizione del prodotto, dì 'questo è il dettaglio del prodotto di prova'.
- Inserisci il prezzo del prodotto, dì '100'.
- Invia il modulo.
Controllo del risultato:
- Il tester verifica manualmente se il prodotto viene visualizzato con tutti i dettagli nel front-end dell'applicazione software.
- Il tester esegue la query nel server di database MYSQL per verificare se la riga specifica è presente
Query:
come aprire un file binario
SELECT * FROM products WHERE product_name = ‘test name’;
Risultato della query da MySQL:
Una riga con i dettagli corrispondenti dovrebbe essere visualizzata come,
mysql> SELECT * FROM products WHERE product_name = 'test name'; + ------------- + ----------------------------- + ----- ------------ + | nome_prodotto | product_details | prezzo_prodotto | + ------------- + ----------------------------- + ----- ------------ + | nome del test | questi sono i dettagli del prodotto di prova | 100 | |
Altri casi da considerare:
- Per alcuni sistemi, utenti diversi avranno privilegi diversi. In tal caso, i tester potrebbero dover controllare la risposta per ogni ruolo utente.
- Se i prodotti duplicati non sono consentiti, un tester può verificarlo aggiungendo di nuovo un prodotto con gli stessi dettagli. Questa volta il database non dovrebbe avere una seconda voce corrispondente allo stesso prodotto.
- Se il software consente la creazione di più prodotti contemporaneamente, il tester può verificare se tutti i dettagli di tutti i prodotti nella presentazione sono stati inseriti correttamente o meno nel database.
- Prova diverse combinazioni di input.
- Controlla cosa succede durante il tempo di inattività del server.
# 2) Funzionalità READ
Per verificare se la voce creata è leggibile, è possibile seguire i seguenti passaggi:
- Creare alcuni prodotti con diverse combinazioni di input tramite la funzionalità CREATE, ad esempio nome del test 1, nome del test 2, nome del test 3.
- Prova a cercare i prodotti.
Controllo del risultato:
- Il tester verifica manualmente se i dettagli del prodotto sono corretti.
- Il tester confronta i dettagli con quelli salvati nel database.
Query:
SELEZIONA * DA prodotti DOVE product_name = 'test name 1' OR product_name = 'test name 12' OR product_name = 'test name 3'; |
Risultato della query da MySQL:
Devono essere visualizzati i dettagli dei prodotti selezionati. Il tester può verificarlo e confrontarlo con i risultati nell'interfaccia utente.
mysql> SELECT * FROM products WHERE product_name = 'test name 1' OR product_name = 'test name 12' OR product_name = 'test name 3'; + ------------- + ----------------------------- + ----- ------------ + | nome_prodotto | product_details | prezzo_prodotto | + ------------- + ----------------------------- + ----- ------------ + | nome del test 1 | questo è il dettaglio del prodotto di prova1 | 100 | | nome del test 2 | questo è il dettaglio del prodotto di prova2 | 100 | | nome del test 3 | questo è il dettaglio del prodotto di prova3 | 100 | |
Altri casi da considerare:
- Visualizza gli elementi uno alla volta.
- Visualizza più elementi contemporaneamente.
- Tentativo di visualizzare un elemento che non esiste.
- Prova a cercare con condizioni diverse.
- Prova a verificare la funzionalità per diversi ruoli utente.
- Controlla cosa succede durante il tempo di inattività del server.
# 3) Funzionalità di AGGIORNAMENTO
Per modificare o aggiornare le voci esistenti, è possibile seguire i seguenti passaggi:
- Crea un prodotto utilizzando la funzionalità CREATE.
- Modifica diversi campi del prodotto, dì 'nome del test' a 'V Neck Top'.
- Invia
Controllo del risultato:
- Il tester verifica manualmente che i dettagli del prodotto siano cambiati
- Tester esegue la query MYSQL e vede i dettagli
Query:
SELECT * FROM products WHERE product_name = ‘V Neck Top’;
Risultato della query da MySQL:
Dovrebbe essere visualizzata una riga con i dettagli corrispondenti.
mysql> SELECT * FROM products WHERE product_name = 'V Neck Top'; + ------------- + ----------------------------- + ----- ------------ + | nome_prodotto | product_details | prezzo_prodotto | + ------------- + ----------------------------- + ----- ------------ + | Top con scollo a V | questi sono i dettagli del prodotto di prova | 100 | + ------------- + ----------------------------- + ----- ------------ + |
Se cerchi con un vecchio nome di prodotto, il database non dovrebbe restituire i dettagli.
Altri casi da considerare:
- Aggiorna più elementi alla volta.
- Aggiorna a un valore chiave già esistente.
- Aggiorna tutti i dettagli o dettagli parziali.
- Aggiorna i campi con diverse combinazioni di input.
- Controlla la funzionalità aggiornata per diversi privilegi.
- Controlla cosa succede durante i tempi di inattività del server.
# 4) Funzionalità DELETE
Per verificare la funzionalità di eliminazione, è possibile seguire i seguenti passaggi:
- Crea un prodotto con funzionalità CREATE.
- Elimina il prodotto.
Controllo del risultato:
- Il tester controlla manualmente se il prodotto viene rimosso dall'interfaccia utente
- Tester controlla manualmente il database MySQL e conferma che la riga corrispondente è stata eliminata.
Query :
SELECT * FROM products WHERE product_name = ‘test name’;
Risultato della query da MySQL:
Questo dovrebbe visualizzare il risultato della query come mostrato di seguito.
mysql>SELECT * FROM products WHERE product_name = ‘test name’; Empty set (0.00 sec)
Altri casi da considerare:
- Elimina più elementi in una singola richiesta.
- Elimina un elemento aggiornato.
- Prendi due schede e prova a dare la richiesta di eliminazione per un prodotto da entrambe le schede.
Conclusione
Il test del database è molto importante in quanto conferma la sicurezza e l'affidabilità di un'applicazione software. La maggior parte delle applicazioni software si occupa della creazione, lettura, aggiornamento ed eliminazione dei dati nel / dal database. A seconda dei requisiti software, i cicli CRUD possono variare. Un tester dovrebbe pianificare casi di test basati sul ciclo CRUD.
Le funzionalità CRUD possono essere testate manualmente e verificate dall'interfaccia utente e dal database. La query SELECT può essere utilizzata per verificare le modifiche nel database corrispondenti a ciascuna operazione CRUD.
Sei un esperto di test CRUD? Hai qualche fatto interessante da condividere con i nostri lettori che sono nuovi a CRUD? Sentiti libero di esprimere i tuoi pensieri / suggerimenti nella sezione commenti qui sotto !!
Lettura consigliata
- Test di database con JMeter
- Documenti di domande campione di certificazione di test ISTQB con risposte
- Migliori strumenti di test del software 2021 [Strumenti di automazione del test QA]
- Differenze chiave tra il test della scatola nera e il test della scatola bianca
- Download dell'eBook Testing Primer
- Un approccio semplice per XML al test di database
- Oltre 40 migliori strumenti di test di database - Soluzioni di test di dati popolari
- Esercitazione sul test della GUI: una guida completa al test dell'interfaccia utente (UI)