test('brokenProofs', (t) => {
   FetchMock.get(`${naval.facebook.url}b`, naval.facebook.body)
   FetchMock.get(`${naval.github.url}b/raw`, naval.github.body)
   FetchMock.get(`${naval.twitter.url}b`, { body: '', status: 400 })
   t.plan(2)
   validateProofs({ account: navalAccounts }, undefined, 'naval.id')
     .then((proofs) => {
       t.equal(proofs.length, 3)
       t.equal(proofs.filter(x => x.valid).length, 2)
       FetchMock.restore()
     })
 })

        it('should folow multiple redirects', () => {
            fetchMock.get('/some/url', { status: 202, headers: { Location: '/other/url' } });
            fetchMock.get('/other/url', { status: 202, headers: { Location: '/last/url' } });
            fetchMock.get('/last/url', { status: 200, body: 'Poll result with redirects' });

            return createXhr().ajax('/some/url', { pollDelay: 0 }).then((r) => {
                expect(r.response.status).toBe(200);
                expect(fetchMock.calls('/some/url').length).toBe(1);
                expect(fetchMock.calls('/other/url').length).toBe(1);
                expect(fetchMock.calls('/last/url').length).toBe(1);
                expect(r.getData()).toBe('Poll result with redirects');
            });
        });

test('Succeeding project creation with remote schema file', async t => {
  const name = 'MyProject'
  const schemaUrl = 'https://graphqlbin/project.graphql'

  // configure HTTP mocks
  fetchMock.post(systemAPIEndpoint, JSON.parse(mockedCreateProjectResponse))

  const schema = simpleTwitterSchema
  fetchMock.get(schemaUrl, schema)

  // create dummy project data
  const props = {name, schemaUrl}

  // prepare environment
  const env = testEnvironment({})
  env.resolver.write(graphcoolConfigFilePath, '{"token": "abcdefgh"}')

  env.out.prefix((t as any)._test.title, `$ graphcool init -s ${schemaUrl} -n ${name}`)

  await t.notThrows(
    initCommand(props, env)
  )

  const expectedProjectFileContent = mockProjectFile1
  t.is(env.resolver.read(graphcoolProjectFileName), expectedProjectFileContent)
  t.is(readProjectIdFromProjectFile(env.resolver, graphcoolProjectFileName), 'abcdefghijklmn')
  t.is(readVersionFromProjectFile(env.resolver, graphcoolProjectFileName), '1')
})

 it('should use supplied Content-Type', async () => {
   fetchMock.get('*', {});
   await kfetch({ pathname: 'my/path', headers: { 'Content-Type': 'CustomContentType' } });
   expect(fetchMock.lastOptions('*').headers).toMatchObject({
     'Content-Type': 'CustomContentType',
   });
 });

test('Succeeding auth without token', async t => {

  // configure HTTP mocks
  fetchMock.post(`${authEndpoint}/create`, {})
  fetchMock.get(`${authEndpoint}/*`, {
    authToken: testToken
  })
  fetchMock.post(`${systemAPIEndpoint}`, {
    data: {
      viewer: {
        user: {
          id: 'abcdefghik'
        }
      }
    }
  })

  // configure auth dependencies
  const env = testEnvironment({})
  const authServer = new TestAuthServer()

  env.out.prefix((t as any)._test.title, '$ graphcool auth')

  // authenticate
  await t.notThrows(
    authCommand({}, env, authServer)
  )

  // verify result
  const {token} = JSON.parse(env.resolver.read(graphcoolConfigFilePath))
  t.is(token, testToken)
})

 it('gets orderbook with default page options when none are provided', async () => {
     const urlWithQuery = `${url}?baseTokenAddress=${
         request.baseTokenAddress
     }&page=1&per_page=100&quoteTokenAddress=${request.quoteTokenAddress}`;
     fetchMock.get(urlWithQuery, orderbookJSON);
     const orderbook = await relayerClient.getOrderbookAsync(request);
     expect(orderbook).to.be.deep.equal(orderbookResponse);
 });

 beforeEach(async () => {
   fetchMock.get('*', { status: 404, body: { foo: 'bar' } });
   try {
     await kfetch({ pathname: 'my/path' });
   } catch (e) {
     error = e;
   }
 });