var res = getResponse();
errorHandler(res, new MWError(400, "Message"));
res.status.calledWith(400).should.equal(true);
res.send.calledWith({error: "Message"}).should.equal(true);var res = getResponse();
errorHandler(res, new Error("Message"));
res.status.calledWith(500).should.equal(true);
res.send.calledWith({error: "Internal server error"}).should.equal(true);var error = new Error("Message");
var res = getResponse();
errorHandler(res, error);
console.error.calledWith(error).should.equal(true);var EIGHTYNINE_DAYS_AGO_IN_MS = Date.now() - (89 * 24 * 60 * 60 * 1000);
var ret = getLastValidDate();
(ret.getTime() < EIGHTYNINE_DAYS_AGO_IN_MS).should.equal(true);var mwInstance = {
db: {
collection: function () {
return {
findOne: R.always(null)
};
}
}
};
var ret = getUserFromToken(mwInstance, "loginToken");
ret.then.should.be.of.type("function");var ret = hashLoginToken("hello");
ret.should.equal("LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=");var res_0 = getResponse();
resultHandler(res_0, {});
res_0.status.calledWith(200).should.equal(true);
res_0.send.calledWith({result: {}}).should.equal(true);
var res_1 = getResponse();
resultHandler(res_1, undefined);
res_1.status.calledWith(200).should.equal(true);
res_1.send.calledWith({result: null}).should.equal(true);var ret = methods._runMethod({}, "", []);
ret.catch(R.identity);
ret.then.should.be.of.type("function");var ctx = {
_methods: {
method: {
fn: sinon.spy(),
context: {}
}
}
};
methods._runMethod.call(ctx, {}, "method", [])
.then(function () {
try {
ctx._methods.method.fn.called.should.equal(true);
} catch (e) {
return done(e);
}
done();
})
.catch(done);var ctx = {
_methods: {
method: {
fn: sinon.spy(),
context: {
prop: "value"
}
}
}
};
methods._runMethod.call(ctx, {userId: null}, "method", [])
.then(function () {
try {
ctx._methods.method.fn.firstCall.thisValue.should.eql({
userId: null,
prop: "value"
});
} catch (e) {
return done(e);
}
done();
})
.catch(done);var ctx = {
_methods: {}
};
methods._runMethod.call(ctx, {}, "method", [])
.then(function () {
done("The promise should have been rejected");
})
.catch(function (err) {
try {
err.code.should.equal(404);
err.message.should.equal("Method not found");
} catch (e) {
return done(e);
}
done();
});var error = {};
var ctx = {
_methods: {
method: {
fn: sinon.stub().throws(error),
context: {}
}
}
};
methods._runMethod.call(ctx, {}, "method", [])
.then(function () {
done("The promise should have been rejected");
})
.catch(function (err) {
try {
err.should.equal(error);
} catch (e) {
return done(e);
}
done();
});var value = {};
var ctx = {
_methods: {
method: {
fn: sinon.stub().returns(value),
context: {}
}
}
};
methods._runMethod.call(ctx, {}, "method", [])
.then(function (val) {
try {
val.should.equal(value);
} catch (e) {
return done(e);
}
done();
})
.catch(done);/*
* express routers are not instances of any class, therefore we can't
* use `instanceOf` for this test. Instead we test it against the
* current implementation, where a router is a function which has,
* according to its API, a `use` property (which is a function too).
*/
var router = methods.getRouter();
router.should.be.of.type("function");
router.use.should.be.of.type("function");var ctx = {
_runMethod: sinon.spy(function () {
return new BPromise(R.identity);
})
};
var route = methods.getRouter.call(ctx);
/*
* Mock the request "only as much as needed" to make it pass through
* the router. We accept this poor compromise since this part is also
* thoroughly tested with integration tests.
*/
var req = {
url: "/",
method: "POST",
context: {},
/*
* If the bodyParser middleware finds a _body property on the
* request, it lets it through.
*/
_body: "notUndefined",
body: {
method: "method",
params: []
}
};
var res = {};
var next = R.identity;
route(req, res, next);
ctx._runMethod.calledWith(req.context, req.body.method, req.body.params).should.equal(true);var ctx = {
_methods: {}
};
var optionalContext = {};
methods.methods.call(ctx, {
name: R.identity
}, optionalContext);
ctx._methods.name.fn.should.equal(R.identity);
ctx._methods.name.context.should.equal(optionalContext);var ctx = {
_methods: {}
};
var troublemaker_0 = function () {
methods.methods.call(ctx, {
name: "notAFunction"
});
};
troublemaker_0.should.throw();
var troublemaker_1 = function () {
methods.methods.call(ctx, {
name: R.identity
}, "notAnObject");
};
troublemaker_1.should.throw();var bodyValidationMiddleware = middleware.bodyValidation();
bodyValidationMiddleware.should.be.of.type("function");
bodyValidationMiddleware.length.should.equal(3);var req = {
body: "malformed body"
};
var res = {
status: sinon.spy(function () {
return res;
}),
send: sinon.spy()
};
var next = sinon.spy();
var bodyValidationMiddleware = middleware.bodyValidation();
bodyValidationMiddleware(req, res, next);
res.status.called.should.equal(true);
res.send.called.should.equal(true);var req = {
body: {
method: "method",
params: []
}
};
var res = {};
var next = sinon.spy();
var bodyValidationMiddleware = middleware.bodyValidation();
bodyValidationMiddleware(req, res, next);
next.called.should.equal(true);var contextMiddleware = middleware.context();
contextMiddleware.should.be.of.type("function");
contextMiddleware.length.should.equal(3);var req = {};
var res = {};
var next = sinon.spy();
var contextMiddleware = middleware.context();
contextMiddleware(req, res, next);
req.context.should.eql({userId: null});
next.called.should.equal(true);var userMiddleware = middleware.user();
userMiddleware.should.be.of.type("function");
userMiddleware.length.should.equal(3);var userMiddleware = middleware.user();
var req = {body: {}};
var res = {};
var next = sinon.spy();
userMiddleware(req, res, next);
next.called.should.equal(true);var userMiddleware = middleware.user({
db: {
collection: R.always({
findOne: function (selector, cb) {
cb(null, undefined);
}
})
}
});
var req = {
body: {
loginToken: "invalid"
}
};
var res = {
status: sinon.spy(function () {
return res;
}),
send: sinon.spy(function () {
var err;
try {
res.status.calledWith(401).should.equal(true);
res.send.called.should.equal(true);
res.send.calledWith({error: "Invalid loginToken"}).should.equal(true);
} catch (e) {
err = e;
}
done(err);
})
};
var next = sinon.spy();
userMiddleware(req, res, next);var userMiddleware = middleware.user({
db: {
collection: R.always({
findOne: function (selector, cb) {
cb(null, {_id: "userId"});
}
})
}
});
var req = {
body: {
loginToken: "valid"
},
context: {}
};
var res = {};
var next = sinon.spy(function () {
var err;
try {
req.context.userId.should.equal("userId");
req.context.user.should.eql({_id: "userId"});
next.called.should.equal(true);
} catch (e) {
err = e;
}
done(err);
});
userMiddleware(req, res, next);var mw = new MW(db);
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({unexpectedProp: "unexpectedValue"})
.expect("Content-Type", /json/)
.expect(400);var mw = new MW(db);
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "nonexistentMethod", params: []})
.expect("Content-Type", /json/)
.expect(404)
.expect({error: "Method not found"});var mw = new MW(db);
mw.methods({
"return:value": function () {
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "return:value", params: []})
.expect("Content-Type", /json/)
.expect(200)
.expect({result: null});var mw = new MW(db);
mw.methods({
"return:value": function () {
return "return:value";
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "return:value", params: []})
.expect("Content-Type", /json/)
.expect(200)
.expect({result: "return:value"});var mw = new MW(db);
mw.methods({
"throw:mw-error": function () {
throw new MW.Error(499, "MW.Error");
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "throw:mw-error", params: []})
.expect("Content-Type", /json/)
.expect(499)
.expect({error: "MW.Error"});var mw = new MW(db);
mw.methods({
"throw:generic-error": function () {
throw new Error("Generic error");
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "throw:generic-error", params: []})
.expect("Content-Type", /json/)
.expect(500)
.expect({error: "Internal server error"});var mw = new MW(db);
mw.methods({
"return:promise:resolved": function () {
return new BPromise(function (resolve, reject) {
setTimeout(function () {
resolve("return:promise:resolved");
}, 10);
});
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "return:promise:resolved", params: []})
.expect("Content-Type", /json/)
.expect(200)
.expect({result: "return:promise:resolved"});var mw = new MW(db);
mw.methods({
"return:promise:rejected:mw-error": function () {
return new BPromise(function (resolve, reject) {
setTimeout(function () {
reject(new MW.Error(499, "MW.Error"));
}, 10);
});
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "return:promise:rejected:mw-error", params: []})
.expect("Content-Type", /json/)
.expect(499)
.expect({error: "MW.Error"});var mw = new MW(db);
mw.methods({
"return:promise:rejected:generic-error": function () {
return new BPromise(function (resolve, reject) {
setTimeout(function () {
reject(new Error("Generic error"));
}, 10);
});
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "return:promise:rejected:generic-error", params: []})
.expect("Content-Type", /json/)
.expect(500)
.expect({error: "Internal server error"});var mw = new MW(db);
mw.methods({
getUserId: function () {
return this.userId;
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "getUserId", params: [], loginToken: "loginToken"})
.expect("Content-Type", /json/)
.expect(200)
.expect({result: "userId"});db.collection("users").findOne({_id: "userId"}, function (err, user) {
// Stringify and parse to convert the Date object at `services.resume.loginTokens.when`
user = JSON.parse(JSON.stringify(user));
var mw = new MW(db);
mw.methods({
getUserIdAndUser: function () {
return [this.userId, this.user];
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "getUserIdAndUser", params: [], loginToken: "loginToken"})
.expect("Content-Type", /json/)
.expect(200)
.expect({result: ["userId", user]});
});var mw = new MW(db);
mw.methods({
getUserId: function () {
return this.userId;
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "getUserId", params: [], loginToken: "invalidLoginToken"})
.expect("Content-Type", /json/)
.expect(401)
.expect({error: "Invalid loginToken"});var mw = new MW(db);
mw.methods({
getUserId: function () {
return this.userId;
}
});
var app = express().use("/", mw.getRouter());
return request(app)
.post("/")
.send({method: "getUserId", params: []})
.expect("Content-Type", /json/)
.expect(200)
.expect({result: null});