+
## Table of Contents
@@ -189,7 +192,7 @@ This book will teach you how to build, test, and operate a GraphQL application u
+_Figure 6.3: VTL renderer result verification process_
+
+Ant needs to test both his request and response mapping templates.
+
+### Testing request mapping templates
+
+Ant starts with the request mapping template. He creates a new file in his `test` folder, and names it `get-survey-by-id-request.vtl.test.ts`.
+
+He opens the new test file in VS Code, and imports the VTL simulator from `helpers` folder.
+
+```typescript
+import { VTLSimulator } from './helpers/vtl-simulator';
+```
+
+Ant imports the `join` function from the `path` module. He uses the `join` function to create an absolute path to the VTL template file he wants to test and uses that path to create the instance of the VTL simulator class.
+
+```typescript
+import { join } from 'path'
+const templatePath = join(__dirname, '..', 'vtl', 'get-survey-by-id-request.vtl')
+const velocity = new VTLSimulator(templatePath)
+```
+
+He creates an empty `describe` block for his tests and names it `get-survey-by-id-request.vtl`. This name is not creative, but it's descriptive, so he likes it.
+
+```typescript
+describe('get-survey-by-id-request.vtl', () => {
+ // TODO: Write unit tests
+}
+```
+
+Ant is finally ready to write his first unit tests.
+
+"Where should I start?" he wonders. "My request template is simple. I can test what happens when I pass a correct ID and an incorrect ID. My GraphQL schema will make sure that I always have the ID and that it is a string, so I do not need to test if the ID exists or not. I'll start with a test that should return the survey with the ID I provided."
+
+He creates a first test inside the `describe` block and names it "should return the survey with the provided ID."
+
+At the beginning of the test, he creates a context object with the following arguments: `{ "id": "First" }`. Then he passes the test context to the `velocity.render` method to render a template and stores the result in the `rendered` variable.
+
+Finally, he checks the `rendered.errors` and `rendered.results` values. The `errors` array should be empty, and the result should have a `payload` that represents the survey with the ID "First," and a version equal to `"2018-05-29"`.
+
+```typescript
+ test('should return the survey with the provided ID', () => {
+ const ctxValues = { arguments: { id: 'first' } }
+ const rendered = velocity.render(ctxValues)
+ expect(rendered.errors).toEqual([])
+ expect(rendered.result).toEqual({
+ payload: {
+ id: 'first',
+ question: 'What is the meaning of life?',
+ },
+ version: '2018-05-29',
+ })
+ })
+```
+
+"That wasn't hard. I hope it works! But let's write the other one before running them."
+
+He creates another test in the `describe` block and names it "should not return payload when survey is not found."
+
+The second test is similar to the first one. Ant creates a test context, with a crucial difference -- the ID is `"x"`, and then uses the `velocity.render` method to render the template. Then he checks that there are no errors and that the result has a version without a payload.
+
+"Maybe I should throw an error when the survey with an ID is not provided. That would improve both my code and my tests. However, this is just a test resolver, so I'll make sure to throw a meaningful error when I connect the resolver to a database."
+
+```typescript
+ test('should not return payload when survey is not found', () => {
+ const ctxValues = { arguments: { id: 'x' } }
+ const rendered = velocity.render(ctxValues)
+ expect(rendered.errors).toEqual([])
+ expect(rendered.result).toEqual({
+ version: '2018-05-29',
+ })
+ })
+```
+
+Ant opens his terminal and navigates the project folder. Then he runs the `npm test` command to run his tests. Jest is running. One second. Two. Three. Five. Eight. Suspension is killing him. And finally, after almost 13 seconds, he sees the green `PASS` on his screen. Both tests passed with the following feedback in his terminal:
+
+```bash
+ PASS test/get-survey-by-id-request.vtl.test.ts (12.433 s)
+
+Test Suites: 1 passed, 1 total
+Tests: 2 passed, 2 total
+Snapshots: 0 total
+Time: 13.383 s
+Ran all test suites.
+```
+
+"Woohoo! It works."
+
+### Testing response mapping templates
+
+"Let's do it again," Ant thinks while he creates another file in his `test` folder and names it `get-survey-by-id-response.vtl.test.ts`. "I can test the error first for the response template."
+
+He opens the new file in his VS Code and imports his VTL simulator and response VTL template at the top, creating an instance of the VTL simulator class.
+
+```typescript
+import { join } from 'path'
+import { VTLSimulator } from './helpers/vtl-simulator'
+const templatePath = join(__dirname, '..', 'vtl', 'get-survey-by-id-response.vtl')
+const velocity = new VTLSimulator(templatePath)
+```
+
+Then he creates a new `describe` block with the name "get-survey-by-id-response.vtl." Ant writes the first test "should return an error if survey is not found." Then he creates an empty context object and renders a template with it. Ant expects that the `errors` array contains the "Survey not found" error. The `result` should be an empty object.
+
+He creates another test: "should return the survey with the provided ID." In this test, he checks that the errors array is empty and that the result is equal to the result he passes in the arguments: `{ something: true }`.
+
+```typescript
+describe('get-survey-by-id-response.vtl', () => {
+ test('should return an error if survey is not found', () => {
+ const ctxValues = {}
+ const rendered = velocity.render(ctxValues)
+ expect(rendered.errors).toEqual([
+ new Error('Survey not found.'),
+ ])
+ expect(rendered.result).toEqual({})
+ })
+
+ test('should return the survey with the provided ID', () => {
+ const ctxValues = { result: { something: true } }
+ const rendered = velocity.render(ctxValues)
+ expect(rendered.errors).toEqual([])
+ expect(rendered.result).toEqual({
+ something: true
+ })
+ })
+})
+```
+
+Ant opens his terminal, runs the `npm test` command again, and sees two green "PASS" statuses 10 seconds later:
+
+```bash
+ PASS test/get-survey-by-id-request.vtl.test.ts
+ PASS test/get-survey-by-id-response.vtl.test.ts (9.427 s)
+
+Test Suites: 2 passed, 2 total
+Tests: 4 passed, 4 total
+Snapshots: 0 total
+Time: 9.924 s, estimated 13 s
+Ran all test suites.
+```
+
+A few minutes later, Ant sends a message to Claudia to brag about his new testing skills.
+
+"Bravo! But don't pop the champagne bottle yet," Claudia says with a smiley, "let's write some end-to-end tests first."
+
+
+> ### Integrating tests with build pipelines
+>
+> In this chapter, Ant will learn how to test an AppSync application. He'll integrate automated tests with their build pipelines to complete the test automation in the Working with deployment pipelines chapter.
+
+------
+
+
+
+
+¹ Test Pyramid, or Test Automation Pyramid, was introduced by Mike Cohn in his book Succeeding with Agile
\ No newline at end of file
This is an excerpt from Chapter 6 of Running Serverless: Realtime GraphQL applications with AppSync, a book by Gojko Adzic, Aleksandar Simović, and Slobodan Stojanović.
+ +Here's a short survey that will help us to polish the story. It'll take two minutes or less to fill it out. Thanks!
+