it("insert", function (done) {
var expected = "commit",
mock = new Framework.Mock(),
transaction = new Framework.Postgresql.Transaction();
mock.mock("transaction", transaction, "query")
.with("INSERT INTO \"table\" (\"id\") VALUES ($1)", [
"id"
])
.resolve(expected);
transaction.insert("table", {
id: "id"
})
.then(function (actual) {
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
.catch(done);
});
it('resolves',function (done) {
var service = {},
validator,
mock = new Framework.Mock();
mock.mock('service',service,'fetchOne')
.with({
id: 'abcdefghijklmnopqrstuvwxyz'
})
.reject(false);
validator = new Framework.Validators.NotExists({
key: 'id',
service: service
});
validator.validate('abcdefghijklmnopqrstuvwxyz')
.then(function () {
return mock.done(done);
})
.catch(done);
});
it("delete", function (done) {
var expected = "commit",
mock = new Framework.Mock(),
transaction = new Framework.Postgresql.Transaction();
mock.mock("transaction", transaction, "query")
.with("DELETE FROM \"table\" WHERE \"id\" = $1", [
"id"
])
.resolve(expected);
transaction.delete("table", {
id: {
comparator: "=",
value: "id"
}
})
.then(function (actual) {
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
.catch(done);
});
it("query rejects", function (done) {
var client = {},
expected = "query",
mock = new Framework.Mock(),
transaction = new Framework.Postgresql.Transaction(client);
mock.mock("client", transaction.client, "query")
.with("sql", "inserts")
.callback(expected);
transaction.query("sql", "inserts")
.then(function () {
throw new Error("resolved");
}, function (actual) {
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
.catch(done);
});
it("send with defaults resolves with result from transport.sendEmail", function (done) {
var service = new Framework.Services.Email({
defaults: {
from: "from",
subject: "subject"
},
transport: {}
}),
email = {
to: "to"
},
expected = "expected",
mock = new Framework.Mock();
mock.mock("transport", service.transport, "sendEmail")
.with({
from: "from",
to: "to",
subject: "subject"
})
.callback(null, expected);
service.send(email)
.then(function (actual) {
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
.catch(done);
});
+ " response.status with 200 and response.json with allowed", function (done) {
var controller = new Framework.Controllers.Model({
acl: new Framework.Acl(),
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: "******",
params: {"params": "params"},
query: {"query": "query"},
body: "body"
},
response = {},
merged = {
"params": "params",
"query": "query"
},
set = [
"model1",
"model2"
],
allowed = [
set[0]
];
mock.mock("service", controller.service, "fetchAll")
.with(merged)
.resolve(set);
mock.mock("acl", controller.acl, "isAllowedQuery")
.with(request.user, controller.resource, "view", set)
.resolve(allowed);
mock.mock("response", response, "status")
.with(200)
.return(true);
mock.mock("response", response, "json")
.with(allowed)
.return(true);
controller.fetchAll()(request, response)
.then(function () {
return mock.done(done);
})
.catch(done);
});
.then(function (actual) {
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
+ " response.status with 200 and response.json with set", function (done) {
var controller = new Framework.Controllers.Model({
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: "******",
params: {"params": "params"},
query: {"query": "query"},
body: "body"
},
response = {},
merged = {
"params": "params",
"query": "query"
},
model = "model";
mock.mock("service", controller.service, "fetchOne")
.with(merged)
.resolve(model);
mock.mock("response", response, "status")
.with(200)
.return(true);
mock.mock("response", response, "json")
.with(model)
.return(true);
controller.fetchOne()(request, response, done)
.then(function () {
return mock.done(done);
})
.catch(done);
});
.then(function (actual) {
Framework.Expect(transaction.started).to.be.ok();
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
+ " with 201 and response.json with model", function (done) {
var controller = new Framework.Controllers.Model({
acl: new Framework.Acl(),
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: {},
body: {}
},
response = {};
mock.mock("acl", controller.acl, "isAllowed")
.with(request.user, controller.resource, "add", request.body)
.resolve(request.body);
mock.mock("service", controller.service, "add")
.with(request.body)
.resolve(request.body);
mock.mock("response", response, "status")
.with(201)
.return(true);
mock.mock("response", response, "json")
.with(request.body)
.return(true);
controller.add()(request, response, done)
.then(function () {
return mock.done(done);
})
.catch(done);
});
+ " service.edit with model which rejects and calls next with error", function (done) {
var controller = new Framework.Controllers.Model({
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: "******",
params: "params",
body: "body"
},
response = {},
model = "model",
next = {},
error = new Error("test");
mock.mock("service", controller.service, "fetchOne")
.with(request.params)
.resolve(model);
mock.mock("service", controller.service, "edit")
.with(model, request.body)
.reject(error);
mock.mock("next", next, "next")
.with(error)
.return(true);
controller.edit()(request, response, next.next)
.then(function () {
return mock.done(done);
})
.catch(done);
});
+ " and request.query which rejects then calls next with error", function (done) {
var controller = new Framework.Controllers.Model({
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: "******",
params: {"params": "params"},
query: {"query": "query"},
body: "body"
},
response = {},
merged = {
"params": "params",
"query": "query"
},
error = new Error("error"),
next = {};
mock.mock("service", controller.service, "fetchOne")
.with(merged)
.reject(error);
mock.mock("next", next, "next")
.with(error)
.return(true);
controller.fetchOne()(request, response, next.next)
.then(function () {
return mock.done(done);
})
.catch(done);
});
.catch(Framework.Errors.NotValid,function (exception) {
Framework.Expect(exception).to.be.eql({
errors: 'Already Exists',
name: 'NotValid'
});
return mock.done(done);
})
it("should call call select on the correct formatter", function (done) {
var format = "postgresql",
mock = new Framework.Mock(),
del = new Framework.Sql.Delete();
mock.mock("formatter", del.formatters[format], "delete")
.return({
inserts: ["inserts"],
sql: "sql"
});
del.build(format);
Framework.Expect(del.sql).to.be.equal("sql");
Framework.Expect(del.inserts).to.be.eql(["inserts"]);
mock.done(done);
});
it("commit", function (done) {
var expected = "commit",
mock = new Framework.Mock(),
transaction = new Framework.Postgresql.Transaction();
mock.mock("transaction", transaction, "query")
.with("COMMIT")
.resolve(expected);
transaction.commit()
.then(function (actual) {
Framework.Expect(actual).to.be.equal(expected);
return mock.done(done);
})
.catch(done);
});
it("add without acl calls service.add with model which rejects and calls next with error",function (done) {
var controller = new Framework.Controllers.Model({
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: {},
body: {}
},
response = {},
next = {},
error = new Error("test");
mock.mock("service", controller.service, "add")
.with(request.body)
.reject(error);
mock.mock("next", next, "next")
.with(error)
.return(true);
controller.add()(request, response, next.next)
.then(function () {
return mock.done(done);
})
.catch(done);
});
it("send rejects with error from transport.sendEmail", function (done) {
var service = new Framework.Services.Email({
defaults: {
from: "from",
subject: "subject"
},
transport: {}
}),
email = {
to: "to"
},
error = "error",
mock = new Framework.Mock();
mock.mock("transport", service.transport, "sendEmail")
.with({
from: "from",
to: "to",
subject: "subject"
})
.callback(error);
service.send(email)
.then(function () {
return done(new Error("resolved"));
})
.catch(function (actual) {
Framework.Expect(actual).to.be.equal(error);
return done();
});
});
it('rejects',function (done) {
var service = {},
validator,
mock = new Framework.Mock();
mock.mock('service',service,'fetchOne')
.with({
id: 'abcdefg0123456789'
})
.resolve(true);
validator = new Framework.Validators.NotExists({
key: 'id',
service: service
});
validator.validate('abcdefg0123456789')
.then(function () {
return done(new Error('resolved'));
})
.catch(Framework.Errors.NotValid,function (exception) {
Framework.Expect(exception).to.be.eql({
errors: 'Already Exists',
name: 'NotValid'
});
return mock.done(done);
})
.catch(done);
});
+ " service.edit with model, response.status with 200 and response.json with model", function (done) {
var controller = new Framework.Controllers.Model({
acl: new Framework.Acl(),
resource: "test",
service: new Framework.Services.Model({
adapter: new Framework.Adapters.Model.Mysql({
pool: {},
primary: ["id"],
table: "test"
})
})
}),
mock = new Framework.Mock(),
request = {
user: "******",
params: "params",
body: "body"
},
response = {},
model = "model";
mock.mock("service", controller.service, "fetchOne")
.with(request.params)
.resolve(model);
mock.mock("acl", controller.acl, "isAllowed")
.with(request.user, controller.resource, "edit", model)
.resolve(model);
mock.mock("service", controller.service, "edit")
.with(request.body, model)
.resolve(request.body);
mock.mock("response", response, "status")
.with(200)
.return(true);
mock.mock("response", response, "json")
.with(request.body)
.return(true);
controller.edit()(request, response)
.then(function () {
return mock.done(done);
})
.catch(done);
});
.then(function () {
return mock.done(done);
})