

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menguji dan men-debug resolver di AWS AppSync (VTL)
<a name="test-debug-resolvers"></a>

**catatan**  
Kami sekarang terutama mendukung runtime APPSYNC\$1JS dan dokumentasinya. [Harap pertimbangkan untuk menggunakan runtime APPSYNC\$1JS dan panduannya di sini.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)

AWS AppSync mengeksekusi resolver pada bidang GraphQL terhadap sumber data. Seperti yang dijelaskan dalam [ikhtisar template pemetaan Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview), resolver berkomunikasi dengan sumber data dengan menggunakan bahasa templating. Ini memungkinkan Anda untuk menyesuaikan perilaku dan menerapkan logika dan kondisi sebelum dan sesudah berkomunikasi dengan sumber data. [Untuk panduan pemrograman gaya tutorial pengantar untuk menulis resolver, lihat panduan pemrograman template pemetaan Resolver.](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide)

Untuk membantu pengembang menulis, menguji, dan men-debug resolver ini, AWS AppSync konsol juga menyediakan alat untuk membuat permintaan dan respons GraphQL dengan data tiruan ke penyelesai bidang individual. Selain itu, Anda dapat melakukan kueri, mutasi, dan langganan di AWS AppSync konsol dan melihat aliran log terperinci dari Amazon CloudWatch dari seluruh permintaan. Ini termasuk hasil dari sumber data.

## Pengujian dengan data tiruan
<a name="testing-with-mock-data"></a>

Ketika resolver GraphQL dipanggil, itu berisi objek yang berisi informasi tentang `context` permintaan. Ini termasuk argumen dari klien, informasi identitas, dan data dari bidang GraphQL induk. Ini juga berisi hasil dari sumber data, yang dapat digunakan dalam template respons. Untuk informasi selengkapnya tentang struktur ini dan utilitas pembantu yang tersedia untuk digunakan saat pemrograman, lihat Referensi Konteks Template [Pemetaan Resolver](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).

Saat menulis atau mengedit resolver, Anda dapat meneruskan objek *konteks *tiruan* atau pengujian* ke editor konsol. Ini memungkinkan Anda untuk melihat bagaimana permintaan dan template respons mengevaluasi tanpa benar-benar berjalan terhadap sumber data. Misalnya, Anda dapat lulus `firstname: Shaggy` argumen pengujian dan melihat bagaimana itu mengevaluasi saat menggunakan `$ctx.args.firstname` dalam kode template Anda. Anda juga dapat menguji evaluasi setiap pembantu utilitas seperti `$util.autoId()` atau`util.time.nowISO8601()`.

### Menguji penyelesai
<a name="test-a-resolver"></a>

Contoh ini akan menggunakan AWS AppSync konsol untuk menguji resolver.

1. Masuk ke Konsol Manajemen AWS dan buka [AppSynckonsol](https://console.aws.amazon.com/appsync/).

   1. Di **APIs dasbor**, pilih GraphQL API Anda.

   1. Di **Sidebar**, pilih **Skema**.

1. Jika Anda belum melakukannya, di bawah tipe dan di samping bidang, pilih **Lampirkan** untuk menambahkan resolver Anda.

   [Untuk informasi selengkapnya tentang cara membuat resolver conplete, lihat Mengonfigurasi resolver.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html)

   Jika tidak, pilih resolver yang sudah ada di lapangan.

1. Di bagian atas halaman **Edit resolver**, **pilih Pilih konteks pengujian, pilih Buat konteks** **baru**.

1. Pilih objek konteks sampel atau isi JSON secara manual di jendela **konteks Eksekusi di bawah** ini.

1. Masukkan **nama konteks Teks**.

1. Pilih tombol **Simpan**.

1. Di bagian atas halaman **Edit Resolver**, pilih **Run** test.

Untuk contoh yang lebih praktis, misalkan Anda memiliki aplikasi yang menyimpan tipe `Dog` GraphQL yang menggunakan pembuatan ID otomatis untuk objek dan menyimpannya di Amazon DynamoDB. Anda juga ingin menulis beberapa nilai dari argumen mutasi GraphQL, dan hanya mengizinkan pengguna tertentu untuk melihat respons. Berikut ini menunjukkan seperti apa skema itu:

```
type Dog {
  breed: String
  color: String
}

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

Saat Anda menambahkan resolver untuk `addDog` mutasi, Anda dapat mengisi objek konteks seperti contoh berikut. Berikut ini memiliki argumen dari klien `name` dan`age`, dan `username` diisi dalam `identity` objek:

```
{
    "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"
    }
}
```

Anda dapat menguji ini menggunakan templat pemetaan permintaan dan respons berikut:

 **Templat Permintaan** 

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

 **Template Respon** 

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

Template yang dievaluasi memiliki data dari objek konteks pengujian Anda dan nilai yang dihasilkan dari`$util.autoId()`. Selain itu, jika Anda mengubah `username` ke nilai selain`Nadia`, hasilnya tidak akan dikembalikan karena pemeriksaan otorisasi akan gagal. Untuk informasi selengkapnya tentang kontrol akses berbutir halus, lihat Kasus [penggunaan otorisasi](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).

### Menguji template pemetaan dengan's AWS AppSync APIs
<a name="testing-with-appsync-api"></a>

Anda dapat menggunakan perintah `EvaluateMappingTemplate` API untuk menguji template pemetaan Anda dari jarak jauh dengan data tiruan. Untuk memulai dengan perintah, pastikan Anda telah menambahkan `appsync:evaluateMappingTemplate` izin ke kebijakan Anda. Contoh:

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "appsync:evaluateMappingTemplate",
            "Resource": "arn:aws:appsync:us-east-1:111122223333:*"
        }
    ]
}
```

------

Anda dapat memanfaatkan perintah dengan menggunakan [AWS CLI](https://aws.amazon.com/cli/)atau [AWS SDKs](https://aws.amazon.com/tools/). Misalnya, ambil `Dog` skema dan templat request/response pemetaannya dari bagian sebelumnya. Menggunakan CLI di stasiun lokal Anda, simpan template permintaan ke file bernama`request.vtl`, lalu simpan `context` objek ke file bernama. `context.json` Dari shell Anda, jalankan perintah berikut:

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

Perintah mengembalikan respon berikut:

```
{
  "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"
}
```

`evaluationResult`Berisi hasil pengujian template yang Anda berikan dengan yang disediakan`context`. Anda juga dapat menguji template Anda menggunakan AWS SDKs. Berikut adalah contoh menggunakan AWS SDK untuk JavaScript V2: 

```
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))
```

Menggunakan SDK, Anda dapat dengan mudah menggabungkan pengujian dari rangkaian pengujian favorit Anda untuk memvalidasi perilaku template Anda. Sebaiknya buat pengujian menggunakan [Jest Testing Framework](https://jestjs.io/), tetapi rangkaian pengujian apa pun berfungsi. Cuplikan berikut menunjukkan validasi hipotetis berjalan. Perhatikan bahwa kami mengharapkan respons evaluasi menjadi JSON yang valid, jadi kami gunakan `JSON.parse` untuk mengambil JSON dari respons string:

```
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)
})
```

 Ini menghasilkan hasil sebagai berikut:

```
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
```

## Mendebug kueri langsung
<a name="debugging-a-live-query"></a>

Tidak ada pengganti untuk end-to-end pengujian dan logging untuk men-debug aplikasi produksi. AWS AppSync memungkinkan Anda mencatat kesalahan dan detail permintaan lengkap menggunakan Amazon CloudWatch. Selain itu, Anda dapat menggunakan AWS AppSync konsol untuk menguji kueri GraphQL, mutasi, dan langganan serta data log streaming langsung untuk setiap permintaan kembali ke editor kueri untuk di-debug secara real time. Untuk langganan, log menampilkan informasi waktu koneksi.

Untuk melakukan ini, Anda harus mengaktifkan CloudWatch log Amazon terlebih dahulu, seperti yang dijelaskan dalam [Pemantauan dan pencatatan](monitoring.md#aws-appsync-monitoring). Selanjutnya, di AWS AppSync konsol, pilih tab **Queries dan kemudian masukkan kueri** GraphQL yang valid. Di bagian kanan bawah, klik dan seret jendela **Log** untuk membuka tampilan log. Di bagian atas halaman, pilih ikon panah putar untuk menjalankan kueri GraphQL Anda. Dalam beberapa saat, log permintaan dan respons lengkap Anda untuk operasi dialirkan ke bagian ini dan Anda dapat melihatnya di konsol.