chore(eslint): apply eslint rules to test directory

sanity-io · Sep 21, 2021 · c1a2e6d · c1a2e6d
1 parent ce7373c
commit c1a2e6d
Show file tree

Hide file tree

Showing 6 changed files with 91 additions and 91 deletions.
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -1,5 +1,5 @@
 module.exports = {
-  env: {node: true, browser: true},
+  env: {node: true, browser: true, jest: true},
   parserOptions: {
     ecmaVersion: 9,
     sourceType: 'module',

diff --git a/test/evaluate.test.ts b/test/evaluate.test.ts
@@ -2,185 +2,185 @@ import {evaluate, parse} from '../src'
 
 describe('Basic parsing', () => {
   test('Example query', async () => {
-    let dataset = [
+    const dataset = [
       {_type: 'product', name: 'T-shirt'},
       {_type: 'product', name: 'Pants'},
       {_type: 'user', name: 'Bob'},
     ]
-    let query = `*[_type == "product"]{name}`
-    let tree = parse(query)
+    const query = `*[_type == "product"]{name}`
+    const tree = parse(query)
 
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual([{name: 'T-shirt'}, {name: 'Pants'}])
   })
 
   test('String function', async () => {
-    let dataset = [
+    const dataset = [
       {_type: 'color', color: 'red', shade: 500, rgb: {r: 255, g: 0, b: 0}},
       {_type: 'color', color: 'green', shade: 500, rgb: {r: 0, g: 255, b: 0}},
     ]
-    let query = `*[_type == "color"]{ "class": color + "-" + string(shade + 100), "rgb": string(rgb) }`
-    let tree = parse(query)
+    const query = `*[_type == "color"]{ "class": color + "-" + string(shade + 100), "rgb": string(rgb) }`
+    const tree = parse(query)
 
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual([
       {class: 'red-600', rgb: null},
       {class: 'green-600', rgb: null},
     ])
   })
 
   test('In-range', async () => {
-    let dataset = [
+    const dataset = [
       {_id: 'a', val: 1},
       {_id: 'b', val: 5},
       {_id: 'c', val: 3},
     ]
-    let query = `*[val in 1..3]._id`
-    let tree = parse(query)
+    const query = `*[val in 1..3]._id`
+    const tree = parse(query)
 
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual(['a', 'c'])
   })
 
   test('select() function', async () => {
-    let dataset = [{_id: 'a', a: true}, {_id: 'b', b: true}, {_id: 'c'}]
-    let query = `*{"a":select(a => 1, b => 2, 3)}.a`
-    let tree = parse(query)
+    const dataset = [{_id: 'a', a: true}, {_id: 'b', b: true}, {_id: 'c'}]
+    const query = `*{"a":select(a => 1, b => 2, 3)}.a`
+    const tree = parse(query)
 
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual([1, 2, 3])
   })
 
   test('Controlling this', async () => {
-    let query = `@`
-    let tree = parse(query)
+    const query = `@`
+    const tree = parse(query)
 
-    for (let root of [1, [1, 2], {a: 'b'}]) {
-      let value = await evaluate(tree, {root})
-      let data = await value.get()
+    for (const root of [1, [1, 2], {a: 'b'}]) {
+      const value = await evaluate(tree, {root})
+      const data = await value.get()
       expect(data).toStrictEqual(root)
     }
   })
 
   test('Re-using stream', async () => {
-    let query = `[[1, 2], [1, 4]] | order(@[0], @[1] desc)`
-    let tree = parse(query)
-    let value = await evaluate(tree)
-    let data = await value.get()
+    const query = `[[1, 2], [1, 4]] | order(@[0], @[1] desc)`
+    const tree = parse(query)
+    const value = await evaluate(tree)
+    const data = await value.get()
     expect(data).toStrictEqual([
       [1, 4],
       [1, 2],
     ])
   })
 
   test('Async documents', async () => {
-    let dataset = (async function* () {
+    const dataset = (async function* () {
       yield {_id: 'a', name: 'Michael'}
       yield {_id: 'b', name: 'George Michael', father: {_ref: 'a'}}
     })()
 
-    let query = `*[father->name == "Michael"][0].name`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const query = `*[father->name == "Michael"][0].name`
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual('George Michael')
   })
 
   test('Parameters', async () => {
-    let query = `*[name == $name][].name`
-    let dataset = [{name: 'Michael'}, {name: 'George Michael'}]
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset, params: {name: 'Michael'}})
-    let data = await value.get()
+    const query = `*[name == $name][].name`
+    const dataset = [{name: 'Michael'}, {name: 'George Michael'}]
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset, params: {name: 'Michael'}})
+    const data = await value.get()
     expect(data).toStrictEqual(['Michael'])
   })
 
   test('Non-array documents', async () => {
-    let dataset = {data: [{person: {_ref: 'b'}}]}
+    const dataset = {data: [{person: {_ref: 'b'}}]}
 
-    let query = `(*).data[]{person->}`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const query = `(*).data[]{person->}`
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual([{person: null}])
   })
 
   test('Slices', async () => {
-    let dataset = ['a', 'b', 'c', 'd', 'e', 'f']
+    const dataset = ['a', 'b', 'c', 'd', 'e', 'f']
 
-    let query = `*[0...5][0..3]`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const query = `*[0...5][0..3]`
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual(['a', 'b', 'c', 'd'])
   })
 
   test('Conditional', async () => {
-    let dataset = [
+    const dataset = [
       {_type: 'book', title: 'A Game of Thrones'},
       {_type: 'tv-show', title: 'Game of Thrones'},
     ]
 
-    let query = `*[] {
+    const query = `*[] {
       _type,
       _type == "book" => {
         title
       }
     }`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual([{_type: 'book', title: 'A Game of Thrones'}, {_type: 'tv-show'}])
   })
 
   test('Paths', async () => {
-    let dataset = [
+    const dataset = [
       {_id: 'drafts.agot', _type: 'book', title: 'A Game of Thrones'},
       {_id: 'agot', _type: 'book', title: 'Game of Thrones'},
     ]
 
-    let query = `*[_id in path("drafts.**")]{_id}`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset})
-    let data = await value.get()
+    const query = `*[_id in path("drafts.**")]{_id}`
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset})
+    const data = await value.get()
     expect(data).toStrictEqual([{_id: 'drafts.agot'}])
   })
 
   test('Override identity()', async () => {
-    let dataset = [{_id: 'yes', user: 'me'}]
-    let query = `{"me":identity(), "nested": *[user == "me"][0]._id}`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset, identity: 'bob'})
-    let data = await value.get()
+    const dataset = [{_id: 'yes', user: 'me'}]
+    const query = `{"me":identity(), "nested": *[user == "me"][0]._id}`
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset, identity: 'bob'})
+    const data = await value.get()
     expect(data).toStrictEqual({me: 'bob', nested: 'yes'})
   })
 
   test('Override now()', async () => {
-    let dataset = [{_id: 'yes', time: '2021-05-06T12:14:15Z'}]
-    let query = `{"me":now(), "nested": *[dateTime(time) == dateTime(now())][0]._id}`
-    let tree = parse(query)
-    let value = await evaluate(tree, {dataset, timestamp: new Date('2021-05-06T12:14:15Z')})
-    let data = await value.get()
+    const dataset = [{_id: 'yes', time: '2021-05-06T12:14:15Z'}]
+    const query = `{"me":now(), "nested": *[dateTime(time) == dateTime(now())][0]._id}`
+    const tree = parse(query)
+    const value = await evaluate(tree, {dataset, timestamp: new Date('2021-05-06T12:14:15Z')})
+    const data = await value.get()
     expect(data).toStrictEqual({me: '2021-05-06T12:14:15.000Z', nested: 'yes'})
   })
 
   test('sanity-functions default', async () => {
-    let query = `sanity::dataset() + sanity::projectId()`
-    let tree = parse(query)
-    let value = await evaluate(tree)
-    let data = await value.get()
+    const query = `sanity::dataset() + sanity::projectId()`
+    const tree = parse(query)
+    const value = await evaluate(tree)
+    const data = await value.get()
     expect(data).toStrictEqual(null)
   })
 
   test('sanity-functions', async () => {
-    let query = `sanity::dataset() + sanity::projectId()`
-    let tree = parse(query)
-    let value = await evaluate(tree, {sanity: {dataset: 'abc', projectId: 'def'}})
-    let data = await value.get()
+    const query = `sanity::dataset() + sanity::projectId()`
+    const tree = parse(query)
+    const value = await evaluate(tree, {sanity: {dataset: 'abc', projectId: 'def'}})
+    const data = await value.get()
     expect(data).toStrictEqual('abcdef')
   })
 })
diff --git a/test/functions.test.ts b/test/functions.test.ts
@@ -15,7 +15,7 @@ describe('Functions', () => {
 
     test('returns the same value for each use in query', async () => {
       const dataset = [
-        {_type: 'product', deep: {deep: {deep: {deep: {deep: {deep: {text: 'value'}}}}}}}
+        {_type: 'product', deep: {deep: {deep: {deep: {deep: {deep: {text: 'value'}}}}}}},
       ]
       const query = `{
         "topTime": now(),

diff --git a/test/generate.js b/test/generate.js
@@ -17,18 +17,18 @@ const STACK = []
 let IDENT = ''
 
 function write(data) {
-  OUTPUT.write(IDENT + data + '\n')
+  OUTPUT.write(`${IDENT + data}\n`)
 }
 
 function openStack(expr) {
-  let [open, close] = expr.split(/BODY/)
+  const [open, close] = expr.split(/BODY/)
   write(open)
   STACK.push(close)
   IDENT += '  '
 }
 
 function closeStack() {
-  let close = STACK.pop()
+  const close = STACK.pop()
   IDENT = IDENT.substring(0, IDENT.length - 2)
   write(close)
 }
@@ -119,8 +119,8 @@ function download(id, url) {
   if (DOWNLOADING.has(id)) return
   DOWNLOADING.add(id)
 
-  let dir = `${__dirname}/datasets`
-  let filename = `${dir}/${id}.ndjson`
+  const dir = `${__dirname}/datasets`
+  const filename = `${dir}/${id}.ndjson`
 
   // File already exists
   if (fs.existsSync(filename)) return

diff --git a/test/generate.sh b/test/generate.sh
@@ -3,11 +3,11 @@ set -eo pipefail
 
 GROQTEST_SUITE_VERSION=${GROQTEST_SUITE_VERSION:-v0.1.33}
 
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
 RESULT="$DIR"/suite.taptest.js
 
-curl -sfL "https://github.com/sanity-io/groq-test-suite/releases/download/$GROQTEST_SUITE_VERSION/suite.ndjson" | \
-  node "$DIR"/generate.js > "$RESULT"
+curl -sfL "https://github.com/sanity-io/groq-test-suite/releases/download/$GROQTEST_SUITE_VERSION/suite.ndjson" |
+  node "$DIR"/generate.js >"$RESULT"
 
 $DIR/../node_modules/.bin/prettier --write "$RESULT"
 

diff --git a/test/parse.test.ts b/test/parse.test.ts
@@ -2,18 +2,18 @@ import {parse} from '../src'
 
 describe('Basic parsing', () => {
   test('Example query', () => {
-    let query = `*[_type == "product"]{name}`
-    let tree = parse(query)
+    const query = `*[_type == "product"]{name}`
+    const tree = parse(query)
     expect(tree).toMatchSnapshot()
   })
 })
 
 describe('Error reporting', () => {
   test('Query with syntax error', () => {
-    let query = `*[_type == "]`
+    const query = `*[_type == "]`
     try {
       parse(query)
-    } catch (error) {
+    } catch (error: any) {
       expect(error.name).toBe('GroqSyntaxError')
       expect(error.position).toBe(13)
       expect(error.message).toBe('Syntax error in GROQ query at position 13')