mirror of
https://github.com/titanscouting/tra-analysis.git
synced 2025-09-27 07:20:19 +00:00
push all website files
This commit is contained in:
Jacob Levine
594
website/functions/node_modules/grpc/node_modules/needle/README.md
generated
vendored
Normal file
594
website/functions/node_modules/grpc/node_modules/needle/README.md
generated
vendored
Normal file
@@ -0,0 +1,594 @@
|
||||
Needle
|
||||
======
|
||||
|
||||
[](https://nodei.co/npm/needle/)
|
||||
|
||||
The leanest and most handsome HTTP client in the Nodelands.
|
||||
|
||||
```js
|
||||
var needle = require('needle');
|
||||
|
||||
needle.get('http://www.google.com', function(error, response) {
|
||||
if (!error && response.statusCode == 200)
|
||||
console.log(response.body);
|
||||
});
|
||||
```
|
||||
|
||||
Callbacks not floating your boat? Needle got your back.
|
||||
|
||||
``` js
|
||||
var data = {
|
||||
file: '/home/johnlennon/walrus.png',
|
||||
content_type: 'image/png'
|
||||
};
|
||||
|
||||
// the callback is optional, and needle returns a `readableStream` object
|
||||
// that triggers a 'done' event when the request/response process is complete.
|
||||
needle
|
||||
.post('https://my.server.com/foo', data, { multipart: true })
|
||||
.on('readable', function() { /* eat your chunks */ })
|
||||
.on('done', function(err, resp) {
|
||||
console.log('Ready-o!');
|
||||
})
|
||||
```
|
||||
|
||||
From version 2.0.x up, Promises are also supported. Just call `needle()` directly and you'll get a native Promise object.
|
||||
|
||||
```js
|
||||
needle('put', 'https://hacking.the.gibson/login', { password: 'god' }, { json: true })
|
||||
.then(function(response) {
|
||||
return doSomethingWith(response)
|
||||
})
|
||||
.catch(function(err) {
|
||||
console.log('Call the locksmith!')
|
||||
})
|
||||
```
|
||||
|
||||
With only two real dependencies, Needle supports:
|
||||
|
||||
- HTTP/HTTPS requests, with the usual verbs you would expect
|
||||
- All of Node's native TLS options, such as 'rejectUnauthorized' (see below)
|
||||
- Basic & Digest authentication with auto-detection
|
||||
- Multipart form-data (e.g. file uploads)
|
||||
- HTTP Proxy forwarding, optionally with authentication
|
||||
- Streaming gzip or deflate decompression
|
||||
- Automatic XML & JSON parsing
|
||||
- 301/302/303 redirect following, with fine-grained tuning, and
|
||||
- Streaming non-UTF-8 charset decoding, via `iconv-lite`
|
||||
|
||||
And yes, Mr. Wayne, it does come in black.
|
||||
|
||||
This makes Needle an ideal alternative for performing quick HTTP requests in Node, either for API interaction, downloading or uploading streams of data, and so on. If you need OAuth, AWS support or anything fancier, you should check out mikeal's request module.
|
||||
|
||||
Install
|
||||
-------
|
||||
|
||||
```
|
||||
$ npm install needle
|
||||
```
|
||||
|
||||
Usage
|
||||
-----
|
||||
|
||||
```js
|
||||
// using promises
|
||||
needle('get', 'https://server.com/posts/12')
|
||||
.then(function(resp) {
|
||||
// ...
|
||||
})
|
||||
.catch(function(err) {
|
||||
// ...
|
||||
})
|
||||
});
|
||||
|
||||
// with callback
|
||||
needle.get('ifconfig.me/all.json', function(error, response, body) {
|
||||
if (error) throw error;
|
||||
|
||||
// body is an alias for `response.body`,
|
||||
// that in this case holds a JSON-decoded object.
|
||||
console.log(body.ip_addr);
|
||||
});
|
||||
|
||||
// no callback, using streams
|
||||
var out = fs.createWriteStream('logo.png');
|
||||
needle.get('https://google.com/images/logo.png').pipe(out).on('finish', function() {
|
||||
console.log('Pipe finished!');
|
||||
});
|
||||
```
|
||||
|
||||
As you can see, you can use Needle with Promises or without them. When using Promises or when a callback is passed, the response's body will be buffered and written to `response.body`, and the callback will be fired when all of the data has been collected and processed (e.g. decompressed, decoded and/or parsed).
|
||||
|
||||
When no callback is passed, however, the buffering logic will be skipped but the response stream will still go through Needle's processing pipeline, so you get all the benefits of post-processing while keeping the streamishness we all love from Node.
|
||||
|
||||
Response pipeline
|
||||
-----------------
|
||||
|
||||
Depending on the response's Content-Type, Needle will either attempt to parse JSON or XML streams, or, if a text response was received, will ensure that the final encoding you get is UTF-8.
|
||||
|
||||
You can also request a gzip/deflated response, which, if sent by the server, will be processed before parsing or decoding is performed.
|
||||
|
||||
```js
|
||||
needle.get('http://stackoverflow.com/feeds', { compressed: true }, function(err, resp) {
|
||||
console.log(resp.body); // this little guy won't be a Gzipped binary blob
|
||||
// but a nice object containing all the latest entries
|
||||
});
|
||||
```
|
||||
|
||||
Or in anti-callback mode, using a few other options:
|
||||
|
||||
```js
|
||||
var options = {
|
||||
compressed : true, // sets 'Accept-Encoding' to 'gzip,deflate'
|
||||
follow_max : 5, // follow up to five redirects
|
||||
rejectUnauthorized : true // verify SSL certificate
|
||||
}
|
||||
|
||||
var stream = needle.get('https://backend.server.com/everything.html', options);
|
||||
|
||||
// read the chunks from the 'readable' event, so the stream gets consumed.
|
||||
stream.on('readable', function() {
|
||||
while (data = this.read()) {
|
||||
console.log(data.toString());
|
||||
}
|
||||
})
|
||||
|
||||
stream.on('done', function(err) {
|
||||
// if our request had an error, our 'done' event will tell us.
|
||||
if (!err) console.log('Great success!');
|
||||
})
|
||||
```
|
||||
|
||||
API
|
||||
---
|
||||
|
||||
### needle(method, url[, data][, options][, callback]) `(> 2.0.x)`
|
||||
|
||||
Calling `needle()` directly returns a Promise. Besides `method` and `url`, all parameters are optional, although when sending a `post`, `put` or `patch` request you will get an error if `data` is not present.
|
||||
|
||||
```js
|
||||
needle('get', 'http://some.url.com')
|
||||
.then(function(resp) { console.log(resp.body) })
|
||||
.catch(function(err) { console.error(err) })
|
||||
})
|
||||
```
|
||||
|
||||
Except from the above, all of Needle's request methods return a Readable stream, and both `options` and `callback` are optional. If passed, the callback will return three arguments: `error`, `response` and `body`, which is basically an alias for `response.body`.
|
||||
|
||||
### needle.head(url[, options][, callback])
|
||||
|
||||
```js
|
||||
needle.head('https://my.backend.server.com', {
|
||||
open_timeout: 5000 // if we're not able to open a connection in 5 seconds, boom.
|
||||
}, function(err, resp) {
|
||||
if (err)
|
||||
console.log('Shoot! Something is wrong: ' + err.message)
|
||||
else
|
||||
console.log('Yup, still alive.')
|
||||
})
|
||||
```
|
||||
|
||||
### needle.get(url[, options][, callback])
|
||||
|
||||
```js
|
||||
needle.get('google.com/search?q=syd+barrett', function(err, resp) {
|
||||
// if no http:// is found, Needle will automagically prepend it.
|
||||
});
|
||||
```
|
||||
|
||||
### needle.post(url, data[, options][, callback])
|
||||
|
||||
```js
|
||||
var options = {
|
||||
headers: { 'X-Custom-Header': 'Bumbaway atuna' }
|
||||
}
|
||||
|
||||
needle.post('https://my.app.com/endpoint', 'foo=bar', options, function(err, resp) {
|
||||
// you can pass params as a string or as an object.
|
||||
});
|
||||
```
|
||||
|
||||
### needle.put(url, data[, options][, callback])
|
||||
|
||||
```js
|
||||
var nested = {
|
||||
params: {
|
||||
are: {
|
||||
also: 'supported'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
needle.put('https://api.app.com/v2', nested, function(err, resp) {
|
||||
console.log('Got ' + resp.bytes + ' bytes.') // another nice treat from this handsome fella.
|
||||
});
|
||||
```
|
||||
|
||||
### needle.patch(url, data[, options][, callback])
|
||||
|
||||
Same behaviour as PUT.
|
||||
|
||||
### needle.delete(url, data[, options][, callback])
|
||||
|
||||
```js
|
||||
var options = {
|
||||
username: 'fidelio',
|
||||
password: 'x'
|
||||
}
|
||||
|
||||
needle.delete('https://api.app.com/messages/123', null, options, function(err, resp) {
|
||||
// in this case, data may be null, but you need to explicity pass it.
|
||||
});
|
||||
```
|
||||
|
||||
### needle.request(method, url, data[, options][, callback])
|
||||
|
||||
Generic request. This not only allows for flexibility, but also lets you perform a GET request with data, in which case will be appended to the request as a query string, unless you pass a `json: true` option (read below).
|
||||
|
||||
```js
|
||||
var params = {
|
||||
q : 'a very smart query',
|
||||
page : 2
|
||||
}
|
||||
|
||||
needle.request('get', 'forum.com/search', params, function(err, resp) {
|
||||
if (!err && resp.statusCode == 200)
|
||||
console.log(resp.body); // here you go, mister.
|
||||
});
|
||||
```
|
||||
|
||||
Now, if you set pass `json: true` among the options, Needle won't set your params as a querystring but instead send a JSON representation of your data through the request's body, as well as set the `Content-Type` and `Accept` headers to `application/json`.
|
||||
|
||||
```js
|
||||
needle.request('get', 'forum.com/search', params, { json: true }, function(err, resp) {
|
||||
if (resp.statusCode == 200) console.log('It worked!');
|
||||
});
|
||||
```
|
||||
|
||||
Events
|
||||
------
|
||||
|
||||
The [Readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable) object returned by the above request methods emits the following events, in addition to the regular ones (e.g. `end`, `close`, `data`, `pipe`, `readable`).
|
||||
|
||||
### Event: `'response'`
|
||||
|
||||
- `response <http.IncomingMessage>`
|
||||
|
||||
Emitted when the underlying [http.ClientRequest](https://nodejs.org/api/http.html#http_class_http_clientrequest) emits a response event. This is after the connection is established and the header received, but before any of it is processed (e.g. authorization required or redirect to be followed). No data has been consumed at this point.
|
||||
|
||||
### Event: `'redirect'`
|
||||
|
||||
- `location <String>`
|
||||
|
||||
Indicates that the a redirect is being followed. This means that the response code was a redirect (`301`, `302`, `303`, `307`) and the given [redirect options](#redirect-options) allowed following the URL received in the `Location` header.
|
||||
|
||||
### Event: `'header'`
|
||||
|
||||
- `statusCode <Integer>`
|
||||
- `headers <Object>`
|
||||
|
||||
Triggered after the header has been processed, and just before the data is to be consumed. This implies that no redirect was followed and/or authentication header was received. In other words, we got a "valid" response.
|
||||
|
||||
### Event: `'done'` (previously 'end')
|
||||
|
||||
- `exception <Error>` (optional)
|
||||
|
||||
Emitted when the request/response process has finished, either because all data was consumed or an error ocurred somewhere in between. Unlike a regular stream's `end` event, Needle's `done` will be fired either on success or on failure, which is why the first argument may be an Error object. In other words:
|
||||
|
||||
```js
|
||||
var resp = needle.get('something.worthy/of/being/streamed/by/needle');
|
||||
resp.pipe(someWritableStream);
|
||||
|
||||
resp.on('done', function(err) {
|
||||
if (err) console.log('An error ocurred: ' + err.message);
|
||||
else console.log('Great success!');
|
||||
})
|
||||
```
|
||||
|
||||
### Event: `'err'`
|
||||
|
||||
- `exception <Error>`
|
||||
|
||||
Emitted when an error ocurrs. This should only happen once in the lifecycle of a Needle request.
|
||||
|
||||
### Event: `'timeout'`
|
||||
|
||||
- `type <String>`
|
||||
|
||||
Emitted when an timeout error occurs. Type can be either 'open', 'response', or 'read'. This will called right before aborting the request, which will also trigger an `err` event, a described above, with an `ECONNRESET` (Socket hang up) exception.
|
||||
|
||||
Request options
|
||||
---------------
|
||||
|
||||
For information about options that've changed, there's always [the changelog](https://github.com/tomas/needle/releases).
|
||||
|
||||
- `agent` : Uses an [http.Agent](https://nodejs.org/api/http.html#http_class_http_agent) of your choice, instead of the global, default one. Useful for tweaking the behaviour at the connection level, such as when doing tunneling (see below for an example).
|
||||
- `json` : When `true`, sets content type to `application/json` and sends request body as JSON string, instead of a query string.
|
||||
- `open_timeout`: (or `timeout`) Returns error if connection takes longer than X milisecs to establish. Defaults to `10000` (10 secs). `0` means no timeout.
|
||||
- `response_timeout`: Returns error if no response headers are received in X milisecs, counting from when the connection is opened. Defaults to `0` (no response timeout).
|
||||
- `read_timeout`: Returns error if data transfer takes longer than X milisecs, once response headers are received. Defaults to `0` (no timeout).
|
||||
- `follow_max` : (or `follow`) Number of redirects to follow. Defaults to `0`. See below for more redirect options.
|
||||
- `multipart` : Enables multipart/form-data encoding. Defaults to `false`. Use it when uploading files.
|
||||
- `proxy` : Forwards request through HTTP(s) proxy. Eg. `proxy: 'http://user:pass@proxy.server.com:3128'`. For more advanced proxying/tunneling use a custom `agent`, as described below.
|
||||
- `headers` : Object containing custom HTTP headers for request. Overrides defaults described below.
|
||||
- `auth` : Determines what to do with provided username/password. Options are `auto`, `digest` or `basic` (default). `auto` will detect the type of authentication depending on the response headers.
|
||||
- `stream_length`: When sending streams, this lets you manually set the Content-Length header --if the stream's bytecount is known beforehand--, preventing ECONNRESET (socket hang up) errors on some servers that misbehave when receiving payloads of unknown size. Set it to `0` and Needle will get and set the stream's length for you, or leave unset for the default behaviour, which is no Content-Length header for stream payloads.
|
||||
- `localAddress` : <string>, IP address. Passed to http/https request. Local interface from witch the request should be emitted.
|
||||
|
||||
Response options
|
||||
----------------
|
||||
|
||||
- `decode_response` : (or `decode`) Whether to decode the text responses to UTF-8, if Content-Type header shows a different charset. Defaults to `true`.
|
||||
- `parse_response` : (or `parse`) Whether to parse XML or JSON response bodies automagically. Defaults to `true`. You can also set this to 'xml' or 'json' in which case Needle will *only* parse the response if the content type matches.
|
||||
- `output` : Dump response output to file. This occurs after parsing and charset decoding is done.
|
||||
- `parse_cookies` : Whether to parse response’s `Set-Cookie` header. Defaults to `true`. If parsed, response cookies will be available at `resp.cookies`.
|
||||
|
||||
HTTP Header options
|
||||
-------------------
|
||||
|
||||
These are basically shortcuts to the `headers` option described above.
|
||||
|
||||
- `cookies` : Builds and sets a Cookie header from a `{ key: 'value' }` object.
|
||||
- `compressed`: If `true`, sets 'Accept-Encoding' header to 'gzip,deflate', and inflates content if zipped. Defaults to `false`.
|
||||
- `username` : For HTTP basic auth.
|
||||
- `password` : For HTTP basic auth. Requires username to be passed, but is optional.
|
||||
- `accept` : Sets 'Accept' HTTP header. Defaults to `*/*`.
|
||||
- `connection`: Sets 'Connection' HTTP header. Not set by default, unless running Node < 0.11.4 in which case it defaults to `close`. More info about this below.
|
||||
- `user_agent`: Sets the 'User-Agent' HTTP header. Defaults to `Needle/{version} (Node.js {node_version})`.
|
||||
- `content_type`: Sets the 'Content-Type' header. Unset by default, unless you're sending data in which case it's set accordingly to whatever is being sent (`application/x-www-form-urlencoded`, `application/json` or `multipart/form-data`). That is, of course, unless the option is passed, either here or through `options.headers`. You're the boss.
|
||||
|
||||
Node.js TLS Options
|
||||
-------------------
|
||||
|
||||
These options are passed directly to `https.request` if present. Taken from the [original documentation](http://nodejs.org/docs/latest/api/https.html):
|
||||
|
||||
- `pfx` : Certificate, Private key and CA certificates to use for SSL.
|
||||
- `key` : Private key to use for SSL.
|
||||
- `passphrase` : A string of passphrase for the private key or pfx.
|
||||
- `cert` : Public x509 certificate to use.
|
||||
- `ca` : An authority certificate or array of authority certificates to check the remote host against.
|
||||
- `ciphers` : A string describing the ciphers to use or exclude.
|
||||
- `rejectUnauthorized` : If true, the server certificate is verified against the list of supplied CAs. An 'error' event is emitted if verification fails. Verification happens at the connection level, before the HTTP request is sent.
|
||||
- `secureProtocol` : The SSL method to use, e.g. SSLv3_method to force SSL version 3.
|
||||
|
||||
Redirect options
|
||||
----------------
|
||||
|
||||
These options only apply if the `follow_max` (or `follow`) option is higher than 0.
|
||||
|
||||
- `follow_set_cookies` : Sends the cookies received in the `set-cookie` header as part of the following request. `false` by default.
|
||||
- `follow_set_referer` : Sets the 'Referer' header to the requested URI when following a redirect. `false` by default.
|
||||
- `follow_keep_method` : If enabled, resends the request using the original verb instead of being rewritten to `get` with no data. `false` by default.
|
||||
- `follow_if_same_host` : When true, Needle will only follow redirects that point to the same host as the original request. `false` by default.
|
||||
- `follow_if_same_protocol` : When true, Needle will only follow redirects that point to the same protocol as the original request. `false` by default.
|
||||
|
||||
Overriding Defaults
|
||||
-------------------
|
||||
|
||||
Yes sir, we have it. Needle includes a `defaults()` method, that lets you override some of the defaults for all future requests. Like this:
|
||||
|
||||
```js
|
||||
needle.defaults({
|
||||
open_timeout: 60000,
|
||||
user_agent: 'MyApp/1.2.3',
|
||||
parse_response: false });
|
||||
```
|
||||
|
||||
This will override Needle's default user agent and 10-second timeout, and disable response parsing, so you don't need to pass those options in every other request.
|
||||
|
||||
More advanced Proxy support
|
||||
---------------------------
|
||||
|
||||
Since you can pass a custom HTTPAgent to Needle you can do all sorts of neat stuff. For example, if you want to use the [`tunnel`](https://github.com/koichik/node-tunnel) module for HTTPS proxying, you can do this:
|
||||
|
||||
```js
|
||||
var tunnel = require('tunnel');
|
||||
var myAgent = tunnel.httpOverHttp({
|
||||
proxy: { host: 'localhost' }
|
||||
});
|
||||
|
||||
needle.get('foobar.com', { agent: myAgent });
|
||||
```
|
||||
|
||||
Regarding the 'Connection' header
|
||||
---------------------------------
|
||||
|
||||
Unless you're running an old version of Node (< 0.11.4), by default Needle won't set the Connection header on requests, yielding Node's default behaviour of keeping the connection alive with the target server. This speeds up inmensely the process of sending several requests to the same host.
|
||||
|
||||
On older versions, however, this has the unwanted behaviour of preventing the runtime from exiting, either because of a bug or 'feature' that was changed on 0.11.4. To overcome this Needle does set the 'Connection' header to 'close' on those versions, however this also means that making new requests to the same host doesn't benefit from Keep-Alive.
|
||||
|
||||
So if you're stuck on 0.10 or even lower and want full speed, you can simply set the Connection header to 'Keep-Alive' by using `{ connection: 'Keep-Alive' }`. Please note, though, that an event loop handler will prevent the runtime from exiting so you'll need to manually call `process.exit()` or the universe will collapse.
|
||||
|
||||
Examples Galore
|
||||
---------------
|
||||
|
||||
### HTTPS GET with Basic Auth
|
||||
|
||||
```js
|
||||
needle.get('https://api.server.com', { username: 'you', password: 'secret' },
|
||||
function(err, resp) {
|
||||
// used HTTP auth
|
||||
});
|
||||
```
|
||||
|
||||
Or use [RFC-1738](http://tools.ietf.org/html/rfc1738#section-3.1) basic auth URL syntax:
|
||||
|
||||
```js
|
||||
needle.get('https://username:password@api.server.com', function(err, resp) {
|
||||
// used HTTP auth from URL
|
||||
});
|
||||
```
|
||||
|
||||
### Digest Auth
|
||||
|
||||
```js
|
||||
needle.get('other.server.com', { username: 'you', password: 'secret', auth: 'digest' },
|
||||
function(err, resp, body) {
|
||||
// needle prepends 'http://' to your URL, if missing
|
||||
});
|
||||
```
|
||||
|
||||
### Custom Accept header, deflate
|
||||
|
||||
```js
|
||||
var options = {
|
||||
compressed : true,
|
||||
follow : 10,
|
||||
accept : 'application/vnd.github.full+json'
|
||||
}
|
||||
|
||||
needle.get('api.github.com/users/tomas', options, function(err, resp, body) {
|
||||
// body will contain a JSON.parse(d) object
|
||||
// if parsing fails, you'll simply get the original body
|
||||
});
|
||||
```
|
||||
|
||||
### GET XML object
|
||||
|
||||
```js
|
||||
needle.get('https://news.ycombinator.com/rss', function(err, resp, body) {
|
||||
// you'll get a nice object containing the nodes in the RSS
|
||||
});
|
||||
```
|
||||
|
||||
### GET binary, output to file
|
||||
|
||||
```js
|
||||
needle.get('http://upload.server.com/tux.png', { output: '/tmp/tux.png' }, function(err, resp, body) {
|
||||
// you can dump any response to a file, not only binaries.
|
||||
});
|
||||
```
|
||||
|
||||
### GET through proxy
|
||||
|
||||
```js
|
||||
needle.get('http://search.npmjs.org', { proxy: 'http://localhost:1234' }, function(err, resp, body) {
|
||||
// request passed through proxy
|
||||
});
|
||||
```
|
||||
|
||||
### GET a very large document in a stream (from 0.7+)
|
||||
|
||||
```js
|
||||
var stream = needle.get('http://www.as35662.net/100.log');
|
||||
|
||||
stream.on('readable', function() {
|
||||
var chunk;
|
||||
while (chunk = this.read()) {
|
||||
console.log('got data: ', chunk);
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### GET JSON object in a stream (from 0.7+)
|
||||
|
||||
```js
|
||||
var stream = needle.get('http://jsonplaceholder.typicode.com/db', { parse: true });
|
||||
|
||||
stream.on('readable', function() {
|
||||
var node;
|
||||
|
||||
// our stream will only emit a single JSON root node.
|
||||
while (node = this.read()) {
|
||||
console.log('got data: ', node);
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### GET JSONStream flexible parser with search query (from 0.7+)
|
||||
|
||||
```js
|
||||
|
||||
// The 'data' element of this stream will be the string representation
|
||||
// of the titles of all posts.
|
||||
|
||||
needle.get('http://jsonplaceholder.typicode.com/db', { parse: true })
|
||||
.pipe(new JSONStream.parse('posts.*.title'));
|
||||
.on('data', function (obj) {
|
||||
console.log('got post title: %s', obj);
|
||||
});
|
||||
```
|
||||
|
||||
### File upload using multipart, passing file path
|
||||
|
||||
```js
|
||||
var data = {
|
||||
foo: 'bar',
|
||||
image: { file: '/home/tomas/linux.png', content_type: 'image/png' }
|
||||
}
|
||||
|
||||
needle.post('http://my.other.app.com', data, { multipart: true }, function(err, resp, body) {
|
||||
// needle will read the file and include it in the form-data as binary
|
||||
});
|
||||
```
|
||||
|
||||
### Stream upload, PUT or POST
|
||||
|
||||
``` js
|
||||
needle.put('https://api.app.com/v2', fs.createReadStream('myfile.txt'), function(err, resp, body) {
|
||||
// stream content is uploaded verbatim
|
||||
});
|
||||
```
|
||||
|
||||
### Multipart POST, passing data buffer
|
||||
|
||||
```js
|
||||
var buffer = fs.readFileSync('/path/to/package.zip');
|
||||
|
||||
var data = {
|
||||
zip_file: {
|
||||
buffer : buffer,
|
||||
filename : 'mypackage.zip',
|
||||
content_type : 'application/octet-stream'
|
||||
}
|
||||
}
|
||||
|
||||
needle.post('http://somewhere.com/over/the/rainbow', data, { multipart: true }, function(err, resp, body) {
|
||||
// if you see, when using buffers we need to pass the filename for the multipart body.
|
||||
// you can also pass a filename when using the file path method, in case you want to override
|
||||
// the default filename to be received on the other end.
|
||||
});
|
||||
```
|
||||
|
||||
### Multipart with custom Content-Type
|
||||
|
||||
```js
|
||||
var data = {
|
||||
token: 'verysecret',
|
||||
payload: {
|
||||
value: JSON.stringify({ title: 'test', version: 1 }),
|
||||
content_type: 'application/json'
|
||||
}
|
||||
}
|
||||
|
||||
needle.post('http://test.com/', data, { timeout: 5000, multipart: true }, function(err, resp, body) {
|
||||
// in this case, if the request takes more than 5 seconds
|
||||
// the callback will return a [Socket closed] error
|
||||
});
|
||||
```
|
||||
|
||||
For even more examples, check out the examples directory in the repo.
|
||||
|
||||
### Testing
|
||||
|
||||
To run tests, you need to generate a self-signed SSL certificate in the `test` directory. After cloning the repository, run the following commands:
|
||||
|
||||
$ mkdir -p test/keys
|
||||
$ openssl genrsa -out test/keys/ssl.key 2048
|
||||
$ openssl req -new -key test/keys/ssl.key -x509 -days 999 -out test/keys/ssl.cert
|
||||
|
||||
Then you should be able to run `npm test` once you have the dependencies in place.
|
||||
|
||||
> Note: Tests currently only work on linux-based environments that have `/proc/self/fd`. They *do not* work on MacOS environments.
|
||||
> You can use Docker to run tests by creating a container and mounting the needle project directory on `/app`
|
||||
> `docker create --name Needle -v /app -w /app -v /app/node_modules -i node:argon`
|
||||
|
||||
Credits
|
||||
-------
|
||||
|
||||
Written by Tomás Pollak, with the help of contributors.
|
||||
|
||||
Copyright
|
||||
---------
|
||||
|
||||
(c) Fork Ltd. Licensed under the MIT license.
|
||||
40
website/functions/node_modules/grpc/node_modules/needle/bin/needle
generated
vendored
Normal file
40
website/functions/node_modules/grpc/node_modules/needle/bin/needle
generated
vendored
Normal file
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env node
|
||||
var needle = require('./../lib/needle');
|
||||
|
||||
function exit(code, str) {
|
||||
console.log(str) || process.exit(code);
|
||||
}
|
||||
|
||||
function usage() {
|
||||
var out = ['Usage: needle [get|head|post|put|delete] url [query]'];
|
||||
out.push('Examples: \n needle get google.com\n needle post server.com/api foo=bar');
|
||||
exit(1, out.join('\n'))
|
||||
}
|
||||
|
||||
if (process.argv[2] == '-v' || process.argv[2] == '--version')
|
||||
exit(0, needle.version);
|
||||
else if (process.argv[2] == null)
|
||||
usage();
|
||||
|
||||
var method = process.argv[2],
|
||||
url = process.argv[3],
|
||||
options = { compressed: true, parse_response: true, follow_max: 5, timeout: 10000 };
|
||||
|
||||
if (!needle[method]) {
|
||||
url = method;
|
||||
method = 'get';
|
||||
}
|
||||
|
||||
var callback = function(err, resp) {
|
||||
if (err) return exit(1, "Error: " + err.message);
|
||||
|
||||
if (process.argv.indexOf('-i') != -1)
|
||||
console.log(resp.headers) || console.log('');
|
||||
|
||||
console.log(resp.body.toString());
|
||||
};
|
||||
|
||||
if (method == 'post' || method == 'put')
|
||||
needle[method](url, process.argv[4], options, callback);
|
||||
else
|
||||
needle[method](url, options, callback);
|
||||
22
website/functions/node_modules/grpc/node_modules/needle/examples/deflated-stream.js
generated
vendored
Normal file
22
website/functions/node_modules/grpc/node_modules/needle/examples/deflated-stream.js
generated
vendored
Normal file
@@ -0,0 +1,22 @@
|
||||
var fs = require('fs'),
|
||||
stream = require('stream'),
|
||||
needle = require('./../');
|
||||
|
||||
var url = 'http://ibl.gamechaser.net/f/tagqfxtteucbuldhezkz/bt_level1.gz';
|
||||
|
||||
var resp = needle.get(url, { compressed: true, follow_max: 10 });
|
||||
console.log('Downloading...');
|
||||
|
||||
resp.on('readable', function() {
|
||||
|
||||
while (data = this.read()) {
|
||||
var lines = data.toString().split('\n');
|
||||
console.log('Got ' + lines.length + ' items.');
|
||||
// console.log(lines);
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
resp.on('done', function(data) {
|
||||
console.log('Done');
|
||||
})
|
||||
16
website/functions/node_modules/grpc/node_modules/needle/examples/digest-auth.js
generated
vendored
Normal file
16
website/functions/node_modules/grpc/node_modules/needle/examples/digest-auth.js
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
var needle = require('./..');
|
||||
|
||||
var opts = {
|
||||
username: 'user3',
|
||||
password: 'user3',
|
||||
auth: 'digest'
|
||||
}
|
||||
|
||||
needle.get('http://test.webdav.org/auth-digest/', opts, function(err, resp, body) {
|
||||
console.log(resp.headers);
|
||||
|
||||
if (resp.statusCode == 401)
|
||||
console.log('\nIt failed.')
|
||||
else
|
||||
console.log('\nIt worked!')
|
||||
});
|
||||
18
website/functions/node_modules/grpc/node_modules/needle/examples/download-to-file.js
generated
vendored
Normal file
18
website/functions/node_modules/grpc/node_modules/needle/examples/download-to-file.js
generated
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
var fs = require('fs'),
|
||||
needle = require('./..'),
|
||||
path = require('path');
|
||||
|
||||
var url = process.argv[2] || 'https://upload.wikimedia.org/wikipedia/commons/a/af/Tux.png';
|
||||
var file = path.basename(url);
|
||||
|
||||
console.log('Downloading ' + file);
|
||||
|
||||
needle.get(url, { output: file, follow: 3 }, function(err, resp, data){
|
||||
console.log('File saved: ' + process.cwd() + '/' + file);
|
||||
|
||||
var size = fs.statSync(file).size;
|
||||
if (size == resp.bytes)
|
||||
console.log(resp.bytes + ' bytes written to file.');
|
||||
else
|
||||
throw new Error('File size mismatch: ' + size + ' != ' + resp.bytes);
|
||||
});
|
||||
25
website/functions/node_modules/grpc/node_modules/needle/examples/multipart-stream.js
generated
vendored
Normal file
25
website/functions/node_modules/grpc/node_modules/needle/examples/multipart-stream.js
generated
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
var needle = require('./../');
|
||||
|
||||
var url = 'http://posttestserver.com/post.php?dir=needle';
|
||||
|
||||
var black_pixel = new Buffer("R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=", 'base64');
|
||||
|
||||
var data = {
|
||||
foo: 'bar',
|
||||
nested: {
|
||||
test: 123
|
||||
},
|
||||
image: { buffer: black_pixel, content_type: 'image/gif' }
|
||||
}
|
||||
|
||||
var resp = needle.post(url, data, { multipart: true });
|
||||
|
||||
resp.on('readable', function() {
|
||||
while (data = this.read()) {
|
||||
console.log(data.toString());
|
||||
}
|
||||
})
|
||||
|
||||
resp.on('done', function(data) {
|
||||
console.log('Done.');
|
||||
})
|
||||
23
website/functions/node_modules/grpc/node_modules/needle/examples/parsed-stream.js
generated
vendored
Normal file
23
website/functions/node_modules/grpc/node_modules/needle/examples/parsed-stream.js
generated
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
//////////////////////////////////////////
|
||||
// This example demonstrates what happends
|
||||
// when you use the built-in JSON parser.
|
||||
//////////////////////////////////////////
|
||||
|
||||
var fs = require('fs'),
|
||||
stream = require('stream'),
|
||||
needle = require('./../');
|
||||
|
||||
var url = 'http://ip.jsontest.com/',
|
||||
resp = needle.get(url, { parse: true });
|
||||
|
||||
resp.on('readable', function(obj) {
|
||||
var chunk;
|
||||
|
||||
while (chunk = this.read()) {
|
||||
console.log('root = ', chunk);
|
||||
}
|
||||
});
|
||||
|
||||
resp.on('done', function() {
|
||||
console.log('Done.');
|
||||
});
|
||||
21
website/functions/node_modules/grpc/node_modules/needle/examples/parsed-stream2.js
generated
vendored
Normal file
21
website/functions/node_modules/grpc/node_modules/needle/examples/parsed-stream2.js
generated
vendored
Normal file
@@ -0,0 +1,21 @@
|
||||
//////////////////////////////////////////
|
||||
// This example illustrates a more complex
|
||||
// example of parsing a JSON stream.
|
||||
//////////////////////////////////////////
|
||||
|
||||
var needle = require('./../'),
|
||||
JSONStream = require('JSONStream');
|
||||
|
||||
var url = 'http://jsonplaceholder.typicode.com/db';
|
||||
|
||||
// Initialize our GET request with our default (JSON)
|
||||
// parsers disabled.
|
||||
|
||||
var json = new needle.get(url, {parse: false})
|
||||
// And now interpret the stream as JSON, returning only the
|
||||
// title of all the posts.
|
||||
.pipe(new JSONStream.parse('posts.*.title'));
|
||||
|
||||
json.on('data', function (obj) {
|
||||
console.log('got title: \'' + obj + '\'');
|
||||
})
|
||||
23
website/functions/node_modules/grpc/node_modules/needle/examples/stream-events.js
generated
vendored
Normal file
23
website/functions/node_modules/grpc/node_modules/needle/examples/stream-events.js
generated
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
var needle = require('./..');
|
||||
|
||||
var resp = needle.get('google.com', { follow_max: 10, timeout: 5000 });
|
||||
|
||||
resp.on('readable', function() {
|
||||
var chunk;
|
||||
while (chunk = this.read()) {
|
||||
console.log('Got ' + chunk.length + ' bytes');
|
||||
}
|
||||
})
|
||||
|
||||
resp.on('headers', function(headers) {
|
||||
console.log('Got headers', headers);
|
||||
})
|
||||
|
||||
resp.on('redirect', function(url) {
|
||||
console.log('Redirected to url ' + url);
|
||||
})
|
||||
|
||||
resp.on('done', function(err) {
|
||||
console.log('Finished. No more data to receive.');
|
||||
if (err) console.log('With error', err)
|
||||
})
|
||||
14
website/functions/node_modules/grpc/node_modules/needle/examples/stream-to-file.js
generated
vendored
Normal file
14
website/functions/node_modules/grpc/node_modules/needle/examples/stream-to-file.js
generated
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
var fs = require('fs'),
|
||||
needle = require('./..'),
|
||||
path = require('path');
|
||||
|
||||
var url = process.argv[2] || 'http://www.google.com/images/errors/robot.png';
|
||||
var file = path.basename(url);
|
||||
|
||||
console.log('Downloading ' + file + '...');
|
||||
needle
|
||||
.get(url)
|
||||
.pipe(fs.createWriteStream(file))
|
||||
.on('done', function() {
|
||||
console.log('Done!')
|
||||
})
|
||||
51
website/functions/node_modules/grpc/node_modules/needle/examples/upload-image.js
generated
vendored
Normal file
51
website/functions/node_modules/grpc/node_modules/needle/examples/upload-image.js
generated
vendored
Normal file
@@ -0,0 +1,51 @@
|
||||
var needle = require('../'),
|
||||
path = require('path');
|
||||
|
||||
var image = 'https://upload.wikimedia.org/wikipedia/commons/a/af/Tux.png';
|
||||
|
||||
function upload(obj, cb) {
|
||||
console.log('Uploading image...');
|
||||
|
||||
var url = 'http://deviantsart.com';
|
||||
|
||||
var opts = {
|
||||
timeout: 10000,
|
||||
follow: 3,
|
||||
multipart: true
|
||||
};
|
||||
|
||||
var params = {
|
||||
file: obj
|
||||
}
|
||||
|
||||
needle.post(url, params, opts, function(err, resp) {
|
||||
if (err || !resp.body.match('url'))
|
||||
return cb(err || new Error('No image URL found.'))
|
||||
|
||||
cb(null, JSON.parse(resp.body).url)
|
||||
})
|
||||
}
|
||||
|
||||
function download(url, cb) {
|
||||
console.log('Getting ' + url);
|
||||
needle.get(url, function(err, resp) {
|
||||
if (err) throw err;
|
||||
|
||||
cb(null, resp.body);
|
||||
})
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// ok, now go.
|
||||
|
||||
download(image, function(err, buffer) {
|
||||
if (err) throw err;
|
||||
|
||||
var obj = { buffer: buffer, content_type: 'image/png' };
|
||||
|
||||
upload(obj, function(err, url) {
|
||||
if (err) throw err;
|
||||
|
||||
console.log('Image uploaded to ' + url);
|
||||
})
|
||||
})
|
||||
110
website/functions/node_modules/grpc/node_modules/needle/lib/auth.js
generated
vendored
Normal file
110
website/functions/node_modules/grpc/node_modules/needle/lib/auth.js
generated
vendored
Normal file
@@ -0,0 +1,110 @@
|
||||
var createHash = require('crypto').createHash;
|
||||
|
||||
function get_header(header, credentials, opts) {
|
||||
var type = header.split(' ')[0],
|
||||
user = credentials[0],
|
||||
pass = credentials[1];
|
||||
|
||||
if (type == 'Digest') {
|
||||
return digest.generate(header, user, pass, opts.method, opts.path);
|
||||
} else if (type == 'Basic') {
|
||||
return basic(user, pass);
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// basic
|
||||
|
||||
function md5(string) {
|
||||
return createHash('md5').update(string).digest('hex');
|
||||
}
|
||||
|
||||
function basic(user, pass) {
|
||||
var str = typeof pass == 'undefined' ? user : [user, pass].join(':');
|
||||
return 'Basic ' + new Buffer(str).toString('base64');
|
||||
}
|
||||
|
||||
////////////////////
|
||||
// digest
|
||||
// logic inspired from https://github.com/simme/node-http-digest-client
|
||||
|
||||
var digest = {};
|
||||
|
||||
digest.parse_header = function(header) {
|
||||
var challenge = {},
|
||||
matches = header.match(/([a-z0-9_-]+)="?([a-z0-9=\/\.@\s-]+)"?/gi);
|
||||
|
||||
for (var i = 0, l = matches.length; i < l; i++) {
|
||||
var parts = matches[i].split('='),
|
||||
key = parts.shift(),
|
||||
val = parts.join('=').replace(/^"/, '').replace(/"$/, '');
|
||||
|
||||
challenge[key] = val;
|
||||
}
|
||||
|
||||
return challenge;
|
||||
}
|
||||
|
||||
digest.update_nc = function(nc) {
|
||||
var max = 99999999;
|
||||
nc++;
|
||||
|
||||
if (nc > max)
|
||||
nc = 1;
|
||||
|
||||
var padding = new Array(8).join('0') + '';
|
||||
nc = nc + '';
|
||||
return padding.substr(0, 8 - nc.length) + nc;
|
||||
}
|
||||
|
||||
digest.generate = function(header, user, pass, method, path) {
|
||||
|
||||
var nc = 1,
|
||||
cnonce = null,
|
||||
challenge = digest.parse_header(header);
|
||||
|
||||
var ha1 = md5(user + ':' + challenge.realm + ':' + pass),
|
||||
ha2 = md5(method.toUpperCase() + ':' + path),
|
||||
resp = [ha1, challenge.nonce];
|
||||
|
||||
if (typeof challenge.qop === 'string') {
|
||||
cnonce = md5(Math.random().toString(36)).substr(0, 8);
|
||||
nc = digest.update_nc(nc);
|
||||
resp = resp.concat(nc, cnonce);
|
||||
}
|
||||
|
||||
resp = resp.concat(challenge.qop, ha2);
|
||||
|
||||
var params = {
|
||||
uri : path,
|
||||
realm : challenge.realm,
|
||||
nonce : challenge.nonce,
|
||||
username : user,
|
||||
response : md5(resp.join(':'))
|
||||
}
|
||||
|
||||
if (challenge.qop) {
|
||||
params.qop = challenge.qop;
|
||||
}
|
||||
|
||||
if (challenge.opaque) {
|
||||
params.opaque = challenge.opaque;
|
||||
}
|
||||
|
||||
if (cnonce) {
|
||||
params.nc = nc;
|
||||
params.cnonce = cnonce;
|
||||
}
|
||||
|
||||
header = []
|
||||
for (var k in params)
|
||||
header.push(k + '="' + params[k] + '"')
|
||||
|
||||
return 'Digest ' + header.join(', ');
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
header : get_header,
|
||||
basic : basic,
|
||||
digest : digest.generate
|
||||
}
|
||||
79
website/functions/node_modules/grpc/node_modules/needle/lib/cookies.js
generated
vendored
Normal file
79
website/functions/node_modules/grpc/node_modules/needle/lib/cookies.js
generated
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
|
||||
// Simple cookie handling implementation based on the standard RFC 6265.
|
||||
//
|
||||
// This module just has two functionalities:
|
||||
// - Parse a set-cookie-header as a key value object
|
||||
// - Write a cookie-string from a key value object
|
||||
//
|
||||
// All cookie attributes are ignored.
|
||||
|
||||
var unescape = require('querystring').unescape;
|
||||
|
||||
var COOKIE_PAIR = /^([^=\s]+)\s*=\s*("?)\s*(.*)\s*\2\s*$/;
|
||||
var EXCLUDED_CHARS = /[\x00-\x1F\x7F\x3B\x3B\s\"\,\\"%]/g;
|
||||
var TRAILING_SEMICOLON = /\x3B+$/;
|
||||
var SEP_SEMICOLON = /\s*\x3B\s*/;
|
||||
|
||||
// i know these should be 'const', but I'd like to keep
|
||||
// supporting earlier node.js versions as long as I can. :)
|
||||
|
||||
var KEY_INDEX = 1; // index of key from COOKIE_PAIR match
|
||||
var VALUE_INDEX = 3; // index of value from COOKIE_PAIR match
|
||||
|
||||
// Returns a copy str trimmed and without trainling semicolon.
|
||||
function cleanCookieString(str) {
|
||||
return str.trim().replace(/\x3B+$/, '');
|
||||
}
|
||||
|
||||
function getFirstPair(str) {
|
||||
var index = str.indexOf('\x3B');
|
||||
return index === -1 ? str : str.substr(0, index);
|
||||
}
|
||||
|
||||
// Returns a encoded copy of str based on RFC6265 S4.1.1.
|
||||
function encodeCookieComponent(str) {
|
||||
return str.toString().replace(EXCLUDED_CHARS, encodeURIComponent);
|
||||
}
|
||||
|
||||
// Parses a set-cookie-string based on the standard defined in RFC6265 S4.1.1.
|
||||
function parseSetCookieString(str) {
|
||||
str = cleanCookieString(str);
|
||||
str = getFirstPair(str);
|
||||
|
||||
var res = COOKIE_PAIR.exec(str);
|
||||
if (!res || !res[VALUE_INDEX]) return null;
|
||||
|
||||
return {
|
||||
name : unescape(res[KEY_INDEX]),
|
||||
value : unescape(res[VALUE_INDEX])
|
||||
};
|
||||
}
|
||||
|
||||
// Parses a set-cookie-header and returns a key/value object.
|
||||
// Each key represents the name of a cookie.
|
||||
function parseSetCookieHeader(header) {
|
||||
if (!header) return {};
|
||||
header = Array.isArray(header) ? header : [header];
|
||||
|
||||
return header.reduce(function(res, str) {
|
||||
var cookie = parseSetCookieString(str);
|
||||
if (cookie) res[cookie.name] = cookie.value;
|
||||
return res;
|
||||
}, {});
|
||||
}
|
||||
|
||||
// Writes a set-cookie-string based on the standard definded in RFC6265 S4.1.1.
|
||||
function writeCookieString(obj) {
|
||||
return Object.keys(obj).reduce(function(str, name) {
|
||||
var encodedName = encodeCookieComponent(name);
|
||||
var encodedValue = encodeCookieComponent(obj[name]);
|
||||
str += (str ? '; ' : '') + encodedName + '=' + encodedValue;
|
||||
return str;
|
||||
}, '');
|
||||
}
|
||||
|
||||
// returns a key/val object from an array of cookie strings
|
||||
exports.read = parseSetCookieHeader;
|
||||
|
||||
// writes a cookie string header
|
||||
exports.write = writeCookieString;
|
||||
53
website/functions/node_modules/grpc/node_modules/needle/lib/decoder.js
generated
vendored
Normal file
53
website/functions/node_modules/grpc/node_modules/needle/lib/decoder.js
generated
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
var iconv,
|
||||
inherits = require('util').inherits,
|
||||
stream = require('stream');
|
||||
|
||||
var regex = /(?:charset|encoding)\s*=\s*['"]? *([\w\-]+)/i;
|
||||
|
||||
inherits(StreamDecoder, stream.Transform);
|
||||
|
||||
function StreamDecoder(charset) {
|
||||
if (!(this instanceof StreamDecoder))
|
||||
return new StreamDecoder(charset);
|
||||
|
||||
stream.Transform.call(this, charset);
|
||||
this.charset = charset;
|
||||
this.parsed_chunk = false;
|
||||
}
|
||||
|
||||
StreamDecoder.prototype._transform = function(chunk, encoding, done) {
|
||||
var res, found;
|
||||
|
||||
// try get charset from chunk, just once
|
||||
if (this.charset == 'iso-8859-1' && !this.parsed_chunk) {
|
||||
this.parsed_chunk = true;
|
||||
|
||||
var matches = regex.exec(chunk.toString());
|
||||
if (matches) {
|
||||
found = matches[1].toLowerCase();
|
||||
this.charset = found == 'utf-8' ? 'utf8' : found;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
res = iconv.decode(chunk, this.charset);
|
||||
} catch(e) { // something went wrong, just return original chunk
|
||||
res = chunk;
|
||||
}
|
||||
|
||||
this.push(res);
|
||||
done();
|
||||
}
|
||||
|
||||
module.exports = function(charset) {
|
||||
try {
|
||||
if (!iconv) iconv = require('iconv-lite');
|
||||
} catch(e) {
|
||||
/* iconv not found */
|
||||
}
|
||||
|
||||
if (iconv)
|
||||
return new StreamDecoder(charset);
|
||||
else
|
||||
return new stream.PassThrough;
|
||||
}
|
||||
98
website/functions/node_modules/grpc/node_modules/needle/lib/multipart.js
generated
vendored
Normal file
98
website/functions/node_modules/grpc/node_modules/needle/lib/multipart.js
generated
vendored
Normal file
@@ -0,0 +1,98 @@
|
||||
var readFile = require('fs').readFile,
|
||||
basename = require('path').basename;
|
||||
|
||||
exports.build = function(data, boundary, callback) {
|
||||
|
||||
if (typeof data != 'object' || typeof data.pipe == 'function')
|
||||
return callback(new Error('Multipart builder expects data as key/val object.'));
|
||||
|
||||
var body = '',
|
||||
object = flatten(data),
|
||||
count = Object.keys(object).length;
|
||||
|
||||
if (count === 0)
|
||||
return callback(new Error('Empty multipart body. Invalid data.'))
|
||||
|
||||
function done(err, section) {
|
||||
if (err) return callback(err);
|
||||
if (section) body += section;
|
||||
--count || callback(null, body + '--' + boundary + '--');
|
||||
};
|
||||
|
||||
for (var key in object) {
|
||||
var value = object[key];
|
||||
if (value === null || typeof value == 'undefined') {
|
||||
done();
|
||||
} else if (Buffer.isBuffer(value)) {
|
||||
var part = { buffer: value, content_type: 'application/octet-stream' };
|
||||
generate_part(key, part, boundary, done);
|
||||
} else {
|
||||
var part = (value.buffer || value.file || value.content_type) ? value : { value: value };
|
||||
generate_part(key, part, boundary, done);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function generate_part(name, part, boundary, callback) {
|
||||
|
||||
var return_part = '--' + boundary + '\r\n';
|
||||
return_part += 'Content-Disposition: form-data; name="' + name + '"';
|
||||
|
||||
function append(data, filename) {
|
||||
|
||||
if (data) {
|
||||
var binary = part.content_type.indexOf('text') == -1;
|
||||
return_part += '; filename="' + encodeURIComponent(filename) + '"\r\n';
|
||||
if (binary) return_part += 'Content-Transfer-Encoding: binary\r\n';
|
||||
return_part += 'Content-Type: ' + part.content_type + '\r\n\r\n';
|
||||
return_part += binary ? data.toString('binary') : data.toString('utf8');
|
||||
}
|
||||
|
||||
callback(null, return_part + '\r\n');
|
||||
};
|
||||
|
||||
if ((part.file || part.buffer) && part.content_type) {
|
||||
|
||||
var filename = part.filename ? part.filename : part.file ? basename(part.file) : name;
|
||||
if (part.buffer) return append(part.buffer, filename);
|
||||
|
||||
readFile(part.file, function(err, data) {
|
||||
if (err) return callback(err);
|
||||
append(data, filename);
|
||||
});
|
||||
|
||||
} else {
|
||||
|
||||
if (typeof part.value == 'object')
|
||||
return callback(new Error('Object received for ' + name + ', expected string.'))
|
||||
|
||||
if (part.content_type) {
|
||||
return_part += '\r\n';
|
||||
return_part += 'Content-Type: ' + part.content_type;
|
||||
}
|
||||
|
||||
return_part += '\r\n\r\n';
|
||||
return_part += new Buffer(String(part.value), 'utf8').toString('binary');
|
||||
append();
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// flattens nested objects for multipart body
|
||||
function flatten(object, into, prefix) {
|
||||
into = into || {};
|
||||
|
||||
for(var key in object) {
|
||||
var prefix_key = prefix ? prefix + '[' + key + ']' : key;
|
||||
var prop = object[key];
|
||||
|
||||
if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type))
|
||||
flatten(prop, into, prefix_key)
|
||||
else
|
||||
into[prefix_key] = prop;
|
||||
}
|
||||
|
||||
return into;
|
||||
}
|
||||
795
website/functions/node_modules/grpc/node_modules/needle/lib/needle.js
generated
vendored
Normal file
795
website/functions/node_modules/grpc/node_modules/needle/lib/needle.js
generated
vendored
Normal file
@@ -0,0 +1,795 @@
|
||||
//////////////////////////////////////////
|
||||
// Needle -- HTTP Client for Node.js
|
||||
// Written by Tomás Pollak <tomas@forkhq.com>
|
||||
// (c) 2012-2017 - Fork Ltd.
|
||||
// MIT Licensed
|
||||
//////////////////////////////////////////
|
||||
|
||||
var fs = require('fs'),
|
||||
http = require('http'),
|
||||
https = require('https'),
|
||||
url = require('url'),
|
||||
stream = require('stream'),
|
||||
debug = require('debug')('needle'),
|
||||
stringify = require('./querystring').build,
|
||||
multipart = require('./multipart'),
|
||||
auth = require('./auth'),
|
||||
cookies = require('./cookies'),
|
||||
parsers = require('./parsers'),
|
||||
decoder = require('./decoder');
|
||||
|
||||
//////////////////////////////////////////
|
||||
// variabilia
|
||||
|
||||
var version = require('../package.json').version;
|
||||
|
||||
var user_agent = 'Needle/' + version;
|
||||
user_agent += ' (Node.js ' + process.version + '; ' + process.platform + ' ' + process.arch + ')';
|
||||
|
||||
var tls_options = 'agent pfx key passphrase cert ca ciphers rejectUnauthorized secureProtocol checkServerIdentity';
|
||||
|
||||
// older versions of node (< 0.11.4) prevent the runtime from exiting
|
||||
// because of connections in keep-alive state. so if this is the case
|
||||
// we'll default new requests to set a Connection: close header.
|
||||
var close_by_default = !http.Agent || http.Agent.defaultMaxSockets != Infinity;
|
||||
|
||||
// see if we have Object.assign. otherwise fall back to util._extend
|
||||
var extend = Object.assign ? Object.assign : require('util')._extend;
|
||||
|
||||
// these are the status codes that Needle interprets as redirects.
|
||||
var redirect_codes = [301, 302, 303, 307];
|
||||
|
||||
//////////////////////////////////////////
|
||||
// decompressors for gzip/deflate bodies
|
||||
|
||||
var decompressors = {};
|
||||
|
||||
try {
|
||||
|
||||
var zlib = require('zlib');
|
||||
decompressors['x-deflate'] = zlib.Inflate;
|
||||
decompressors['deflate'] = zlib.Inflate;
|
||||
decompressors['x-gzip'] = zlib.Gunzip;
|
||||
decompressors['gzip'] = zlib.Gunzip;
|
||||
|
||||
// Enable Z_SYNC_FLUSH to avoid Z_BUF_ERROR errors (Node PR #2595)
|
||||
var zlib_options = {
|
||||
flush: zlib.Z_SYNC_FLUSH,
|
||||
finishFlush: zlib.Z_SYNC_FLUSH
|
||||
}
|
||||
|
||||
} catch(e) { /* zlib not available */ }
|
||||
|
||||
//////////////////////////////////////////
|
||||
// options and aliases
|
||||
|
||||
var defaults = {
|
||||
// data
|
||||
boundary : '--------------------NODENEEDLEHTTPCLIENT',
|
||||
encoding : 'utf8',
|
||||
parse_response : 'all', // same as true. valid options: 'json', 'xml' or false/null
|
||||
proxy : null,
|
||||
|
||||
// headers
|
||||
accept : '*/*',
|
||||
user_agent : user_agent,
|
||||
|
||||
// numbers
|
||||
open_timeout : 10000,
|
||||
response_timeout : 0,
|
||||
read_timeout : 0,
|
||||
follow_max : 0,
|
||||
stream_length : -1,
|
||||
|
||||
// booleans
|
||||
decode_response : true,
|
||||
parse_cookies : true,
|
||||
follow_set_cookies : false,
|
||||
follow_set_referer : false,
|
||||
follow_keep_method : false,
|
||||
follow_if_same_host : false,
|
||||
follow_if_same_protocol : false
|
||||
}
|
||||
|
||||
var aliased = {
|
||||
options: {
|
||||
decode : 'decode_response',
|
||||
parse : 'parse_response',
|
||||
timeout : 'open_timeout',
|
||||
follow : 'follow_max'
|
||||
},
|
||||
inverted: {}
|
||||
}
|
||||
|
||||
// only once, invert aliased keys so we can get passed options.
|
||||
Object.keys(aliased.options).map(function(k) {
|
||||
var value = aliased.options[k];
|
||||
aliased.inverted[value] = k;
|
||||
});
|
||||
|
||||
//////////////////////////////////////////
|
||||
// helpers
|
||||
|
||||
function keys_by_type(type) {
|
||||
return Object.keys(defaults).map(function(el) {
|
||||
if (defaults[el] !== null && defaults[el].constructor == type)
|
||||
return el;
|
||||
}).filter(function(el) { return el })
|
||||
}
|
||||
|
||||
function parse_content_type(header) {
|
||||
if (!header || header === '') return {};
|
||||
|
||||
var found, charset = 'iso-8859-1', arr = header.split(';');
|
||||
|
||||
if (arr.length > 1 && (found = arr[1].match(/charset=(.+)/)))
|
||||
charset = found[1];
|
||||
|
||||
return { type: arr[0], charset: charset };
|
||||
}
|
||||
|
||||
function is_stream(obj) {
|
||||
return typeof obj.pipe === 'function';
|
||||
}
|
||||
|
||||
function get_stream_length(stream, given_length, cb) {
|
||||
if (given_length > 0)
|
||||
return cb(given_length);
|
||||
|
||||
if (stream.end !== void 0 && stream.end !== Infinity && stream.start !== void 0)
|
||||
return cb((stream.end + 1) - (stream.start || 0));
|
||||
|
||||
fs.stat(stream.path, function(err, stat) {
|
||||
cb(stat ? stat.size - (stream.start || 0) : null);
|
||||
});
|
||||
}
|
||||
|
||||
//////////////////////////////////////////
|
||||
// the main act
|
||||
|
||||
function Needle(method, uri, data, options, callback) {
|
||||
// if (!(this instanceof Needle)) {
|
||||
// return new Needle(method, uri, data, options, callback);
|
||||
// }
|
||||
|
||||
if (typeof uri !== 'string')
|
||||
throw new TypeError('URL must be a string, not ' + uri);
|
||||
|
||||
this.method = method;
|
||||
this.uri = uri;
|
||||
this.data = data;
|
||||
|
||||
if (typeof options == 'function') {
|
||||
this.callback = options;
|
||||
this.options = {};
|
||||
} else {
|
||||
this.callback = callback;
|
||||
this.options = options;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Needle.prototype.setup = function(uri, options) {
|
||||
|
||||
function get_option(key, fallback) {
|
||||
// if original is in options, return that value
|
||||
if (typeof options[key] != 'undefined') return options[key];
|
||||
|
||||
// otherwise, return value from alias or fallback/undefined
|
||||
return typeof options[aliased.inverted[key]] != 'undefined'
|
||||
? options[aliased.inverted[key]] : fallback;
|
||||
}
|
||||
|
||||
function check_value(expected, key) {
|
||||
var value = get_option(key),
|
||||
type = typeof value;
|
||||
|
||||
if (type != 'undefined' && type != expected)
|
||||
throw new TypeError(type + ' received for ' + key + ', but expected a ' + expected);
|
||||
|
||||
return (type == expected) ? value : defaults[key];
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////
|
||||
// the basics
|
||||
|
||||
var config = {
|
||||
http_opts : {
|
||||
localAddress: get_option('localAddress', undefined)
|
||||
}, // passed later to http.request() directly
|
||||
output : options.output,
|
||||
proxy : get_option('proxy', defaults.proxy),
|
||||
parser : get_option('parse_response', defaults.parse_response),
|
||||
encoding : options.encoding || (options.multipart ? 'binary' : defaults.encoding)
|
||||
}
|
||||
|
||||
keys_by_type(Boolean).forEach(function(key) {
|
||||
config[key] = check_value('boolean', key);
|
||||
})
|
||||
|
||||
keys_by_type(Number).forEach(function(key) {
|
||||
config[key] = check_value('number', key);
|
||||
})
|
||||
|
||||
// populate http_opts with given TLS options
|
||||
tls_options.split(' ').forEach(function(key) {
|
||||
if (typeof options[key] != 'undefined') {
|
||||
config.http_opts[key] = options[key];
|
||||
if (typeof options.agent == 'undefined')
|
||||
config.http_opts.agent = false; // otherwise tls options are skipped
|
||||
}
|
||||
});
|
||||
|
||||
//////////////////////////////////////////////////
|
||||
// headers, cookies
|
||||
|
||||
config.headers = {
|
||||
'accept' : options.accept || defaults.accept,
|
||||
'user-agent' : options.user_agent || defaults.user_agent
|
||||
}
|
||||
|
||||
if (options.content_type)
|
||||
config.headers['content-type'] = options.content_type;
|
||||
|
||||
// set connection header if opts.connection was passed, or if node < 0.11.4 (close)
|
||||
if (options.connection || close_by_default)
|
||||
config.headers['connection'] = options.connection || 'close';
|
||||
|
||||
if ((options.compressed || defaults.compressed) && typeof zlib != 'undefined')
|
||||
config.headers['accept-encoding'] = 'gzip,deflate';
|
||||
|
||||
if (options.cookies)
|
||||
config.headers['cookie'] = cookies.write(options.cookies);
|
||||
|
||||
//////////////////////////////////////////////////
|
||||
// basic/digest auth
|
||||
|
||||
if (uri.match(/[^\/]@/)) { // url contains user:pass@host, so parse it.
|
||||
var parts = (url.parse(uri).auth || '').split(':');
|
||||
options.username = parts[0];
|
||||
options.password = parts[1];
|
||||
}
|
||||
|
||||
if (options.username) {
|
||||
if (options.auth && (options.auth == 'auto' || options.auth == 'digest')) {
|
||||
config.credentials = [options.username, options.password];
|
||||
} else {
|
||||
config.headers['authorization'] = auth.basic(options.username, options.password);
|
||||
}
|
||||
}
|
||||
|
||||
// if proxy is present, set auth header from either url or proxy_user option.
|
||||
if (config.proxy) {
|
||||
if (config.proxy.indexOf('http') === -1)
|
||||
config.proxy = 'http://' + config.proxy;
|
||||
|
||||
if (config.proxy.indexOf('@') !== -1) {
|
||||
var proxy = (url.parse(config.proxy).auth || '').split(':');
|
||||
options.proxy_user = proxy[0];
|
||||
options.proxy_pass = proxy[1];
|
||||
}
|
||||
|
||||
if (options.proxy_user)
|
||||
config.headers['proxy-authorization'] = auth.basic(options.proxy_user, options.proxy_pass);
|
||||
}
|
||||
|
||||
// now that all our headers are set, overwrite them if instructed.
|
||||
for (var h in options.headers)
|
||||
config.headers[h.toLowerCase()] = options.headers[h];
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
Needle.prototype.start = function() {
|
||||
|
||||
var out = new stream.PassThrough({ objectMode: false }),
|
||||
uri = this.uri,
|
||||
data = this.data,
|
||||
method = this.method,
|
||||
callback = (typeof this.options == 'function') ? this.options : this.callback,
|
||||
options = this.options || {};
|
||||
|
||||
// if no 'http' is found on URL, prepend it.
|
||||
if (uri.indexOf('http') === -1)
|
||||
uri = uri.replace(/^(\/\/)?/, 'http://');
|
||||
|
||||
var self = this, body, waiting = false, config = this.setup(uri, options);
|
||||
|
||||
// unless options.json was set to false, assume boss also wants JSON if content-type matches.
|
||||
var json = options.json || (options.json !== false && config.headers['content-type'] == 'application/json');
|
||||
|
||||
if (data) {
|
||||
|
||||
if (options.multipart) { // boss says we do multipart. so we do it.
|
||||
var boundary = options.boundary || defaults.boundary;
|
||||
|
||||
waiting = true;
|
||||
multipart.build(data, boundary, function(err, parts) {
|
||||
if (err) throw(err);
|
||||
|
||||
config.headers['content-type'] = 'multipart/form-data; boundary=' + boundary;
|
||||
next(parts);
|
||||
});
|
||||
|
||||
} else if (is_stream(data)) {
|
||||
|
||||
if (method.toUpperCase() == 'GET')
|
||||
throw new Error('Refusing to pipe() a stream via GET. Did you mean .post?');
|
||||
|
||||
if (config.stream_length > 0 || (config.stream_length === 0 && data.path)) {
|
||||
// ok, let's get the stream's length and set it as the content-length header.
|
||||
// this prevents some servers from cutting us off before all the data is sent.
|
||||
waiting = true;
|
||||
get_stream_length(data, config.stream_length, function(length) {
|
||||
data.length = length;
|
||||
next(data);
|
||||
})
|
||||
|
||||
} else {
|
||||
// if the boss doesn't want us to get the stream's length, or if it doesn't
|
||||
// have a file descriptor for that purpose, then just head on.
|
||||
body = data;
|
||||
}
|
||||
|
||||
} else if (Buffer.isBuffer(data)) {
|
||||
|
||||
body = data; // use the raw buffer as request body.
|
||||
|
||||
} else if (method.toUpperCase() == 'GET' && !json) {
|
||||
|
||||
// append the data to the URI as a querystring.
|
||||
uri = uri.replace(/\?.*|$/, '?' + stringify(data));
|
||||
|
||||
} else { // string or object data, no multipart.
|
||||
|
||||
// if string, leave it as it is, otherwise, stringify.
|
||||
body = (typeof(data) === 'string') ? data
|
||||
: json ? JSON.stringify(data) : stringify(data);
|
||||
|
||||
// ensure we have a buffer so bytecount is correct.
|
||||
body = new Buffer(body, config.encoding);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function next(body) {
|
||||
if (body) {
|
||||
if (body.length) config.headers['content-length'] = body.length;
|
||||
|
||||
// if no content-type was passed, determine if json or not.
|
||||
if (!config.headers['content-type']) {
|
||||
config.headers['content-type'] = json
|
||||
? 'application/json; charset=utf-8'
|
||||
: 'application/x-www-form-urlencoded'; // no charset says W3 spec.
|
||||
}
|
||||
}
|
||||
|
||||
// unless a specific accept header was set, assume json: true wants JSON back.
|
||||
if (options.json && (!options.accept && !(options.headers || {}).accept))
|
||||
config.headers['accept'] = 'application/json';
|
||||
|
||||
self.send_request(1, method, uri, config, body, out, callback);
|
||||
}
|
||||
|
||||
if (!waiting) next(body);
|
||||
return out;
|
||||
}
|
||||
|
||||
Needle.prototype.get_request_opts = function(method, uri, config) {
|
||||
var opts = config.http_opts,
|
||||
proxy = config.proxy,
|
||||
remote = proxy ? url.parse(proxy) : url.parse(uri);
|
||||
|
||||
opts.protocol = remote.protocol;
|
||||
opts.host = remote.hostname;
|
||||
opts.port = remote.port || (remote.protocol == 'https:' ? 443 : 80);
|
||||
opts.path = proxy ? uri : remote.pathname + (remote.search || '');
|
||||
opts.method = method;
|
||||
opts.headers = config.headers;
|
||||
|
||||
if (!opts.headers['host']) {
|
||||
// if using proxy, make sure the host header shows the final destination
|
||||
var target = proxy ? url.parse(uri) : remote;
|
||||
opts.headers['host'] = target.hostname;
|
||||
|
||||
// and if a non standard port was passed, append it to the port header
|
||||
if (target.port && [80, 443].indexOf(target.port) === -1) {
|
||||
opts.headers['host'] += ':' + target.port;
|
||||
}
|
||||
}
|
||||
|
||||
return opts;
|
||||
}
|
||||
|
||||
Needle.prototype.should_follow = function(location, config, original) {
|
||||
if (!location) return false;
|
||||
|
||||
// returns true if location contains matching property (host or protocol)
|
||||
function matches(property) {
|
||||
var property = original[property];
|
||||
return location.indexOf(property) !== -1;
|
||||
}
|
||||
|
||||
// first, check whether the requested location is actually different from the original
|
||||
if (location === original)
|
||||
return false;
|
||||
|
||||
if (config.follow_if_same_host && !matches('host'))
|
||||
return false; // host does not match, so not following
|
||||
|
||||
if (config.follow_if_same_protocol && !matches('protocol'))
|
||||
return false; // procotol does not match, so not following
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Needle.prototype.send_request = function(count, method, uri, config, post_data, out, callback) {
|
||||
|
||||
var timer,
|
||||
returned = 0,
|
||||
self = this,
|
||||
request_opts = this.get_request_opts(method, uri, config),
|
||||
protocol = request_opts.protocol == 'https:' ? https : http;
|
||||
|
||||
function done(err, resp) {
|
||||
if (returned++ > 0)
|
||||
return debug('Already finished, stopping here.');
|
||||
|
||||
if (timer) clearTimeout(timer);
|
||||
request.removeListener('error', had_error);
|
||||
|
||||
if (callback)
|
||||
return callback(err, resp, resp ? resp.body : undefined);
|
||||
|
||||
// NOTE: this event used to be called 'end', but the behaviour was confusing
|
||||
// when errors ocurred, because the stream would still emit an 'end' event.
|
||||
out.emit('done', err);
|
||||
}
|
||||
|
||||
function had_error(err) {
|
||||
debug('Request error', err);
|
||||
out.emit('err', err);
|
||||
done(err || new Error('Unknown error when making request.'));
|
||||
}
|
||||
|
||||
function set_timeout(type, milisecs) {
|
||||
if (timer) clearTimeout(timer);
|
||||
if (milisecs <= 0) return;
|
||||
|
||||
timer = setTimeout(function() {
|
||||
out.emit('timeout', type);
|
||||
request.abort();
|
||||
// also invoke done() to terminate job on read_timeout
|
||||
if (type == 'read') done(new Error(type + ' timeout'));
|
||||
}, milisecs);
|
||||
}
|
||||
|
||||
// handle errors on the underlying socket, that may be closed while writing
|
||||
// for an example case, see test/long_string_spec.js. we make sure this
|
||||
// scenario ocurred by verifying the socket's writable & destroyed states.
|
||||
function on_socket_end() {
|
||||
if (!this.writable && this.destroyed === false) {
|
||||
this.destroy();
|
||||
had_error(new Error('Remote end closed socket abruptly.'))
|
||||
}
|
||||
}
|
||||
|
||||
debug('Making request #' + count, request_opts);
|
||||
var request = protocol.request(request_opts, function(resp) {
|
||||
|
||||
var headers = resp.headers;
|
||||
debug('Got response', resp.statusCode, headers);
|
||||
out.emit('response', resp);
|
||||
|
||||
set_timeout('read', config.read_timeout);
|
||||
|
||||
// if we got cookies, parse them unless we were instructed not to. make sure to include any
|
||||
// cookies that might have been set on previous redirects.
|
||||
if (config.parse_cookies && (headers['set-cookie'] || config.stored_cookies)) {
|
||||
resp.cookies = extend(config.stored_cookies || {}, cookies.read(headers['set-cookie']));
|
||||
debug('Got cookies', resp.cookies);
|
||||
}
|
||||
|
||||
// if redirect code is found, determine if we should follow it according to the given options.
|
||||
if (redirect_codes.indexOf(resp.statusCode) !== -1 && self.should_follow(headers.location, config, uri)) {
|
||||
// clear timer before following redirects to prevent unexpected setTimeout consequence
|
||||
clearTimeout(timer);
|
||||
|
||||
if (count <= config.follow_max) {
|
||||
out.emit('redirect', headers.location);
|
||||
|
||||
// unless 'follow_keep_method' is true, rewrite the request to GET before continuing.
|
||||
if (!config.follow_keep_method) {
|
||||
method = 'GET';
|
||||
post_data = null;
|
||||
delete config.headers['content-length']; // in case the original was a multipart POST request.
|
||||
}
|
||||
|
||||
// if follow_set_cookies is true, make sure to put any cookies in the next request's headers.
|
||||
if (config.follow_set_cookies && resp.cookies) {
|
||||
config.stored_cookies = resp.cookies;
|
||||
config.headers['cookie'] = cookies.write(resp.cookies);
|
||||
}
|
||||
|
||||
if (config.follow_set_referer)
|
||||
config.headers['referer'] = encodeURI(uri); // the original, not the destination URL.
|
||||
|
||||
config.headers['host'] = null; // clear previous Host header to avoid conflicts.
|
||||
|
||||
debug('Redirecting to ' + url.resolve(uri, headers.location));
|
||||
return self.send_request(++count, method, url.resolve(uri, headers.location), config, post_data, out, callback);
|
||||
} else if (config.follow_max > 0) {
|
||||
return done(new Error('Max redirects reached. Possible loop in: ' + headers.location));
|
||||
}
|
||||
}
|
||||
|
||||
// if auth is requested and credentials were not passed, resend request, provided we have user/pass.
|
||||
if (resp.statusCode == 401 && headers['www-authenticate'] && config.credentials) {
|
||||
if (!config.headers['authorization']) { // only if authentication hasn't been sent
|
||||
var auth_header = auth.header(headers['www-authenticate'], config.credentials, request_opts);
|
||||
|
||||
if (auth_header) {
|
||||
config.headers['authorization'] = auth_header;
|
||||
return self.send_request(count, method, uri, config, post_data, out, callback);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ok, so we got a valid (non-redirect & authorized) response. let's notify the stream guys.
|
||||
out.emit('header', resp.statusCode, headers);
|
||||
out.emit('headers', headers);
|
||||
|
||||
var pipeline = [],
|
||||
mime = parse_content_type(headers['content-type']),
|
||||
text_response = mime.type && mime.type.indexOf('text/') != -1;
|
||||
|
||||
// To start, if our body is compressed and we're able to inflate it, do it.
|
||||
if (headers['content-encoding'] && decompressors[headers['content-encoding']]) {
|
||||
|
||||
var decompressor = decompressors[headers['content-encoding']](zlib_options);
|
||||
|
||||
// make sure we catch errors triggered by the decompressor.
|
||||
decompressor.on('error', had_error);
|
||||
pipeline.push(decompressor);
|
||||
}
|
||||
|
||||
// If parse is enabled and we have a parser for it, then go for it.
|
||||
if (config.parser && parsers[mime.type]) {
|
||||
|
||||
// If a specific parser was requested, make sure we don't parse other types.
|
||||
var parser_name = config.parser.toString().toLowerCase();
|
||||
if (['xml', 'json'].indexOf(parser_name) == -1 || parsers[mime.type].name == parser_name) {
|
||||
|
||||
// OK, so either we're parsing all content types or the one requested matches.
|
||||
out.parser = parsers[mime.type].name;
|
||||
pipeline.push(parsers[mime.type].fn());
|
||||
|
||||
// Set objectMode on out stream to improve performance.
|
||||
out._writableState.objectMode = true;
|
||||
out._readableState.objectMode = true;
|
||||
}
|
||||
|
||||
// If we're not parsing, and unless decoding was disabled, we'll try
|
||||
// decoding non UTF-8 bodies to UTF-8, using the iconv-lite library.
|
||||
} else if (text_response && config.decode_response
|
||||
&& mime.charset && !mime.charset.match(/utf-?8$/i)) {
|
||||
pipeline.push(decoder(mime.charset));
|
||||
}
|
||||
|
||||
// And `out` is the stream we finally push the decoded/parsed output to.
|
||||
pipeline.push(out);
|
||||
|
||||
// Now, release the kraken!
|
||||
var tmp = resp;
|
||||
while (pipeline.length) {
|
||||
tmp = tmp.pipe(pipeline.shift());
|
||||
}
|
||||
|
||||
// If the user has requested and output file, pipe the output stream to it.
|
||||
// In stream mode, we will still get the response stream to play with.
|
||||
if (config.output && resp.statusCode == 200) {
|
||||
|
||||
// for some reason, simply piping resp to the writable stream doesn't
|
||||
// work all the time (stream gets cut in the middle with no warning).
|
||||
// so we'll manually need to do the readable/write(chunk) trick.
|
||||
var file = fs.createWriteStream(config.output);
|
||||
file.on('error', had_error);
|
||||
|
||||
out.on('end', function() {
|
||||
if (file.writable) file.end();
|
||||
});
|
||||
|
||||
file.on('close', function() {
|
||||
delete out.file;
|
||||
})
|
||||
|
||||
out.on('readable', function() {
|
||||
var chunk;
|
||||
while ((chunk = this.read()) !== null) {
|
||||
if (file.writable) file.write(chunk);
|
||||
|
||||
// if callback was requested, also push it to resp.body
|
||||
if (resp.body) resp.body.push(chunk);
|
||||
}
|
||||
})
|
||||
|
||||
out.file = file;
|
||||
}
|
||||
|
||||
// Only aggregate the full body if a callback was requested.
|
||||
if (callback) {
|
||||
resp.raw = [];
|
||||
resp.body = [];
|
||||
resp.bytes = 0;
|
||||
|
||||
// Gather and count the amount of (raw) bytes using a PassThrough stream.
|
||||
var clean_pipe = new stream.PassThrough();
|
||||
resp.pipe(clean_pipe);
|
||||
|
||||
clean_pipe.on('readable', function() {
|
||||
var chunk;
|
||||
while ((chunk = this.read()) != null) {
|
||||
resp.bytes += chunk.length;
|
||||
resp.raw.push(chunk);
|
||||
}
|
||||
})
|
||||
|
||||
// Listen on the 'readable' event to aggregate the chunks, but only if
|
||||
// file output wasn't requested. Otherwise we'd have two stream readers.
|
||||
if (!config.output || resp.statusCode != 200) {
|
||||
out.on('readable', function() {
|
||||
var chunk;
|
||||
while ((chunk = this.read()) !== null) {
|
||||
// We're either pushing buffers or objects, never strings.
|
||||
if (typeof chunk == 'string') chunk = new Buffer(chunk);
|
||||
|
||||
// Push all chunks to resp.body. We'll bind them in resp.end().
|
||||
resp.body.push(chunk);
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// And set the .body property once all data is in.
|
||||
out.on('end', function() {
|
||||
if (resp.body) { // callback mode
|
||||
|
||||
// we want to be able to access to the raw data later, so keep a reference.
|
||||
resp.raw = Buffer.concat(resp.raw);
|
||||
|
||||
// if parse was successful, we should have an array with one object
|
||||
if (resp.body[0] !== undefined && !Buffer.isBuffer(resp.body[0])) {
|
||||
|
||||
// that's our body right there.
|
||||
resp.body = resp.body[0];
|
||||
|
||||
// set the parser property on our response. we may want to check.
|
||||
if (out.parser) resp.parser = out.parser;
|
||||
|
||||
} else { // we got one or several buffers. string or binary.
|
||||
resp.body = Buffer.concat(resp.body);
|
||||
|
||||
// if we're here and parsed is true, it means we tried to but it didn't work.
|
||||
// so given that we got a text response, let's stringify it.
|
||||
if (text_response || out.parser) {
|
||||
resp.body = resp.body.toString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// if an output file is being written to, make sure the callback
|
||||
// is triggered after all data has been written to it.
|
||||
if (out.file) {
|
||||
out.file.on('close', function() {
|
||||
done(null, resp, resp.body);
|
||||
})
|
||||
} else { // elvis has left the building.
|
||||
done(null, resp, resp.body);
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
}); // end request call
|
||||
|
||||
// unless open_timeout was disabled, set a timeout to abort the request.
|
||||
set_timeout('open', config.open_timeout);
|
||||
|
||||
// handle errors on the request object. things might get bumpy.
|
||||
request.on('error', had_error);
|
||||
|
||||
// make sure timer is cleared if request is aborted (issue #257)
|
||||
request.once('abort', function() {
|
||||
if (timer) clearTimeout(timer);
|
||||
})
|
||||
|
||||
// handle socket 'end' event to ensure we don't get delayed EPIPE errors.
|
||||
request.once('socket', function(socket) {
|
||||
if (socket.connecting) {
|
||||
socket.once('connect', function() {
|
||||
set_timeout('response', config.response_timeout);
|
||||
})
|
||||
} else {
|
||||
set_timeout('response', config.response_timeout);
|
||||
}
|
||||
|
||||
// console.log(socket);
|
||||
if (!socket.on_socket_end) {
|
||||
socket.on_socket_end = on_socket_end;
|
||||
socket.once('end', function() { process.nextTick(on_socket_end.bind(socket)) });
|
||||
}
|
||||
})
|
||||
|
||||
if (post_data) {
|
||||
if (is_stream(post_data)) {
|
||||
post_data.pipe(request);
|
||||
} else {
|
||||
request.write(post_data, config.encoding);
|
||||
request.end();
|
||||
}
|
||||
} else {
|
||||
request.end();
|
||||
}
|
||||
|
||||
out.request = request;
|
||||
return out;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////
|
||||
// exports
|
||||
|
||||
if (typeof Promise !== 'undefined') {
|
||||
module.exports = function() {
|
||||
var verb, args = [].slice.call(arguments);
|
||||
|
||||
if (args[0].match(/\.|\//)) // first argument looks like a URL
|
||||
verb = (args.length > 2) ? 'post' : 'get';
|
||||
else
|
||||
verb = args.shift();
|
||||
|
||||
if (verb.match(/get|head/) && args.length == 2)
|
||||
args.splice(1, 0, null); // assume no data if head/get with two args (url, options)
|
||||
|
||||
return new Promise(function(resolve, reject) {
|
||||
module.exports.request(verb, args[0], args[1], args[2], function(err, resp) {
|
||||
return err ? reject(err) : resolve(resp);
|
||||
});
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
module.exports.version = version;
|
||||
|
||||
module.exports.defaults = function(obj) {
|
||||
for (var key in obj) {
|
||||
var target_key = aliased.options[key] || key;
|
||||
|
||||
if (defaults.hasOwnProperty(target_key) && typeof obj[key] != 'undefined') {
|
||||
if (target_key != 'parse_response' && target_key != 'proxy') {
|
||||
// ensure type matches the original, except for proxy/parse_response that can be null/bool or string
|
||||
var valid_type = defaults[target_key].constructor.name;
|
||||
|
||||
if (obj[key].constructor.name != valid_type)
|
||||
throw new TypeError('Invalid type for ' + key + ', should be ' + valid_type);
|
||||
}
|
||||
defaults[target_key] = obj[key];
|
||||
}
|
||||
}
|
||||
|
||||
return defaults;
|
||||
}
|
||||
|
||||
'head get'.split(' ').forEach(function(method) {
|
||||
module.exports[method] = function(uri, options, callback) {
|
||||
return new Needle(method, uri, null, options, callback).start();
|
||||
}
|
||||
})
|
||||
|
||||
'post put patch delete'.split(' ').forEach(function(method) {
|
||||
module.exports[method] = function(uri, data, options, callback) {
|
||||
return new Needle(method, uri, data, options, callback).start();
|
||||
}
|
||||
})
|
||||
|
||||
module.exports.request = function(method, uri, data, opts, callback) {
|
||||
return new Needle(method, uri, data, opts, callback).start();
|
||||
};
|
||||
120
website/functions/node_modules/grpc/node_modules/needle/lib/parsers.js
generated
vendored
Normal file
120
website/functions/node_modules/grpc/node_modules/needle/lib/parsers.js
generated
vendored
Normal file
@@ -0,0 +1,120 @@
|
||||
//////////////////////////////////////////
|
||||
// Defines mappings between content-type
|
||||
// and the appropriate parsers.
|
||||
//////////////////////////////////////////
|
||||
|
||||
var Transform = require('stream').Transform;
|
||||
var sax = require('sax');
|
||||
|
||||
function parseXML(str, cb) {
|
||||
var obj, current, parser = sax.parser(true, { trim: true, lowercase: true })
|
||||
parser.onerror = parser.onend = done;
|
||||
|
||||
function done(err) {
|
||||
parser.onerror = parser.onend = function() { }
|
||||
cb(err, obj)
|
||||
}
|
||||
|
||||
function newElement(name, attributes) {
|
||||
return {
|
||||
name: name || '',
|
||||
value: '',
|
||||
attributes: attributes || {},
|
||||
children: []
|
||||
}
|
||||
}
|
||||
|
||||
parser.ontext = function(t) {
|
||||
if (current) current.value += t
|
||||
}
|
||||
|
||||
parser.onopentag = function(node) {
|
||||
var element = newElement(node.name, node.attributes)
|
||||
if (current) {
|
||||
element.parent = current
|
||||
current.children.push(element)
|
||||
} else { // root object
|
||||
obj = element
|
||||
}
|
||||
|
||||
current = element
|
||||
};
|
||||
|
||||
parser.onclosetag = function() {
|
||||
if (typeof current.parent !== 'undefined') {
|
||||
var just_closed = current
|
||||
current = current.parent
|
||||
delete just_closed.parent
|
||||
}
|
||||
}
|
||||
|
||||
parser.write(str).close()
|
||||
}
|
||||
|
||||
function parserFactory(name, fn) {
|
||||
|
||||
function parser() {
|
||||
var chunks = [],
|
||||
stream = new Transform({ objectMode: true });
|
||||
|
||||
// Buffer all our data
|
||||
stream._transform = function(chunk, encoding, done) {
|
||||
chunks.push(chunk);
|
||||
done();
|
||||
}
|
||||
|
||||
// And call the parser when all is there.
|
||||
stream._flush = function(done) {
|
||||
var self = this,
|
||||
data = Buffer.concat(chunks);
|
||||
|
||||
try {
|
||||
fn(data, function(err, result) {
|
||||
if (err) throw err;
|
||||
self.push(result);
|
||||
});
|
||||
} catch (err) {
|
||||
self.push(data); // just pass the original data
|
||||
} finally {
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
return stream;
|
||||
}
|
||||
|
||||
return { fn: parser, name: name };
|
||||
}
|
||||
|
||||
var parsers = {}
|
||||
|
||||
function buildParser(name, types, fn) {
|
||||
var parser = parserFactory(name, fn);
|
||||
types.forEach(function(type) {
|
||||
parsers[type] = parser;
|
||||
})
|
||||
}
|
||||
|
||||
buildParser('json', [
|
||||
'application/json',
|
||||
'text/javascript'
|
||||
], function(buffer, cb) {
|
||||
var err, data;
|
||||
try { data = JSON.parse(buffer); } catch (e) { err = e; }
|
||||
cb(err, data);
|
||||
});
|
||||
|
||||
buildParser('xml', [
|
||||
'text/xml',
|
||||
'application/xml',
|
||||
'application/rdf+xml',
|
||||
'application/rss+xml',
|
||||
'application/atom+xml'
|
||||
], function(buffer, cb) {
|
||||
parseXML(buffer.toString(), function(err, obj) {
|
||||
cb(err, obj)
|
||||
})
|
||||
});
|
||||
|
||||
module.exports = parsers;
|
||||
module.exports.use = buildParser;
|
||||
49
website/functions/node_modules/grpc/node_modules/needle/lib/querystring.js
generated
vendored
Normal file
49
website/functions/node_modules/grpc/node_modules/needle/lib/querystring.js
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
// based on the qs module, but handles null objects as expected
|
||||
// fixes by Tomas Pollak.
|
||||
|
||||
var toString = Object.prototype.toString;
|
||||
|
||||
function stringify(obj, prefix) {
|
||||
if (prefix && (obj === null || typeof obj == 'undefined')) {
|
||||
return prefix + '=';
|
||||
} else if (toString.call(obj) == '[object Array]') {
|
||||
return stringifyArray(obj, prefix);
|
||||
} else if (toString.call(obj) == '[object Object]') {
|
||||
return stringifyObject(obj, prefix);
|
||||
} else if (toString.call(obj) == '[object Date]') {
|
||||
return obj.toISOString();
|
||||
} else if (prefix) { // string inside array or hash
|
||||
return prefix + '=' + encodeURIComponent(String(obj));
|
||||
} else if (String(obj).indexOf('=') !== -1) { // string with equal sign
|
||||
return String(obj);
|
||||
} else {
|
||||
throw new TypeError('Cannot build a querystring out of: ' + obj);
|
||||
}
|
||||
};
|
||||
|
||||
function stringifyArray(arr, prefix) {
|
||||
var ret = [];
|
||||
|
||||
for (var i = 0, len = arr.length; i < len; i++) {
|
||||
if (prefix)
|
||||
ret.push(stringify(arr[i], prefix + '[]'));
|
||||
else
|
||||
ret.push(stringify(arr[i]));
|
||||
}
|
||||
|
||||
return ret.join('&');
|
||||
}
|
||||
|
||||
function stringifyObject(obj, prefix) {
|
||||
var ret = [];
|
||||
|
||||
Object.keys(obj).forEach(function(key) {
|
||||
ret.push(stringify(obj[key], prefix
|
||||
? prefix + '[' + encodeURIComponent(key) + ']'
|
||||
: encodeURIComponent(key)));
|
||||
})
|
||||
|
||||
return ret.join('&');
|
||||
}
|
||||
|
||||
exports.build = stringify;
|
||||
19
website/functions/node_modules/grpc/node_modules/needle/license.txt
generated
vendored
Normal file
19
website/functions/node_modules/grpc/node_modules/needle/license.txt
generated
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
Copyright (c) Fork, Ltd.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
7
website/functions/node_modules/grpc/node_modules/needle/note.xml
generated
vendored
Normal file
7
website/functions/node_modules/grpc/node_modules/needle/note.xml
generated
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<note>
|
||||
<to>Tove</to>
|
||||
<from>Jani</from>
|
||||
<heading>Reminder</heading>
|
||||
<body>Don't forget me this weekend!</body>
|
||||
</note>
|
||||
7
website/functions/node_modules/grpc/node_modules/needle/note.xml.1
generated
vendored
Normal file
7
website/functions/node_modules/grpc/node_modules/needle/note.xml.1
generated
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<note>
|
||||
<to>Tove</to>
|
||||
<from>Jani</from>
|
||||
<heading>Reminder</heading>
|
||||
<body>Don't forget me this weekend!</body>
|
||||
</note>
|
||||
102
website/functions/node_modules/grpc/node_modules/needle/package.json
generated
vendored
Normal file
102
website/functions/node_modules/grpc/node_modules/needle/package.json
generated
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
{
|
||||
"_from": "needle@^2.2.1",
|
||||
"_id": "needle@2.2.4",
|
||||
"_inBundle": true,
|
||||
"_integrity": "sha512-HyoqEb4wr/rsoaIDfTH2aVL9nWtQqba2/HvMv+++m8u0dz808MaagKILxtfeSN7QU7nvbQ79zk3vYOJp9zsNEA==",
|
||||
"_location": "/grpc/needle",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "needle@^2.2.1",
|
||||
"name": "needle",
|
||||
"escapedName": "needle",
|
||||
"rawSpec": "^2.2.1",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "^2.2.1"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/grpc/node-pre-gyp"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/needle/-/needle-2.2.4.tgz",
|
||||
"_shasum": "51931bff82533b1928b7d1d69e01f1b00ffd2a4e",
|
||||
"_spec": "needle@^2.2.1",
|
||||
"_where": "/home/pixel/sources/grpc-node/packages/grpc-native-core/node_modules/node-pre-gyp",
|
||||
"author": {
|
||||
"name": "Tomás Pollak",
|
||||
"email": "tomas@forkhq.com"
|
||||
},
|
||||
"bin": {
|
||||
"needle": "./bin/needle"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/tomas/needle/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"dependencies": {
|
||||
"debug": "^2.1.2",
|
||||
"iconv-lite": "^0.4.4",
|
||||
"sax": "^1.2.4"
|
||||
},
|
||||
"deprecated": false,
|
||||
"description": "The leanest and most handsome HTTP client in the Nodelands.",
|
||||
"devDependencies": {
|
||||
"JSONStream": "",
|
||||
"jschardet": "",
|
||||
"mocha": "",
|
||||
"q": "",
|
||||
"should": "^13.2.3",
|
||||
"sinon": "^2.3.0",
|
||||
"xml2js": ""
|
||||
},
|
||||
"directories": {
|
||||
"lib": "./lib"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 0.10.x"
|
||||
},
|
||||
"homepage": "https://github.com/tomas/needle#readme",
|
||||
"keywords": [
|
||||
"http",
|
||||
"https",
|
||||
"simple",
|
||||
"request",
|
||||
"client",
|
||||
"multipart",
|
||||
"upload",
|
||||
"proxy",
|
||||
"deflate",
|
||||
"timeout",
|
||||
"charset",
|
||||
"iconv",
|
||||
"cookie",
|
||||
"redirect"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "./lib/needle",
|
||||
"name": "needle",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/tomas/needle.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "mocha test"
|
||||
},
|
||||
"tags": [
|
||||
"http",
|
||||
"https",
|
||||
"simple",
|
||||
"request",
|
||||
"client",
|
||||
"multipart",
|
||||
"upload",
|
||||
"proxy",
|
||||
"deflate",
|
||||
"timeout",
|
||||
"charset",
|
||||
"iconv",
|
||||
"cookie",
|
||||
"redirect"
|
||||
],
|
||||
"version": "2.2.4"
|
||||
}
|
||||
196
website/functions/node_modules/grpc/node_modules/needle/test/basic_auth_spec.js
generated
vendored
Normal file
196
website/functions/node_modules/grpc/node_modules/needle/test/basic_auth_spec.js
generated
vendored
Normal file
@@ -0,0 +1,196 @@
|
||||
var helpers = require('./helpers'),
|
||||
should = require('should'),
|
||||
needle = require('./../'),
|
||||
server;
|
||||
|
||||
var port = 7707;
|
||||
|
||||
describe('Basic Auth', function() {
|
||||
|
||||
before(function(done) {
|
||||
server = helpers.server({ port: port }, done);
|
||||
})
|
||||
|
||||
after(function(done) {
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
///////////////// helpers
|
||||
|
||||
var get_auth = function(header) {
|
||||
var token = header.split(/\s+/).pop();
|
||||
return token && new Buffer(token, 'base64').toString().split(':');
|
||||
}
|
||||
|
||||
describe('when neither username or password are passed', function() {
|
||||
|
||||
it('doesnt send any Authorization headers', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.not.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when username is an empty string, and password is a valid string', function() {
|
||||
|
||||
var opts = { username: '', password: 'foobar', parse: true };
|
||||
|
||||
it('doesnt send any Authorization headers', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.not.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
});
|
||||
|
||||
describe('when username is a valid string, but no username is passed', function() {
|
||||
|
||||
var opts = { username: 'foobar', parse: true };
|
||||
|
||||
it('sends Authorization header', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('Basic Auth only includes username, without colon', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
var auth = get_auth(sent_headers['authorization']);
|
||||
auth[0].should.equal('foobar');
|
||||
auth.should.have.lengthOf(1);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when username is a valid string, and password is null', function() {
|
||||
|
||||
var opts = { username: 'foobar', password: null, parse: true };
|
||||
|
||||
it('sends Authorization header', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('Basic Auth only includes both username and password', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
var auth = get_auth(sent_headers['authorization']);
|
||||
auth[0].should.equal('foobar');
|
||||
auth[1].should.equal('');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when username is a valid string, and password is an empty string', function() {
|
||||
|
||||
var opts = { username: 'foobar', password: '', parse: true };
|
||||
|
||||
it('sends Authorization header', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('Basic Auth only includes both username and password', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
var auth = get_auth(sent_headers['authorization']);
|
||||
auth[0].should.equal('foobar');
|
||||
auth[1].should.equal('');
|
||||
auth.should.have.lengthOf(2);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when username AND password are non empty strings', function() {
|
||||
|
||||
var opts = { username: 'foobar', password: 'jakub', parse: true };
|
||||
|
||||
it('sends Authorization header', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('Basic Auth only includes both user and password', function(done) {
|
||||
needle.get('localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
var auth = get_auth(sent_headers['authorization']);
|
||||
auth[0].should.equal('foobar');
|
||||
auth[1].should.equal('jakub');
|
||||
auth.should.have.lengthOf(2);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('URL with @ but not username/pass', function() {
|
||||
it('doesnt send Authorization header', function(done) {
|
||||
var url = 'localhost:' + port + '/abc/@def/xyz.zip';
|
||||
|
||||
needle.get(url, {}, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.not.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('sends user:pass headers if passed via options', function(done) {
|
||||
var url = 'localhost:' + port + '/abc/@def/xyz.zip';
|
||||
|
||||
needle.get(url, { username: 'foo' }, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.containEql('authorization');
|
||||
sent_headers['authorization'].should.eql('Basic Zm9v')
|
||||
done();
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('when username/password are included in URL', function() {
|
||||
var opts = { parse: true };
|
||||
|
||||
it('sends Authorization header', function(done) {
|
||||
needle.get('foobar:jakub@localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
Object.keys(sent_headers).should.containEql('authorization');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('Basic Auth only includes both user and password', function(done) {
|
||||
needle.get('foobar:jakub@localhost:' + port, opts, function(err, resp) {
|
||||
var sent_headers = resp.body.headers;
|
||||
var auth = get_auth(sent_headers['authorization']);
|
||||
auth[0].should.equal('foobar');
|
||||
auth[1].should.equal('jakub');
|
||||
auth.should.have.lengthOf(2);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
94
website/functions/node_modules/grpc/node_modules/needle/test/compression_spec.js
generated
vendored
Normal file
94
website/functions/node_modules/grpc/node_modules/needle/test/compression_spec.js
generated
vendored
Normal file
@@ -0,0 +1,94 @@
|
||||
var should = require('should'),
|
||||
needle = require('./../'),
|
||||
http = require('http'),
|
||||
zlib = require('zlib'),
|
||||
stream = require('stream'),
|
||||
port = 11123,
|
||||
server;
|
||||
|
||||
describe('compression', function(){
|
||||
|
||||
require.bind(null, 'zlib').should.not.throw()
|
||||
|
||||
var jsonData = '{"foo":"bar"}';
|
||||
|
||||
describe('when server supports compression', function(){
|
||||
|
||||
before(function(){
|
||||
server = http.createServer(function(req, res) {
|
||||
var raw = new stream.PassThrough();
|
||||
|
||||
var acceptEncoding = req.headers['accept-encoding'];
|
||||
if (!acceptEncoding) {
|
||||
acceptEncoding = '';
|
||||
}
|
||||
|
||||
if (acceptEncoding.match(/\bdeflate\b/)) {
|
||||
res.setHeader('Content-Encoding', 'deflate');
|
||||
raw.pipe(zlib.createDeflate()).pipe(res);
|
||||
} else if (acceptEncoding.match(/\bgzip\b/)) {
|
||||
res.setHeader('Content-Encoding', 'gzip');
|
||||
raw.pipe(zlib.createGzip()).pipe(res);
|
||||
} else {
|
||||
raw.pipe(res);
|
||||
}
|
||||
|
||||
res.setHeader('Content-Type', 'application/json')
|
||||
if (req.headers['with-bad']) {
|
||||
res.end('foo'); // end, no deflate data
|
||||
} else {
|
||||
raw.end(jsonData)
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
server.listen(port);
|
||||
});
|
||||
|
||||
after(function(done){
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('and client requests no compression', function() {
|
||||
it('should have the body decompressed', function(done){
|
||||
needle.get('localhost:' + port, function(err, response, body){
|
||||
should.ifError(err);
|
||||
body.should.have.property('foo', 'bar');
|
||||
response.bytes.should.equal(jsonData.length);
|
||||
done();
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('and client requests gzip compression', function() {
|
||||
it('should have the body decompressed', function(done){
|
||||
needle.get('localhost:' + port, {headers: {'Accept-Encoding': 'gzip'}}, function(err, response, body){
|
||||
should.ifError(err);
|
||||
body.should.have.property('foo', 'bar');
|
||||
response.bytes.should.not.equal(jsonData.length);
|
||||
done();
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('and client requests deflate compression', function() {
|
||||
it('should have the body decompressed', function(done){
|
||||
needle.get('localhost:' + port, {headers: {'Accept-Encoding': 'deflate'}}, function(err, response, body){
|
||||
should.ifError(err);
|
||||
body.should.have.property('foo', 'bar');
|
||||
response.bytes.should.not.equal(jsonData.length);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should rethrow errors from decompressors', function(done){
|
||||
needle.get('localhost:' + port, {headers: {'Accept-Encoding': 'deflate', 'With-Bad': 'true'}}, function(err, response, body) {
|
||||
should.exist(err);
|
||||
err.message.should.equal("incorrect header check");
|
||||
err.code.should.equal("Z_DATA_ERROR")
|
||||
done();
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
305
website/functions/node_modules/grpc/node_modules/needle/test/cookies_spec.js
generated
vendored
Normal file
305
website/functions/node_modules/grpc/node_modules/needle/test/cookies_spec.js
generated
vendored
Normal file
@@ -0,0 +1,305 @@
|
||||
var needle = require('../'),
|
||||
cookies = require('../lib/cookies'),
|
||||
sinon = require('sinon'),
|
||||
http = require('http'),
|
||||
should = require('should'),
|
||||
assert = require('assert');
|
||||
|
||||
var WEIRD_COOKIE_NAME = 'wc',
|
||||
BASE64_COOKIE_NAME = 'bc',
|
||||
FORBIDDEN_COOKIE_NAME = 'fc',
|
||||
NUMBER_COOKIE_NAME = 'nc';
|
||||
|
||||
var WEIRD_COOKIE_VALUE = '!\'*+#()&-./0123456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~',
|
||||
BASE64_COOKIE_VALUE = 'Y29va2llCg==',
|
||||
FORBIDDEN_COOKIE_VALUE = ' ;"\\,',
|
||||
NUMBER_COOKIE_VALUE = 12354342;
|
||||
|
||||
var TEST_HOST = 'localhost',
|
||||
NO_COOKIES_TEST_PORT = 11112,
|
||||
ALL_COOKIES_TEST_PORT = 11113;
|
||||
|
||||
describe('cookies', function() {
|
||||
|
||||
var setCookieHeader, headers, server, opts;
|
||||
|
||||
function decode(str) {
|
||||
return decodeURIComponent(str);
|
||||
}
|
||||
|
||||
function encode(str) {
|
||||
str = str.toString().replace(/[\x00-\x1F\x7F]/g, encodeURIComponent);
|
||||
return str.replace(/[\s\"\,;\\%]/g, encodeURIComponent);
|
||||
}
|
||||
|
||||
before(function() {
|
||||
setCookieHeader = [
|
||||
WEIRD_COOKIE_NAME + '=' + encode(WEIRD_COOKIE_VALUE) + ';',
|
||||
BASE64_COOKIE_NAME + '=' + encode(BASE64_COOKIE_VALUE) + ';',
|
||||
FORBIDDEN_COOKIE_NAME + '=' + encode(FORBIDDEN_COOKIE_VALUE) + ';',
|
||||
NUMBER_COOKIE_NAME + '=' + encode(NUMBER_COOKIE_VALUE) + ';'
|
||||
];
|
||||
});
|
||||
|
||||
before(function(done) {
|
||||
serverAllCookies = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'text/html');
|
||||
res.setHeader('Set-Cookie', setCookieHeader);
|
||||
res.end('200');
|
||||
}).listen(ALL_COOKIES_TEST_PORT, TEST_HOST, done);
|
||||
});
|
||||
|
||||
after(function(done) {
|
||||
serverAllCookies.close(done);
|
||||
});
|
||||
|
||||
describe('with default options', function() {
|
||||
it('no cookie header is set on request', function(done) {
|
||||
needle.get(
|
||||
TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, function(err, response) {
|
||||
assert(!response.req._headers.cookie);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('if response does not contain cookies', function() {
|
||||
before(function(done) {
|
||||
serverNoCookies = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'text/html');
|
||||
res.end('200');
|
||||
}).listen(NO_COOKIES_TEST_PORT, TEST_HOST, done);
|
||||
});
|
||||
|
||||
it('response.cookies is undefined', function(done) {
|
||||
needle.get(
|
||||
TEST_HOST + ':' + NO_COOKIES_TEST_PORT, function(error, response) {
|
||||
assert(!response.cookies);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
after(function(done) {
|
||||
serverNoCookies.close(done);
|
||||
});
|
||||
});
|
||||
|
||||
describe('if response contains cookies', function() {
|
||||
|
||||
it('puts them on resp.cookies', function(done) {
|
||||
needle.get(
|
||||
TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, function(error, response) {
|
||||
response.should.have.property('cookies');
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('parses them as a object', function(done) {
|
||||
needle.get(
|
||||
TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, function(error, response) {
|
||||
response.cookies.should.be.an.instanceOf(Object)
|
||||
.and.have.property(WEIRD_COOKIE_NAME);
|
||||
response.cookies.should.have.property(BASE64_COOKIE_NAME);
|
||||
response.cookies.should.have.property(FORBIDDEN_COOKIE_NAME);
|
||||
response.cookies.should.have.property(NUMBER_COOKIE_NAME);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('must decode it', function(done) {
|
||||
needle.get(
|
||||
TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, function(error, response) {
|
||||
response.cookies.wc.should.be.eql(WEIRD_COOKIE_VALUE);
|
||||
response.cookies.bc.should.be.eql(BASE64_COOKIE_VALUE);
|
||||
response.cookies.fc.should.be.eql(FORBIDDEN_COOKIE_VALUE);
|
||||
response.cookies.nc.should.be.eql(NUMBER_COOKIE_VALUE.toString());
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
describe('when a cookie value is invalid', function() {
|
||||
|
||||
before(function() {
|
||||
setCookieHeader = [
|
||||
'geo_city=%D1%E0%ED%EA%F2-%CF%E5%F2%E5%F0%E1%F3%F0%E3'
|
||||
];
|
||||
})
|
||||
|
||||
it('doesnt blow up', function(done) {
|
||||
needle.get(TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, function(error, response) {
|
||||
should.not.exist(error)
|
||||
var whatever = 'efbfbdefbfbdefbfbdefbfbdefbfbd2defbfbdefbfbdefbfbdefbfbdefbfbdefbfbdefbfbdefbfbdefbfbd';
|
||||
new Buffer(response.cookies.geo_city).toString('hex').should.eql(whatever)
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and response is a redirect', function() {
|
||||
|
||||
var redirectServer, testPort = 22222;
|
||||
|
||||
var responseCookies = [
|
||||
[ // first req
|
||||
WEIRD_COOKIE_NAME + '=' + encode(WEIRD_COOKIE_VALUE) + ';',
|
||||
BASE64_COOKIE_NAME + '=' + encode(BASE64_COOKIE_VALUE) + ';',
|
||||
'FOO=123;'
|
||||
], [ // second req
|
||||
FORBIDDEN_COOKIE_NAME + '=' + encode(FORBIDDEN_COOKIE_VALUE) + ';',
|
||||
NUMBER_COOKIE_NAME + '=' + encode(NUMBER_COOKIE_VALUE) + ';'
|
||||
], [ // third red
|
||||
'FOO=BAR;'
|
||||
]
|
||||
]
|
||||
|
||||
before(function() {
|
||||
redirectServer = http.createServer(function(req, res) {
|
||||
var number = parseInt(req.url.replace('/', ''));
|
||||
var nextUrl = 'http://' + TEST_HOST + ':' + testPort + '/' + (number + 1);
|
||||
|
||||
if (responseCookies[number]) { // got cookies
|
||||
res.statusCode = 302;
|
||||
res.setHeader('Set-Cookie', responseCookies[number]);
|
||||
res.setHeader('Location', nextUrl);
|
||||
} else if (number == 3) {
|
||||
res.statusCode = 302; // redirect but without cookies
|
||||
res.setHeader('Location', nextUrl);
|
||||
}
|
||||
|
||||
res.end('OK');
|
||||
}).listen(22222, TEST_HOST);
|
||||
});
|
||||
|
||||
after(function(done) {
|
||||
redirectServer.close(done);
|
||||
})
|
||||
|
||||
describe('and follow_set_cookies is false', function() {
|
||||
|
||||
var opts = {
|
||||
follow_set_cookies: false,
|
||||
follow_max: 4
|
||||
};
|
||||
|
||||
it('no cookie header set on redirection request', function(done) {
|
||||
var spy = sinon.spy(cookies, 'write');
|
||||
|
||||
needle.get(TEST_HOST + ':' + testPort + '/0', opts, function(err, resp) {
|
||||
spy.callCount.should.eql(0);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('and follow_set_cookies is true', function() {
|
||||
var opts = {
|
||||
follow_set_cookies: true,
|
||||
follow_max: 4
|
||||
};
|
||||
|
||||
it('should have all the cookies', function(done) {
|
||||
needle.get(TEST_HOST + ':' + testPort + '/0', opts, function(err, resp) {
|
||||
resp.cookies.should.have.property(WEIRD_COOKIE_NAME);
|
||||
resp.cookies.should.have.property(BASE64_COOKIE_NAME);
|
||||
resp.cookies.should.have.property(FORBIDDEN_COOKIE_NAME);
|
||||
resp.cookies.should.have.property(NUMBER_COOKIE_NAME);
|
||||
resp.cookies.should.have.property('FOO');
|
||||
resp.cookies.FOO.should.eql('BAR'); // should overwrite previous one
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('with parse_cookies = false', function() {
|
||||
it('does not parse them', function(done) {
|
||||
needle.get(
|
||||
TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, { parse_cookies: false }, function(error, response) {
|
||||
assert(!response.cookies);
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('if request contains cookie header', function() {
|
||||
var opts = {
|
||||
cookies: {}
|
||||
};
|
||||
|
||||
before(function() {
|
||||
opts.cookies[WEIRD_COOKIE_NAME] = WEIRD_COOKIE_VALUE;
|
||||
opts.cookies[BASE64_COOKIE_NAME] = BASE64_COOKIE_VALUE;
|
||||
opts.cookies[FORBIDDEN_COOKIE_NAME] = FORBIDDEN_COOKIE_VALUE;
|
||||
opts.cookies[NUMBER_COOKIE_NAME] = NUMBER_COOKIE_VALUE;
|
||||
});
|
||||
|
||||
it('must be a valid cookie string', function(done) {
|
||||
var COOKIE_PAIR = /^([^=\s]+)\s*=\s*("?)\s*(.*)\s*\2\s*$/;
|
||||
|
||||
var full_header = [
|
||||
WEIRD_COOKIE_NAME + '=' + WEIRD_COOKIE_VALUE,
|
||||
BASE64_COOKIE_NAME + '=' + BASE64_COOKIE_VALUE,
|
||||
FORBIDDEN_COOKIE_NAME + '=' + encode(FORBIDDEN_COOKIE_VALUE),
|
||||
NUMBER_COOKIE_NAME + '=' + NUMBER_COOKIE_VALUE
|
||||
].join('; ')
|
||||
|
||||
needle.get(TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, opts, function(error, response) {
|
||||
var cookieString = response.req._headers.cookie;
|
||||
cookieString.should.be.type('string');
|
||||
|
||||
cookieString.split(/\s*;\s*/).forEach(function(pair) {
|
||||
COOKIE_PAIR.test(pair).should.be.exactly(true);
|
||||
});
|
||||
|
||||
cookieString.should.be.exactly(full_header);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('dont have to encode allowed characters', function(done) {
|
||||
var COOKIE_PAIR = /^([^=\s]+)\s*=\s*("?)\s*(.*)\s*\2\s*$/,
|
||||
KEY_INDEX = 1,
|
||||
VALUE_INEX = 3;
|
||||
|
||||
needle.get(TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, opts, function(error, response) {
|
||||
var cookieObj = {},
|
||||
cookieString = response.req._headers.cookie;
|
||||
|
||||
cookieString.split(/\s*;\s*/).forEach(function(str) {
|
||||
var pair = COOKIE_PAIR.exec(str);
|
||||
cookieObj[pair[KEY_INDEX]] = pair[VALUE_INEX];
|
||||
});
|
||||
|
||||
cookieObj[WEIRD_COOKIE_NAME].should.be.exactly(WEIRD_COOKIE_VALUE);
|
||||
cookieObj[BASE64_COOKIE_NAME].should.be.exactly(BASE64_COOKIE_VALUE);
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('must encode forbidden characters', function(done) {
|
||||
var COOKIE_PAIR = /^([^=\s]+)\s*=\s*("?)\s*(.*)\s*\2\s*$/,
|
||||
KEY_INDEX = 1,
|
||||
VALUE_INEX = 3;
|
||||
|
||||
needle.get(TEST_HOST + ':' + ALL_COOKIES_TEST_PORT, opts, function(error, response) {
|
||||
var cookieObj = {},
|
||||
cookieString = response.req._headers.cookie;
|
||||
|
||||
cookieString.split(/\s*;\s*/).forEach(function(str) {
|
||||
var pair = COOKIE_PAIR.exec(str);
|
||||
cookieObj[pair[KEY_INDEX]] = pair[VALUE_INEX];
|
||||
});
|
||||
|
||||
cookieObj[FORBIDDEN_COOKIE_NAME].should.not.be.eql(
|
||||
FORBIDDEN_COOKIE_VALUE);
|
||||
cookieObj[FORBIDDEN_COOKIE_NAME].should.be.exactly(
|
||||
encode(FORBIDDEN_COOKIE_VALUE));
|
||||
cookieObj[FORBIDDEN_COOKIE_NAME].should.be.exactly(
|
||||
encodeURIComponent(FORBIDDEN_COOKIE_VALUE));
|
||||
done();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
86
website/functions/node_modules/grpc/node_modules/needle/test/decoder_spec.js
generated
vendored
Normal file
86
website/functions/node_modules/grpc/node_modules/needle/test/decoder_spec.js
generated
vendored
Normal file
@@ -0,0 +1,86 @@
|
||||
var should = require('should'),
|
||||
needle = require('./../'),
|
||||
Q = require('q'),
|
||||
chardet = require('jschardet');
|
||||
|
||||
describe('character encoding', function() {
|
||||
|
||||
var url;
|
||||
this.timeout(5000);
|
||||
|
||||
describe('test A', function() {
|
||||
|
||||
before(function() {
|
||||
url = 'http://www.nina.jp/server/slackware/webapp/tomcat_charset.html';
|
||||
})
|
||||
|
||||
describe('with decode = false', function() {
|
||||
|
||||
it('does not decode', function(done) {
|
||||
|
||||
needle.get(url, { decode: false }, function(err, resp) {
|
||||
resp.body.should.be.a.String;
|
||||
chardet.detect(resp.body).encoding.should.eql('windows-1252');
|
||||
resp.body.indexOf('EUCを使う').should.eql(-1);
|
||||
done();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with decode = true', function() {
|
||||
|
||||
it('decodes', function(done) {
|
||||
|
||||
needle.get(url, { decode: true }, function(err, resp) {
|
||||
resp.body.should.be.a.String;
|
||||
chardet.detect(resp.body).encoding.should.eql('ascii');
|
||||
resp.body.indexOf('EUCを使う').should.not.eql(-1);
|
||||
done();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('test B', function() {
|
||||
|
||||
it('encodes to UTF-8', function(done) {
|
||||
|
||||
// Our Needle wrapper that requests a chinese website.
|
||||
var task = Q.nbind(needle.get, needle, 'http://www.chinesetop100.com/');
|
||||
|
||||
// Different instantiations of this task
|
||||
var tasks = [Q.fcall(task, {decode: true}),
|
||||
Q.fcall(task, {decode: false})];
|
||||
|
||||
var results = tasks.map(function(task) {
|
||||
return task.then(function(obj) {
|
||||
return obj[0].body;
|
||||
});
|
||||
});
|
||||
|
||||
// Execute all requests concurrently
|
||||
Q.all(results).done(function(bodies) {
|
||||
|
||||
var charsets = [
|
||||
chardet.detect(bodies[0]).encoding,
|
||||
chardet.detect(bodies[1]).encoding,
|
||||
]
|
||||
|
||||
// We wanted to decode our first stream.
|
||||
charsets[0].should.equal('ascii');
|
||||
bodies[0].indexOf('全球中文网站前二十强').should.not.equal(-1);
|
||||
|
||||
// But not our second stream.
|
||||
charsets[1].should.equal('windows-1252');
|
||||
bodies[1].indexOf('全球中文网站前二十强').should.equal(-1);
|
||||
|
||||
done();
|
||||
});
|
||||
})
|
||||
})
|
||||
})
|
||||
286
website/functions/node_modules/grpc/node_modules/needle/test/errors_spec.js
generated
vendored
Normal file
286
website/functions/node_modules/grpc/node_modules/needle/test/errors_spec.js
generated
vendored
Normal file
@@ -0,0 +1,286 @@
|
||||
var needle = require('../'),
|
||||
sinon = require('sinon'),
|
||||
should = require('should'),
|
||||
http = require('http'),
|
||||
Emitter = require('events').EventEmitter,
|
||||
helpers = require('./helpers');
|
||||
|
||||
var get_catch = function(url, opts) {
|
||||
var err;
|
||||
try {
|
||||
needle.get(url, opts);
|
||||
} catch(e) {
|
||||
err = e;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
describe('errors', function() {
|
||||
|
||||
after(function(done) {
|
||||
setTimeout(done, 100)
|
||||
})
|
||||
|
||||
describe('when host does not exist', function() {
|
||||
|
||||
var url = 'http://unexistinghost/foo';
|
||||
|
||||
describe('with callback', function() {
|
||||
|
||||
it('does not throw', function() {
|
||||
var ex = get_catch(url);
|
||||
should.not.exist(ex);
|
||||
})
|
||||
|
||||
it('callbacks an error', function(done) {
|
||||
needle.get(url, function(err) {
|
||||
err.should.be.a.Error;
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('error should be ENOTFOUND or EADDRINFO or EAI_AGAIN', function(done) {
|
||||
needle.get(url, function(err) {
|
||||
err.code.should.match(/ENOTFOUND|EADDRINFO|EAI_AGAIN/)
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('does not callback a response', function(done) {
|
||||
needle.get(url, function(err, resp) {
|
||||
should.not.exist(resp);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('does not emit an error event', function(done) {
|
||||
var emitted = false;
|
||||
var req = needle.get(url, function(err, resp) { })
|
||||
|
||||
req.on('error', function() {
|
||||
emitted = true;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
emitted.should.eql(false);
|
||||
done();
|
||||
}, 100);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('without callback', function() {
|
||||
|
||||
it('does not throw', function() {
|
||||
var ex = get_catch(url);
|
||||
should.not.exist(ex);
|
||||
})
|
||||
|
||||
it('emits end event once, with error', function(done) {
|
||||
var callcount = 0,
|
||||
stream = needle.get(url);
|
||||
|
||||
stream.on('done', function(err) {
|
||||
callcount++;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
callcount.should.equal(1);
|
||||
done();
|
||||
}, 200)
|
||||
})
|
||||
|
||||
it('error should be ENOTFOUND or EADDRINFO or EAI_AGAIN', function(done) {
|
||||
var errorific,
|
||||
stream = needle.get(url);
|
||||
|
||||
stream.on('done', function(err) {
|
||||
errorific = err;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
should.exist(errorific);
|
||||
errorific.code.should.match(/ENOTFOUND|EADDRINFO|EAI_AGAIN/)
|
||||
done();
|
||||
}, 200)
|
||||
})
|
||||
|
||||
it('does not emit a readable event', function(done) {
|
||||
var called = false,
|
||||
stream = needle.get(url);
|
||||
|
||||
stream.on('readable', function() {
|
||||
called = true;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
called.should.be.false;
|
||||
done();
|
||||
}, 50)
|
||||
})
|
||||
|
||||
it('does not emit an error event', function(done) {
|
||||
var emitted = false,
|
||||
req = needle.get(url);
|
||||
|
||||
req.on('error', function() {
|
||||
emitted = true;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
emitted.should.eql(false);
|
||||
done();
|
||||
}, 100);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when request times out waiting for response', function() {
|
||||
|
||||
var server,
|
||||
url = 'http://localhost:3333/foo';
|
||||
|
||||
var send_request = function(cb) {
|
||||
return needle.get(url, { response_timeout: 200 }, cb);
|
||||
}
|
||||
|
||||
before(function() {
|
||||
server = helpers.server({ port: 3333, wait: 1000 });
|
||||
})
|
||||
|
||||
after(function() {
|
||||
server.close();
|
||||
})
|
||||
|
||||
describe('with callback', function() {
|
||||
|
||||
it('aborts the request', function(done) {
|
||||
|
||||
var time = new Date();
|
||||
|
||||
send_request(function(err) {
|
||||
var timediff = (new Date() - time);
|
||||
timediff.should.be.within(200, 300);
|
||||
done();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
it('callbacks an error', function(done) {
|
||||
send_request(function(err) {
|
||||
err.should.be.a.Error;
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('error should be ECONNRESET', function(done) {
|
||||
send_request(function(err) {
|
||||
err.code.should.equal('ECONNRESET')
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('does not callback a response', function(done) {
|
||||
send_request(function(err, resp) {
|
||||
should.not.exist(resp);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('does not emit an error event', function(done) {
|
||||
var emitted = false;
|
||||
|
||||
var req = send_request(function(err, resp) {
|
||||
should.not.exist(resp);
|
||||
})
|
||||
|
||||
req.on('error', function() {
|
||||
emitted = true;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
emitted.should.eql(false);
|
||||
done();
|
||||
}, 350);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('without callback', function() {
|
||||
|
||||
it('emits done event once, with error', function(done) {
|
||||
var called = 0,
|
||||
stream = send_request();
|
||||
|
||||
stream.on('done', function(err) {
|
||||
called++;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
called.should.equal(1);
|
||||
done();
|
||||
}, 250)
|
||||
})
|
||||
|
||||
it('aborts the request', function(done) {
|
||||
|
||||
var time = new Date();
|
||||
var stream = send_request();
|
||||
|
||||
stream.on('done', function(err) {
|
||||
var timediff = (new Date() - time);
|
||||
timediff.should.be.within(200, 300);
|
||||
done();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
it('error should be ECONNRESET', function(done) {
|
||||
var error,
|
||||
stream = send_request();
|
||||
|
||||
stream.on('done', function(err) {
|
||||
error = err;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
error.code.should.equal('ECONNRESET')
|
||||
done();
|
||||
}, 250)
|
||||
})
|
||||
|
||||
it('does not emit a readable event', function(done) {
|
||||
var called = false,
|
||||
stream = send_request();
|
||||
|
||||
stream.on('readable', function() {
|
||||
called = true;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
called.should.be.false;
|
||||
done();
|
||||
}, 250)
|
||||
})
|
||||
|
||||
it('does not emit an error event', function(done) {
|
||||
var emitted = false;
|
||||
var req = send_request();
|
||||
|
||||
req.on('error', function() {
|
||||
emitted = true;
|
||||
})
|
||||
|
||||
setTimeout(function() {
|
||||
emitted.should.eql(false);
|
||||
done();
|
||||
}, 100);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
198
website/functions/node_modules/grpc/node_modules/needle/test/headers_spec.js
generated
vendored
Normal file
198
website/functions/node_modules/grpc/node_modules/needle/test/headers_spec.js
generated
vendored
Normal file
@@ -0,0 +1,198 @@
|
||||
var http = require('http'),
|
||||
helpers = require('./helpers'),
|
||||
should = require('should');
|
||||
|
||||
var port = 5432;
|
||||
|
||||
describe('request headers', function() {
|
||||
|
||||
var needle,
|
||||
server,
|
||||
existing_sockets,
|
||||
original_defaultMaxSockets;
|
||||
|
||||
before(function(done) {
|
||||
setTimeout(function() {
|
||||
existing_sockets = get_active_sockets().length;
|
||||
server = helpers.server({ port: port }, done);
|
||||
}, 100);
|
||||
})
|
||||
|
||||
after(function(done) {
|
||||
server.close(done)
|
||||
})
|
||||
|
||||
function send_request(opts, cb) {
|
||||
needle.get('http://localhost:' + port, opts, cb);
|
||||
}
|
||||
|
||||
function get_active_sockets() {
|
||||
var handles = process._getActiveHandles();
|
||||
|
||||
// only return the ones that have a .end() function (like a socket)
|
||||
return handles.filter(function(el) {
|
||||
if (el.constructor.name.toString() == 'Socket') {
|
||||
return el.destroyed !== true;
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
describe('old node versions (<0.11.4) with persistent keep-alive connections', function() {
|
||||
|
||||
before(function() {
|
||||
delete require.cache[require.resolve('..')] // in case it was already loaded
|
||||
original_defaultMaxSockets = http.Agent.defaultMaxSockets;
|
||||
http.Agent.defaultMaxSockets = 5;
|
||||
needle = require('..');
|
||||
})
|
||||
|
||||
after(function() {
|
||||
http.Agent.defaultMaxSockets = original_defaultMaxSockets;
|
||||
delete require.cache[require.resolve('..')]
|
||||
})
|
||||
|
||||
describe('default options', function() {
|
||||
|
||||
it('sends a Connection: close header', function(done) {
|
||||
send_request({}, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('close');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('no open sockets remain after request', function(done) {
|
||||
send_request({}, function(err, resp) {
|
||||
get_active_sockets().length.should.eql(existing_sockets);
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('passing connection: close', function() {
|
||||
|
||||
it('sends a Connection: close header', function(done) {
|
||||
send_request({ connection: 'close' }, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('close');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('no open sockets remain after request', function(done) {
|
||||
send_request({ connection: 'close' }, function(err, resp) {
|
||||
get_active_sockets().length.should.eql(existing_sockets);
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('passing connection: keep-alive', function() {
|
||||
|
||||
it('sends a Connection: keep-alive header (using options.headers.connection)', function(done) {
|
||||
send_request({ headers: { connection: 'keep-alive' }}, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('keep-alive');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('sends a Connection: keep-alive header (using options.connection)', function(done) {
|
||||
send_request({ connection: 'keep-alive' }, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('keep-alive');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('one open socket remain after request', function(done) {
|
||||
send_request({ connection: 'keep-alive' }, function(err, resp) {
|
||||
get_active_sockets().length.should.eql(existing_sockets + 1);
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('new node versions with smarter connection disposing', function() {
|
||||
|
||||
before(function() {
|
||||
delete require.cache[require.resolve('..')]
|
||||
original_defaultMaxSockets = http.Agent.defaultMaxSockets;
|
||||
http.Agent.defaultMaxSockets = Infinity;
|
||||
needle = require('..');
|
||||
})
|
||||
|
||||
after(function() {
|
||||
http.Agent.defaultMaxSockets = original_defaultMaxSockets;
|
||||
delete require.cache[require.resolve('..')]
|
||||
})
|
||||
|
||||
describe('default options', function() {
|
||||
|
||||
// TODO:
|
||||
// this is weird. by default, new node versions set a 'close' header
|
||||
// while older versions set a keep-alive header
|
||||
|
||||
it.skip('sets a Connection header', function(done) {
|
||||
send_request({}, function(err, resp) {
|
||||
// should.not.exist(resp.body.headers['connection']);
|
||||
// done();
|
||||
})
|
||||
})
|
||||
|
||||
it.skip('one open sockets remain after request', function(done) {
|
||||
send_request({}, function(err, resp) {
|
||||
// get_active_sockets().length.should.eql(1);
|
||||
// done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('passing connection: close', function() {
|
||||
|
||||
it('sends a Connection: close header', function(done) {
|
||||
send_request({ connection: 'close' }, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('close');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('no open sockets remain after request', function(done) {
|
||||
send_request({ connection: 'close' }, function(err, resp) {
|
||||
get_active_sockets().length.should.eql(existing_sockets);
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('passing connection: keep-alive', function() {
|
||||
|
||||
it('sends a Connection: keep-alive header (using options.headers.connection)', function(done) {
|
||||
send_request({ headers: { connection: 'keep-alive' }}, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('keep-alive');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('sends a Connection: keep-alive header (using options.connection)', function(done) {
|
||||
send_request({ connection: 'keep-alive' }, function(err, resp) {
|
||||
resp.body.headers['connection'].should.eql('keep-alive');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('one open socket remain after request', function(done) {
|
||||
send_request({ connection: 'keep-alive' }, function(err, resp) {
|
||||
get_active_sockets().length.should.eql(existing_sockets + 1);
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
72
website/functions/node_modules/grpc/node_modules/needle/test/helpers.js
generated
vendored
Normal file
72
website/functions/node_modules/grpc/node_modules/needle/test/helpers.js
generated
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
var fs = require('fs');
|
||||
|
||||
var protocols = {
|
||||
http : require('http'),
|
||||
https : require('https')
|
||||
}
|
||||
|
||||
var keys = {
|
||||
cert : fs.readFileSync(__dirname + '/keys/ssl.cert'),
|
||||
key : fs.readFileSync(__dirname + '/keys/ssl.key')
|
||||
}
|
||||
|
||||
var helpers = {};
|
||||
|
||||
helpers.server = function(opts, cb) {
|
||||
|
||||
var defaults = {
|
||||
code : 200,
|
||||
headers : {'Content-Type': 'application/json'}
|
||||
}
|
||||
|
||||
var mirror_response = function(req) {
|
||||
return JSON.stringify({
|
||||
headers: req.headers,
|
||||
body: req.body
|
||||
})
|
||||
}
|
||||
|
||||
var get = function(what) {
|
||||
if (!opts[what])
|
||||
return defaults[what];
|
||||
|
||||
if (typeof opts[what] == 'function')
|
||||
return opts[what](); // set them at runtime
|
||||
else
|
||||
return opts[what];
|
||||
}
|
||||
|
||||
var finish = function(req, res) {
|
||||
res.writeHead(get('code'), get('headers'));
|
||||
res.end(opts.response || mirror_response(req));
|
||||
}
|
||||
|
||||
var handler = function(req, res) {
|
||||
|
||||
req.setEncoding('utf8'); // get as string
|
||||
req.body = '';
|
||||
req.on('data', function(str) { req.body += str })
|
||||
req.socket.on('error', function(e) {
|
||||
// res.writeHead(500, {'Content-Type': 'text/plain'});
|
||||
// res.end('Error: ' + e.message);
|
||||
})
|
||||
|
||||
setTimeout(function(){
|
||||
finish(req, res);
|
||||
}, opts.wait || 0);
|
||||
|
||||
};
|
||||
|
||||
var protocol = opts.protocol || 'http';
|
||||
var server;
|
||||
|
||||
if (protocol == 'https')
|
||||
server = protocols[protocol].createServer(keys, handler);
|
||||
else
|
||||
server = protocols[protocol].createServer(handler);
|
||||
|
||||
server.listen(opts.port, cb);
|
||||
return server;
|
||||
}
|
||||
|
||||
module.exports = helpers;
|
||||
34
website/functions/node_modules/grpc/node_modules/needle/test/long_string_spec.js
generated
vendored
Normal file
34
website/functions/node_modules/grpc/node_modules/needle/test/long_string_spec.js
generated
vendored
Normal file
@@ -0,0 +1,34 @@
|
||||
var needle = require('../'),
|
||||
should = require('should');
|
||||
|
||||
describe('when posting a very long string', function() {
|
||||
|
||||
this.timeout(20000);
|
||||
|
||||
function get_string(length) {
|
||||
var str = '';
|
||||
for (var i = 0; i < length; i++) {
|
||||
str += 'x';
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
it("shouldn't throw an EPIPE error out of nowhere", function(done) {
|
||||
var error;
|
||||
|
||||
function finished() {
|
||||
setTimeout(function() {
|
||||
should.not.exist(error);
|
||||
done();
|
||||
}, 300);
|
||||
}
|
||||
|
||||
try {
|
||||
needle.post('https://google.com', { data: get_string(Math.pow(2, 20)) }, finished)
|
||||
} catch(e) {
|
||||
error = e;
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
254
website/functions/node_modules/grpc/node_modules/needle/test/output_spec.js
generated
vendored
Normal file
254
website/functions/node_modules/grpc/node_modules/needle/test/output_spec.js
generated
vendored
Normal file
@@ -0,0 +1,254 @@
|
||||
var should = require('should'),
|
||||
needle = require('./../'),
|
||||
http = require('http'),
|
||||
sinon = require('sinon'),
|
||||
stream = require('stream'),
|
||||
fs = require('fs'),
|
||||
port = 11111,
|
||||
server;
|
||||
|
||||
describe('with output option', function() {
|
||||
|
||||
var server, handler, file = '/tmp/foobar.out';
|
||||
|
||||
function send_request_cb(where, cb) {
|
||||
var url = 'http://localhost:' + port + '/whatever.file';
|
||||
return needle.get(url, { output: where }, cb);
|
||||
}
|
||||
|
||||
function send_request_stream(where, cb) {
|
||||
var url = 'http://localhost:' + port + '/whatever.file';
|
||||
var stream = needle.get(url, { output: where });
|
||||
stream.on('end', cb);
|
||||
}
|
||||
|
||||
// this will only work in UNICES
|
||||
function get_open_file_descriptors() {
|
||||
var list = fs.readdirSync('/proc/self/fd');
|
||||
return list.length;
|
||||
}
|
||||
|
||||
var send_request = send_request_cb;
|
||||
|
||||
before(function(){
|
||||
server = http.createServer(function(req, res) {
|
||||
handler(req, res);
|
||||
}).listen(port);
|
||||
});
|
||||
|
||||
after(function() {
|
||||
server.close();
|
||||
})
|
||||
|
||||
beforeEach(function() {
|
||||
try { fs.unlinkSync(file) } catch(e) { };
|
||||
})
|
||||
|
||||
describe('and a 404 response', function() {
|
||||
|
||||
before(function() {
|
||||
handler = function(req, res) {
|
||||
res.writeHead(404, {'Content-Type': 'text/plain' });
|
||||
res.end();
|
||||
}
|
||||
})
|
||||
|
||||
it('doesnt attempt to write a file', function(done) {
|
||||
var spy = sinon.spy(fs, 'createWriteStream');
|
||||
send_request(file, function(err, resp) {
|
||||
resp.statusCode.should.eql(404);
|
||||
spy.called.should.eql(false);
|
||||
spy.restore();
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('doesnt actually write a file', function(done) {
|
||||
send_request(file, function(err, resp) {
|
||||
resp.statusCode.should.eql(404);
|
||||
fs.existsSync(file).should.eql(false);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and a 200 response', function() {
|
||||
|
||||
describe('for an empty response', function() {
|
||||
|
||||
before(function() {
|
||||
handler = function(req, res) {
|
||||
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
||||
res.end();
|
||||
}
|
||||
})
|
||||
|
||||
it('uses a writableStream', function(done) {
|
||||
var spy = sinon.spy(fs, 'createWriteStream');
|
||||
send_request(file, function(err, resp) {
|
||||
resp.statusCode.should.eql(200);
|
||||
spy.called.should.eql(true);
|
||||
spy.restore();
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('writes a file', function(done) {
|
||||
fs.existsSync(file).should.eql(false);
|
||||
send_request(file, function(err, resp) {
|
||||
fs.existsSync(file).should.eql(true);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('file is zero bytes in length', function(done) {
|
||||
send_request(file, function(err, resp) {
|
||||
fs.statSync(file).size.should.equal(0);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
if (process.platform != 'win32') {
|
||||
it('closes the file descriptor', function(done) {
|
||||
var open_descriptors = get_open_file_descriptors();
|
||||
send_request(file + Math.random(), function(err, resp) {
|
||||
var current_descriptors = get_open_file_descriptors();
|
||||
open_descriptors.should.eql(current_descriptors);
|
||||
done()
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
describe('for a JSON response', function() {
|
||||
|
||||
before(function() {
|
||||
handler = function(req, res) {
|
||||
res.writeHead(200, { 'Content-Type': 'application/javascript' });
|
||||
res.end(JSON.stringify({foo: 'bar'}));
|
||||
}
|
||||
})
|
||||
|
||||
it('uses a writableStream', function(done) {
|
||||
var spy = sinon.spy(fs, 'createWriteStream');
|
||||
send_request(file, function(err, resp) {
|
||||
resp.statusCode.should.eql(200);
|
||||
spy.called.should.eql(true);
|
||||
spy.restore();
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('writes a file', function(done) {
|
||||
fs.existsSync(file).should.eql(false);
|
||||
send_request(file, function(err, resp) {
|
||||
fs.existsSync(file).should.eql(true);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('file size equals response length', function(done) {
|
||||
send_request(file, function(err, resp) {
|
||||
fs.statSync(file).size.should.equal(resp.bytes);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('response pipeline is honoured (JSON is decoded by default)', function(done) {
|
||||
send_request_stream(file, function(err, resp) {
|
||||
// we need to wait a bit since writing to config.output
|
||||
// happens independently of needle's callback logic.
|
||||
setTimeout(function() {
|
||||
fs.readFileSync(file).toString().should.eql('{\"foo\":\"bar\"}');
|
||||
done();
|
||||
}, 20);
|
||||
})
|
||||
})
|
||||
|
||||
it('closes the file descriptor', function(done) {
|
||||
var open_descriptors = get_open_file_descriptors();
|
||||
send_request(file + Math.random(), function(err, resp) {
|
||||
var current_descriptors = get_open_file_descriptors();
|
||||
open_descriptors.should.eql(current_descriptors);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('for a binary file', function() {
|
||||
|
||||
var pixel = new Buffer("base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs", "base64");
|
||||
|
||||
before(function() {
|
||||
handler = function(req, res) {
|
||||
res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Transfer-Encoding': 'chunked' });
|
||||
res.write(pixel.slice(0, 10));
|
||||
res.write(pixel.slice(10, 20));
|
||||
res.write(pixel.slice(20, 30));
|
||||
res.write(pixel.slice(30));
|
||||
res.end();
|
||||
}
|
||||
})
|
||||
|
||||
it('uses a writableStream', function(done) {
|
||||
var spy = sinon.spy(fs, 'createWriteStream');
|
||||
send_request(file, function(err, resp) {
|
||||
resp.statusCode.should.eql(200);
|
||||
spy.called.should.eql(true);
|
||||
spy.restore();
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('writes a file', function(done) {
|
||||
fs.existsSync(file).should.eql(false);
|
||||
send_request(file, function(err, resp) {
|
||||
fs.existsSync(file).should.eql(true);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('file size equals response length', function(done) {
|
||||
send_request(file, function(err, resp) {
|
||||
fs.statSync(file).size.should.equal(resp.bytes);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('file is equal to original buffer', function(done) {
|
||||
send_request(file, function(err, resp) {
|
||||
// we need to wait a bit since writing to config.output
|
||||
// happens independently of needle's callback logic.
|
||||
setTimeout(function() {
|
||||
fs.readFileSync(file).should.eql(pixel);
|
||||
done();
|
||||
}, 20);
|
||||
})
|
||||
})
|
||||
|
||||
it('returns the data in resp.body too', function(done) {
|
||||
send_request(file, function(err, resp) {
|
||||
resp.body.should.eql(pixel);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
if (process.platform != 'win32') {
|
||||
it('closes the file descriptor', function(done) {
|
||||
var open_descriptors = get_open_file_descriptors();
|
||||
send_request(file + Math.random(), function(err, resp) {
|
||||
var current_descriptors = get_open_file_descriptors();
|
||||
open_descriptors.should.eql(current_descriptors);
|
||||
done()
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
494
website/functions/node_modules/grpc/node_modules/needle/test/parsing_spec.js
generated
vendored
Normal file
494
website/functions/node_modules/grpc/node_modules/needle/test/parsing_spec.js
generated
vendored
Normal file
@@ -0,0 +1,494 @@
|
||||
var should = require('should'),
|
||||
needle = require('./../'),
|
||||
http = require('http'),
|
||||
port = 11111,
|
||||
server;
|
||||
|
||||
describe('parsing', function(){
|
||||
|
||||
describe('when response is an JSON string', function(){
|
||||
|
||||
var json_string = '{"foo":"bar"}';
|
||||
|
||||
before(function(done){
|
||||
server = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'application/json');
|
||||
res.end(json_string);
|
||||
}).listen(port, done);
|
||||
});
|
||||
|
||||
after(function(done){
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('and parse option is not passed', function() {
|
||||
|
||||
describe('with default parse_response', function() {
|
||||
|
||||
before(function() {
|
||||
needle.defaults().parse_response.should.eql('all')
|
||||
})
|
||||
|
||||
it('should return object', function(done){
|
||||
needle.get('localhost:' + port, function(err, response, body){
|
||||
should.ifError(err);
|
||||
body.should.have.property('foo', 'bar');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and default parse_response is set to false', function() {
|
||||
|
||||
it('does NOT return object when disabled using .defaults', function(done){
|
||||
needle.defaults({ parse_response: false })
|
||||
|
||||
needle.get('localhost:' + port, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.an.instanceof(Buffer)
|
||||
body.toString().should.eql('{"foo":"bar"}');
|
||||
|
||||
needle.defaults({ parse_response: 'all' });
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse option is true', function() {
|
||||
|
||||
describe('and JSON is valid', function() {
|
||||
|
||||
it('should return object', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, response, body){
|
||||
should.not.exist(err);
|
||||
body.should.have.property('foo', 'bar')
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should have a .parser = json property', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.parser.should.eql('json');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
});
|
||||
|
||||
describe('and response is empty', function() {
|
||||
|
||||
var old_json_string;
|
||||
|
||||
before(function() {
|
||||
old_json_string = json_string;
|
||||
json_string = "";
|
||||
});
|
||||
|
||||
after(function() {
|
||||
json_string = old_json_string;
|
||||
});
|
||||
|
||||
it('should return an empty string', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.body.should.equal('');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and JSON is invalid', function() {
|
||||
|
||||
var old_json_string;
|
||||
|
||||
before(function() {
|
||||
old_json_string = json_string;
|
||||
json_string = "this is not going to work";
|
||||
});
|
||||
|
||||
after(function() {
|
||||
json_string = old_json_string;
|
||||
});
|
||||
|
||||
it('does not throw', function(done) {
|
||||
(function(){
|
||||
needle.get('localhost:' + port, { parse: true }, done);
|
||||
}).should.not.throw();
|
||||
});
|
||||
|
||||
it('does NOT return object', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.a.String;
|
||||
body.toString().should.eql('this is not going to work');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
});
|
||||
|
||||
})
|
||||
|
||||
describe('and parse option is false', function() {
|
||||
|
||||
it('does NOT return object', function(done){
|
||||
needle.get('localhost:' + port, { parse: false }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.an.instanceof(Buffer)
|
||||
body.toString().should.eql('{"foo":"bar"}');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should NOT have a .parser = json property', function(done) {
|
||||
needle.get('localhost:' + port, { parse: false }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(resp.parser);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse option is "xml"', function() {
|
||||
|
||||
it('does NOT return object', function(done){
|
||||
needle.get('localhost:' + port, { parse: 'xml' }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.an.instanceof(Buffer)
|
||||
body.toString().should.eql('{"foo":"bar"}');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should NOT have a .parser = json property', function(done) {
|
||||
needle.get('localhost:' + port, { parse: 'xml' }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(resp.parser);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
});
|
||||
|
||||
describe('when response is JSON \'false\'', function(){
|
||||
|
||||
var json_string = 'false';
|
||||
|
||||
before(function(done){
|
||||
server = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'application/json');
|
||||
res.end(json_string);
|
||||
}).listen(port, done);
|
||||
});
|
||||
|
||||
after(function(done){
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('and parse option is not passed', function() {
|
||||
|
||||
it('should return object', function(done){
|
||||
needle.get('localhost:' + port, function(err, response, body){
|
||||
should.ifError(err);
|
||||
body.should.equal(false);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse option is true', function() {
|
||||
|
||||
describe('and JSON is valid', function() {
|
||||
|
||||
it('should return object', function(done){
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, response, body){
|
||||
should.not.exist(err);
|
||||
body.should.equal(false)
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
});
|
||||
|
||||
describe('and response is empty', function() {
|
||||
|
||||
var old_json_string;
|
||||
|
||||
before(function() {
|
||||
old_json_string = json_string;
|
||||
json_string = "";
|
||||
});
|
||||
|
||||
after(function() {
|
||||
json_string = old_json_string;
|
||||
});
|
||||
|
||||
it('should return an empty string', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.body.should.equal('');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and JSON is invalid', function() {
|
||||
|
||||
var old_json_string;
|
||||
|
||||
before(function() {
|
||||
old_json_string = json_string;
|
||||
json_string = "this is not going to work";
|
||||
});
|
||||
|
||||
after(function() {
|
||||
json_string = old_json_string;
|
||||
});
|
||||
|
||||
it('does not throw', function(done) {
|
||||
(function(){
|
||||
needle.get('localhost:' + port, { parse: true }, done);
|
||||
}).should.not.throw();
|
||||
});
|
||||
|
||||
it('does NOT return object', function(done) {
|
||||
needle.get('localhost:' + port, { parse: true }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.a.String;
|
||||
body.toString().should.eql('this is not going to work');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
});
|
||||
|
||||
})
|
||||
|
||||
describe('and parse option is false', function() {
|
||||
|
||||
it('does NOT return object', function(done){
|
||||
needle.get('localhost:' + port, { parse: false }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.an.instanceof(Buffer)
|
||||
body.toString().should.eql('false');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse option is "xml"', function() {
|
||||
|
||||
it('does NOT return object', function(done){
|
||||
needle.get('localhost:' + port, { parse: 'xml' }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.be.an.instanceof(Buffer)
|
||||
body.toString().should.eql('false');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
|
||||
});
|
||||
|
||||
describe('when response is an invalid XML string', function(){
|
||||
|
||||
before(function(done){
|
||||
server = http.createServer(function(req, res) {
|
||||
res.writeHeader(200, {'Content-Type': 'application/xml'})
|
||||
res.end("<post><body there11post>")
|
||||
}).listen(port, done);
|
||||
});
|
||||
|
||||
after(function(done){
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('and parse_response is true', function(){
|
||||
|
||||
it('should return original string', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: true }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.eql('<post><body there11post>')
|
||||
should.not.exist(body.name);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should not have a .parser = xml property', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: true }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(resp.parser);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse response is false', function(){
|
||||
|
||||
it('should return valid object', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: false }, function(err, response, body){
|
||||
should.not.exist(err);
|
||||
body.toString().should.eql('<post><body there11post>')
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should not have a .parser property', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: false }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(resp.parser)
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when response is a valid XML string', function(){
|
||||
|
||||
before(function(done) {
|
||||
server = http.createServer(function(req, res) {
|
||||
res.writeHeader(200, {'Content-Type': 'application/xml'})
|
||||
res.end("<post><p>hello</p><p>world</p></post>")
|
||||
}).listen(port, done);
|
||||
});
|
||||
|
||||
after(function(done) {
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('and parse_response is true', function(){
|
||||
|
||||
it('should return valid object', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: true }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.name.should.eql('post')
|
||||
body.children[0].name.should.eql('p')
|
||||
body.children[0].value.should.eql('hello')
|
||||
|
||||
body.children[1].name.should.eql('p')
|
||||
body.children[1].value.should.eql('world')
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should have a .parser = xml property', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: true }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.parser.should.eql('xml');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse response is false', function(){
|
||||
|
||||
it('should return valid object', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: false }, function(err, response, body){
|
||||
should.not.exist(err);
|
||||
body.toString().should.eql('<post><p>hello</p><p>world</p></post>')
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should not have a .parser property', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: false }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(resp.parser)
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
|
||||
describe('valid XML, using xml2js', function() {
|
||||
|
||||
var parsers, origParser;
|
||||
|
||||
before(function(done) {
|
||||
var xml2js = require('xml2js')
|
||||
parsers = require('../lib/parsers');
|
||||
origParser = parsers['application/xml'];
|
||||
|
||||
var customParser = require('xml2js').parseString;
|
||||
parsers.use('xml2js', ['application/xml'], function(buff, cb) {
|
||||
var opts = { explicitRoot: true, explicitArray: false };
|
||||
customParser(buff, opts, cb);
|
||||
})
|
||||
|
||||
server = http.createServer(function(req, res) {
|
||||
res.writeHeader(200, {'Content-Type': 'application/xml'})
|
||||
res.end("<post><p>hello</p><p>world</p></post>")
|
||||
}).listen(port, done);
|
||||
});
|
||||
|
||||
after(function(done) {
|
||||
parsers['application/xml'] = origParser;
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('and parse_response is true', function(){
|
||||
|
||||
it('should return valid object', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: true }, function(err, response, body) {
|
||||
should.not.exist(err);
|
||||
body.should.eql({ post: { p: ['hello', 'world' ]}})
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should have a .parser = xml property', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: true }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.parser.should.eql('xml2js');
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and parse response is false', function(){
|
||||
|
||||
it('should return valid object', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: false }, function(err, response, body){
|
||||
should.not.exist(err);
|
||||
body.toString().should.eql('<post><p>hello</p><p>world</p></post>')
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
it('should not have a .parser property', function(done) {
|
||||
needle.get('localhost:' + port, { parse_response: false }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
should.not.exist(resp.parser)
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
|
||||
})
|
||||
1021
website/functions/node_modules/grpc/node_modules/needle/test/post_data_spec.js
generated
vendored
Normal file
1021
website/functions/node_modules/grpc/node_modules/needle/test/post_data_spec.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
202
website/functions/node_modules/grpc/node_modules/needle/test/proxy_spec.js
generated
vendored
Normal file
202
website/functions/node_modules/grpc/node_modules/needle/test/proxy_spec.js
generated
vendored
Normal file
@@ -0,0 +1,202 @@
|
||||
var helpers = require('./helpers'),
|
||||
should = require('should'),
|
||||
sinon = require('sinon'),
|
||||
http = require('http'),
|
||||
needle = require('./../');
|
||||
|
||||
var port = 7707;
|
||||
var url = 'localhost:' + port;
|
||||
var nonexisting_host = 'awepfokawepofawe.com';
|
||||
|
||||
describe('proxy option', function() {
|
||||
|
||||
var spy, opts;
|
||||
|
||||
function send_request(opts, done) {
|
||||
if (spy) spy.restore();
|
||||
spy = sinon.spy(http, 'request');
|
||||
needle.get(url, opts, done);
|
||||
}
|
||||
|
||||
//////////////////////
|
||||
// proxy opts helpers
|
||||
|
||||
function not_proxied(done) {
|
||||
return function(err, resp) {
|
||||
var path = spy.args[0][0].path;
|
||||
path.should.eql('/'); // not the full original URI
|
||||
spy.restore();
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
function proxied(host, port, done) {
|
||||
return function(err, resp) {
|
||||
var path = spy.args[0][0].path;
|
||||
path.should.eql('http://' + url); // the full original URI
|
||||
|
||||
var http_host = spy.args[0][0].host;
|
||||
if (http_host) http_host.should.eql(host);
|
||||
|
||||
var http_port = spy.args[0][0].port;
|
||||
if (http_port) http_port.should.eql(port);
|
||||
|
||||
spy.restore();
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////
|
||||
// auth helpers
|
||||
|
||||
function get_auth(header) {
|
||||
var token = header.split(/\s+/).pop();
|
||||
return token && new Buffer(token, 'base64').toString().split(':');
|
||||
}
|
||||
|
||||
function no_proxy_auth(done) {
|
||||
return function(err, resp) {
|
||||
var headers = spy.args[0][0].headers;
|
||||
Object.keys(headers).should.not.containEql('proxy-authorization');
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
function header_set(name, user, pass, done) {
|
||||
return function(err, resp) {
|
||||
var headers = spy.args[0][0].headers;
|
||||
var auth = get_auth(headers[name]);
|
||||
auth[0].should.eql(user);
|
||||
auth[1].should.eql(pass);
|
||||
done();
|
||||
}
|
||||
}
|
||||
|
||||
function proxy_auth_set(user, pass, done) {
|
||||
return header_set('proxy-authorization', user, pass, done);
|
||||
}
|
||||
|
||||
function basic_auth_set(user, pass, done) {
|
||||
return header_set('authorization', user, pass, done);
|
||||
}
|
||||
|
||||
after(function() {
|
||||
spy.restore();
|
||||
})
|
||||
|
||||
describe('when null proxy is passed', function() {
|
||||
|
||||
it('does not proxy', function(done) {
|
||||
send_request({ proxy: null }, not_proxied(done))
|
||||
})
|
||||
|
||||
describe('but defaults has been set', function() {
|
||||
|
||||
before(function() {
|
||||
needle.defaults({ proxy: 'foobar' });
|
||||
})
|
||||
|
||||
after(function() {
|
||||
needle.defaults({ proxy: null });
|
||||
})
|
||||
|
||||
it('tries to proxy anyway', function(done) {
|
||||
send_request({}, proxied('foobar', 80, done))
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when weird string is passed', function() {
|
||||
|
||||
it('tries to proxy anyway', function(done) {
|
||||
send_request({ proxy: 'alfalfa' }, proxied('alfalfa', 80, done))
|
||||
})
|
||||
})
|
||||
|
||||
describe('when valid url is passed', function() {
|
||||
|
||||
it('proxies request', function(done) {
|
||||
send_request({ proxy: nonexisting_host + ':123/done' }, proxied(nonexisting_host, '123', done))
|
||||
})
|
||||
|
||||
it('does not set a Proxy-Authorization header', function(done) {
|
||||
send_request({ proxy: nonexisting_host + ':123/done' }, no_proxy_auth(done));
|
||||
})
|
||||
|
||||
describe('and proxy url contains user:pass', function() {
|
||||
|
||||
before(function() {
|
||||
opts = {
|
||||
proxy: 'http://mj:x@' + nonexisting_host + ':123/done'
|
||||
}
|
||||
})
|
||||
|
||||
it('proxies request', function(done) {
|
||||
send_request(opts, proxied(nonexisting_host, '123', done))
|
||||
})
|
||||
|
||||
it('sets Proxy-Authorization header', function(done) {
|
||||
send_request(opts, proxy_auth_set('mj', 'x', done));
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and a proxy_user is passed', function() {
|
||||
|
||||
before(function() {
|
||||
opts = {
|
||||
proxy: nonexisting_host + ':123',
|
||||
proxy_user: 'someone',
|
||||
proxy_pass: 'else'
|
||||
}
|
||||
})
|
||||
|
||||
it('proxies request', function(done) {
|
||||
send_request(opts, proxied(nonexisting_host, '123', done))
|
||||
})
|
||||
|
||||
it('sets Proxy-Authorization header', function(done) {
|
||||
send_request(opts, proxy_auth_set('someone', 'else', done));
|
||||
})
|
||||
|
||||
describe('and url also contains user:pass', function() {
|
||||
|
||||
it('url user:pass wins', function(done) {
|
||||
var opts = {
|
||||
proxy: 'http://xxx:yyy@' + nonexisting_host + ':123',
|
||||
proxy_user: 'someone',
|
||||
proxy_pass: 'else'
|
||||
}
|
||||
|
||||
send_request(opts, proxy_auth_set('xxx', 'yyy', done));
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and options.username is also present', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { proxy_user: 'foobar', username: 'someone' };
|
||||
})
|
||||
|
||||
it('a separate Authorization header is set', function(done) {
|
||||
var opts = {
|
||||
proxy: nonexisting_host + ':123',
|
||||
proxy_user: 'someone',
|
||||
proxy_pass: 'else',
|
||||
username: 'test',
|
||||
password: 'X'
|
||||
}
|
||||
|
||||
send_request(opts, basic_auth_set('test', 'X', done));
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
128
website/functions/node_modules/grpc/node_modules/needle/test/querystring_spec.js
generated
vendored
Normal file
128
website/functions/node_modules/grpc/node_modules/needle/test/querystring_spec.js
generated
vendored
Normal file
@@ -0,0 +1,128 @@
|
||||
var should = require('should'),
|
||||
stringify = require('../lib/querystring').build;
|
||||
|
||||
describe('stringify', function() {
|
||||
|
||||
describe('with null', function() {
|
||||
|
||||
it('throws', function() {
|
||||
(function() {
|
||||
var res = stringify(null);
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with a number', function() {
|
||||
|
||||
it('throws', function() {
|
||||
(function() {
|
||||
var res = stringify(100);
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with a string', function() {
|
||||
|
||||
describe('that is empty', function() {
|
||||
|
||||
it('throws', function() {
|
||||
(function() {
|
||||
var res = stringify('');
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('that doesnt contain an equal sign', function() {
|
||||
|
||||
it('throws', function() {
|
||||
(function() {
|
||||
var res = stringify('boomshagalaga');
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('that contains an equal sign', function() {
|
||||
|
||||
it('works', function() {
|
||||
var res = stringify('hello=123');
|
||||
res.should.eql('hello=123');
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with an array', function() {
|
||||
|
||||
describe('with key val objects', function() {
|
||||
|
||||
it('works', function() {
|
||||
var res = stringify([ {foo: 'bar'} ]);
|
||||
res.should.eql('foo=bar');
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('where all elements are strings with an equal sign', function() {
|
||||
|
||||
it('works', function() {
|
||||
var res = stringify([ 'bar=123', 'quux=' ]);
|
||||
res.should.eql('bar=123&quux=');
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with random words', function() {
|
||||
|
||||
it('throws', function() {
|
||||
(function() {
|
||||
var res = stringify(['hello', 'there']);
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with integers', function() {
|
||||
|
||||
it('throws', function() {
|
||||
(function() {
|
||||
var res = stringify([123, 432]);
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with an object', function() {
|
||||
|
||||
it('works', function() {
|
||||
var res = stringify({ test: 100 });
|
||||
res.should.eql('test=100');
|
||||
})
|
||||
|
||||
describe('with object where val is an array', function() {
|
||||
|
||||
it('works', function() {
|
||||
var res = stringify({ foo: ['bar', 'baz'] });
|
||||
res.should.eql('foo[]=bar&foo[]=baz');
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('with object where val is an array of key val objects', function() {
|
||||
|
||||
it('works', function() {
|
||||
var res = stringify({ foo: [{'1': 'bar'}, {'2': 'baz'}] });
|
||||
res.should.eql('foo[][1]=bar&foo[][2]=baz');
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
392
website/functions/node_modules/grpc/node_modules/needle/test/redirect_spec.js
generated
vendored
Normal file
392
website/functions/node_modules/grpc/node_modules/needle/test/redirect_spec.js
generated
vendored
Normal file
@@ -0,0 +1,392 @@
|
||||
var helpers = require('./helpers'),
|
||||
should = require('should'),
|
||||
sinon = require('sinon'),
|
||||
needle = require('./../');
|
||||
|
||||
var ports = {
|
||||
http : 8888,
|
||||
https : 9999
|
||||
}
|
||||
|
||||
var protocols = {
|
||||
http : require('http'),
|
||||
https : require('https')
|
||||
}
|
||||
|
||||
var code = 301;
|
||||
var location; // var to set the response location
|
||||
|
||||
function response_code() {
|
||||
return code;
|
||||
}
|
||||
|
||||
function response_headers() {
|
||||
return { 'Content-Type': 'text/plain', 'Location': location }
|
||||
}
|
||||
|
||||
describe('redirects', function() {
|
||||
|
||||
var spies = {},
|
||||
servers = {};
|
||||
|
||||
var current_protocol;
|
||||
var hostname = require('os').hostname();
|
||||
|
||||
// open two servers, one that responds to a redirect
|
||||
before(function(done) {
|
||||
|
||||
var conf = {
|
||||
port : ports.http,
|
||||
code : response_code,
|
||||
headers : response_headers
|
||||
}
|
||||
|
||||
servers.http = helpers.server(conf, function() {
|
||||
conf.port = ports.https;
|
||||
conf.protocol = 'https';
|
||||
servers.https = helpers.server(conf, done);
|
||||
});
|
||||
})
|
||||
|
||||
after(function(done) {
|
||||
servers.http.close(function() {
|
||||
servers.https.close(done);
|
||||
});
|
||||
})
|
||||
|
||||
var prots = {'http': 'https'};
|
||||
Object.keys(prots).forEach(function(protocol) {
|
||||
|
||||
current_protocol = protocol;
|
||||
var other_protocol = protocol == 'http' ? 'https' : 'http';
|
||||
|
||||
var opts, // each test will modify this
|
||||
host = '127.0.0.1',
|
||||
url = protocol + '://' + host + ':' + ports[protocol] + '/hello';
|
||||
|
||||
function send_request(opts, cb) {
|
||||
opts.rejectUnauthorized = false;
|
||||
// console.log(' -- sending request ' + url + ' -- redirect to ' + location);
|
||||
needle.post(url, { foo: 'bar' }, opts, cb);
|
||||
}
|
||||
|
||||
function not_followed(done) {
|
||||
send_request(opts, function(err, resp) {
|
||||
resp.statusCode.should.eql(301);
|
||||
if (current_protocol == 'http') {
|
||||
spies.http.callCount.should.eql(1); // only original request
|
||||
spies.https.callCount.should.eql(0);
|
||||
} else {
|
||||
spies.http.callCount.should.eql(0);
|
||||
spies.https.callCount.should.eql(1); // only original request
|
||||
}
|
||||
done();
|
||||
})
|
||||
}
|
||||
|
||||
function followed_same_protocol(done) {
|
||||
send_request(opts, function(err, resp) {
|
||||
// the original request plus the redirect one
|
||||
spies[current_protocol].callCount.should.eql(2);
|
||||
done();
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
function followed_other_protocol(done) {
|
||||
send_request(opts, function(err, resp) {
|
||||
// on new node versions, https.request calls http.request internally,
|
||||
// so we need to amount for that additional call.
|
||||
|
||||
var http_calls = protocols.http.Agent.defaultMaxSockets == Infinity ? 2 : 1;
|
||||
|
||||
spies.http.callCount.should.eql(http_calls); // the one(s) from http.request
|
||||
spies.https.callCount.should.eql(1); // the one from https.request (redirect)
|
||||
done();
|
||||
})
|
||||
}
|
||||
|
||||
// set a spy on [protocol].request
|
||||
// so we can see how many times a request was made
|
||||
before(function() {
|
||||
spies.http = sinon.spy(protocols.http, 'request');
|
||||
spies.https = sinon.spy(protocols.https, 'request');
|
||||
})
|
||||
|
||||
// and make sure it is restored after each test
|
||||
afterEach(function() {
|
||||
spies.http.reset();
|
||||
spies.https.reset();
|
||||
})
|
||||
|
||||
after(function() {
|
||||
spies.http.restore();
|
||||
spies.https.restore();
|
||||
})
|
||||
|
||||
describe('when overriding defaults', function() {
|
||||
|
||||
before(function() {
|
||||
needle.defaults({ follow_max: 10 });
|
||||
opts = {};
|
||||
})
|
||||
|
||||
after(function() {
|
||||
// reset values to previous
|
||||
needle.defaults({ follow_max: 0 });
|
||||
})
|
||||
|
||||
describe('and redirected to the same path on same host and protocol', function() {
|
||||
before(function() {
|
||||
location = url;
|
||||
})
|
||||
it('does not follow redirect', not_followed);
|
||||
})
|
||||
|
||||
describe('and redirected to the same path on same host and different protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(protocol, other_protocol).replace(ports[protocol], ports[other_protocol]);
|
||||
})
|
||||
|
||||
it('follows redirect', followed_other_protocol);
|
||||
})
|
||||
|
||||
describe('and redirected to a different path on same host, same protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace('/hello', '/goodbye');
|
||||
})
|
||||
it('follows redirect', followed_same_protocol);
|
||||
})
|
||||
|
||||
describe('and redirected to a different path on same host, different protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace('/hello', '/goodbye').replace(protocol, other_protocol).replace(ports[protocol], ports[other_protocol]);
|
||||
})
|
||||
it('follows redirect', followed_other_protocol);
|
||||
})
|
||||
|
||||
describe('and redirected to same path on another host, same protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(host, hostname);
|
||||
})
|
||||
it('follows redirect', followed_same_protocol);
|
||||
})
|
||||
|
||||
describe('and redirected to same path on another host, different protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(host, hostname).replace(protocol, other_protocol).replace(ports[protocol], ports[other_protocol]);
|
||||
})
|
||||
it('follows redirect', followed_other_protocol);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
// false and null have the same result
|
||||
var values = [false, null];
|
||||
values.forEach(function(value) {
|
||||
|
||||
describe('when follow is ' + value, function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow: value };
|
||||
})
|
||||
|
||||
|
||||
|
||||
describe('and redirected to the same path on same host and protocol', function() {
|
||||
before(function() {
|
||||
location = url;
|
||||
})
|
||||
|
||||
it('throws an error', function() {
|
||||
(function() {
|
||||
send_request(opts, function() { });
|
||||
}).should.throw;
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when follow is true', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow: true };
|
||||
})
|
||||
|
||||
describe('and redirected to the same path on same host and protocol', function() {
|
||||
before(function() { location = url })
|
||||
|
||||
it('throws an error', function() {
|
||||
(function() {
|
||||
send_request(opts, function() { });
|
||||
}).should.throw;
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('when follow is > 0', function() {
|
||||
|
||||
before(function() {
|
||||
needle.defaults({ follow: 10 });
|
||||
})
|
||||
|
||||
after(function() {
|
||||
needle.defaults({ follow: 0 });
|
||||
})
|
||||
|
||||
describe('when keep_method is false', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_keep_method: false };
|
||||
})
|
||||
|
||||
// defaults to follow host and protocol
|
||||
describe('and redirected to the same path on same host and different protocol', function() {
|
||||
|
||||
before(function() {
|
||||
location = url.replace(protocol, other_protocol);
|
||||
})
|
||||
|
||||
it('follows redirect', followed_other_protocol);
|
||||
|
||||
it('sends a GET request with no data', function(done) {
|
||||
send_request(opts, function(err, resp) {
|
||||
spies.http.args[0][0].method.should.eql('GET');
|
||||
// spy.args[0][3].should.eql(null);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and set_referer is true', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_set_referer: true };
|
||||
})
|
||||
|
||||
// defaults to follow host and protocol
|
||||
describe('and redirected to the same path on same host and different protocol', function() {
|
||||
|
||||
before(function() {
|
||||
location = url.replace(protocol, other_protocol);
|
||||
})
|
||||
|
||||
it('follows redirect', followed_other_protocol);
|
||||
|
||||
it('sets Referer header when following redirect', function(done) {
|
||||
send_request(opts, function(err, resp) {
|
||||
spies.http.args[0][0].headers['referer'].should.eql("http://" + host + ":8888/hello");
|
||||
// spies.http.args[0][3].should.eql({ foo: 'bar'});
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and keep_method is true', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_keep_method: true };
|
||||
})
|
||||
|
||||
// defaults to follow host and protocol
|
||||
describe('and redirected to the same path on same host and different protocol', function() {
|
||||
|
||||
before(function() {
|
||||
location = url.replace(protocol, other_protocol);
|
||||
})
|
||||
|
||||
it('follows redirect', followed_other_protocol);
|
||||
|
||||
it('sends a POST request with the original data', function(done) {
|
||||
send_request(opts, function(err, resp) {
|
||||
spies.http.args[0][0].method.should.eql('post');
|
||||
// spies.http.args[0][3].should.eql({ foo: 'bar'});
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and if_same_host is false', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_if_same_host: false };
|
||||
})
|
||||
|
||||
// by default it will follow other protocols
|
||||
describe('and redirected to same path on another domain, same protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(host, hostname);
|
||||
})
|
||||
it('follows redirect', followed_same_protocol);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and if_same_host is true', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_if_same_host: true };
|
||||
})
|
||||
|
||||
// by default it will follow other protocols
|
||||
describe('and redirected to same path on another domain, same protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(host, hostname);
|
||||
})
|
||||
|
||||
it('does not follow redirect', not_followed);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and if_same_protocol is false', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_if_same_protocol: false };
|
||||
})
|
||||
|
||||
// by default it will follow other hosts
|
||||
describe('and redirected to same path on another domain, different protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(host, hostname).replace(protocol, other_protocol).replace(ports[protocol], ports[other_protocol]);
|
||||
})
|
||||
it('follows redirect', followed_other_protocol);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('and if_same_protocol is true', function() {
|
||||
|
||||
before(function() {
|
||||
opts = { follow_if_same_protocol: true };
|
||||
})
|
||||
|
||||
// by default it will follow other hosts
|
||||
describe('and redirected to same path on another domain, different protocol', function() {
|
||||
before(function() {
|
||||
location = url.replace(host, hostname).replace(protocol, other_protocol).replace(ports[protocol], ports[other_protocol]);
|
||||
})
|
||||
it('does not follow redirect', not_followed);
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
});
|
||||
45
website/functions/node_modules/grpc/node_modules/needle/test/redirect_with_timeout.js
generated
vendored
Normal file
45
website/functions/node_modules/grpc/node_modules/needle/test/redirect_with_timeout.js
generated
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
var should = require('should')
|
||||
var needle = require('./../')
|
||||
|
||||
describe('follow redirects when read_timeout is set', function () {
|
||||
|
||||
it('clear timeout before following redirect', function (done) {
|
||||
var opts = {
|
||||
open_timeout: 1000,
|
||||
read_timeout: 3000,
|
||||
follow: 5,
|
||||
user_agent: 'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36'
|
||||
}
|
||||
|
||||
var timedOut = 0
|
||||
var redirects = 0
|
||||
|
||||
var timer = setTimeout(function () {
|
||||
var hasRedirects = redirects > 0
|
||||
hasRedirects.should.equal(true)
|
||||
done()
|
||||
}, opts.read_timeout || 3000)
|
||||
|
||||
var resp = needle.get('http://google.com/', opts, function (err, resp, body) {
|
||||
var noErr = err === null
|
||||
var hasBody = body.length > 0
|
||||
noErr.should.equal(true);
|
||||
hasBody.should.equal(true);
|
||||
});
|
||||
|
||||
resp.on('redirect', function (location) {
|
||||
redirects++
|
||||
// console.info(' Redirected to ', location)
|
||||
})
|
||||
|
||||
resp.on('timeout', function (type) {
|
||||
timedOut++
|
||||
timedOut.should.equal(0)
|
||||
// console.error(' ', type, 'timeout')
|
||||
clearTimeout(timer)
|
||||
done()
|
||||
})
|
||||
|
||||
}).timeout(30000)
|
||||
|
||||
})
|
||||
202
website/functions/node_modules/grpc/node_modules/needle/test/request_stream_spec.js
generated
vendored
Normal file
202
website/functions/node_modules/grpc/node_modules/needle/test/request_stream_spec.js
generated
vendored
Normal file
@@ -0,0 +1,202 @@
|
||||
var fs = require('fs'),
|
||||
needle = require('..'),
|
||||
stream = require('stream'),
|
||||
http = require('http'),
|
||||
should = require('should'),
|
||||
sinon = require('sinon');
|
||||
|
||||
var port = 2233;
|
||||
|
||||
describe('request stream length', function() {
|
||||
|
||||
var server, writable;
|
||||
|
||||
function createServer() {
|
||||
return http.createServer(function(req, res) {
|
||||
|
||||
req.on('data', function(chunk) {
|
||||
// console.log(chunk.length);
|
||||
})
|
||||
|
||||
req.on('end', function() {
|
||||
res.writeHeader(200, { 'Content-Type': 'application/json'})
|
||||
res.end(JSON.stringify({ headers: req.headers }))
|
||||
})
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
before(function(done) {
|
||||
server = createServer();
|
||||
server.listen(port, done)
|
||||
})
|
||||
|
||||
beforeEach(function() {
|
||||
writable = new stream.Readable();
|
||||
writable._read = function() {
|
||||
this.push('hello world');
|
||||
this.push(null);
|
||||
}
|
||||
})
|
||||
|
||||
after(function(done) {
|
||||
server.close(done)
|
||||
})
|
||||
|
||||
function send_request(opts, cb) {
|
||||
needle.post('http://localhost:' + port, writable, opts, function(err, resp) {
|
||||
cb(err, resp)
|
||||
})
|
||||
}
|
||||
|
||||
describe('no stream_length set', function() {
|
||||
|
||||
it('doesnt set Content-Length header', function(done) {
|
||||
send_request({}, function(err, resp) {
|
||||
should.not.exist(resp.body.headers['content-length']);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('doesnt work if Transfer-Encoding is set to a blank string', function(done) {
|
||||
send_request({ headers: { 'Transfer-Encoding': '' }}, function(err, resp) {
|
||||
err.code.should.eql('ECONNRESET');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('works if Transfer-Encoding is not set', function(done) {
|
||||
send_request({}, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.statusCode.should.eql(200);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('stream_length set to invalid value', function() {
|
||||
|
||||
it('sets Content-Length header to that value', function(done) {
|
||||
send_request({ stream_length: 5 }, function(err, resp) {
|
||||
should.exist(err);
|
||||
err.code.should.eql('ECONNRESET');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('doesnt work if Transfer-Encoding is set to a blank string', function(done) {
|
||||
send_request({ stream_length: 5, headers: { 'Transfer-Encoding': '' }}, function(err, resp) {
|
||||
err.code.should.eql('ECONNRESET');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('doesnt work if Transfer-Encoding is not set', function(done) {
|
||||
send_request({ stream_length: 5 }, function(err, resp) {
|
||||
err.code.should.eql('ECONNRESET');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('stream_length is set to valid value', function() {
|
||||
|
||||
it('sets Content-Length header to that value', function(done) {
|
||||
send_request({ stream_length: 11 }, function(err, resp) {
|
||||
resp.body.headers['content-length'].should.eql('11');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('works if Transfer-Encoding is set to a blank string', function(done) {
|
||||
send_request({ stream_length: 11, headers: { 'Transfer-Encoding': '' }}, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.statusCode.should.eql(200);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('works if Transfer-Encoding is not set', function(done) {
|
||||
send_request({ stream_length: 11 }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.statusCode.should.eql(200);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
|
||||
describe('stream_length set to 0', function() {
|
||||
|
||||
describe('stream with path', function() {
|
||||
|
||||
var stub;
|
||||
|
||||
beforeEach(function() {
|
||||
writable.path = '/foo/bar';
|
||||
stub = sinon.stub(fs, 'stat', function(path, cb) {
|
||||
cb(null, { size: 11 })
|
||||
})
|
||||
})
|
||||
|
||||
afterEach(function() {
|
||||
stub.restore();
|
||||
})
|
||||
|
||||
it('sets Content-Length header to streams length', function(done) {
|
||||
send_request({ stream_length: 0 }, function(err, resp) {
|
||||
resp.body.headers['content-length'].should.eql('11');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('works if Transfer-Encoding is set to a blank string', function(done) {
|
||||
send_request({ stream_length: 0, headers: { 'Transfer-Encoding': '' }}, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.statusCode.should.eql(200);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('works if Transfer-Encoding is not set', function(done) {
|
||||
send_request({ stream_length: 0 }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.statusCode.should.eql(200);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('stream without path', function() {
|
||||
it('does not set Content-Length header', function(done) {
|
||||
send_request({ stream_length: 0 }, function(err, resp) {
|
||||
should.not.exist(resp.body.headers['content-length']);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('doesnt work if Transfer-Encoding is set to a blank string', function(done) {
|
||||
send_request({ stream_length: 0, headers: { 'Transfer-Encoding': '' }}, function(err, resp) {
|
||||
err.code.should.eql('ECONNRESET');
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
it('works if Transfer-Encoding is not set', function(done) {
|
||||
send_request({ stream_length: 0 }, function(err, resp) {
|
||||
should.not.exist(err);
|
||||
resp.statusCode.should.eql(200);
|
||||
done()
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
139
website/functions/node_modules/grpc/node_modules/needle/test/response_stream_spec.js
generated
vendored
Normal file
139
website/functions/node_modules/grpc/node_modules/needle/test/response_stream_spec.js
generated
vendored
Normal file
@@ -0,0 +1,139 @@
|
||||
var should = require('should'),
|
||||
needle = require('./../'),
|
||||
http = require('http'),
|
||||
stream = require('stream'),
|
||||
fs = require('fs'),
|
||||
port = 11111,
|
||||
server;
|
||||
|
||||
describe('response streams', function() {
|
||||
|
||||
describe('when the server sends back json', function(){
|
||||
|
||||
before(function() {
|
||||
server = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'application/json')
|
||||
res.end('{"foo":"bar"}')
|
||||
}).listen(port);
|
||||
});
|
||||
|
||||
after(function() {
|
||||
server.close();
|
||||
})
|
||||
|
||||
describe('and the client uses streams', function(){
|
||||
|
||||
it('should create a proper streams2 stream', function(done) {
|
||||
var stream = needle.get('localhost:' + port)
|
||||
|
||||
// newer node versions set this to null instead of false
|
||||
var bool = !!stream._readableState.flowing;
|
||||
should.equal(false, bool);
|
||||
|
||||
var readableCalled = false;
|
||||
stream.on('readable', function() {
|
||||
readableCalled = true;
|
||||
})
|
||||
|
||||
stream.on('done', function() {
|
||||
readableCalled.should.be.true;
|
||||
done();
|
||||
});
|
||||
|
||||
stream.resume()
|
||||
|
||||
})
|
||||
|
||||
it('emits a single data item which is our JSON object', function(done) {
|
||||
var stream = needle.get('localhost:' + port)
|
||||
|
||||
var chunks = [];
|
||||
stream.on('readable', function () {
|
||||
while (chunk = this.read()) {
|
||||
chunk.should.be.an.Object;
|
||||
chunks.push(chunk);
|
||||
}
|
||||
})
|
||||
|
||||
stream.on('done', function () {
|
||||
chunks.should.have.length(1)
|
||||
chunks[0].should.have.property('foo', 'bar');
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
it('emits a raw buffer if we do not want to parse JSON', function(done) {
|
||||
var stream = needle.get('localhost:' + port, { parse: false })
|
||||
|
||||
var chunks = [];
|
||||
stream.on('readable', function () {
|
||||
while (chunk = this.read()) {
|
||||
Buffer.isBuffer(chunk).should.be.true;
|
||||
chunks.push(chunk);
|
||||
}
|
||||
})
|
||||
|
||||
stream.on('done', function() {
|
||||
var body = Buffer.concat(chunks).toString();
|
||||
body.should.equal('{"foo":"bar"}')
|
||||
done();
|
||||
});
|
||||
})
|
||||
|
||||
})
|
||||
})
|
||||
|
||||
describe('when the server sends back what was posted to it', function () {
|
||||
var file = 'asdf.txt';
|
||||
|
||||
before(function(done){
|
||||
server = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'application/octet')
|
||||
req.pipe(res);
|
||||
}).listen(port);
|
||||
|
||||
fs.writeFile(file, 'contents of stream', done);
|
||||
});
|
||||
|
||||
after(function(done){
|
||||
server.close();
|
||||
fs.unlink(file, done);
|
||||
})
|
||||
|
||||
it('can PUT a stream', function (done) {
|
||||
var stream = needle.put('localhost:' + port, fs.createReadStream(file), { stream: true });
|
||||
|
||||
var chunks = [];
|
||||
stream.on('readable', function () {
|
||||
while (chunk = this.read()) {
|
||||
Buffer.isBuffer(chunk).should.be.true;
|
||||
chunks.push(chunk);
|
||||
}
|
||||
})
|
||||
|
||||
stream.on('end', function () {
|
||||
var body = Buffer.concat(chunks).toString();
|
||||
body.should.equal('contents of stream')
|
||||
done();
|
||||
});
|
||||
});
|
||||
|
||||
it('can PATCH a stream', function (done) {
|
||||
var stream = needle.patch('localhost:' + port, fs.createReadStream(file), { stream: true });
|
||||
|
||||
var chunks = [];
|
||||
stream.on('readable', function () {
|
||||
while (chunk = this.read()) {
|
||||
Buffer.isBuffer(chunk).should.be.true;
|
||||
chunks.push(chunk);
|
||||
}
|
||||
})
|
||||
|
||||
stream.on('end', function () {
|
||||
var body = Buffer.concat(chunks).toString();
|
||||
body.should.equal('contents of stream')
|
||||
done();
|
||||
});
|
||||
});
|
||||
})
|
||||
})
|
||||
66
website/functions/node_modules/grpc/node_modules/needle/test/socket_pool_spec.js
generated
vendored
Normal file
66
website/functions/node_modules/grpc/node_modules/needle/test/socket_pool_spec.js
generated
vendored
Normal file
@@ -0,0 +1,66 @@
|
||||
var needle = require('../'),
|
||||
should = require('should'),
|
||||
http = require('http');
|
||||
|
||||
var server, port = 11112;
|
||||
|
||||
describe('socket reuse', function() {
|
||||
|
||||
before(function() {
|
||||
server = http.createServer(function(req, res) {
|
||||
res.setHeader('Content-Type', 'application/json');
|
||||
setTimeout(function() {
|
||||
res.end('{"foo":"bar"}');
|
||||
}, 50);
|
||||
}).listen(port);
|
||||
});
|
||||
|
||||
after(function() {
|
||||
server.close();
|
||||
});
|
||||
|
||||
describe('when sockets are reused', function() {
|
||||
|
||||
var httpAgent = new http.Agent({
|
||||
keepAlive : true,
|
||||
maxSockets : 1
|
||||
});
|
||||
|
||||
it('does not duplicate listeners on .end', function(done) {
|
||||
|
||||
var last_error;
|
||||
var count = 10;
|
||||
|
||||
function completed(err) {
|
||||
--count || done(last_error);
|
||||
}
|
||||
|
||||
function send() {
|
||||
needle.get('localhost:' + port, { agent: httpAgent }, function(err, resp) {
|
||||
if (err)
|
||||
throw new Error("Unexpected error: " + err);
|
||||
|
||||
// lets go through all sockets and inspect all socket objects
|
||||
for (hostTarget in httpAgent.sockets) {
|
||||
httpAgent.sockets[hostTarget].forEach(function(socket) {
|
||||
// normally, there are 2 internal listeners and 1 needle sets up,
|
||||
// but to be sure the test does not fail even if newer node versions
|
||||
// introduce additional listeners, we use a higher limit.
|
||||
try {
|
||||
socket.listeners('end').length.should.be.below(5, "too many listeners on the socket object's end event");
|
||||
} catch (e) {
|
||||
last_error = e;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
completed();
|
||||
});
|
||||
}
|
||||
|
||||
for (var i = 0; i < count; i++) {
|
||||
send();
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
155
website/functions/node_modules/grpc/node_modules/needle/test/url_spec.js
generated
vendored
Normal file
155
website/functions/node_modules/grpc/node_modules/needle/test/url_spec.js
generated
vendored
Normal file
@@ -0,0 +1,155 @@
|
||||
var needle = require('../'),
|
||||
sinon = require('sinon'),
|
||||
should = require('should'),
|
||||
http = require('http'),
|
||||
helpers = require('./helpers');
|
||||
|
||||
var port = 3456;
|
||||
|
||||
describe('urls', function() {
|
||||
|
||||
var server, url;
|
||||
|
||||
function send_request(cb) {
|
||||
return needle.get(url, cb);
|
||||
}
|
||||
|
||||
before(function(done){
|
||||
server = helpers.server({ port: port }, done);
|
||||
})
|
||||
|
||||
after(function(done) {
|
||||
server.close(done);
|
||||
})
|
||||
|
||||
describe('null URL', function(){
|
||||
|
||||
it('throws', function(){
|
||||
(function() {
|
||||
send_request()
|
||||
}).should.throw();
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('invalid protocol', function(){
|
||||
|
||||
before(function() {
|
||||
url = 'foo://google.com/what'
|
||||
})
|
||||
|
||||
it('does not throw', function(done) {
|
||||
(function() {
|
||||
send_request(function(err) {
|
||||
done();
|
||||
})
|
||||
}).should.not.throw()
|
||||
})
|
||||
|
||||
it('returns an error', function(done) {
|
||||
send_request(function(err) {
|
||||
err.should.be.an.Error;
|
||||
err.code.should.match(/ENOTFOUND|EADDRINFO|EAI_AGAIN/)
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('invalid host', function(){
|
||||
|
||||
before(function() {
|
||||
url = 'http://s1\\\2.com/'
|
||||
})
|
||||
|
||||
it('fails', function(done) {
|
||||
(function() {
|
||||
send_request(function(){ })
|
||||
}.should.throw(TypeError))
|
||||
done()
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
/*
|
||||
describe('invalid path', function(){
|
||||
|
||||
before(function() {
|
||||
url = 'http://www.google.com\\\/x\\\ %^&*() /x2.com/'
|
||||
})
|
||||
|
||||
it('fails', function(done) {
|
||||
send_request(function(err) {
|
||||
err.should.be.an.Error;
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
*/
|
||||
|
||||
describe('valid protocol and path', function() {
|
||||
|
||||
before(function() {
|
||||
url = 'http://localhost:' + port + '/foo';
|
||||
})
|
||||
|
||||
it('works', function(done) {
|
||||
send_request(function(err){
|
||||
should.not.exist(err);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('no protocol but with slashes and valid path', function() {
|
||||
|
||||
before(function() {
|
||||
url = '//localhost:' + port + '/foo';
|
||||
})
|
||||
|
||||
it('works', function(done) {
|
||||
send_request(function(err){
|
||||
should.not.exist(err);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('no protocol nor slashes and valid path', function() {
|
||||
|
||||
before(function() {
|
||||
url = 'localhost:' + port + '/foo';
|
||||
})
|
||||
|
||||
it('works', function(done) {
|
||||
send_request(function(err){
|
||||
should.not.exist(err);
|
||||
done();
|
||||
})
|
||||
})
|
||||
|
||||
})
|
||||
|
||||
describe('double encoding', function() {
|
||||
|
||||
var path = '/foo?email=' + encodeURIComponent('what-ever@Example.Com');
|
||||
|
||||
before(function() {
|
||||
url = 'localhost:' + port + path
|
||||
});
|
||||
|
||||
it('should not occur', function(done) {
|
||||
send_request(function(err, res) {
|
||||
should.not.exist(err);
|
||||
should(res.req.path).be.exactly(path);
|
||||
done();
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
})
|
||||
|
||||
})
|
||||
17
website/functions/node_modules/grpc/node_modules/needle/test/utils/formidable.js
generated
vendored
Normal file
17
website/functions/node_modules/grpc/node_modules/needle/test/utils/formidable.js
generated
vendored
Normal file
@@ -0,0 +1,17 @@
|
||||
var formidable = require('formidable'),
|
||||
http = require('http'),
|
||||
util = require('util');
|
||||
|
||||
var port = process.argv[2] || 8888;
|
||||
|
||||
http.createServer(function(req, res) {
|
||||
var form = new formidable.IncomingForm();
|
||||
form.parse(req, function(err, fields, files) {
|
||||
res.writeHead(200, {'content-type': 'text/plain'});
|
||||
res.write('received upload:\n\n');
|
||||
console.log(util.inspect({fields: fields, files: files}))
|
||||
res.end(util.inspect({fields: fields, files: files}));
|
||||
});
|
||||
}).listen(port);
|
||||
|
||||
console.log('HTTP server listening on port ' + port);
|
||||
62
website/functions/node_modules/grpc/node_modules/needle/test/utils/proxy.js
generated
vendored
Normal file
62
website/functions/node_modules/grpc/node_modules/needle/test/utils/proxy.js
generated
vendored
Normal file
@@ -0,0 +1,62 @@
|
||||
var http = require('http'),
|
||||
https = require('https'),
|
||||
url = require('url');
|
||||
|
||||
var port = 1234,
|
||||
log = true,
|
||||
request_auth = false;
|
||||
|
||||
http.createServer(function(request, response) {
|
||||
|
||||
console.log(request.headers);
|
||||
console.log("Got request: " + request.url);
|
||||
console.log("Forwarding request to " + request.headers['host']);
|
||||
|
||||
if (request_auth) {
|
||||
if (!request.headers['proxy-authorization']) {
|
||||
response.writeHead(407, {'Proxy-Authenticate': 'Basic realm="proxy.com"'})
|
||||
return response.end('Hello.');
|
||||
}
|
||||
}
|
||||
|
||||
var remote = url.parse(request.url);
|
||||
var protocol = remote.protocol == 'https:' ? https : http;
|
||||
|
||||
var opts = {
|
||||
host: request.headers['host'],
|
||||
port: remote.port || (remote.protocol == 'https:' ? 443 : 80),
|
||||
method: request.method,
|
||||
path: remote.pathname,
|
||||
headers: request.headers
|
||||
}
|
||||
|
||||
var proxy_request = protocol.request(opts, function(proxy_response){
|
||||
|
||||
proxy_response.on('data', function(chunk) {
|
||||
if (log) console.log(chunk.toString());
|
||||
response.write(chunk, 'binary');
|
||||
});
|
||||
proxy_response.on('end', function() {
|
||||
response.end();
|
||||
});
|
||||
|
||||
response.writeHead(proxy_response.statusCode, proxy_response.headers);
|
||||
});
|
||||
|
||||
request.on('data', function(chunk) {
|
||||
if (log) console.log(chunk.toString());
|
||||
proxy_request.write(chunk, 'binary');
|
||||
});
|
||||
|
||||
request.on('end', function() {
|
||||
proxy_request.end();
|
||||
});
|
||||
|
||||
}).listen(port);
|
||||
|
||||
process.on('uncaughtException', function(err){
|
||||
console.log('Uncaught exception!');
|
||||
console.log(err);
|
||||
});
|
||||
|
||||
console.log("Proxy server listening on port " + port);
|
||||
104
website/functions/node_modules/grpc/node_modules/needle/test/utils/test.js
generated
vendored
Normal file
104
website/functions/node_modules/grpc/node_modules/needle/test/utils/test.js
generated
vendored
Normal file
@@ -0,0 +1,104 @@
|
||||
// TODO: write specs. :)
|
||||
|
||||
var fs = require('fs'),
|
||||
client = require('./../../');
|
||||
|
||||
process.env.DEBUG = true;
|
||||
|
||||
var response_callback = function(err, resp, body){
|
||||
console.log(err);
|
||||
if(resp) console.log("Got status code " + resp.statusCode)
|
||||
console.log(body);
|
||||
}
|
||||
|
||||
function simple_head(){
|
||||
client.head('http://www.amazon.com', response_callback);
|
||||
}
|
||||
|
||||
function simple_get(){
|
||||
client.get('http://www.nodejs.org', response_callback);
|
||||
}
|
||||
|
||||
function proxy_get(){
|
||||
client.get('https://www.google.com/search?q=nodejs', {proxy: 'http://localhost:1234'}, response_callback);
|
||||
}
|
||||
|
||||
function auth_get(){
|
||||
client.get('https://www.twitter.com', {username: 'asd', password: '123'}, response_callback);
|
||||
}
|
||||
|
||||
function simple_post(url){
|
||||
|
||||
var data = {
|
||||
foo: 'bar',
|
||||
baz: {
|
||||
nested: 'attribute'
|
||||
}
|
||||
}
|
||||
|
||||
client.post(url, data, response_callback);
|
||||
|
||||
}
|
||||
|
||||
function multipart_post(url){
|
||||
|
||||
var filename = 'test_file.txt';
|
||||
var data = 'Plain text data.\nLorem ipsum dolor sit amet.\nBla bla bla.\n';
|
||||
fs.writeFileSync(filename, data);
|
||||
|
||||
var black_pixel = new Buffer("data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=".replace(/^data:image\/\w+;base64,/, ""), "base64");
|
||||
|
||||
var data = {
|
||||
foo: 'bar',
|
||||
bar: 'baz',
|
||||
nested: {
|
||||
my_document: { file: filename, content_type: 'text/plain' },
|
||||
even: {
|
||||
more: 'nesting'
|
||||
}
|
||||
},
|
||||
pixel: { filename: 'black_pixel.gif', buffer: black_pixel, content_type: 'image/gif' },
|
||||
field2: {value: JSON.stringify({"json":[ {"one":1}, {"two":2} ]}), content_type: 'application/json' }
|
||||
}
|
||||
|
||||
client.post(url, data, {multipart: true}, function(err, resp, body){
|
||||
|
||||
console.log(err);
|
||||
console.log("Got status code " + resp.statusCode)
|
||||
console.log(body);
|
||||
fs.unlink(filename);
|
||||
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
switch(process.argv[2]){
|
||||
case 'head':
|
||||
simple_head();
|
||||
break;
|
||||
case 'get':
|
||||
simple_get();
|
||||
break;
|
||||
case 'auth':
|
||||
auth_get();
|
||||
break;
|
||||
case 'proxy':
|
||||
proxy_get();
|
||||
break;
|
||||
case 'post':
|
||||
simple_post(process.argv[3] || 'http://posttestserver.com/post.php');
|
||||
break;
|
||||
case 'multipart':
|
||||
multipart_post(process.argv[3] || 'http://posttestserver.com/post.php?dir=example');
|
||||
break;
|
||||
case 'all':
|
||||
simple_head();
|
||||
simple_get();
|
||||
auth_get();
|
||||
proxy_get();
|
||||
simple_post(process.argv[3] || 'http://posttestserver.com/post.php');
|
||||
multipart_post(process.argv[3] || 'http://posttestserver.com/post.php?dir=example');
|
||||
break;
|
||||
default:
|
||||
console.log("Usage: ./test.js [head|get|auth|proxy|multipart]")
|
||||
}
|
||||
Reference in New Issue
Block a user