Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemples de code avec Amazon Q Developer
Cette section fournit des exemples réalistes de la manière d'améliorer votre expérience et la génération de code en mettant l'accent sur Python and Java langues. Outre des exemples en ligne, certains scénarios montrent comment vous pouvez utiliser la fonctionnalité de chat d'Amazon Q Developer pour demander des recommandations de code pendant que vous programmez.
Pour plus d’informations, consultez les rubriques suivantes :
+ [Python exemples ](examples-python.md)
+ [Java exemples ](examples-java.md)
+ [Exemples de chat](examples-chat.md)
# Python exemples
Procédez comme suit : Python des exemples montrent comment vous pouvez commencer à générer des suggestions de code en ligne avec Amazon Q Developer. Ces exemples illustratifs vous montrent comment déclencher l'assistant de codage pour vos propres projets. La plupart des exemples suivants sont applicables à d'autres langues :
+ [Génération de classes et de fonctions](#classes-python)
+ [Code du document](#code-python)
+ [Générer des algorithmes](#algorithms-python)
+ [Générer des tests unitaires](#tests-python)
## Génération de classes et de fonctions
Pour générer une implémentation de classe complète ou partielle, utilisez des commentaires de code. Le commentaire décrit l'intention de la classe. Commencez simplement et ajoutez plus de détails si nécessaire. Après avoir généré une classe, vous pouvez continuer à générer des fonctions dans son squelette.
Lorsque vous rédigez des commentaires, il est préférable d'utiliser la structure de commentaires de la langue. Entrée Python, pour les commentaires d'une seule ligne, utilisez `#` ***.***Pour les commentaires multilignes, utilisez `''' '''` ou`""" """`.
Entrée :
```
'''
DocumentReader class. has a name, children and optional parent.
Includes I/O functions to read and
write document
'''
```
Sortie :
```
class DocumentReader:
def __init__(self, name, children, parent=None):
self.name = name
self.parent = parent
self.children = children
def read(self):
"""Reads current document and returns text"""
pass
def write(self, text):
"""Writes text to current document"""
pass
```
Maintenant qu'il existe une classe initiale, une fonction supplémentaire peut être générée avec des commentaires supplémentaires.
Entrée :
```
'''
function to read document from local directory path and print the first line of the document
'''
```
Sortie :
```
def read_document(self, path):
"""Reads document from path and prints first line"""
import os
if os.path.isfile(path):
with open(path, 'r') as f:
print(f.readline())
else:
print(f"File not found at {path}")
```
## Code du document
Réduisez le temps consacré à la documentation du code en vous appuyant sur la documentation en ligne. Addition Python pauses dans les commentaires`''' '''`.
Entrée :
```
class S3Utils:
'''
'''
def __init__(self):
self.base_url = "https://s3"
def generate_s3_url(self, bucket_name, region):
return f"{self.base_url}.{region}.amazonaws.com/{bucket_name}"
# Example usage:
if __name__ == "__main__":
s3_util = S3Utils()
bucket_name = "my-example-bucket"
region = "us-west-1"
s3_url = s3_util.generate_s3_url(bucket_name, region)
print(f"S3 URL for bucket '{bucket_name}' in region '{region}': {s3_url}")
```
Sortie :
```
class S3Utils:
'''
Class to generate S3 URL from bucket name and region
'''
def __init__(self):
self.base_url = "https://s3"
def generate_s3_url(self, bucket_name, region):
return f"{self.base_url}.{region}.amazonaws.com/{bucket_name}"
# Example usage:
if __name__ == "__main__":
s3_util = S3Utils()
bucket_name = "my-example-bucket"
region = "us-west-1"
s3_url = s3_util.generate_s3_url(bucket_name, region)
print(f"S3 URL for bucket '{bucket_name}' in region '{region}': {s3_url}")
```
## Générer des algorithmes
Amazon Q Developer peut générer des algorithmes populaires, en particulier ceux liés à AWS SDKs. Dans votre script, ajoutez une invite qui indique la fonction que vous souhaitez utiliser.
Cet exemple montre comment générer un dictionnaire de clés d'identification utilisateur pour nommer des valeurs, puis comment générer une fonction de tri à l'aide de l'algorithme de tri à bulles.
Entrée :
```
class SortList:
@staticmethod
def get_user_id_name_map():
user_id_name_map = {
1: "Amit",
2: "Rahul",
3: "Vijay",
4: "Raj",
5: "Kumar"
}
return user_id_name_map
'''
Sort the list of user id's alphabetically using bubble sort
'''
```
Sortie :
```
@staticmethod
def sort_user_id_name_map():
user_id_name_map = SortList.get_user_id_name_map()
list_of_user_ids = list(user_id_name_map.keys())
list_of_user_names = list(user_id_name_map.values())
print("Before sort: ", list_of_user_ids)
for i in range(len(list_of_user_ids)):
for j in range(len(list_of_user_ids) - i - 1):
if list_of_user_names[j] > list_of_user_names[j + 1]:
list_of_user_ids[j], list_of_user_ids[j + 1] = list_of_user_ids[j + 1], list_of_user_ids[j]
list_of_user_names[j], list_of_user_names[j + 1] = list_of_user_names[j + 1], list_of_user_names[j]
print("After sort: ", list_of_user_ids)
```
En outre, vous pouvez créer des instructions pour les procédures standard. Dans cet exemple, l'utilisateur crée une invite pour stocker le dictionnaire dans une table Amazon DynamoDB. Au début du script, l'utilisateur ajoute une invite à ajouter des bibliothèques DynamoDB afin de fournir un contexte supplémentaire à Amazon Q Developer.
Entrée :
```
'''
Add libraries for Amazon Dynamo DB
'''
```
Sortie :
```
'''
Add libraries for Amazon Dynamo DB and JSON.
iMport necessary libraries for working with Amazon DynamoDB and JSON data.
'''
import boto3
import json
from botocore.exceptions import ClientError
def load_data_to_dynamodb(table_name, data_file):
# Create a DynamoDB resource
dynamodb = boto3.resource('dynamodb')
# Get a reference to the table
table = dynamodb.Table(table_name)
# Load data from the JSON file
with open(data_file, 'r') as file:
data = json.load(file)
# Iterate over the data and load it to the table
for item in data:
try:
table.put_item(Item=item)
print(f"Successfully loaded data: {item}")
except ClientError as e:
print(f"Error loading data: {e.response['Error']['Message']}")
# Example usage
load_data_to_dynamodb('myTable', 'data.json')
```
Désormais, l'utilisateur peut facilement demander à Amazon Q de l'aider à stocker le dictionnaire dans DynamoDB.
Entrée :
```
'''
function to store the above sorted dict to dynamodb table named users
'''
```
Sortie :
```
@staticmethod
def store_user_id_name_map_in_dynamodb():
user_id_name_map = SortList.get_user_id_name_map()
list_of_user_ids = list(user_id_name_map.keys())
list_of_user_names = list(user_id_name_map.values())
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('users')
for i in range(len(list_of_user_ids)):
try:
response = table.put_item(
Item={
'user_id': list_of_user_ids[i],
'user_name': list_of_user_names[i]
}
)
except ClientError as e:
print(e.response['Error']['Message'])
```
## Générer des tests unitaires
Grâce aux commentaires intégrés, Amazon Q Developer peut générer des tests unitaires pour effectuer des assertions et d'autres tests. Dans cet exemple, l'utilisateur demande à Amazon Q de générer les bibliothèques applicables aux tests unitaires afin de définir le contexte du script de test. L'utilisateur demande ensuite à Amazon Q d'écrire une fonction de test pour cette `sort_user_id_name_map` fonction.
Entrée :
```
'''
Import all the required unit test libraries for python and then generate a unit test for sort_user_id_name_map function.
'''
```
Sortie :
```
import unittest
from unittest.mock import patch
from sort_user_id_name_map import sort_user_id_name_map
class TestSortUserIdNameMap(unittest.TestCase):
@patch('sort_user_id_name_map.sort_user_id_name_map')
def test_sort_user_id_name_map(self, mock_sort):
mock_sort.return_value = {'id1': 'name1', 'id2': 'name2'}
result = sort_user_id_name_map({'id2': 'name2', 'id1': 'name1'})
self.assertEqual(result, {'id1': 'name1', 'id2': 'name2'})
if __name__ == '__main__':
unittest.main()
```
En outre, lors d'une discussion entre l'utilisateur et Amazon Q Developer, celui-ci suggère et génère des tests unitaires basés sur les instructions de saisie du code de l'utilisateur. Pour plus d'informations, consultez la section [Exemples de chat](examples-chat.md).
# Java exemples
Procédez comme suit : Java des exemples montrent comment les utilisateurs peuvent commencer à générer des suggestions de code en ligne. Ces exemples illustratifs vous montrent comment déclencher l'assistant de codage pour vos propres projets. La plupart des exemples suivants sont applicables à d'autres langues :
+ [Génération de classes et de fonctions](#classes-java)
+ [Code du document](#code-java)
+ [Générer des algorithmes](#algorithms-java)
+ [Générer des tests unitaires](#tests-java)
## Génération de classes et de fonctions
Pour générer une implémentation de classe complète ou partielle, utilisez des commentaires de code. Le commentaire décrit l'intention de la classe. Commencez simplement et ajoutez plus de détails si nécessaire. Après avoir généré une classe, vous pouvez continuer à générer des fonctions au sein de son squelette.
Lorsque vous rédigez des commentaires, il est préférable d'utiliser la structure de commentaires de la langue. Entrée Java, c'est `/** */`*.*
Entrée :
```
/**
* DocumentReader class. has a name, children and optional parent.
* Includes I/O functions to read and
* write document
*/
```
Sortie :
```
/**
* DocumentReader class. has a name, children and optional parent.
* Includes I/O functions to read and
* write document
*/
import java.util.ArrayList;
public class DocumentReader {
private String name;
private DocumentReader parent;
private ArrayList children;
/**
* Constructor
* @param name name of the document
* @param parent parent of the document
*/
public DocumentReader(String name, DocumentReader parent) {
this.name = name;
this.parent = parent;
this.children = new ArrayList<>();
}
/**
* Constructor
* @param name name of the document
*/
public DocumentReader(String name) {
this(name, null);
}
/**
* Getter for name
* @return name of the document
*/
public String getName() {
return name;
}
/**
* Getter for parent
* @return parent of the document
*/
public DocumentReader getParent() {
return parent;
}
/**
* Getter for children
* @return children of the document
*/
public ArrayList getChildren() {
return children;
}
/**
* Adds a child to the document
* @param child child to be added
*/
public void addChild(DocumentReader child) {
children.add(child);
}
/**
* Removes a child from the document
* @param child child to be removed
*/
public void removeChild(DocumentReader child) {
children.remove(child);
}
}
```
Maintenant qu'il existe une classe initiale, une fonction supplémentaire peut être générée avec des commentaires supplémentaires.
Entrée :
```
/**
* function to read document from local directory path
* and print first line of document
*/
```
Sortie :
```
/**
* function to read document from local directory path
* and print first line of document
*/
public void readDocument() {
try {
BufferedReader reader = new BufferedReader(new FileReader(name));
String line = reader.readLine();
System.out.println(line);
reader.close();
} catch (IOException e) {
System.out.println("Error reading document: " + e.getMessage());
}
}
```
## Code du document
Réduisez le temps consacré à la documentation du code en vous appuyant sur la documentation en ligne. Ajoutez un Java pause dans les commentaires`/* */`.
Entrée :
```
import java.util.function.Function;
public class S3Utils {
/*
*
*/
public static Function generateS3Function(String bucketName, String region) {
return (String key) -> {
String url = generateS3Url(bucketName, key, region);
return url;
};
}
}
```
Si la génération en ligne n'a pas lieu, exécutez une suggestion en ligne d'Amazon Q Developer après avoir placé votre curseur à l'endroit où vous souhaitez obtenir de la documentation.
Sortie :
```
import java.util.function.Function;
public class S3Utils {
/*
* Generate a function that returns the S3 URL for a given key
* @param bucketName the name of the bucket
* @param region the region of the bucket
* @return the function that generates the S3 URL
*/
public static Function generateS3Function(String bucketName, String region) {
return (String key) -> {
String url = generateS3Url(bucketName, key, region);
return url;
};
}
}
```
Pour des explications plus simples du code (classes, fonctions ou éléments de script), utilisez des caractères directs (`//`) placés stratégiquement avant les sections de code dans lesquelles vous souhaitez ajouter de la documentation.
Entrée :
```
//
public class S3Utils {
/*
* Generate a function that returns the S3 URL for a given key
* @param bucketName the name of the bucket
* @param region the region of the bucket
* @return the function that generates the S3 URL
*/
public static Function generateS3Function(String bucketName, String region) {
return (String key) -> {
String url = generateS3Url(bucketName, key, region);
return url;
};
}
}
```
Sortie :
```
// This class is used to generate a function that returns the S3 URL for a given key
public class S3Utils {
/*
* Generate a function that returns the S3 URL for a given key
* @param bucketName the name of the bucket
* @param region the region of the bucket
* @return the function that generates the S3 URL
*/
public static Function generateS3Function(String bucketName, String region) {
return (String key) -> {
String url = generateS3Url(bucketName, key, region);
return url;
};
}
}
```
## Générer des algorithmes
Amazon Q Developer peut générer des algorithmes populaires, notamment liés à AWS SDKs. Dans votre script, ajoutez une invite qui indique la fonction que vous souhaitez utiliser.
Cet exemple génère une carte de hachage des clés d'identification utilisateur vers les valeurs des noms, puis génère une fonction de tri à l'aide de l'algorithme de tri par bulles.
Entrée :
```
import java.util.HashMap;
public class SortList {
// generate key value pair hash map for
// user id and name
public static HashMap getUserIdNameMap() {
HashMap userIdNameMap = new HashMap();
userIdNameMap.put(1, "Amit");
userIdNameMap.put(2, "Rahul");
userIdNameMap.put(3, "Vijay");
userIdNameMap.put(4, "Raj");
userIdNameMap.put(5, "Kumar");
return userIdNameMap;
}
/*
* Create function to sort UserIdName map by name alphabetically using bubble sort
*/
}
```
Sortie :
```
/*
* Create function to sort UserIdName map by name alphabetically using bubble sort
*/
public static HashMap sortUserIdNameMap(HashMap userIdNameMap) {
int size = userIdNameMap.size();
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (userIdNameMap.get(i).compareTo(userIdNameMap.get(j)) > 0) {
String temp = userIdNameMap.get(i);
userIdNameMap.put(i, userIdNameMap.get(j));
userIdNameMap.put(j, temp);
}
}
}
return userIdNameMap;
}
```
En outre, les utilisateurs peuvent créer des instructions pour les procédures standard. Dans cet exemple, l'utilisateur crée une invite pour stocker la carte de hachage dans une table Amazon DynamoDB. Au début du script, l'utilisateur ajoute une invite pour ajouter DynamoDB Java bibliothèques pour aider à fournir un contexte supplémentaire à Amazon Q Developer.
Entrée :
```
// add libraries for Amazon DynamoDB
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
/*
* Store sorted UserIdName map into Amazon DynamoDB table named users
*/
```
Sortie :
```
// add libraries for Amazon DynamoDB
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
/*
* Store sorted UserIdName map into Amazon DynamoDB table named users
*/
public static void storeSortedUserIdNameMap(HashMap userIdNameMap) {
// create Amazon DynamoDB client
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.defaultClient();
// store sorted UserIdName map into Amazon DynamoDB table named users
for (int userId : userIdNameMap.keySet()) {
String name = userIdNameMap.get(userId);
client.putItem("users", new HashMap() {{
put("userId", userId);
put("name", name);
}});
}
}
```
## Générer des tests unitaires
Grâce aux commentaires intégrés, Amazon Q Developer peut générer des tests unitaires pour effectuer des assertions et d'autres JUnit tests. Dans cet exemple, l'utilisateur demande d'abord à Amazon Q de générer les bibliothèques applicables JUnit pour définir le contexte du script de test. Ensuite, l'utilisateur crée une classe publique suivie d'un déclarateur et de chaînes de commentaires.
Entrée :
```
// import libraries for java unit tests
import org.junit.Test;
import static org.junit.Assert.*;
public class UnitTests {
@Test
/*
* Create unit test for getUserIdNameMap
*/
}
```
Sortie :
```
@Test
/*
* Create unit test for getUserIdNameMap
*/
public void testGetUserIdNameMap() {
// create a new instance of the UserIdNameMap class
UserIdNameMap userIdNameMap = new UserIdNameMap();
// create a new instance of the User class
User user = new User("John", "Doe");
// add the user to the map
userIdNameMap.addUser(user);
// get the user from the map
User retrievedUser = userIdNameMap.getUser("John");
// assert that the retrieved user is the same as the user added to the map
assertEquals(user, retrievedUser);
}
```
En outre, lors d'une discussion entre l'utilisateur et Amazon Q Developer, celui-ci suggère et génère des tests unitaires basés sur les instructions de saisie du code de l'utilisateur. Pour plus d'informations, consultez la section [Exemples de chat](examples-chat.md).
# Exemples de chat
Amazon Q Developer Chat aide les développeurs à effectuer diverses tâches, telles que le codage, le test et la mise à niveau des applications, le diagnostic des erreurs, la réalisation d'analyses de sécurité et de correctifs, ainsi que l'optimisation AWS des ressources. Cette section explique comment le chat avec Amazon Q peut aider un développeur à effectuer des tâches de programmation classiques, telles que les suivantes :
+ [Renseignez-vous sur Services AWS](#services-chat)
+ [Générer du code](#code-chat)
+ [Générer des tests unitaires](#tests-chat)
+ [Expliquer le code](#explain-chat)
## Renseignez-vous sur Services AWS
Les utilisateurs peuvent poser des questions aux développeurs Amazon Q Services AWS, par exemple pour trouver le bon service ou comprendre les meilleures pratiques.
### Discutez de Services AWS
Utilisateur :
Quel est le meilleur service de conteneur à utiliser pour gérer ma charge de travail si je dois réduire mes coûts ?
Amazon Q :
Sur la base des informations fournies, il semble que vous recherchiez un service de conteneur rentable pour gérer vos charges de travail. Dans ce cas, je recommande d'envisager Amazon Elastic Container Service (Amazon ECS) avec Fargate. [1]
Amazon ECS with Fargate est un moteur de calcul sans serveur pour les conteneurs qui vous permet d'exécuter vos conteneurs sans avoir à gérer d'infrastructure sous-jacente. Avec Fargate, vous n'avez pas besoin de provisionner ou de gérer des serveurs : Fargate s'en charge pour vous. Cela peut vous aider à réduire vos coûts, car vous ne payez que pour les ressources de calcul réellement utilisées par vos conteneurs, sans avoir à payer pour la capacité de serveur inactive. [2]
Voici quelques avantages clés liés à l'utilisation d'Amazon ECS avec Fargate :
• Pas besoin de gérer des serveurs ou des clusters : Fargate s'occupe du provisionnement et de la gestion de l'infrastructure pour vous.
• Pay-as-you-go tarification : vous ne payez que pour les ressources informatiques utilisées par vos conteneurs, sans avoir à payer pour les capacités inutilisées.
• Dimensionnement automatique — Fargate peut automatiquement redimensionner vos conteneurs à la hausse ou à la baisse en fonction de la demande.
• Intégration étroite avec d'autres outils Services AWS tels que l'équilibrage de charge, la journalisation et la surveillance.
Les ressources fournies mentionnent également que le service ECS offre une flexibilité en termes de planification et de placement des conteneurs, ce qui peut vous aider à optimiser davantage vos coûts.
Je vous recommande de consulter le détail des tarifs d'Amazon ECS with Fargate sur AWS le site Web afin d'avoir une meilleure idée des coûts en fonction de vos exigences spécifiques en matière de charge de travail. Et bien sûr, n'hésitez pas à me faire savoir si vous avez d'autres questions \$1
Sources
[1] Quel service de AWS conteneur vous convient le mieux ?
[aptgetops.tech > - -vous aws-container-services-which one-is-right-for](https://aptgetops.tech/aws-container-services-which-one-is-right-for-you)
[2] Java options de conteneur pour les charges de travail non HTTP
[stackoverflow.com > Questions > 43417016](https://stackoverflow.com/questions/43417016/java-container-options-for-non-http-worloads)
**Mettre fin à la discussion sur Amazon Q Services AWS**
## Générer du code
Les utilisateurs peuvent demander de l'aide à Amazon Q Developer pour écrire des extraits de code.
### Discuter de l'écriture de code
Utilisateur :
Pouvez-vous me donner un exemple de la façon de répertorier tous les compartiments S3 à l'aide du ? AWS SDK pour Python (Boto)
Amazon Q :
Voici certainement un exemple de la façon de répertorier tous les compartiments S3 à l'aide du AWS SDK pour Python (Boto)[1] :
```
import boto3
# Create an S3 client
s3 = boto3.client('s3')
# List all the buckets
response = s3.list_buckets()
# Print the name of each bucket
for bucket in response['Buckets']:
print(bucket['Name'])
```
Voici comment fonctionne le code :
1. Nous importons d'abord la bibliothèque boto3, qui est le SDK pour Python.
1. Nous créons un client S3 en utilisant`boto3.client('s3')`.
1. Nous appelons la `list_buckets()` méthode sur le client S3, qui renvoie une réponse contenant une liste de tous les compartiments du compte.
1. Nous parcourons ensuite la `Buckets` liste dans la réponse et imprimons le nom de chaque compartiment.
Il s'agit d'un exemple simple, mais il AWS SDK pour Python (Boto) fournit de nombreuses autres fonctionnalités avancées pour travailler avec Amazon S3, telles que la création, la suppression et la gestion d'objets dans des compartiments, la définition de politiques de compartiment, etc. Vous trouverez d'autres exemples et de la documentation dans la documentation AWS SDK pour Python (Boto)(). [2]
N'oubliez pas que lorsque vous travaillez avec Services AWS, il est important de suivre les meilleures pratiques en matière de gestion des informations d'identification et des informations sensibles, telles que le stockage des clés AWS d'accès dans des variables d'environnement au lieu de les coder en dur dans le code.
Sources : [1] [Exemples Amazon S3 utilisant le SDK pour Python ( AWS Boto3) - Exemples de code SDK docs.aws.amazon.com > code-library > latest-1x >... > python-s3.html](https://docs.aws.amazon.com/code-library/latest/ug/python_3_s3_code_examples.html)
[2] [Commencez à utiliser les buckets et les objets Amazon S3 à l'aide d'un AWS SDK - Exemples de code AWS SDK docs.aws.amazon.com > code-library > latest-1x >... >](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example_s3_Scenario_GettingStarted_section.html) s3\$1example\$1s3\$1buckets\$1 \$1sect... GettingStarted
**Fin de la discussion Amazon Q sur l'écriture de code**
## Générer des tests unitaires
Les utilisateurs peuvent envoyer le code sélectionné sous forme d'invite à Amazon Q Developer, où des instructions supplémentaires sont appliquées, telles que la génération d'un test unitaire. Pour step-by-step obtenir des instructions, consultez la section [Envoyer du code à Amazon Q](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/explain-update-code.html#send-code) dans le manuel *Amazon Q Developer User Guide*.
### Discuter des tests unitaires
Utilisateur :
Rédigez un test unitaire avec des données fictives pour la fonction suivante :
```
// poll messages from Amazon SQS queue name
public List pollMessages(String queueName) {
List messages = new ArrayList<>();
// poll messages from queue
ReceiveMessageResult = sqsClient.receiveMessage(new ReceiveMessageRequest().
for (Message : receiveMessageResult.getMessages()) {
messages.add(message.getBody());
}
return messages;
}
```
Amazon Q :
Pour écrire un test unitaire avec des données fictives pour la fonction PollMessages, nous pouvons utiliser un framework de simulation tel que Mockito. Voici un exemple :
```
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.model.Message;
import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
import com.amazonaws.services.sqs.model.ReceiveMessageResult;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Arrays;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
@ExtendWith(MockitoExtension.class)
public class SQSUtilsTest {
@Mock
private AmazonSQS sqsClient;
@InjectMocks
private SQSUtils sqsUtils;
@Test
public void testPollMessages() {
// Arrange
String queueName = "test-queue";
Message message1 = new Message().withBody("message1");
Message message2 = new Message().withBody("message2");
ReceiveMessageResult receiveMessageResult = new ReceiveMessageResult().withMessages(message1, message2);
Mockito.when(sqsClient.receiveMessage(new ReceiveMessageRequest().withQueueUrl(queueName)))
.thenReturn(receiveMessageResult);
// Act
List messages = sqsUtils.pollMessages(queueName);
// Assert
assertEquals(Arrays.asList("message1", "message2"), messages);
}
}
```
Dans cet exemple, nous utilisons Mockito pour simuler le client AmazonSQS et configurer le comportement attendu de la méthode ReceiveMessage afin qu'elle renvoie deux messages fictifs dont les corps sont « message1 » et « message2 ». Ensuite, nous appelons la méthode PollMessages et affirmons que la liste de messages renvoyée correspond aux valeurs attendues.
Les points essentiels sont les suivants :
1. Nous utilisons l'annotation @ ExtendWith (MockitoExtension.class) pour activer l'intégration de Mockito avec. JUnit
1. Nous utilisons l'annotation @Mock pour créer une instance fictive du client AmazonSQS.
1. Nous utilisons l'InjectMocks annotation @ pour injecter le faux client AmazonSQS dans la SQSUtils classe.
1. Dans la méthode de test, nous avons défini le comportement attendu de la méthode ReceiveMessage à l'aide de Mockito.when () .thenReturn ().
1. Nous appelons la méthode PollMessages et affirmons que la liste des messages renvoyés correspond aux valeurs attendues.
Cette approche nous permet de tester la méthode PollMessages sans réellement interagir avec le service Amazon SQS, ce qui peut rendre le test plus rapide et plus fiable.
**Fin** de la **discussion Amazon Q sur les tests unitaires**
## Expliquer le code
Pour les processus de révision du code, les développeurs peuvent envoyer une sélection de code à Amazon Q Developer afin de mieux comprendre le code. En outre, l'explication fournie par Amazon Q peut également servir à des fins de documentation. Dans l'exemple suivant, Amazon Q explique la fonction de gestion à l'aide d'une AWS Lambda fonction, puis propose une docstring.
### Discuter sur l'explication du code
Utilisateur :
Expliquez la partie suivante de mon code :
```
def lambda_handler(event, context):
dynamodb = boto3.resource('dynamodb')
s3_client = boto3.client('s3')
table = dynamodb.Table('DYNAMODB_TABLE')
# Get s3 object from the event
print(event)
print(context)
# get object from event
bucket_key = event['Records'][0]['s3']['object']['key']
object_key = unquote_plus(bucket_key)
fullText = detect_text(object_key, bucket)
response = s3_client.head_object(Bucket=bucket, Key=object_key)
print(response)
print(fullText)
metadata = response['ResponseMetadata']
metadata = json.dumps(metadata)
now = datetime.now()
current_time = now.strftime("%A %d %B, %Y %H:%M:%S")
print("Current Time =", current_time + "\n\n")
reason, outcome = detect_restaurant_closure(fullText, current_time)
table.put_item(
Item={
'id': object_key,
'creationTime': now.strftime("%Y-%m-%d %H:%M:%S"),
'reason': reason,
'text': fullText,
'metadata': metadata
}
)
```
Amazon Q :
Le bloc de code fourni semble être une AWS Lambda fonction écrite en Python. Permettez-moi de vous expliquer les principaux aspects de ce code :
1. La fonction s'appelle lambda\$1handler et constitue le point d'entrée de la fonction Lambda.
1. Il utilise la bibliothèque boto3 pour interagir avec AWS DynamoDB et les services S3.
1. La fonction extrait une clé d'objet S3 et un nom de compartiment à partir des données d'événements entrantes.
1. Il appelle ensuite une fonction detect\$1text (qui n'apparaît pas dans le code fourni) pour extraire le contenu en texte intégral de l'objet S3.
1. La fonction récupère également les métadonnées relatives à l'objet S3 à l'aide de la méthode head\$1object.
1. Il extrait ensuite l'heure actuelle et appelle une fonction detect\$1restaurant\$1closure (également non illustrée) pour déterminer la raison et le résultat de la fermeture d'un restaurant sur la base du texte extrait.
1. Enfin, la fonction stocke les informations suivantes dans une table DynamoDB :
+ La clé de l'objet S3 comme identifiant
+ L'heure de création
+ La raison et le résultat de la fermeture du restaurant
+ Le texte extrait de l'objet S3
Dans l'ensemble, cette fonction Lambda semble faire partie d'un système plus vaste qui traite les objets S3, extrait le contenu du texte, l'analyse pour y détecter les informations relatives à la fermeture des restaurants et stocke les résultats dans une table DynamoDB. Les détails spécifiques des fonctions detect\$1text et detect\$1restaurant\$1closure seraient nécessaires pour bien comprendre les fonctionnalités de ce code.
**Fin de la réponse d'Amazon Q**
Utilisateur : résumez cette explication dans une docstring pour cette fonction lambda\$1handler
Amazon Q : Voici une chaîne de documentation suggérée pour la fonction lambda\$1handler [1] :
```
def lambda_handler(event, context):
"""
AWS Lambda function that processes an S3 object, extracts text content, analyzes it, and stores the results.
Args:
event (dict): The event data that triggered the Lambda function, containing information about the S3 object.
context (object): The context object provided by AWS Lambda, containing information about the runtime environment.
Returns:
None
"""
# function implementation details...
```
Cette docstring fournit un résumé de haut niveau de l'objectif de la fonction, des paramètres d'entrée attendus et de la valeur de retour attendue (ou de son absence, dans ce cas). Cela permet à l'utilisateur de comprendre clairement ce que fait la fonction lambda\$1handler sans entrer dans les détails de l'implémentation.
Sources : [1] Définissez le gestionnaire de fonctions Lambda en C\$1 - AWS Lambda [https://docs.aws.amazon.com/lambda/latest/dg/csharp-handler.html - : \$1:text=Le gestionnaire de fonctions Lambda](https://docs.aws.amazon.com/lambda/latest/dg/csharp-handler.html#:~:text=The%20Lambda%20function%20handler%20is,%2C%20exits%2C%20or%20times%20out.) est, sort ou expire.
**Fin de la discussion Amazon Q sur l'explication du code**