Si vous cherchez des conseils pour tester une interface de programmation d’applications (API) avec Python ou JavaScript, vous êtes au bon endroit.
La frontière est mince entre le choix d’une interface de programmation d’applications (API) et la décision de travailler ou non avec elle. La plupart des API REST ont une architecture générique et suivent un chemin de requête commun. Mais certaines API s’écartent de la norme. Par conséquent, elles deviennent difficiles à utiliser.

Ainsi, avant de construire l’ensemble de votre logiciel sur une API, vous devez effectuer des contrôles de qualité et vous assurer qu’elle fonctionne correctement. Alors, qu’est-ce que les tests d’API, et comment tester une API ?

 

Qu’est-ce que les tests d’API ?

Les tests d’API impliquent l’évaluation initiale de la fonctionnalité, de la sécurité, de l’évolutivité, de la vitesse, etc. d’une API afin de déterminer si elle est idéale pour le programme qui souhaite l’utiliser. Mais de manière superficielle, il peut s’agir de tester si elle envoie les réponses appropriées lorsque vous effectuez des requêtes via ses différents points de terminaison.

En fonction de sa structure, lorsque vous testez une API, vous effectuez des requêtes (Get, Post, Update ou Delete) vers ses points d’extrémité pertinents. Il existe de nombreuses métriques à vérifier pendant les tests d’API. Mais au niveau débutant, vous voulez valider l’intégrité d’une API à partir de son code d’état et vous assurer qu’elle récupère et accepte les bonnes données.

À cette fin, comme toute requête Web, une API peut renvoyer le code d’état 200, 400 ou 500, voire d’autres.

La plupart des API utilisent des réponses JSON pour servir leurs charges utiles. Selon l’objectif, d’autres peuvent accepter et répondre avec des charges utiles XML, multipart ou HTML.

 

Comment tester une API à l’aide de Python et de JavaScript ?

Bien qu’il existe de nombreux outils de test d’API à interface utilisateur graphique (GUI) sur Internet, vous pouvez évaluer une API de manière plus critique avec des scripts écrits.

Une API indique dans sa documentation le type de requêtes qu’elle autorise et fournit des points de terminaison pertinents pour celles-ci. Vous pouvez donc les saisir et les tester en utilisant les méthodes de requête appropriées.
Contrairement à la phase de production proprement dite, les tests d’API sont rudimentaires. Vous n’avez donc pas besoin d’autant de spécificité que lorsque vous exécutez l’API pour la production. Bien qu’il existe différents types de tests d’API, nous nous concentrerons davantage sur les tests de validation des réponses dans cet article.

Dans ce tutoriel, nous allons tester une API de magasin fictive à l’aide de fetch de JavaScript et de la bibliothèque requests de Python. Ce faisant, nous testerons les points de terminaison pour obtenir, afficher, mettre à jour et supprimer des données.

 

Comment tester un point de terminaison d’API Get avec JavaScript

Comme vous le feriez en production, vous pouvez tester une API en JavaScript en utilisant soit Axios, soit la méthode d’extraction.

Pour obtenir l’état de la réponse de l’API à l’aide de la méthode fetch :

fetch(‘https://fakestoreapi.com/products’,
).then(res =>{

console.log(res)
})

La requête ci-dessus renvoie un état 200 s’il s’agit d’une réponse valide. Une fois la requête réussie, vous pouvez alors demander des données en temps réel à l’API.

Récupérons les données de cette API :

fetch(‘https://fakestoreapi.com/products’,
).then(res =>{
if (res.ok){
return res.json()

}
}).then(response=>{
console.log(response)
}).catch(err => console.log(err))

La réponse au code de récupération ci-dessus ressemble à ceci :

Pour obtenir le prix de tous les produits, par exemple, vous pouvez utiliser la fonction map :

fetch(‘https://fakestoreapi.com/products’,
).then(res =>{
if (res.ok){
return res.json()
}
}).then(response=>{
response.map(data =>{
console.log(données.prix)
})
// console.log(response)

}).catch(err => console.log(err))

Test d’un point de terminaison Get avec Python

Comme mentionné précédemment, Python utilise également la bibliothèque requests pour accéder aux données d’une API.

Pour vérifier l’état de la réponse dans ce cas :

importez requests
data = requests.get(‘https://fakestoreapi.com/products’)
print(data.status_code)

L’enregistrement des données comme nous l’avons fait ci-dessus renvoie un statut correspondant. Dans ce cas, il s’agit de 200.

Maintenant, obtenons les mêmes données avec Python comme nous l’avons fait en utilisant JavaScript :

import requests
data = requests.get(‘https://fakestoreapi.com/products’)
mesDonnées = data.json()
print(mesdonnées)

Vous pouvez obtenir des données spécifiques en utilisant la boucle for.

Pour obtenir les prix des produits, par exemple :

importez requests
data = requests.get(‘https://fakestoreapi.com/products’)
mesDonnées = data.json()

indexes = 0
pour i dans myData :
produits = myData[indexes]
indices +=1
print(goods[« price »])

Test d’un post endpoint avec JavaScript

Après avoir testé et vérifié que la requête Get fonctionne, en fonction de votre objectif et de ce que l’API propose, vous voudrez peut-être vérifier si vous pouvez également y insérer des données.

Contrairement à la requête Get, une requête Post accepte une charge utile. De plus, vous devrez préciser qu’il s’agit d’une requête Post :

// Spécifiez la charge utile
let payload = {
title : ‘new product’,
price : 13.5,
description : ‘test description’,
image :  »,
catégorie : ‘électronique’.
}

fetch(‘https://fakestoreapi.com/products’,
{
méthode : « Post »,
en-têtes:{
Content-Type’ : ‘application/json’ (type de contenu)

},
corps : JSON.stringify(payload) //convertit la charge utile en JSON
}
).then(res =>{

méthode : « Post »,
headers:{
Content-Type  » :  » application/json « .

},
corps : JSON.stringify(payload) //convertit la charge utile en JSON
}
).then(res =>{
if (res.ok){
console.log(res.status)
return res.json()
}
}).then(response => {
console.log(response)
}).catch(err => console.log(err))

Le code ci-dessus enregistre le code d’état de la réponse et les nouvelles informations insérées lorsque vous l’exécutez. Cela vous indique si votre demande a été acceptée ou non. En général, si le code d’état est 200, cela signifie que votre API a un point de terminaison valide qui renvoie la réponse appropriée.

Test des requêtes post avec Python

Vous pouvez également tester le point de terminaison post d’une API à l’aide de requests.post de Python. Comme vous l’avez fait lors de l’utilisation de fetch de JavaScript, vous devez également spécifier la charge utile ici :

import requests
payload = {
‘title’ : ‘nouveau produit’,
‘prix’ : 13.5,
description’ : ‘description du test’,
image’ :  »,
catégorie » : « électronique ».
}
Posted = requests.post(‘https://fakestoreapi.com/products’,
données = charge utile
)
print(Posted.status_code)
print(Posted.json())

Comme JavaScript, le code Python ci-dessus enregistre également le code d’état de la réponse et les nouvelles données spécifiées dans les données utiles.

 

Test des points de terminaison Put

La mise à jour des données de l’API s’effectue de la même manière que leur publication et leur obtention dans les deux langues.

Pour ce faire, en utilisant le fetch de JavaScript, il suffit de remplacer Post par Put :

// Spécifiez la charge utile
let payload = {
title : ‘new product’,
price : 13.5,
description : ‘test description’,
image :  »,
catégorie : ‘électronique’.
}

fetch(‘https://fakestoreapi.com/products/19′,
{
méthode : « Put »,
en-têtes:{
Content-Type’ : ‘application/json’ (type de contenu)
},
corps : JSON.stringify(payload) //convertit la charge utile en JSON

}
).then(res =>{
if (res.ok){
console.log(res.status)
return res.json()
}
}).then(response => {
console.log(response)
}).catch(err => console.log(err))

Si vous prêtez attention au point de terminaison de l’API, vous verrez qu’il inclut cette fois l’ID du produit. C’est ainsi que l’API sait quelles données vous voulez mettre à jour dans ce cas.

Néanmoins, certaines API peuvent utiliser d’autres méthodes pour élaborer leurs points de terminaison. Il ne s’agit donc pas d’une norme.

Pour tester la mise à jour des données de l’API en utilisant Python, vous utilisez plutôt requests.put :

import requests
payload = {
‘title’ : ‘nouveau produit’,
‘prix’ : 13.5,
description’ : ‘description du test’,
image’ :  »,
catégorie » : « électronique ».
}
Posted = requests.put(‘https://fakestoreapi.com/products/19’,
données = données utiles

)
print(Posted.status_code)
print(Posted.json())

Les exemples ci-dessus, s’ils réussissent, insèrent les nouvelles données à la position 19, comme indiqué par le point de terminaison de l’API.

Test de la demande de suppression

Supprimer des données d’une API est aussi simple que de faire une demande Get. En effet, contrairement à Post et Put, vous n’avez pas besoin de spécifier de charge utile. Tout ce dont vous avez besoin est le point de terminaison de la suppression.

L’API que nous avons choisie ici utilise l’ID du produit pour suivre ses données. Ainsi, la suppression d’un produit est facile :

fetch(‘https://fakestoreapi.com/products/19′,
{
méthode : « Supprimer »,
en-têtes:{
Content-Type’ : ‘application/json’ (type de contenu)
}
}
).then(res =>{
if (res.ok){
console.log(res.status)
return res.json()
}
}).then(response => {
console.log(response)
}).catch(err => console.log(err))

Il suffit de quelques lignes de code pour réaliser la même chose en utilisant Python :

import requests
Posted = requests.delete(‘https://fakestoreapi.com/products/19’,
)
print(Posted.status_code)
print(Posted.json())

Les deux exemples ci-dessus enregistrent le code d’état de la réponse et les données appartenant à l’identifiant interrogé (19 dans ce cas).

 

Ces méthodes de test sont-elles génériques ?

Bien que nous nous soyons concentrés sur une seule API dans cet article, les méthodes utilisées pour tester les points de terminaison CRUD ne sont pas différentes lorsqu’il s’agit d’autres API. La seule différence, bien sûr, réside dans les règles entourant la structure de chaque API et les directives de demande de données. Une fois que vous les avez déchiffrées pour une API donnée, vous pouvez alors utiliser la méthode appropriée, telle que décrite ici, pour tester les points de terminaison correspondants. Ainsi, puisque chaque API a des règles pour s’y connecter, lors des tests, certaines peuvent fournir des paramètres supplémentaires que vous devez inclure dans vos en-têtes de requête. Ces paramètres comprennent généralement un jeton d’accès ou d’autres paramètres fournis dans la documentation.