How to use

RequestAPI

in

request

async get_redirect_url(redirect_url) {
  request.get(redirect_url, error => {
   if (error) {
    console.log('收款通知失败,请检查redirect_url是否正确!' + redirect_url);
   } else {
    console.log('收款成功，已通知服务器' + redirect_url);
   }
  });
 }

function hasOpenWebHook(port, reverse) {
 assert.ok(port);
 const error = new Error('open-webhook-check failed');
 let connected = false;
 return request.get(`http://127.0.0.1:${port}`)
  .then(() => {
   connected = true;
  }).catch(e => {
   if (e.statusCode < 500) connected = true;
  }).finally(() => {
   if (reverse) {
    if (connected) throw error;
    return;
   }
   if (!connected) throw error;
  });
}

async function gitHubLatestRelease() {
  return new Promise((resolve, reject) => {
    request.get({
      url: url,
      json: true,
      headers: { 'User-Agent': 'Joplin Readme Updater' },
    }, (error, response, data) => {
      if (error) {
        reject(error);
      } else if (response.statusCode !== 200) {
        console.warn(data);
        reject(new Error(`Error HTTP ${response.statusCode}`));
      } else {
        resolve(data);
      }
    });
  });
}

request.post(

async function gitHubContributors(page) {
  return new Promise((resolve, reject) => {
    request.get({
      url: `https://api.github.com/repos/laurent22/joplin/contributors${page ? `?page=${page}` : ''}`,
      json: true,
      headers: { 'User-Agent': 'Joplin Readme Updater' },
    }, (error, response, data) => {
      if (error) {
        reject(error);
      } else if (response.statusCode !== 200) {
        reject(new Error(`Error HTTP ${response.statusCode}`));
      } else {
        resolve(data);
      }
    });
  });
}

test('should send 405 for others http verbs', async t => {
 const url = await getUrl()
 try {
  await request.put(`${url}/`, { resolveWithFullResponse: true })
 } catch (e) {
  t.is(e.statusCode, 405)
 }
})

it('should throw an error if a PUT request comes in', async () => {
 const fn = jest.fn();
 try {
  await request.put(`${server.url}/test`);
  expect(err.message.indexOf('make a GET or a POST request')).toBeGreaterThan(-1);
  fn();
 } catch (err) {
  expect(err.statusCode).toBe(400);
 }
 expect(fn).not.toHaveBeenCalled();
});

test('should send an empty response in case of succes when storing log and should invoke broadcast.setState() once', async t => {
 const feed = utils.getMockedFeed()
 const broadcast = utils.getMockedBroadcast()
 const url = await getUrl(feed, broadcast)
 const payload = { event: 'hello' }
 const params = {
  resolveWithFullResponse: true,
  body: payload,
  json: true
 }
 const res = await request.post(`${url}/`, params)
 t.is(td.explain(broadcast.setState).callCount, 1)
 t.is(res.statusCode, 204)
 t.falsy(res.body)
})

test('should send 500 in case of failure when storing log', async t => {
 const feed = utils.getMockedFeedThatFailsOnAppend()
 const url = await getUrl(feed)
 const params = {
  resolveWithFullResponse: true,
  body: {
   event: 'hello'
  },
  json: true
 }
 try {
  await request.post(`${url}/`, params)
 } catch (e) {
  t.is(e.statusCode, 500)
 }
})

test('should send 403 when POSTING from a not allowed origin and origin is not specified in headers', async t => {
 const url = await getUrl(
  utils.getMockedFeed(),
  utils.getMockedBroadcast(),
  utils.getMockedSse(),
  utils.getMockedStatsDb(),
  'another origin'
 )
 try {
  await request.post(`${url}/`, { resolveWithFullResponse: true })
 } catch (e) {
  t.is(e.statusCode, 403)
 }
})

test('should send 400 in case of invalid JSON', async t => {
 const url = await getUrl()
 const params = {
  resolveWithFullResponse: true
 }
 try {
  await request.post(`${url}/`, params)
 } catch (e) {
  t.is(e.statusCode, 400)
 }
})

test('should send 404', async t => {
 const url = await getUrl()
 const params = {
  resolveWithFullResponse: true
 }
 try {
  await request.get(`${url}/doesnotexist`, params)
 } catch (e) {
  t.is(e.statusCode, 404)
 }
})

request.post(

request.post(

request.post(