lukechilds
/
got
mirror of https://github.com/lukechilds/got.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #118 from sindresorhus/async-tests 

Rewrite tests with async/await
http2
Vsevolod Strukchinsky 9 years ago
parent
0737217650 f7500d474e
commit
a87000edc9
12 changed files with 215 additions and 346 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 46
      test/arguments.js
  2. 37
      test/error.js
  3. 27
      test/gzip.js
  4. 47
      test/headers.js
  5. 30
      test/helpers.js
  6. 69
      test/http.js
  7. 27
      test/https.js
  8. 53
      test/json.js
  9. 118
      test/post.js
  10. 56
      test/redirects.js
  11. 18
      test/retry.js
  12. 19
      test/unix-socket.js

46
test/arguments.js
View File

@ -21,42 +21,30 @@ test.before('arguments - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('arguments - url argument is required', t => { test('arguments - url argument is required', async t => {
t.plan(2); try {
t.throws(() => { await got();
got(undefined, () => {}); t.fail('Exception is not thrown');
}, /Parameter `url` must be a string or object, not undefined/); } catch (err) {
got().catch(err => {
t.regexTest(/Parameter `url` must be a string or object, not undefined/, err.message); t.regexTest(/Parameter `url` must be a string or object, not undefined/, err.message);
}); }
}); });
test('arguments - accepts url.parse object as first argument', t => { test('arguments - accepts url.parse object as first argument', async t => {
got({ t.is((await got({hostname: s.host, port: s.port, path: '/test'})).body, '/test');
hostname: s.host,
port: s.port,
path: '/test'
}, (err, data) => {
t.ifError(err);
t.is(data, '/test');
t.end();
});
}); });
test('arguments - overrides querystring from opts', t => { test('arguments - overrides querystring from opts', async t => {
got(`${s.url}/?test=doge`, {query: {test: 'wow'}}, (err, data) => { t.is((await got(`${s.url}/?test=doge`, {query: {test: 'wow'}})).body, '/?test=wow');
t.ifError(err);
t.is(data, '/?test=wow');
t.end();
});
}); });
test('arguments - should throw with auth in url', t => { test('arguments - should throw with auth in url', async t => {
t.throws(() => { try {
got(`https://test:45d3ps453@account.myservice.com/api/token`, () => {}); await got(`https://test:45d3ps453@account.myservice.com/api/token`);
}, /Basic authentication must be done with auth option/); t.fail('Exception is not thrown');
t.end(); } catch (err) {
t.regexTest(/Basic authentication must be done with auth option/, err.message);
}
}); });
test.after('arguments - cleanup', t => { test.after('arguments - cleanup', t => {

37
test/error.js
View File

@ -13,35 +13,44 @@ test.before('error - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('error - error message', t => { test('error - error message', async t => {
got(s.url, err => { try {
await got(s.url);
t.fail('Exception was not thrown');
} catch (err) {
t.ok(err); t.ok(err);
t.is(err.message, 'Response code 404 (Not Found)'); t.is(err.message, 'Response code 404 (Not Found)');
t.is(err.host, `${s.host}:${s.port}`); t.is(err.host, `${s.host}:${s.port}`);
t.is(err.method, 'GET'); t.is(err.method, 'GET');
t.end(); }
});
}); });
test('error - dns error message', t => { test('error - dns error message', async t => {
got('.com', {retries: 0}, err => { try {
await got('.com', {retries: 0});
t.fail('Exception was not thrown');
} catch (err) {
t.ok(err); t.ok(err);
t.regexTest(/getaddrinfo ENOTFOUND/, err.message); t.regexTest(/getaddrinfo ENOTFOUND/, err.message);
t.is(err.host, '.com'); t.is(err.host, '.com');
t.is(err.method, 'GET'); t.is(err.method, 'GET');
t.end(); }
});
}); });
test('error - options.body error message', t => { test('error - options.body error message', async t => {
t.plan(2); try {
t.throws(() => {
got(s.url, {body: () => {}}, () => {}); got(s.url, {body: () => {}}, () => {});
}, /options.body must be a ReadableStream, string, Buffer or plain Object/); t.fail('Exception was not thrown');
} catch (err) {
t.regexTest(/options.body must be a ReadableStream, string, Buffer or plain Object/, err.message);
}
got(s.url, {body: () => {}}).catch(err => { try {
await got(s.url, {body: () => {}});
t.fail('Exception was not thrown');
} catch (err) {
t.regexTest(/options.body must be a ReadableStream, string, Buffer or plain Object/, err.message); t.regexTest(/options.body must be a ReadableStream, string, Buffer or plain Object/, err.message);
}); }
}); });
test.after('error - cleanup', t => { test.after('error - cleanup', t => {

27
test/gzip.js
View File

@ -24,30 +24,23 @@ test.before('gzip - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('gzip - ungzip content', t => { test('gzip - ungzip content', async t => {
got(s.url, (err, data) => { t.is((await got(s.url)).body, testContent);
t.ifError(err);
t.is(data, testContent);
t.end();
});
}); });
test('gzip - ungzip error', t => { test('gzip - ungzip error', async t => {
got(`${s.url}/corrupted`, err => { try {
t.ok(err); await got(`${s.url}/corrupted`);
t.fail('Exception was not thrown');
} catch (err) {
t.is(err.message, 'incorrect header check'); t.is(err.message, 'incorrect header check');
t.is(err.path, '/corrupted'); t.is(err.path, '/corrupted');
t.is(err.name, 'ReadError'); t.is(err.name, 'ReadError');
t.end(); }
});
}); });
test('gzip - preserve headers property', t => { test('gzip - preserve headers property', async t => {
got(s.url, (err, data, res) => { t.ok((await got(s.url)).headers);
t.ifError(err);
t.ok(res.headers);
t.end();
});
}); });
test.after('gzip - cleanup', t => { test.after('gzip - cleanup', t => {

47
test/headers.js
View File

@ -12,56 +12,29 @@ test.before('headers - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('headers - send user-agent header by default', t => { test('headers - send user-agent header by default', async t => {
got(s.url, (err, data) => { const headers = (await got(s.url, {json: true})).body;
t.ifError(err);
const headers = JSON.parse(data);
t.is(headers['user-agent'], 'https://github.com/sindresorhus/got'); t.is(headers['user-agent'], 'https://github.com/sindresorhus/got');
t.end();
});
}); });
test('headers - send accept-encoding header by default', t => { test('headers - send accept-encoding header by default', async t => {
got(s.url, (err, data) => { const headers = (await got(s.url, {json: true})).body;
t.ifError(err);
const headers = JSON.parse(data);
t.is(headers['accept-encoding'], 'gzip,deflate'); t.is(headers['accept-encoding'], 'gzip,deflate');
t.end();
});
}); });
test('headers - send accept header with json option', t => { test('headers - send accept header with json option', async t => {
got(s.url, {json: true}, (err, headers) => { const headers = (await got(s.url, {json: true})).body;
t.ifError(err);
t.is(headers.accept, 'application/json'); t.is(headers.accept, 'application/json');
t.end();
});
}); });
test('headers - send host header by default', t => { test('headers - send host header by default', async t => {
got(s.url, (err, data) => { const headers = (await got(s.url, {json: true})).body;
t.ifError(err);
const headers = JSON.parse(data);
t.is(headers.host, `localhost:${s.port}`); t.is(headers.host, `localhost:${s.port}`);
t.end();
});
}); });
test('headers - transform headers names to lowercase', t => { test('headers - transform headers names to lowercase', async t => {
got(s.url, {headers: {'USER-AGENT': 'test'}}, (err, data) => { const headers = (await got(s.url, {headers: {'USER-AGENT': 'test'}, json: true})).body;
t.ifError(err);
const headers = JSON.parse(data);
t.is(headers['user-agent'], 'test'); t.is(headers['user-agent'], 'test');
t.end();
});
}); });
test.after('headers - cleanup', t => { test.after('headers - cleanup', t => {

30
test/helpers.js
View File

@ -17,28 +17,26 @@ test.before('helpers - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('helpers - callback mode', t => { test('helpers - callback mode', async t => {
got.get(s.url, (err, data) => { t.is((await got.get(s.url)).body, 'ok');
t.ifError(err);
t.is(data, 'ok');
t.end();
});
}); });
test('helpers - promise mode', t => { test('helpers - promise mode', async t => {
t.plan(3); t.is((await got.get(s.url)).body, 'ok');
got.get(s.url).then(res => {
t.is(res.body, 'ok');
});
got.get(`${s.url}/404`).catch(err => { try {
await got.get(`${s.url}/404`);
t.fail('Exception is not thrown');
} catch (err) {
t.is(err.response.body, 'not found'); t.is(err.response.body, 'not found');
}); }
got.get('.com', {retries: 0}).catch(err => { try {
await got.get('.com', {retries: 0});
t.fail('Exception is not thrown');
} catch (err) {
t.ok(err); t.ok(err);
}); }
}); });
test.after('helpers - cleanup', t => { test.after('helpers - cleanup', t => {

69
test/http.js
View File

@ -27,66 +27,45 @@ test.before('http - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('http - callback mode', t => { test('http - simple request', async t => {
got(s.url, (err, data) => { t.is((await got(s.url)).body, 'ok');
t.ifError(err);
t.is(data, 'ok');
t.end();
});
}); });
test('http - protocol-less URLs', t => { test('http - protocol-less URLs', async t => {
got(s.url.replace(/^http:\/\//, ''), (err, data) => { t.is((await got(s.url.replace(/^http:\/\//, ''))).body, 'ok');
t.ifError(err);
t.is(data, 'ok');
t.end();
});
}); });
test('http - empty response', t => { test('http - empty response', async t => {
got(`${s.url}/empty`, (err, data) => { t.is((await got(`${s.url}/empty`)).body, '');
t.ifError(err);
t.is(data, '');
t.end();
});
}); });
test('http - error with code', t => { test('http - error with code', async t => {
got(`${s.url}/404`, (err, data) => { try {
t.ok(err); await got(`${s.url}/404`);
t.fail('Exception was not thrown');
} catch (err) {
t.is(err.statusCode, 404); t.is(err.statusCode, 404);
t.is(data, 'not'); t.is(err.response.body, 'not');
t.end(); }
});
}); });
test('http - buffer on encoding === null', t => { test('http - buffer on encoding === null', async t => {
got(s.url, {encoding: null}, (err, data) => { const data = (await got(s.url, {encoding: null})).body;
t.ifError(err);
t.ok(Buffer.isBuffer(data)); t.ok(Buffer.isBuffer(data));
t.end();
});
}); });
test('http - timeout option', t => { test('http - timeout option', async t => {
got(`${s.url}/404`, {timeout: 1, retries: 0}, err => { try {
await got(`${s.url}/404`, {timeout: 1, retries: 0});
t.fail('Exception was not thrown');
} catch (err) {
t.is(err.code, 'ETIMEDOUT'); t.is(err.code, 'ETIMEDOUT');
t.end(); }
});
}); });
test('http - query option', t => { test('http - query option', async t => {
t.plan(4); t.is((await got(s.url, {query: {recent: true}})).body, 'recent');
t.is((await got(s.url, {query: 'recent=true'})).body, 'recent');
got(s.url, {query: {recent: true}}, (err, data) => {
t.ifError(err);
t.is(data, 'recent');
});
got(s.url, {query: 'recent=true'}, (err, data) => {
t.ifError(err);
t.is(data, 'recent');
});
}); });
test.after('http - cleanup', t => { test.after('http - cleanup', t => {

27
test/https.js
View File

@ -47,34 +47,21 @@ test.before('https - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('https - redirects from http to https works', t => { test('https - redirects from http to https works', async t => {
got('http://github.com', (err, data) => { t.ok((await got('http://github.com')).body);
t.ifError(err);
t.ok(data);
t.end();
});
}); });
test('https - make request to https server', t => { test('https - make request to https server', async t => {
got('https://google.com', { t.ok((await got('https://google.com', {strictSSL: true})).body);
strictSSL: true
}, (err, data) => {
t.ifError(err);
t.ok(data);
t.end();
});
}); });
test('https - make request to https server with ca', t => { test('https - make request to https server with ca', async t => {
got(s.url, { const {body} = await got(s.url, {
strictSSL: true, strictSSL: true,
ca: caRootCert, ca: caRootCert,
headers: {host: 'sindresorhus.com'} headers: {host: 'sindresorhus.com'}
}, (err, data) => {
t.ifError(err);
t.is(data, 'ok');
t.end();
}); });
t.is(body, 'ok');
}); });
test.after('https - cleanup', t => { test.after('https - cleanup', t => {

53
test/json.js
View File

@ -31,47 +31,44 @@ test.before('json - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('json - json option should parse response', t => { test('json - json option should parse response', async t => {
got(s.url, {json: true}, (err, json) => { t.same((await got(s.url, {json: true})).body, {data: 'dog'});
t.ifError(err);
t.same(json, {data: 'dog'});
t.end();
});
}); });
test('json - json option should not parse responses without a body', t => { test('json - json option should not parse responses without a body', async t => {
got(`${s.url}/204`, {json: true}, err => { const {body} = await got(`${s.url}/204`, {json: true});
t.ifError(err); t.is(body, '');
t.end();
});
}); });
test('json - json option wrap parsing errors', t => { test('json - json option wrap parsing errors', async t => {
got(`${s.url}/invalid`, {json: true}, err => { try {
t.ok(err); await got(`${s.url}/invalid`, {json: true});
t.fail('Exception was not thrown');
} catch (err) {
t.regexTest(/Unexpected token/, err.message); t.regexTest(/Unexpected token/, err.message);
t.ok(err.message.indexOf(err.hostname) !== -1, err.message); t.ok(err.message.indexOf(err.hostname) !== -1, err.message);
t.is(err.path, '/invalid'); t.is(err.path, '/invalid');
t.end(); }
});
}); });
test('json - json option should parse non-200 responses', t => { test('json - json option should parse non-200 responses', async t => {
got(`${s.url}/non200`, {json: true}, (err, json) => { try {
t.ok(err); await got(`${s.url}/non200`, {json: true});
t.same(json, {data: 'dog'}); t.fail('Exception was not thrown');
t.end(); } catch (err) {
}); t.same(err.response.body, {data: 'dog'});
}
}); });
test('json - json option should catch errors on invalid non-200 responses', t => { test('json - json option should catch errors on invalid non-200 responses', async t => {
got(`${s.url}/non200-invalid`, {json: true}, (err, json) => { try {
t.ok(err); await got(`${s.url}/non200-invalid`, {json: true});
t.fail('Exception was not thrown');
} catch (err) {
t.regexTest(/Unexpected token/, err.message); t.regexTest(/Unexpected token/, err.message);
t.is(json, 'Internal error'); t.is(err.response.body, 'Internal error');
t.is(err.path, '/non200-invalid'); t.is(err.path, '/non200-invalid');
t.end(); }
});
}); });
test.after('json - cleanup', t => { test.after('json - cleanup', t => {

118
test/post.js
View File

@ -1,3 +1,5 @@
/**/
import test from 'ava'; import test from 'ava';
import intoStream from 'into-stream'; import intoStream from 'into-stream';
import got from '../'; import got from '../';
@ -22,106 +24,80 @@ test.before('post - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('post - GET can have body', t => { test('post - GET can have body', async t => {
t.plan(3); const {body, headers} = await got.get(s.url, {body: 'hi'});
t.is(body, 'hi');
got.get(s.url, {body: 'hi'}, (err, data, res) => { t.is(headers.method, 'GET');
t.ifError(err);
t.is(data, 'hi');
t.is(res.headers.method, 'GET');
});
}); });
test('post - send data from options with post request', t => { test('post - send data from options with post request', async t => {
t.plan(6); const {body} = await got(s.url, {body: 'wow'});
t.is(body, 'wow');
got(s.url, {body: 'wow'}, (err, data) => { });
t.ifError(err);
t.is(data, 'wow');
});
got(s.url, {body: new Buffer('wow')}, (err, data) => {
t.ifError(err);
t.is(data, 'wow');
});
got(s.url, {body: intoStream(['wow'])}, (err, data) => { test('post - send data from options with post request', async t => {
t.ifError(err); const {body} = await got(s.url, {body: new Buffer('wow')});
t.is(data, 'wow'); t.is(body, 'wow');
});
}); });
test('post - works with empty post response', t => { test('post - send data from options with post request', async t => {
got(`${s.url}/empty`, {body: 'wow'}, (err, data) => { const {body} = await got(s.url, {body: intoStream(['wow'])});
t.ifError(err); t.is(body, 'wow');
t.is(data, '');
t.end();
});
}); });
test('post - post have content-length header to string', t => { test('post - works with empty post response', async t => {
t.plan(10); const {body} = await got(`${s.url}/empty`, {body: 'wow'});
t.is(body, '');
});
got(`${s.url}/headers`, { test('post - post have content-length header to string', async t => {
body: 'wow', const {body} = await got(`${s.url}/headers`, {body: 'wow', json: true});
json: true t.is(body['content-length'], '3');
}, (err, headers) => { });
t.ifError(err);
t.is(headers['content-length'], '3');
});
got(`${s.url}/headers`, { test('post - post have content-length header to string', async t => {
body: new Buffer('wow'), const {body} = await got(`${s.url}/headers`, {body: new Buffer('wow'), json: true});
json: true t.is(body['content-length'], '3');
}, (err, headers) => { });
t.ifError(err);
t.is(headers['content-length'], '3');
});
got(`${s.url}/headers`, { test('post - post have content-length header to string', async t => {
body: intoStream(['wow']), const {body} = await got(`${s.url}/headers`, {body: intoStream(['wow']), json: true});
json: true t.is(body['content-length'], undefined);
}, (err, headers) => { });
t.ifError(err);
t.is(headers['content-length'], undefined);
});
got(`${s.url}/headers`, { test('post - post have content-length header to string', async t => {
const {body} = await got(`${s.url}/headers`, {
body: 'wow', body: 'wow',
json: true, json: true,
headers: { headers: {
'content-length': '10' 'content-length': '10'
} }
}, (err, headers) => {
t.ifError(err);
t.is(headers['content-length'], '10');
}); });
t.is(body['content-length'], '10');
});
got(`${s.url}/headers`, { test('post - post have content-length header to string', async t => {
const {body} = await got(`${s.url}/headers`, {
body: '3\r\nwow\r\n0\r\n', body: '3\r\nwow\r\n0\r\n',
json: true, json: true,
headers: { headers: {
'transfer-encoding': 'chunked' 'transfer-encoding': 'chunked'
} }
}, (err, headers) => {
t.ifError(err);
t.is(headers['content-length'], undefined);
}); });
t.is(body['content-length'], undefined);
}); });
test('post - works with plain object in body', t => { test('post - works with plain object in body', async t => {
t.plan(4); const {body} = await got(s.url, {
got(s.url, {
body: { body: {
such: 'wow' such: 'wow'
} }
}, (err, data) => {
t.ifError(err);
t.is(data, 'such=wow');
}); });
t.is(body, 'such=wow');
});
got(`${s.url}/headers`, { test('post - works with plain object in body', async t => {
const {body} = await got(`${s.url}/headers`, {
headers: { headers: {
'content-type': 'doge' 'content-type': 'doge'
}, },
@ -129,10 +105,8 @@ test('post - works with plain object in body', t => {
such: 'wow' such: 'wow'
}, },
json: true json: true
}, (err, headers) => {
t.ifError(err);
t.is(headers['content-type'], 'doge');
}); });
t.is(body['content-type'], 'doge');
}); });
test.after('post - cleanup', t => { test.after('post - cleanup', t => {

56
test/redirects.js
View File

@ -40,56 +40,40 @@ test.before('redirects - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('redirects - follows redirect', t => { test('redirects - follows redirect', async t => {
got(`${s.url}/finite`, (err, data) => { t.is((await got(`${s.url}/finite`)).body, 'reached');
t.ifError(err);
t.is(data, 'reached');
t.end();
});
}); });
test('redirects - follows relative redirect', t => { test('redirects - follows relative redirect', async t => {
got(`${s.url}/relative`, (err, data) => { t.is((await got(`${s.url}/relative`)).body, 'reached');
t.ifError(err);
t.is(data, 'reached');
t.end();
});
}); });
test('redirects - throws on endless redirect', t => { test('redirects - throws on endless redirect', async t => {
got(`${s.url}/endless`, err => { try {
t.ok(err, 'should get error'); await got(`${s.url}/endless`);
t.fail('Exception was not thrown');
} catch (err) {
t.is(err.message, 'Redirected 10 times. Aborting.'); t.is(err.message, 'Redirected 10 times. Aborting.');
t.end(); }
});
}); });
test('redirects - query in options are not breaking redirects', t => { test('redirects - query in options are not breaking redirects', async t => {
got(`${s.url}/relativeQuery`, {query: 'bang'}, (err, data) => { t.is((await got(`${s.url}/relativeQuery`, {query: 'bang'})).body, 'reached');
t.ifError(err);
t.is(data, 'reached');
t.end();
});
}); });
test('redirects - hostname+path in options are not breaking redirects', t => { test('redirects - hostname+path in options are not breaking redirects', async t => {
got(`${s.url}/relative`, { t.is((await got(`${s.url}/relative`, {hostname: s.host, path: '/relative'})).body, 'reached');
hostname: s.host,
path: '/relative'
}, (err, data) => {
t.ifError(err);
t.is(data, 'reached');
t.end();
});
}); });
test('redirects - redirect only GET and HEAD requests', t => { test('redirects - redirect only GET and HEAD requests', async t => {
got(`${s.url}/relative`, {body: 'wow'}, err => { try {
await got(`${s.url}/relative`, {body: 'wow'});
t.fail('Exception was not thrown');
} catch (err) {
t.is(err.message, 'Response code 302 (Moved Temporarily)'); t.is(err.message, 'Response code 302 (Moved Temporarily)');
t.is(err.path, '/relative'); t.is(err.path, '/relative');
t.is(err.statusCode, 302); t.is(err.statusCode, 302);
t.end(); }
});
}); });
test.after('redirects - cleanup', t => { test.after('redirects - cleanup', t => {

18
test/retry.js
View File

@ -22,19 +22,17 @@ test.before('retry - setup', t => {
s.listen(s.port, () => t.end()); s.listen(s.port, () => t.end());
}); });
test('retry - timeout errors', t => { test('retry - timeout errors', async t => {
got(`${s.url}/knock-twice`, {timeout: 1000}, (err, data) => { t.is((await got(`${s.url}/knock-twice`, {timeout: 1000})).body, 'who`s there?');
t.ifError(err);
t.is(data, 'who`s there?');
t.end();
});
}); });
test('retry - can be disabled with option', t => { test('retry - can be disabled with option', async t => {
got(`${s.url}/try-me`, {timeout: 1000, retries: 0}, () => { try {
await got(`${s.url}/try-me`, {timeout: 1000, retries: 0});
} catch (err) {
t.ok(err);
}
t.is(trys, 1); t.is(trys, 1);
t.end();
});
}); });
test.after('error - cleanup', t => { test.after('error - cleanup', t => {

19
test/unix-socket.js
View File

@ -15,25 +15,14 @@ test.before('unix-socket - setup', t => {
s.listen(socketPath, () => t.end()); s.listen(socketPath, () => t.end());
}); });
test('unix-socket - request via unix socket', t => { test('unix-socket - request via unix socket', async t => {
// borrow unix domain socket url format from request module
const url = format('http://unix:%s:%s', socketPath, '/'); const url = format('http://unix:%s:%s', socketPath, '/');
t.is((await got(url)).body, 'ok');
got(url, (err, data) => {
t.ifError(err);
t.is(data, 'ok');
t.end();
});
}); });
test('unix-socket - protocol-less request', t => { test('unix-socket - protocol-less request', async t => {
const url = format('unix:%s:%s', socketPath, '/'); const url = format('unix:%s:%s', socketPath, '/');
t.is((await got(url)).body, 'ok');
got(url, (err, data) => {
t.ifError(err);
t.is(data, 'ok');
t.end();
});
}); });
test.after('unix-socket - cleanup', t => { test.after('unix-socket - cleanup', t => {

Write Preview
Loading…
Cancel
Save