Discussion :

[alexiiiis]

Bonjour à tous,
Je suis tout nouveau dans le monde des tests, et j'ai du mal à comprendre quelques principes. Je viens donc glaner votre savoir.

J'ai créé une app Mobile avec React Native, avec un serveur Node/Express relié à une BDD PostGres, et j'utilise TypeScript.
Je voudrais savoir l'intérêt de créer une fausse fonction ( mock ) ? Pourquoi devrions nous Mocker une fonction au lieu d'importer celle que nous avons déjà écrite ?
Egalement, j'arrive à faire des tests de bases ainsi qu'à appeler un endpoint de type Get/Post. En faisant un post, j'insers dans ma BDD, alors que je penses qu'il ne faudrait pas, ai-je raison ? Si oui il faudrait également mocker la BDD.

En suivant la doc de Jest, j'ai clairement du mal à comprendre comment Mocker une fonction. Et je ne trouve rien en ce qui concerne la BDD.

Je vous remercie d'avance comme toujours.

ps : Si vous avez des livres pour s'améliorer ou des sites que vous utilisez. Je pense que connaître les Tests unitaires c'est un skills plutôt sympa puisque beaucoup de dev font l'impasse dessus.

[djedjethai]

Bonjour,

Lors des tests on essai toujours d’exécuter la vrai fonction, mais parfois ce n est pas possible car le contexte nécessaire a l exécution de cette dernière n est pas reproductible, ainsi nous sommes obliges de la Moquer.

Par example dans une app on execute un payment avec l'API Stripe, pour simplement tester l'execution du code ou se trouve cette function on peut tout simplement la Moquer plutot que de l'implementer (ce qui pour Stripe est faisable mais plus complique, soi dit en passant).

on utilise 'jest-supertest'

dans le package.json

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 "devDependencies": {         
    "@types/jest": "^26.0.22", 
    "@types/supertest": "^2.0.11",  
    "jest": "^26.6.3",         
    "mongodb-memory-server": "^6.9.6",
    "supertest": "^6.1.3",     
    "ts-jest": "^26.5.5"       
  }

Par example un fichier /src/directory/monExample.ts

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import Stripe from 'stripe'
 
// instancie l objet
const stripe = new Stripe(process.env.STRIPE_KEY!, {
         apiVersion: '2020-08-27'        
 })
 
// === Logic pour recuperer l order et le token ====
 
// creer la charge(le payment)
router.post('/api/payments', async (req: Request, res: Response) => {
 const { token, order } = req.body
 const charge = await stripe.charges.create({
               currency: 'usd',
               amount: order.price * 100, 
               source: token
 })
 res.status(201).send({ok})
 
})

lors des test on veut s assurer que cette function(le payment) a bien ete effectuer, aussi on Mock cette function, dans un fichier nomme __mocks__
le path donne: /src/__mocks__/stripe.ts

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
export const stripe = { 
        charges: {
                // mockResolvedValue, est propre a la simulation d'une promise
                // si ce n est pas une promise on utilise la method .mockImplementation()
                create: jest.fn().mockResolvedValue({}) 
        }
}

Et dans ton fichier test qui se trouve au path: /src/directory/__test__/monExample.test.ts

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
import request from 'supertest'
import { app } from '/path/to/app' // la page index(la main page quoi) de ton programme
 
it('test la route /api/payments et la function charge moque de Stripe', async() => {
 
  const order = {
     userId: "uiytiytiyutiuytiuy",
     price: 20
  }
 
  // simulate une post request provenant du client, avec le token de payment(propre a Stripe) et l order
  // on verifie que la route de notre Api retourne un http code 201 
   await request(app)
		.post('/api/payments')
		.send({
			token: 'tok_visa',
			order
               })
               .expect(201)
 
 
  // on accede aux argument de la function Moque, "qui a ete invoquee lors de l execution du code lorsqu'on a executer la precedente request(app)"
  // vu qu il y a une function Moque de Stripe, c'est cette derniere qui est execute lors des tests (et non pas la vrai function de Stripe)
  // le [0][0] pour acceder au 1er arg
  // const chargeOptions = stripe.charges.create.mock.calls[0][0] !! Mais la Typescript bloc car le type n est pas declare donc
   const chargeOptions = (stripe.charges.create as jest.Mock).mock.calls[0][0]
 
  // on verifie(test) que la function Stripe(la function Moque) ai bien ete execute
   expect(chargeOptions.source).toEqual('tok_visa')
   expect(chargeOptions.amount).toEqual(20*100)
   expect(chargeOptions.currency).toEqual('usd')
 
})

J'espere que c'est relativement clair..... (si on avait reellement implemente la connection avec Stripe ca aurait ete beaucoup plus complique)

Pour la bdd on utilise le package "mongodb-memory-server"(dans cet example on ne s en sert pas), cela cree une instance de Mongodb specifique aux tests (a chaque execution d'un test l instance est cree puis detruite).

Ce type de test n'est pas vraiment un "test-unitaire", on se rapproche des tests "d'integration" car on test differents elements connectes ensembles: "la route et la logique qu'elle contient"

Si pour toi les test c est nouveau je te conseille de commencer avec des tests unitaires "Jest" ou le Node core module "assert"(tres bien pour comprendre la logique des tests)

Vois les cours de developpez.com, il y a en a des tres bons aussi (cote tests je ne sais pas).

[alexiiiis]

Super je te remercie, d'avoir pris le temps de répondre, c'est plus clair deja. Merci d'avoir même mis du code, ca m'a aide !!

Pour la bdd on utilise le package "mongodb-memory-server"(dans cet example on ne s en sert pas), cela cree une instance de Mongodb specifique aux tests (a chaque execution d'un test l instance est cree puis detruite).

J'ai remarque, que mongodb était très populaire pour les tests, une raison particulière ? A contrario je trouve pas grand chose avec PostGresql.

Ce type de test n'est pas vraiment un "test-unitaire", on se rapproche des tests "d'integration" car on test differents elements connectes ensembles: "la route et la logique qu'elle contient"

Effectivement, j'ai utilise le mauvais vocabulaire, ce sont des tests d'integrations.

Si pour toi les test c est nouveau je te conseille de commencer avec des tests unitaires "Jest" ou le Node core module "assert"(tres bien pour comprendre la logique des tests)
Si tu maitrises un peu l anglais, il y a plein de cours pour pas cher. Sinon vois les cours de developpez.com, il y a en a des tres bons aussi (cote tests je ne sais pas).

Je te remercie pour les recommandations je vais y jeter un oeil.

[djedjethai]

MongoDb est tres populaire dans le monde de NodeJS (pas que pour les tests) car cette BDD store les datas dans un format similaire au "json". Aussi avec le set JS/front-end, NodeJS/back-end et MongoDB en BDD le traitement des datas est simplifie. De plus l'utilisation de "Mongoose" (un ODM Object-Document-Modeling) simplifie encore l'utilisation de MongoDB. Au final dans l'univers JS MongoDB s'impose souvent. Ceci dit ce n est pas toujours le meilleurs choix, Sql or Postgres s'utilisent egalement(mais sont beaucoup moins populaires). Vois les pros et cons entre les databases SQL et les NoSQL.

ps. Note que si tu as une BDD Postgres dans ton app, lors des tests tu utilises Postgres pas mongoDB ni SQL (j ai marque MongoDB car je n ai pas fait attention que tu utilises Postgres)

[alexiiiis]

Tu as réussi à me vendre MongoDb ahah. je vais y jeter un coup d'oeil du coup. Plus qu'à lire la Doc haha une de plus !!
KopKoun MyKrap djedjethai (ok ok j'ai essaye !!!, Merci bien en tout cas)

[djedjethai]

ah ah ah, oui c'est bien prononce. Si tu veux developper avec NodeJS, MongoDB est en quelque sorte un passage oblige. Bon courage.