@sanity/client 2.24.3-pte.128 → 3.0.2

package/test/client.test.js

@@ -1,11 +1,3 @@
-/* eslint-disable strict, import/no-unassigned-import */
-// (Node 4 compat)
-
-'use strict'
-
-// eslint-disable-next-line import/no-unassigned-import
-require('hard-rejection/register')
-
 const test = require('tape')
 const nock = require('nock')
 const assign = require('xtend')
@@ -162,6 +154,56 @@ test('can use request() for API-relative requests (custom api version)', (t) =>
     .then(t.end)
 })
 
+test('observable requests are lazy', (t) => {
+  let didRequest = false
+  nock(projectHost())
+    .get('/v1/ping')
+    .reply(() => {
+      didRequest = true
+      return [200, {pong: true}]
+    })
+
+  const req = getClient().observable.request({uri: '/ping'})
+
+  setTimeout(() => {
+    t.false(didRequest)
+    req.subscribe({
+      next: (res) => {
+        t.true(didRequest)
+      },
+      error: t.ifError,
+      complete: t.end,
+    })
+  }, 1)
+})
+
+test('observable requests are cold', (t) => {
+  let requestCount = 0
+  nock(projectHost())
+    .get('/v1/ping')
+    .twice()
+    .reply(() => {
+      requestCount++
+      return [200, {pong: true}]
+    })
+
+  const req = getClient().observable.request({uri: '/ping'})
+
+  t.equal(requestCount, 0)
+  req.subscribe({
+    next: () => {
+      t.equal(requestCount, 1)
+      req.subscribe({
+        next: () => {
+          t.equal(requestCount, 2)
+        },
+        error: t.ifError,
+        complete: t.end,
+      })
+    },
+    error: t.ifError,
+  })
+})
 test('can use getUrl() to get API-relative paths', (t) => {
   t.equal(getClient().getUrl('/bar/baz'), `${projectHost()}/v1/bar/baz`)
   t.end()
@@ -1055,17 +1097,6 @@ test('patch() can take a query and params', (t) => {
   t.end()
 })
 
-test('merge() patch can be applied multiple times', (t) => {
-  const patch = getClient()
-    .patch('abc123')
-    .merge({count: 1, foo: 'bar'})
-    .merge({count: 2, bar: 'foo'})
-    .serialize()
-
-  t.deepEqual(patch, {id: 'abc123', merge: {count: 2, foo: 'bar', bar: 'foo'}})
-  t.end()
-})
-
 test('setIfMissing() patch can be applied multiple times', (t) => {
   const patch = getClient()
     .patch('abc123')
@@ -1208,7 +1239,6 @@ test('can apply diffMatchPatch()', (t) => {
 
 test('all patch methods throw on non-objects being passed as argument', (t) => {
   const patch = getClient().patch('abc123')
-  t.throws(() => patch.merge([]), /merge\(\) takes an object of properties/, 'merge throws')
   t.throws(() => patch.set(null), /set\(\) takes an object of properties/, 'set throws')
   t.throws(
     () => patch.setIfMissing('foo'),
@@ -1774,6 +1804,76 @@ test('listeners connect to listen endpoint with prefixed request tag, emits even
     })
 })
 
+test('listeners requests are lazy', (t) => {
+  const response = [
+    ':',
+    '',
+    'event: welcome',
+    'data: {"listenerName":"LGFXwOqrf1GHawAjZRnhd6"}',
+    '',
+    'event: mutation',
+    `data: ${JSON.stringify({})}`,
+  ].join('\n')
+
+  let didRequest = false
+  nock(projectHost())
+    .get('/v1/data/listen/foo?query=foo.bar&includeResult=true')
+    .reply(() => {
+      didRequest = true
+      return [200, response]
+    })
+  const req = getClient().listen('foo.bar', {}, {events: ['welcome']})
+  setTimeout(() => {
+    t.false(didRequest)
+    const sub = req.subscribe({
+      next: (r) => {
+        t.true(didRequest)
+        sub.unsubscribe()
+        t.end()
+      },
+    })
+  }, 10)
+})
+
+test('listener requests are cold', (t) => {
+  const response = [
+    ':',
+    '',
+    'event: welcome',
+    'data: {"listenerName":"LGFXwOqrf1GHawAjZRnhd6"}',
+    '',
+    ':',
+  ].join('\n')
+
+  let requestCount = 0
+  nock(projectHost())
+    .get('/v1/data/listen/foo?query=foo.bar&includeResult=true')
+    .twice()
+    .reply(() => {
+      requestCount++
+      return [200, response]
+    })
+
+  const req = getClient().listen('foo.bar', {}, {events: ['welcome']})
+
+  t.equal(requestCount, 0)
+  const firstSub = req.subscribe({
+    next: (r) => {
+      t.equal(requestCount, 1)
+      firstSub.unsubscribe()
+      const secondSub = req.subscribe({
+        next: () => {
+          t.equal(requestCount, 2)
+          secondSub.unsubscribe()
+          t.end()
+        },
+        error: t.ifError,
+      })
+    },
+    error: t.ifError,
+  })
+})
+
 /*****************
  * ASSETS        *
  *****************/
@@ -1883,7 +1983,6 @@ test('uploads images with progress events', (t) => {
     .post('/v1/assets/images/foo', isImage)
     .reply(201, {url: 'https://some.asset.url'})
 
-  // @todo write a test that asserts upload events (slowness)
   getClient()
     .observable.assets.upload('image', fs.createReadStream(fixturePath))
     .pipe(filter((event) => event.type === 'progress'))
@@ -2114,7 +2213,7 @@ test('will use live API for mutations', (t) => {
   client.create({_type: 'foo', title: 'yep'}).then(noop).catch(t.ifError).then(t.end)
 })
 
-test('will use live API if token is specified', (t) => {
+test('will use cdn for queries even when with token specified', (t) => {
   const client = sanityClient({
     projectId: 'abc123',
     dataset: 'foo',
@@ -2123,7 +2222,7 @@ test('will use live API if token is specified', (t) => {
   })
 
   const reqheaders = {Authorization: 'Bearer foo'}
-  nock('https://abc123.api.sanity.io', {reqheaders})
+  nock('https://abc123.apicdn.sanity.io', {reqheaders})
     .get('/v1/data/query/foo?query=*')
     .reply(200, {result: []})
 
@@ -2277,48 +2376,3 @@ test('handles HTTP errors gracefully', (t) => {
       t.end()
     })
 })
-
-// @todo these tests are failing because `nock` doesn't work well with `timed-out`
-test.skip('handles connection timeouts gracefully', (t) => {
-  const doc = {_id: 'barfoo', visits: 5}
-  const expectedBody = {mutations: [{create: doc}]}
-  nock(projectHost())
-    .post('/v1/data/mutate/foo?returnIds=true&returnDocuments=true&visibility=sync', expectedBody)
-    .socketDelay(75)
-    .delay({head: 500, body: 750})
-    .reply(200, {transactionId: 'abc123', documents: []})
-
-  getClient({timeout: 150})
-    .create(doc)
-    .then(() => {
-      t.fail('Should not call success handler on timeouts')
-      t.end()
-    })
-    .catch((err) => {
-      t.ok(err instanceof Error, 'should error')
-      t.equal(err.code, 'ETIMEDOUT', `should have timeout error code, got err\n${err.toString()}`)
-      t.end()
-    })
-})
-
-// @todo these tests are failing because `nock` doesn't work well with `timed-out`
-test.skip('handles socket timeouts gracefully', (t) => {
-  const doc = {_id: 'barfoo', visits: 5}
-  const expectedBody = {mutations: [{create: doc}]}
-  nock(projectHost())
-    .post('/v1/data/mutate/foo?returnIds=true&returnDocuments=true&visibility=sync', expectedBody)
-    .socketDelay(1000)
-    .reply(200)
-
-  getClient({timeout: 150})
-    .create(doc)
-    .then(() => {
-      t.fail('Should not call success handler on timeouts')
-      t.end()
-    })
-    .catch((err) => {
-      t.ok(err instanceof Error, 'should error')
-      t.equal(err.code, 'ESOCKETTIMEDOUT', 'should have timeout error code')
-      t.end()
-    })
-})