Resolver di test e debug (VTL)

Nota

Ora supportiamo principalmente il runtime APPSYNC_JS e la relativa documentazione. Prendi in considerazione l'utilizzo del runtime APPSYNC_JS e delle relative guide qui.

AWS AppSync esegue resolver su un campo GraphQL su un'origine dati. Come descritto nella panoramica dei modelli di mappatura Resolver, i resolver comunicano con le fonti di dati utilizzando un linguaggio di template. Ciò consente di personalizzare il comportamento e applicare logica e condizioni prima e dopo la comunicazione con l'origine dati. Per una guida introduttiva alla programmazione in stile tutorial per la scrittura di resolver, consulta la guida alla programmazione dei modelli di mappatura Resolver.

Per aiutare gli sviluppatori a scrivere, testare ed eseguire il debug di questi resolver, la AWS AppSync console fornisce anche strumenti per creare una richiesta e una risposta GraphQL con dati fittizi fino al singolo resolver di campo. Inoltre, puoi eseguire query, mutazioni e sottoscrizioni nella AWS AppSync console e visualizzare un flusso di log dettagliato da Amazon dell'intera richiesta. CloudWatch Ciò include i risultati di un'origine dati.

Test con dati fittizi

Quando viene richiamato un resolver GraphQL, contiene un context oggetto che contiene informazioni sulla richiesta. Tali informazioni includono gli argomenti provenienti da un client, le informazioni sull'identità e i dati del campo GraphQL padre. Contiene anche i risultati della fonte di dati, che possono essere utilizzati nel modello di risposta. Per ulteriori informazioni su questa struttura e sulle utilità helper disponibili per la programmazione, consulta le informazioni di riferimento contestuali sui modelli di mappatura dei resolver.

Quando si scrive o si modifica un resolver, è possibile passare un oggetto di contesto fittizio o di test all'editor della console. In questo modo è possibile vedere in che modo i modelli di richiesta e di risposta eseguono la valutazione senza effettivamente eseguire un'origine dati. Puoi ad esempio passare un argomento firstname: Shaggy di test e vedere i relativi risultati quando usi $ctx.args.firstname nel codice del modello. Puoi anche testare la valutazione di utilità helper, ad esempio $util.autoId() o util.time.nowISO8601().

Test dei resolver

Questo esempio utilizzerà la AWS AppSync console per testare i resolver.

1. Accedere alla AWS Management Console e aprire la console AppSync.

   1. Nella dashboard delle API, scegli la tua API GraphQL.

   2. Nella barra laterale, scegli Schema.

2. Se non l'hai già fatto, sotto il tipo e accanto al campo, scegli Allega per aggiungere il tuo resolver.

   Per ulteriori informazioni su come creare un resolver completo, consulta Configurazione dei resolver.

   Altrimenti, seleziona il resolver già presente nel campo.

3. Nella parte superiore della pagina Modifica resolver, scegli Seleziona contesto di test, scegli Crea nuovo contesto.

4. Seleziona un oggetto contestuale di esempio o compila il JSON manualmente nella finestra del contesto di esecuzione sottostante.

5. Immettete un nome di contesto di testo.

6. Seleziona il pulsante Save (Salva).

7. Nella parte superiore della pagina Edit Resolver, scegli Esegui test.

Per un esempio più pratico, supponiamo di avere un'app che memorizza un tipo GraphQL che utilizza la generazione automatica Dog di ID per gli oggetti e li archivia in Amazon DynamoDB. Devi inoltre scrivere alcuni valori dagli argomenti di una mutazione GraphQL e permettere la visualizzazione di una risposta solo a determinati utenti. Di seguito viene mostrato come potrebbe apparire lo schema:

type Dog {
  breed: String
  color: String
}

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

Quando aggiungi un resolver per la addDog mutazione, puoi popolare un oggetto di contesto come nell'esempio seguente. Il seguente include gli argomenti name e age del client, oltre che un elemento username popolato nell'oggetto 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"
    }
}

Puoi eseguire un test usando i modelli di mappatura della richiesta e della risposta seguenti:

Modello di richiesta

{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key" : {
        "id" : { "S" : "$util.autoId()" }
    },
    "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}

Modello di risposta

#if ($context.identity.username == "Nadia")
  $util.toJson($ctx.result)
#else
  $util.unauthorized()
#end

Il modello valutato contiene i dati dell'oggetto context di test e il valore generato da $util.autoId(). Inoltre, se decidi di modificare username in un valore diverso da Nadia, i risultati non verranno restituiti perché il controllo di autorizzazione avrebbe esito negativo. Per ulteriori informazioni sul controllo granulare degli accessi, consulta Casi d'uso delle autorizzazioni.

Test dei modelli di mappatura con le API AWS AppSync

Puoi utilizzare il comando EvaluateMappingTemplate API per testare in remoto i tuoi modelli di mappatura con dati simulati. Per iniziare con il comando, assicurati di aver aggiunto l'appsync:evaluateMappingTemplateautorizzazione alla tua politica. Ad esempio:

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

Puoi sfruttare il comando utilizzando gli AWS CLIo AWSSDK. Ad esempio, prendi Dog lo schema e i relativi modelli di mappatura richiesta/risposta della sezione precedente. Utilizzando la CLI sulla stazione locale, salvate il modello di richiesta in un file denominatorequest.vtl, quindi salvate l'contextoggetto in un file denominato. context.json Dalla tua shell, esegui il seguente comando:

aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json

Il comando restituisce la seguente risposta:

{
  "evaluationResult": "{\n    \"version\" : \"2017-02-28\",\n    \"operation\" : \"PutItem\",\n    \"key\" : {\n        \"id\" : { \"S\" : \"afcb4c85-49f8-40de-8f2b-248949176456\" }\n    },\n    \"attributeValues\" : {\"firstname\":{\"S\":\"Shaggy\"},\"age\":{\"N\":4}}\n}\n"
}

evaluationResultContiene i risultati del test del modello fornito con quello fornitocontext. Puoi anche testare i tuoi modelli utilizzando gli AWS SDK. Ecco un esempio di utilizzo dell'AWSSDK per JavaScript la versione 2:

const AWS = require('aws-sdk')
const client = new AWS.AppSync({ region: 'us-east-2' })

const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')

client
  .evaluateMappingTemplate({ template, context })
  .promise()
  .then((data) => console.log(data))

Utilizzando l'SDK, puoi incorporare facilmente i test della tua suite di test preferita per convalidare il comportamento del tuo modello. Ti consigliamo di creare test utilizzando Jest Testing Framework, ma qualsiasi suite di test funziona. Il seguente frammento mostra un'ipotetica esecuzione di convalida. Nota che ci aspettiamo che la risposta di valutazione sia un codice JSON valido, quindi lo utilizziamo JSON.parse per recuperare JSON dalla stringa di risposta:

const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })

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

Ciò produce il seguente risultato:

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 total
Time: 1.511 s, estimated 2 s

Eseguire il debug di una query live

Non c'è nulla che possa sostituire un end-to-end test e una registrazione per eseguire il debug di un'applicazione di produzione. AWS AppSync consente di registrare gli errori e i dettagli completi della richiesta utilizzando Amazon. CloudWatch Puoi inoltre usare la console AWS AppSync per testare query, mutazioni e sottoscrizioni GraphQL, oltre che dati di log di flusso in tempo reale per ogni richiesta nell'editor di query, per eseguire il debug in tempo reale. Per le sottoscrizioni, i log visualizzano le informazioni relative al tempo della connessione.

A tale scopo, è necessario che Amazon CloudWatch logs sia abilitato in anticipo, come descritto in Monitoraggio e registrazione. Passa quindi alla console AWS AppSync , scegli la scheda Queries (Query) e inserisci una query GraphQL valida. Nella sezione in basso a destra, fai clic e trascina la finestra Logs per aprire la visualizzazione dei log. Sulla parte superiore della pagina, scegliere l'icona con la freccia per la riproduzione per eseguire la query GraphQL. Dopo alcuni istati, i log completi per la richiesta e la risposta per l'operazione verranno trasmessi in questa sezione della console, dove potrai visualizzarli.