L'hosting di un'API comporta la responsabilità di assicurarsi che funzioni. Non c'è modo migliore o più semplice per farlo dei test automatizzati con uno strumento come Mocha.

Lo sviluppo di software moderno fa un grande uso delle API. Fungono da collegamento cruciale tra le applicazioni lato client e le applicazioni back-end, nonché tra diverse app interne o esterne.

Le API consentono una comunicazione e uno scambio di dati fluidi, consentendo ai componenti software di interagire senza problemi tra loro. Garantire l'affidabilità, la funzionalità e le prestazioni di queste API è della massima importanza per offrire un'esperienza utente senza soluzione di continuità e mantenere l'integrità complessiva del sistema.

È quindi importante testare a fondo le tue API per contrassegnare e correggere i bug durante lo sviluppo per prevenire potenziali errori di sistema negli ambienti di produzione.

Test delle API Node.js utilizzando Mocha, Chai e Chai-HTTP

Moka è un framework di test ampiamente utilizzato che è compatibile con vari

instagram viewer
Framework JavaScript. Una delle sue caratteristiche principali è un test runner flessibile che semplifica il processo di gestione ed esecuzione dei casi di test in modo efficace.

Supporta inoltre vari stili di test, inclusi test sincroni e asincroni, consentendo un'ampia gamma di scenari di test.

D'altra parte, Chai E Chai HTTP sono librerie di asserzioni che puoi usare insieme a Mocha. Chai fornisce un'ampia gamma di interfacce di asserzione espressive e leggibili come dovrebbe, aspettarsi e asserire. Mentre, Chai-HTTP, un'estensione di Chai, fornisce un'interfaccia specificamente progettata per testare le richieste HTTP e affermare le loro risposte.

Utilizzando Mocha insieme a Chai e Chai-HTTP, puoi testare le API in modo efficace. Il flusso di lavoro del test prevede:

  • Esecuzione di richieste HTTP agli endpoint API specificati.
  • Definire le risposte attese.
  • Convalida dei dati ricevuti dall'origine specificata, i codici di stato HTTP e altro.

Puoi anche simulare scenari di test di errore API che possono verificarsi in tali situazioni e quali azioni dovrebbero essere attivate nel caso in cui si verifichino.

Puoi trovare il codice di questo progetto nel suo file Deposito GitHub.

Configurare il progetto Express.js e il database MongoDB

Per iniziare, creare un server web Expresse installa questi pacchetti:

npm installa cors dotenv mongoose mongodb

Prossimo, creare un database MongoDB O configurare un cluster MongoDB sul cloud. Quindi copiare l'URL di connessione al database, creare un file .env file nella directory principale e incollare la stringa di connessione al database:

CONNECTION_STRING="stringa di connessione"

Per completare il processo di installazione, è necessario configurare la connessione al database e definire i modelli di dati per i dati utente. Fare riferimento al codice nel repository GitHub di questo progetto per:

  • Configurare la connessione al database, in utils/db.js.
  • Definire lo schema dei dati utente in modelli/user.model.js.

Definire le funzioni del gestore per le route API

Le funzioni del controller gestiranno l'aggiunta e il recupero dei dati degli utenti nel database. Per garantire la funzionalità di queste funzioni del gestore, verificherai se possono inviare e recuperare correttamente i dati dal database.

Nella directory principale, crea un file controller/userControllers.js file e aggiungere il seguente codice:

cost Utente = richiedere('../modelli/utente.modello');
exports.registerUser = asincrono (req, res) => {
cost { username, password } = req.body;


Tentativo {
attendere User.create({ username, password});
 res.stato(201).Inviare({ Messaggio: 'Utente registrato con successo' });
 } presa (errore) {
consolare.log (errore);
 res.stato(500).Inviare({ Messaggio: 'Si è verificato un errore!! ' });
 }
};
exports.getUsers = asincrono (req, res) => {
Tentativo {
cost utenti = attendere Utente.find({});
 res.json (utenti);
 } presa (errore) {
consolare.log (errore);
 res.stato(500).Inviare({ Messaggio: 'Si è verificato un errore!!' });
 }
};

Definire le rotte API

Crea un nuovo route/userRoutes.js file nella directory principale e aggiungere il seguente codice.

cost espresso = richiedere('esprimere');
cost router = espresso. Router();
cost userController = richiedere('../controller/userController');
router.post('/API/registrati', userControllers.registerUser);
router.get('/api/utenti', userControllers.getUsers);
modulo.exports = router;

Definisci il punto di ingresso del tuo server

Aggiorna il tuo server.js file con il seguente codice.

cost espresso = richiedere('esprimere');
cost cor = richiedere('cor');
cost app = espresso();
cost porto = 5000;
richiedere('dotenv'.config();
cost connectDB = richiedere('./utils/db');
connettiDB();


app.use (express.json());
app.use (express.urlencoded({ esteso: VERO }));
app.use(cors());


cost userRoute = richiedere('./percorsi/percorsi utente');
app.use('/', userRoute);


app.listen (porta, () => {
consolare.tronco d'albero(`Il server è in ascolto http://localhost:${porta}`);
});
modulo.exports = app;

Scrivere ed eseguire i casi di test con Mocha

Con l'API utente in atto, vai avanti e configura l'ambiente di test. Innanzitutto, installa questi pacchetti come dipendenze dev.

npm installa mocha chai chai-http --save-dev

Ora aggiungi il seguente script al tuo file package.json.

"copioni": {
"test": "moka --timeout 10000"
},

Questo comando eseguirà i casi di test: l'aggiunta della proprietà timeout con un valore appropriato consente di controllare il tempo massimo consentito per l'esecuzione dei singoli casi di test.

Ciò può essere utile per evitare che i test vengano eseguiti a tempo indeterminato o vengano completati troppo rapidamente prima che i casi di test siano terminati.

Testare gli endpoint API

Nella directory principale, crea una nuova cartella e assegnale un nome test. All'interno di questa cartella, crea un nuovo file user.tests.js file e aggiungere il codice seguente per il test case dell'endpoint POST.

cost cia = richiedere('cai');
cost chaiHttp = richiedere('chai-http');
cost app = richiedere('../server'); 
chai.use (chaiHttp);
cost aspettati = chai.aspettati;


descrivere('API utente', () => {
 descrivere('POST/api/registrati', () => {
 Esso('dovrebbe gestire la registrazione dell'utente', (fatto) => {
 chai.request (app)
 .inviare('/API/registrati')
 .Inviare({ nome utente: 'utenteprova', parola d'ordine: 'password di prova' })
 .FINE((errare, ris) => {
Se (errare) {
 aspettati (res).to.have.status(500);
 aspettati (res.body).to.have.property('Messaggio').che.è.uguale('Si è verificato un errore!!');
 } altro {
 aspettati (res).to.have.status(201);
 aspettati (res.body).to.have.property('Messaggio').pari('Utente registrato con successo');
 }
 Fatto();
 });
 });
 });
});

Questo codice definisce un test case utilizzando Chai e Chai HTTP per testare la funzionalità di registrazione utente dell'API utente.

Invia una richiesta POST all'endpoint specificato e fa asserzioni sulla risposta API prevista, verificando se la funzionalità di registrazione dell'utente ha avuto esito positivo o se si è verificato un errore.

Ecco una ripartizione dei componenti principali del test case:

  • aspettarsi -Questo oggetto consente di utilizzare i metodi di asserzione Chai per effettuare asserzioni sulla risposta prevista dall'API.
  • descrivere - Descrive i casi di test correlati insieme, in questo caso, i test relativi al API utente. Il blocco di descrizione annidato raggruppa ulteriori casi di test correlati insieme, in questo caso, the POST /api/register. Questo aiuta a organizzare i casi di test specificamente correlati a una particolare funzionalità.
  • Esso - Questa funzione descrive il comportamento previsto dell'endpoint API.
  • FINE - Questa funzione invia la richiesta e fornisce una funzione di callback per gestire la risposta. La funzione di callback esegue asserzioni utilizzando il aspettarsi funzione per controllare la risposta ricevuta dall'API.
  • Fatto - Questa funzione viene eseguita per contrassegnare la fine del test case.

Infine, aggiungi il codice per il test case dell'endpoint GET subito dopo il test case dell'endpoint POST.

descrivere('OTTIENI /api/utenti', () => {
 Esso('dovrebbe recuperare tutti i dati utente', (fatto) => {
 chai.request (app)
 .Ottenere('/api/utenti')
 .FINE((errare, ris) => {
Se (errare) {
 aspettati (res).to.have.status(500);
 aspettati (res.body).to.have.property('Messaggio').che.è.uguale("Si è verificato un errore durante il recupero dei dati utente");
 } altro {
 aspettati (res).to.have.status(200);
 aspettati (res.body).to.be.an('vettore');
 }
 Fatto();
 });
 });
});

Vai avanti ed esegui lo script di test sul tuo terminale per eseguire i due casi di test.

prova npm

Se l'esecuzione dei casi di test non rileva errori, dovresti vedere un output simile che indica che i test sono stati superati correttamente.

Gli errori di test possono verificarsi a causa di vari motivi, ad esempio problemi di connettività di rete durante le richieste HTTP al database, dati richiesti mancanti, errori logici e altri problemi.

Mocha fa un buon lavoro nell'identificare ed evidenziare tali errori, fornendo rapporti di prova chiari e dettagliati nei registri visualizzati nella finestra del terminale. Ciò consente di identificare e diagnosticare facilmente i problemi specifici che hanno causato il fallimento del test.

Mocha non ti dà scuse per non testare le tue API

Mentre testare manualmente la funzionalità delle tue API utilizzando strumenti come Postman è un test valido approccio, sfruttando Mocha e altri framework di test per i test automatizzati lo porta al successivo livello.

Con questi strumenti di test, puoi automatizzare rapidamente e facilmente i test per coprire un'ampia gamma di scenari e casi limite. Ciò ti consente di rilevare rapidamente i bug e risolverli prima di distribuire le tue API, assicurandoti di spedire software di alta qualità alla produzione.