vulcan 0.6.1 → 0.7.0

data/server/node_modules/restler/package.json

@@ -1,10 +1,37 @@
 {
-    "name": "restler",
-    "version": "0.2.4",
-    "description": "An HTTP client library for node.js",
-    "contributors": [{ "name": "Dan Webb", "email": "dan@danwebb.net" }],
-    "homepage": "https://github.com/danwrong/restler",
-    "directories" : { "lib" : "./lib" },
-    "main" : "./lib/restler",
-    "engines": { "node": ">= 0.3.7" }
+  "name": "restler",
+  "version": "2.0.1",
+  "description": "An HTTP client library for node.js",
+  "contributors": [
+    {
+      "name": "Dan Webb",
+      "email": "dan@danwebb.net"
+    }
+  ],
+  "homepage": "https://github.com/danwrong/restler",
+  "directories": {
+    "lib": "./lib"
+  },
+  "main": "./lib/restler",
+  "engines": {
+    "node": ">= 0.6.x"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "nodeunit": ">=0.5.0",
+    "xml2js": ">=0.1.0",
+    "yaml": ">=0.2.0",
+    "iconv": ">=1.0.0"
+  },
+  "_npmUser": {
+    "name": "ddollar",
+    "email": "ddollar@gmail.com"
+  },
+  "_id": "restler@2.0.1",
+  "optionalDependencies": {},
+  "_engineSupported": true,
+  "_npmVersion": "1.1.21",
+  "_nodeVersion": "v0.6.17",
+  "_defaultsLoaded": true,
+  "_from": "restler@2.x.x"
 }

data/server/node_modules/restler/test/all.js

@@ -1 +1,6 @@
-require('./restler');
+
+require('./restler'); // debug
+var nodeunit = require('nodeunit');
+var reporter = nodeunit.reporters['default'];
+process.chdir(__dirname);
+reporter.run(['restler.js']);

data/server/node_modules/restler/test/restler.js

@@ -1,168 +1,674 @@
-var helper = require('./test_helper'),
-    rest   = require('../lib/restler'),
-    sys    = require('util');
-    
-helper.testCase("Basic Tests", helper.echoServer, {
-  testRequestShouldTakePath: function(host, test) {
-    rest.get(host + '/thing').on('complete', function(data) {
-      test.ok(/^GET \/thing/.test(data), 'should hit /thing');
-    });
-  },
-  testRequestShouldWorkWithNoPath: function(host, test) {
-   rest.get(host).on('complete', function(data) {
-     test.ok(/^GET \//.test(data), 'should hit /');
-   });
-  },
-  testRequestShouldWorkPreserveQueryStringInURL: function(host, test) {
-   rest.get(host + '/thing?boo=yah').on('complete', function(data) {
-     test.ok(/^GET \/thing\?boo\=yah/.test(data), 'should hit /thing?boo=yah');
-   });
-  },
-  testRequestShouldBeAbleToGET: function(host, test) {
-   rest.get(host).on('complete', function(data) {
-     test.ok(/^GET/.test(data), 'should be GET');
-   });
-  },
-  testRequestShouldBeAbleToPUT: function(host, test) {
-   rest.put(host).on('complete', function(data) {
-     test.ok(/^PUT/.test(data), 'should be PUT');
-   });
-  },
-  testRequestShouldBeAbleToPOST: function(host, test) {
-   rest.post(host).on('complete', function(data) {
-     test.ok(/^POST/.test(data), 'should be POST');
-   });
-  },
-  testRequestShouldBeAbleToDELETE: function(host, test) {
-   rest.del(host).on('complete', function(data) {
-     test.ok(/^DELETE/.test(data), 'should be DELETE');
-   });
-  },
-  testRequestShouldSerializeQuery: function(host, test) {
+
+var rest   = require('../lib/restler');
+var http   = require('http');
+var sys    = require('util');
+var path   = require('path');
+var fs     = require('fs');
+var crypto = require('crypto');
+var zlib   = null;
+var Iconv  = null;
+
+try {
+  zlib = require('zlib');
+} catch (err) {}
+
+try {
+  Iconv = require('iconv').Iconv;
+} catch (err) {}
+
+var p = sys.inspect;
+
+var port = 9000;
+var hostname = 'localhost';
+var host = 'http://' + hostname + ':' + port;
+
+var nodeunit = require('nodeunit');
+nodeunit.assert.re = function(actual, expected, message) {
+  new RegExp(expected).test(actual) || nodeunit.assert.fail(actual, expected, message, '~=', nodeunit.assert.re);
+};
+
+
+function setup(response) {
+  return function(next) {
+    this.server = http.createServer(response);
+    this.server.listen(port, hostname, next);
+  };
+}
+
+function teardown() {
+  return function (next) {
+    this.server._handle && this.server.close();
+    process.nextTick(next);
+  };
+}
+
+
+function echoResponse(request, response) {
+  if (request.headers['x-connection-abort'] == 'true') {
+    request.connection.destroy();
+    return;
+  }
+  var echo = [];
+  echo.push(request.method + ' ' + request.url + ' HTTP/' + request.httpVersion);
+  for (var header in request.headers) {
+    echo.push(header + ': ' + request.headers[header]);
+  }
+  echo.push('', '');
+  echo = echo.join('\r\n');
+
+  request.addListener('data', function(chunk) {
+    echo += chunk.toString('binary');
+  });
+
+  request.addListener('end', function() {
+    response.writeHead(request.headers['x-status-code'] || 200, {
+      'content-type': 'text/plain',
+      'content-length': echo.length,
+      'request-method': request.method.toLowerCase()
+    });
+    setTimeout(function() {
+      response.end(request.method == 'HEAD' ? undefined : echo);
+    }, request.headers['x-delay'] | 0);
+  });
+}
+
+module.exports['Basic'] = {
+
+  setUp: setup(echoResponse),
+  tearDown: teardown(),
+
+  'Should GET': function (test) {
+    rest.get(host).on('complete', function(data) {
+      test.re(data, /^GET/, 'should be GET');
+      test.done();
+    });
+  },
+
+  'Should PATCH': function(test) {
+    rest.patch(host).on('complete', function(data) {
+      test.re(data, /^PATCH/, 'should be PATCH');
+      test.done();
+    });
+  },
+
+  'Should PUT': function(test) {
+    rest.put(host).on('complete', function(data) {
+      test.re(data, /^PUT/, 'should be PUT');
+      test.done();
+    });
+  },
+
+  'Should POST': function(test) {
+    rest.post(host).on('complete', function(data) {
+      test.re(data, /^POST/, 'should be POST');
+      test.done();
+    });
+  },
+
+  'Should DELETE': function(test) {
+    rest.del(host).on('complete', function(data) {
+      test.re(data, /^DELETE/, 'should be DELETE');
+      test.done();
+    });
+  },
+
+  'Should HEAD': function(test) {
+    rest.head(host).on('complete', function(data, response) {
+      test.equal(response.headers['request-method'], 'head', 'should be HEAD');
+      test.done();
+    });
+  },
+
+  'Should GET withouth path': function(test) {
+    rest.get(host).on('complete', function(data) {
+      test.re(data, /^GET \//, 'should hit /');
+      test.done();
+    });
+  },
+
+  'Should GET path': function(test) {
+      rest.get(host + '/thing').on('complete', function(data) {
+        test.re(data, /^GET \/thing/, 'should hit /thing');
+        test.done();
+      });
+    },
+
+  'Should preserve query string in url': function(test) {
+    rest.get(host + '/thing?boo=yah').on('complete', function(data) {
+      test.re(data, /^GET \/thing\?boo\=yah/, 'should hit /thing?boo=yah');
+      test.done();
+    });
+  },
+
+  'Should serialize query': function(test) {
     rest.get(host, { query: { q: 'balls' } }).on('complete', function(data) {
-      test.ok(/^GET \/\?q\=balls/.test(data), 'should hit /?q=balls');
+      test.re(data, /^GET \/\?q\=balls/, 'should hit /?q=balls');
+      test.done();
     });
   },
-  testRequestShouldPostBody: function(host, test) {
-    rest.post(host, { data: "balls" }).on('complete', function(data) {
-      test.ok(/\r\n\r\nballs/.test(data), 'should have balls in the body')
+
+  'Should POST body': function(test) {
+    rest.post(host, { data: 'balls' }).on('complete', function(data) {
+      test.re(data, /\r\n\r\nballs/, 'should have balls in the body');
+      test.done();
     });
   },
-  testRequestShouldSerializePostBody: function(host, test) {
+
+  'Should serialize POST body': function(test) {
     rest.post(host, { data: { q: 'balls' } }).on('complete', function(data) {
-      test.ok(/content-type\: application\/x-www-form-urlencoded/.test(data), 
-                      'should set content-type');
-      test.ok(/content-length\: 7/.test(data), 'should set content-length');
-      test.ok(/\r\n\r\nq=balls/.test(data), 'should have balls in the body')
+      test.re(data, /content-type\: application\/x-www-form-urlencoded/, 'should set content-type');
+      test.re(data, /content-length\: 7/, 'should set content-length');
+      test.re(data, /\r\n\r\nq=balls/, 'should have balls in the body');
+      test.done();
     });
   },
-  testRequestShouldSendHeaders: function(host, test) {
+
+  'Should send headers': function(test) {
     rest.get(host, {
       headers: { 'Content-Type': 'application/json' }
     }).on('complete', function(data) {
-      test.ok(/content\-type\: application\/json/.test(data), 'should content type header')
+      test.re(data, /content\-type\: application\/json/, 'should have "content-type" header');
+      test.done();
     });
   },
-  testRequestShouldSendBasicAuth: function(host, test) {
+
+  'Should send basic auth': function(test) {
     rest.post(host, { username: 'danwrong', password: 'flange' }).on('complete', function(data) {
-      test.ok(/authorization\: Basic ZGFud3Jvbmc6Zmxhbmdl/.test(data), 'should have auth header')
+      test.re(data, /authorization\: Basic ZGFud3Jvbmc6Zmxhbmdl/, 'should have "authorization "header');
+      test.done();
     });
   },
-  testRequestShouldSendBasicAuthIfInURL: function(host, test) {
-    var port = host.match(/\:(\d+)/)[1];
-    host = "http://danwrong:flange@localhost:" + port;
-    rest.post(host).on('complete', function(data) {
-      test.ok(/authorization\: Basic ZGFud3Jvbmc6Zmxhbmdl/.test(data), 'should have auth header')
+
+  'Should send basic auth if in url': function(test) {
+    rest.post('http://danwrong:flange@' + hostname + ':' + port).on('complete', function(data) {
+      test.re(data, /authorization\: Basic ZGFud3Jvbmc6Zmxhbmdl/, 'should have "authorization" header');
+      test.done();
     });
   },
-  testRequestShouldFire2XXAnd200Events: function(host, test) {
-    var count = 0;
-    
+
+  'Should fire 2XX and 200 events': function(test) {
+    test.expect(3);
     rest.get(host).on('2XX', function() {
-      count++;
+      test.ok(true);
     }).on('200', function() {
-      count++;
+      test.ok(true);
     }).on('complete', function() {
-      test.equal(2, count);
+      test.ok(true);
+      test.done();
     });
   },
-  testRequestShouldFireError4XXand404EventsFor404: function(host, test) {
-    var count = 0;
-    
-    rest.get(host, { headers: { 'X-Give-Me-Status': 404 }}).on('error', function() {
-      count++;
+
+  'Should fire fail, 4XX and 404 events for 404': function(test) {
+    test.expect(4);
+    rest.get(host, { headers: { 'x-status-code': 404 }}).on('fail', function() {
+      test.ok(true);
     }).on('4XX', function() {
-      count++;
+      test.ok(true);
     }).on('404', function() {
-      count++;
+      test.ok(true);
     }).on('complete', function() {
-      test.equal(3, count);
+      test.ok(true);
+      test.done();
     });
+  },
+
+  'Should fire error and complete events on connection abort': function(test) {
+    test.expect(2);
+    rest.get(host, { headers: { 'x-connection-abort': 'true' }}).on('error', function() {
+      test.ok(true);
+    }).on('complete', function() {
+      test.ok(true);
+      test.done();
+    });
+  },
+
+  'Should correctly retry': function(test) {
+    var counter = 0;
+    rest.get(host, { headers: { 'x-connection-abort': 'true' }}).on('complete', function() {
+      if (++counter < 3) {
+        this.retry(10);
+      } else {
+        test.ok(true);
+        test.done();
+      }
+    });
+  },
+
+  'Should correctly retry after abort': function(test) {
+    var counter = 0;
+    rest.get(host).on('complete', function() {
+      if (++counter < 3) {
+        this.retry().abort();
+      } else {
+        test.ok(true);
+        test.done();
+      }
+    }).abort();
+  },
+
+  'Should correctly retry while pending': function(test) {
+    var counter = 0, request;
+    function command() {
+      var args = [].slice.call(arguments);
+      var method = args.shift();
+      method && setTimeout(function() {
+        request[method]();
+        command.apply(null, args);
+      }, 50);
+    }
+
+    request = rest.get(host, { headers: { 'x-delay': '1000' } }).on('complete', function() {
+      if (++counter < 3) {
+        command('retry', 'abort');
+      } else {
+        test.ok(true);
+        test.done();
+      }
+    });
+    command('abort');
   }
-});
- 
-helper.testCase('Multipart Tests', helper.echoServer, {
- testMultipartRequestWithSimpleVars: function(host, test) {
-   rest.post(host, {
-     data: { a: 1, b: 'thing' },
-     multipart: true
-   }).on('complete', function(data) {
-     test.ok(/content-type\: multipart\/form-data/.test(data), 'should set content type')
-     test.ok(/name="a"(\s)+1/.test(data), 'should send a=1');
-     test.ok(/name="b"(\s)+thing/.test(data), 'should send b=thing');
-   });
- }
-});
-
-
-helper.testCase("Deserialization Tests", helper.dataServer, {
-  testAutoSerializerShouldParseJSON: function(host, test) {
-    rest.get(host, {
-      headers: { 'Accepts': 'application/json' }
+
+};
+
+module.exports['Multipart'] = {
+
+  setUp: setup(echoResponse),
+  tearDown: teardown(),
+
+  'Test multipart request with simple vars': function(test) {
+    rest.post(host, {
+      data: { a: 10, b: 'thing' },
+      multipart: true
     }).on('complete', function(data) {
-      test.equal(true, data.ok, "returned " + sys.inspect(data));
+      test.re(data, /content-type\: multipart\/form-data/, 'should set "content-type" header')
+      test.re(data, /name="a"(\s)+10/, 'should send a=10');
+      test.re(data, /name="b"(\s)+thing/, 'should send b=thing');
+      test.re(data, /content-length: 200/, 'should send content-length header');
+
+      test.done();
+    });
+  }
+
+};
+
+
+function dataResponse(request, response) {
+  switch (request.url) {
+    case '/json':
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end('{ "ok": true }');
+      break;
+    case '/xml':
+      response.writeHead(200, { 'content-type': 'application/xml' });
+      response.end('<document><ok>true</ok></document>');
+      break;
+    case '/yaml':
+      response.writeHead(200, { 'content-type': 'application/yaml' });
+      response.end('ok: true');
+      break;
+    case '/gzip':
+      response.writeHead(200, { 'content-encoding': 'gzip' });
+      response.end(Buffer('H4sIAAAAAAAAA0vOzy0oSi0uTk1RSEksSUweHFwADdgOgJYAAAA=', 'base64'));
+      break;
+    case '/deflate':
+      response.writeHead(200, { 'content-encoding': 'deflate' });
+      response.end(Buffer('eJxLzs8tKEotLk5NUUhJLElMHhxcAI9GO1c=', 'base64'));
+      break;
+    case '/truth':
+      response.writeHead(200, {
+        'content-encoding': 'deflate',
+        'content-type': 'application/json'
+      });
+      response.end(Buffer('eJw1i0sKgDAQQ++S9Sj+cDFXEReCoy2UCv0oIt7dEZEsEvKSC4eZErjoCTaCr5uQjICHilQjYfLxkAD+g/IN3BCcXXT3GSF7u0uI2vjs3HubwW1ZdwRRcCZj/QpOIcv9ACXbJLo=', 'base64'));
+      break;
+    case '/binary':
+      response.writeHead(200);
+      response.end(Buffer([9, 30, 64, 135, 200]));
+      break;
+    case '/push-json':
+      var echo = '';
+      request.addListener('data', function(chunk) {
+        echo += chunk.toString('binary');
+      });
+      request.addListener('end', function() {
+        response.writeHead(200, {
+          'content-type': 'application/json'
+        });
+        response.end(JSON.stringify(JSON.parse(echo)));
+      });
+      break;
+    case '/custom-mime':
+      response.writeHead(200, {
+        'content-type': 'application/vnd.github.beta.raw+json; charset=UTF-8'
+      });
+      response.end(JSON.stringify([6,6,6]));
+      break;
+    case '/mal-json':
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end('Чебурашка');
+      break;
+    case '/mal-xml':
+      response.writeHead(200, { 'content-type': 'application/xml' });
+      response.end('Чебурашка');
+      break;
+    case '/mal-yaml':
+      response.writeHead(200, { 'content-type': 'application/yaml' });
+      response.end('{Чебурашка');
+      break;
+    case '/abort':
+      setTimeout(function() {
+        response.writeHead(200);
+        response.end('not aborted');
+      }, 100);
+      break;
+    case '/charset':
+      response.writeHead(200, {
+        'content-type': 'text/plain; charset=windows-1251'
+      });
+      response.end(Buffer('e0e1e2e3e4e5b8e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff', 'hex'));
+      break;
+    default:
+      response.writeHead(404);
+      response.end();
+  }
+}
+
+module.exports['Deserialization'] = {
+
+  setUp: setup(dataResponse),
+  tearDown: teardown(),
+
+  'Should parse JSON': function(test) {
+    rest.get(host + '/json').on('complete', function(data) {
+      test.equal(data.ok, true, 'returned: ' + p(data));
+      test.done();
     });
   },
-  testAutoSerializerShouldParseXML: function(host, test) {
-    rest.get(host, {
-      headers: { 'Accepts': 'application/xml' }
-    }).on('complete', function(data) {
-      test.equal("true", data.ok, "returned " + sys.inspect(data));
+
+  'Should parse XML': function(test) {
+    rest.get(host + '/xml').on('complete', function(data, response) {
+      test.equal(data.ok, 'true', 'returned: ' + response.raw + ' || ' + p(data));
+      test.done();
     });
   },
-  testAutoSerializerShouldParseYAML: function(host, test) {
-    rest.get(host, {
-      headers: { 'Accepts': 'application/yaml' }
+
+  'Should parse YAML': function(test) {
+    rest.get(host + '/yaml').on('complete', function(data) {
+      test.equal(data.ok, true, 'returned: ' + p(data));
+      test.done();
+    });
+  },
+
+  'Should gunzip': function(test) {
+    if (zlib) {
+      rest.get(host + '/gzip').on('complete', function(data) {
+        test.re(data, /^(compressed data){10}$/, 'returned: ' + p(data));
+        test.done();
+      });
+    } else {
+      test.done();
+    }
+  },
+
+  'Should inflate': function(test) {
+    if (zlib) {
+      rest.get(host + '/deflate').on('complete', function(data) {
+        test.re(data, /^(compressed data){10}$/, 'returned: ' + p(data));
+        test.done();
+      })
+    } else {
+      test.done();
+    }
+  },
+
+  'Should decode and parse': function(test) {
+    if (zlib) {
+      rest.get(host + '/truth').on('complete', function(data) {
+        try {
+          with (data) {
+            var result = what + (is + the + answer + to + life + the + universe + and + everything).length;
+          }
+          test.equal(result, 42, 'returned: ' + p(data));
+        } catch (err) {
+          test.ok(false, 'returned: ' + p(data));
+        }
+        test.done();
+      })
+    } else {
+      test.done();
+    }
+  },
+
+  'Should decode as buffer': function(test) {
+    rest.get(host + '/binary', { decoding: 'buffer' }).on('complete', function(data) {
+      test.ok(data instanceof Buffer, 'should be buffer');
+      test.equal(data.toString('base64'), 'CR5Ah8g=', 'returned: ' + p(data));
+      test.done();
+    })
+  },
+
+  'Should decode as binary': function(test) {
+    rest.get(host + '/binary', { decoding: 'binary' }).on('complete', function(data) {
+      test.ok(typeof data == 'string', 'should be string: ' + p(data));
+      test.equal(data, '\t\u001e@‡È', 'returned: ' + p(data));
+      test.done();
+    })
+  },
+
+  'Should decode as base64': function(test) {
+    rest.get(host + '/binary', { decoding: 'base64' }).on('complete', function(data) {
+      test.ok(typeof data == 'string', 'should be string: ' + p(data));
+      test.equal(data, 'CR5Ah8g=', 'returned: ' + p(data));
+      test.done();
+    })
+  },
+
+  'Should post and parse JSON': function(test) {
+    var obj = { secret : 'very secret string' };
+    rest.post(host + '/push-json', {
+      headers: {
+        'content-type': 'application/json'
+      },
+      data: JSON.stringify(obj)
     }).on('complete', function(data) {
-      test.equal(true, data.ok, "returned " + sys.inspect(data));
+      test.equal(obj.secret, data.secret, 'returned: ' + p(data));
+      test.done();
+    })
+  },
+
+  'Should post and parse JSON via shortcut method': function(test) {
+    var obj = { secret : 'very secret string' };
+    rest.postJson(host + '/push-json', obj).on('complete', function(data) {
+      test.equal(obj.secret, data.secret, 'returned: ' + p(data));
+      test.done();
     });
+  },
+
+  'Should understand custom mime-type': function(test) {
+    rest.parsers.auto.matchers['application/vnd.github+json'] = function(data, callback) {
+      rest.parsers.json.call(this, data, function(err, data) {
+        err || (data.__parsedBy__ = 'github');
+        callback(err, data);
+      });
+    };
+    rest.get(host + '/custom-mime').on('complete', function(data) {
+      test.expect(3);
+      test.ok(Array.isArray(data), 'should be array, returned: ' + p(data));
+      test.equal(data.join(''), '666', 'should be [6,6,6], returned: ' + p(data));
+      test.equal(data.__parsedBy__, 'github', 'should use vendor-specific parser, returned: ' + p(data.__parsedBy__));
+      test.done();
+    });
+  },
+
+  'Should correctly soft-abort request': function(test) {
+    test.expect(4);
+    rest.get(host + '/abort').on('complete', function(data) {
+      test.equal(data, null, 'data should be null');
+      test.equal(this.aborted, true, 'should be aborted');
+      test.done();
+    }).on('error', function(err) {
+        test.ok(false, 'should not emit error event');
+      }).on('abort', function(err) {
+        test.equal(err, null, 'err should be null');
+        test.equal(this.aborted, true, 'should be aborted');
+      }).on('success', function() {
+        test.ok(false, 'should not emit success event');
+      }).on('fail', function() {
+        test.ok(false, 'should not emit fail event');
+      }).abort();
+  },
+
+  'Should correctly hard-abort request': function(test) {
+    test.expect(4);
+    rest.get(host + '/abort').on('complete', function(data) {
+      test.ok(data instanceof Error, 'should be error, got: ' + p(data));
+      test.equal(this.aborted, true, 'should be aborted');
+      test.done();
+    }).on('error', function(err) {
+        test.ok(err instanceof Error, 'should be error, got: ' + p(err));
+      }).on('abort', function(err) {
+        test.equal(this.aborted, true, 'should be aborted');
+      }).on('success', function() {
+        test.ok(false, 'should not emit success event');
+      }).on('fail', function() {
+        test.ok(false, 'should not emit fail event');
+      }).abort(true);
+  },
+
+  'Should correctly handle malformed JSON': function(test) {
+    test.expect(4);
+    rest.get(host + '/mal-json').on('complete', function(data, response) {
+      test.ok(data instanceof Error, 'should be instanceof Error, got: ' + p(data));
+      test.re(data.message, /^Failed to parse/, 'should contain "Failed to parse", got: ' + p(data.message));
+      test.equal(response.raw, 'Чебурашка', 'should be "Чебурашка", got: ' + p(response.raw));
+      test.done();
+    }).on('error', function(err) {
+      test.ok(err instanceof Error, 'should be instanceof Error, got: ' + p(err));
+    }).on('success', function() {
+      test.ok(false, 'should not have got here');
+    }).on('fail', function() {
+      test.ok(false, 'should not have got here');
+    });
+  },
+
+  'Should correctly handle malformed XML': function(test) {
+    test.expect(4);
+    rest.get(host + '/mal-xml').on('complete', function(data, response) {
+      test.ok(data instanceof Error, 'should be instanceof Error, got: ' + p(data));
+      test.re(data.message, /^Failed to parse/, 'should contain "Failed to parse", got: ' + p(data.message));
+      test.equal(response.raw, 'Чебурашка', 'should be "Чебурашка", got: ' + p(response.raw));
+      test.done();
+    }).on('error', function(err) {
+      test.ok(err instanceof Error, 'should be instanceof Error, got: ' + p(err));
+    }).on('success', function() {
+      test.ok(false, 'should not have got here');
+    }).on('fail', function() {
+      test.ok(false, 'should not have got here');
+    });
+  },
+
+  'Should correctly handle malformed YAML': function(test) {
+    test.expect(4);
+    rest.get(host + '/mal-yaml').on('complete', function(data, response) {
+      test.ok(data instanceof Error, 'should be instanceof Error, got: ' + p(data));
+      test.re(data.message, /^Failed to parse/, 'should contain "Failed to parse", got: ' + p(data.message));
+      test.equal(response.raw, '{Чебурашка', 'should be "{Чебурашка", got: ' + p(response.raw));
+      test.done();
+    }).on('error', function(err) {
+      test.ok(err instanceof Error, 'should be instanceof Error, got: ' + p(err));
+    }).on('success', function() {
+      test.ok(false, 'should not have got here');
+    }).on('fail', function() {
+      test.ok(false, 'should not have got here');
+    });
+  }
+
+};
+
+if (Iconv) {
+  module.exports['Deserialization']['Should correctly convert charsets '] = function(test) {
+    rest.get(host + '/charset').on('complete', function(data) {
+      test.equal(data, 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя');
+      test.done();
+    });
+  };
+}
+
+
+function redirectResponse(request, response) {
+  if (request.url == '/redirected') {
+    response.writeHead(200, { 'content-type': 'text/plain' });
+    response.end('redirected');
+  } else if (request.url == '/') {
+    response.writeHead(301, {
+      'location': host + '/' + (request.headers['x-redirects'] ? '1' : 'redirected')
+    });
+    response.end('redirect');
+  } else {
+    var count = parseInt(request.url.substr(1));
+    var max = parseInt(request.headers['x-redirects']);
+    response.writeHead(count < max ? 301 : 200, {
+      'location': host + '/' + (count + 1)
+    });
+    response.end(count.toString(10));
   }
-});
+}
+
+module.exports['Redirect'] = {
 
-helper.testCase('Redirect Tests', helper.redirectServer, {
-  testShouldAutomaticallyFollowRedirects: function(host, test) {
+  setUp: setup(redirectResponse),
+  tearDown: teardown(),
+
+  'Should follow redirects': function(test) {
     rest.get(host).on('complete', function(data) {
-      test.equal('Hell Yeah!', data, "returned " + sys.inspect(data));
+      test.equal(data, 'redirected', 'returned: ' + p(data));
+      test.done();
+    });
+  },
+
+  'Should follow multiple redirects': function(test) {
+    rest.get(host, {
+      headers: { 'x-redirects': '5' }
+    }).on('complete', function(data) {
+      test.equal(data, '5', 'returned: ' + p(data));
+      test.done();
     });
   }
-});
 
-helper.testCase('Content-Length Tests', helper.contentLengthServer, {
-  testRequestHeaderIncludesContentLengthWithJSONData: function(host, test){
-    var jsonString = JSON.stringify({ greeting: 'hello world' });
+};
+
+
+function contentLengthResponse(request, response) {
+  response.writeHead(200, { 'content-type': 'text/plain' });
+  if ('content-length' in request.headers) {
+    response.write(request.headers['content-length']);
+  } else {
+    response.write('content-length is not set');
+  }
+  response.end();
+}
+
+module.exports['Content-Length'] = {
+
+  setUp: setup(contentLengthResponse),
+  tearDown: teardown(),
+
+  'JSON content length': function(test) {
     rest.post(host, {
-      data: jsonString
-    }).on('complete', function(data){
+      data: JSON.stringify({ greeting: 'hello world' })
+    }).on('complete', function(data) {
       test.equal(26, data, 'should set content-length');
+      test.done();
     });
   },
-  testJSONMultibyteContentLength: function (host, test){
-    var multibyteData = JSON.stringify({ greeting: 'こんにちは世界' });
+
+  'JSON multibyte content length': function (test) {
     rest.post(host, {
-      data: multibyteData
+      data: JSON.stringify({ greeting: 'こんにちは世界' })
     }).on('complete', function(data) {
-      test.notEqual(22, data, 'should unicode string length');
       test.equal(36, data, 'should byte-size content-length');
+      test.done();
     });
   }
-});
+
+};