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.

Tester et déboguer les résolveurs dans AWS AppSync () JavaScript

AWS AppSync exécute des résolveurs sur un champ GraphQL par rapport à une source de données. Lorsque vous travaillez avec des résolveurs de pipeline, les fonctions interagissent avec vos sources de données. Comme décrit dans la présentation des JavaScript résolveurs, les fonctions communiquent avec les sources de données à l'aide de gestionnaires de requêtes et de réponses écrits JavaScript et exécutés sur le APPSYNC_JS moteur d'exécution. Cela vous permet de fournir une logique et des conditions personnalisées avant et après la communication avec la source de données.

Pour aider les développeurs à écrire, tester et déboguer ces résolveurs, la AWS AppSync console fournit également des outils permettant de créer une requête et une réponse GraphQL avec des données fictives jusqu'au résolveur de champs individuel. En outre, vous pouvez effectuer des requêtes, des mutations et des abonnements dans la AWS AppSync console et consulter un journal détaillé de l'intégralité de la demande d'Amazon CloudWatch. Cela inclut les résultats de la source de données.

Tester avec des données fictives

Lorsqu'un résolveur GraphQL est invoqué, il contient un context objet contenant des informations pertinentes sur la requête. Ces informations incluent les arguments d'un client, les informations d'identité et les données du champ GraphQL parent. Il stocke également les résultats de la source de données, qui peuvent être utilisés dans le gestionnaire de réponses. Pour plus d'informations sur cette structure et les utilitaires d'assistance disponibles à utiliser lors de la programmation, consultez la référence de l'objet contextuel Resolver.

Lorsque vous écrivez ou modifiez une fonction de résolution, vous pouvez transmettre un objet de contexte fictif ou de test à l'éditeur de console. Cela vous permet de voir comment les gestionnaires de demandes et de réponses s'évaluent sans réellement se heurter à une source de données. Par exemple, vous pouvez transmettre un argument de test firstname: Shaggy et voir comment il est analysé lors de l'utilisation de ctx.args.firstname dans votre modèle de code. Vous pouvez également tester l'évaluation de n'importe quelle annotation d'utilitaire telle que util.autoId() ou util.time.nowISO8601().

Tester les résolveurs

Cet exemple utilisera la AWS AppSync console pour tester les résolveurs.

Pour un exemple plus pratique, supposons que vous disposiez d'une application stockant un type GraphQL Dog qui utilise la génération automatique d'identifiants pour les objets et les stocke dans Amazon DynamoDB. Vous souhaitez également écrire des valeurs à partir des arguments d'une mutation GraphQL et n'autoriser que certains utilisateurs à voir une réponse. L'extrait suivant montre à quoi pourrait ressembler le schéma :

type Dog {
  breed: String
  color: String
}

type Mutation {
  addDog(firstname: String, age: Int): Dog
}

Vous pouvez écrire une AWS AppSync fonction et l'ajouter à votre addDog résolveur pour gérer la mutation. Pour tester votre AWS AppSync fonction, vous pouvez renseigner un objet de contexte comme dans l'exemple suivant. Le suivant possède les arguments name et age du client, ainsi qu'un username renseigné dans l'objet identity :

{
    "arguments" : {
        "firstname": "Shaggy",
        "age": 4
    },
    "source" : {},
    "result" : {
        "breed" : "Miniature Schnauzer",
        "color" : "black_grey"
    },
    "identity": {
        "sub" : "uuid",
        "issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
        "username" : "Nadia",
        "claims" : { },
        "sourceIp" :[  "x.x.x.x" ],
        "defaultAuthStrategy" : "ALLOW"
    }
}

Vous pouvez tester votre AWS AppSync fonction à l'aide du code suivant :

import { util } from '@aws-appsync/utils';

export function request(ctx) {
  return {
    operation: 'PutItem',
    key: util.dynamodb.toMapValues({ id: util.autoId() }),
    attributeValues: util.dynamodb.toMapValues(ctx.args),
  };
}

export function response(ctx) {
  if (ctx.identity.username === 'Nadia') {
    console.log("This request is allowed")
    return ctx.result;
  }
  util.unauthorized();
}

Le gestionnaire de demandes et de réponses évalué contient les données de votre objet de contexte de test et la valeur générée à partir deutil.autoId(). De plus, si vous deviez modifier username avec une valeur autre que Nadia, les résultats ne seront pas renvoyés, car le contrôle d'autorisation échouerait. Pour plus d'informations sur le contrôle d'accès détaillé, consultez la section Cas d'utilisation des autorisations.

Tester les gestionnaires de demandes et de réponses avec AWS AppSync APIs

Vous pouvez utiliser la EvaluateCode API commande pour tester votre code à distance avec des données simulées. Pour commencer à utiliser la commande, assurez-vous d'avoir ajouté l'appsync:evaluateMappingCodeautorisation à votre politique. Par exemple :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "appsync:evaluateCode",
            "Resource": "arn:aws:appsync:<region>:<account>:*"
        }
    ]
}

Vous pouvez utiliser la commande en utilisant le AWS CLIou AWS SDKs. Prenons l'exemple du Dog schéma et de ses gestionnaires de demandes et de réponses de AWS AppSync fonctions présentés dans la section précédente. À CLI l'aide de votre station locale, enregistrez le code dans un fichier nommécode.js, puis enregistrez l'contextobjet dans un fichier nommécontext.json. Depuis votre shell, exécutez la commande suivante :

$ aws appsync evaluate-code \
  --code file://code.js \
  --function response \
  --context file://context.json \
  --runtime name=APPSYNC_JS,runtimeVersion=1.0.0

La réponse contient un evaluationResult contenant la charge utile renvoyée par votre gestionnaire. Il contient également un logs objet contenant la liste des journaux générés par votre gestionnaire lors de l'évaluation. Cela permet de déboguer facilement l'exécution de votre code et de consulter les informations relatives à votre évaluation pour vous aider à résoudre le problème. Par exemple :

{
    "evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
    "logs": [
        "INFO - code.js:13:5: \"This request is allowed\""
    ]
}

Ils evaluationResult peuvent être analysés comme JSON suit :

{
  "breed": "Miniature Schnauzer",
  "color": "black_grey"
}

À l'aide duSDK, vous pouvez facilement intégrer des tests issus de votre suite de tests préférée pour valider le comportement de vos gestionnaires. Nous vous recommandons de créer des tests à l'aide du Jest Testing Framework, mais toutes les suites de tests fonctionnent. L'extrait suivant montre une exécution de validation hypothétique. Notez que nous nous attendons à ce que la réponse d'évaluation soit valideJSON. Nous utilisons donc JSON.parse pour récupérer à JSON partir de la chaîne de réponse :

const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')

test('request correctly calls DynamoDB', async () => {
  const code = fs.readFileSync('./code.js', 'utf8')
  const context = fs.readFileSync('./context.json', 'utf8')
  const contextJSON = JSON.parse(context)
  
  const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
  const result = JSON.parse(response.evaluationResult)
  
  expect(result.key.id.S).toBeDefined()
  expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})

Cela donne le résultat suivant :

Ran all test suites.
> jest

PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s

Débogage d'une requête en direct

Rien ne remplace un end-to-end test et une journalisation pour déboguer une application de production. AWS AppSync vous permet de consigner les erreurs et de fournir les détails complets des demandes à l'aide d'Amazon CloudWatch. En outre, vous pouvez utiliser la AWS AppSync console pour tester les requêtes GraphQL, les mutations et les abonnements, ainsi que pour diffuser en direct les données du journal de chaque requête dans l'éditeur de requêtes afin de les déboguer en temps réel. Pour les abonnements, les journaux affichent les informations de temps de connexion.

Pour ce faire, vous devez activer Amazon CloudWatch Logs à l'avance, comme décrit dans Surveillance et journalisation. Ensuite, dans la AWS AppSync console, choisissez l'onglet Requêtes, puis entrez une requête GraphQL valide. Dans la section inférieure droite, cliquez et faites glisser la fenêtre Logs pour ouvrir la vue des logs. À l'aide de la flèche « Play » en haut de la page, exécutez votre requête GraphQL. Dans quelques instants, l'intégralité de vos journaux de demandes et de réponses relatifs à l'opération est diffusée dans cette section et vous pouvez les consulter dans la console.