Archived
1
0
Fork 0

Reorganise test

This commit is contained in:
Ethanell 2020-08-25 17:53:21 +02:00
parent 39b847c79e
commit 43227d42ad
2 changed files with 434 additions and 424 deletions

View file

@ -17,236 +17,242 @@ async function databaseExit(models) {
delete require.cache[require.resolve("../models")]; delete require.cache[require.resolve("../models")];
} }
describe("Database objects tests", () => {
describe("Database Department tests", () => {
let models;
describe("Database Department tests", () => { before(async () => {
let models; models = await databaseEnter();
});
before(async () => { after(async () => {
models = await databaseEnter(); await databaseExit(models);
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Department creation", async () => {
expect(await models.Department.create({name: "TestDepartment"})).to.be.instanceOf(models.Department);
});
it("Department validation", async () => {
await models.Department.create({name: "TestDepartment"});
return expect(models.Department.create({name: "TestDepartment"})).to.be.rejectedWith(models.Sequelize.ValidationError);
});
});
describe("Database Sandwich tests", () => {
let models;
before(async () => {
models = await databaseEnter();
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Sandwich creation", async () => {
expect(await models.Sandwich.create({name: "TestSandwich", price: 1.5})).to.be.instanceOf(models.Sandwich);
});
it("Sandwich validation", async () => {
await models.Sandwich.create({name: "TestSandwich", price: 1.5});
return expect(models.Sandwich.create({name: "TestSandwich", price: 1.5})).to.be.rejectedWith(models.Sequelize.ValidationError);
});
});
describe("Database User test", () => {
let models;
before(async () => {
models = await databaseEnter()
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("User creation", async () => {
expect(await models.User.create({
username: "test",
email: "test@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: "test"
})).to.be.instanceOf(models.User);
});
it("User password", async () => {
let testPassword = "test";
let testUser = await models.User.create({
username: "test",
email: "test@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: testPassword});
expect(testUser.checkPassword(testPassword)).to.be.equal(true);
});
it("User validation", async () => {
await models.User.create({
username: "test",
email: "test@test.fr",
emailToken: "Keyboard Cat",
firstName: "Test",
lastName: "Test",
passwordHash: "test",
passwordToken: "Keyboard Cat"
}); });
return Promise.all([ afterEach(async () => {
//Username await wipeDatabase(models);
expect(models.User.create({ });
it("Department creation", async () => {
expect(await models.Department.create({name: "TestDepartment"})).to.be.instanceOf(models.Department);
});
it("Department validation", async () => {
await models.Department.create({name: "TestDepartment"});
return expect(models.Department.create({name: "TestDepartment"})).to.be.rejectedWith(models.Sequelize.ValidationError);
});
});
describe("Database Sandwich tests", () => {
let models;
before(async () => {
models = await databaseEnter();
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Sandwich creation", async () => {
expect(await models.Sandwich.create({name: "TestSandwich", price: 1.5})).to.be.instanceOf(models.Sandwich);
});
it("Sandwich validation", async () => {
await models.Sandwich.create({name: "TestSandwich", price: 1.5});
return expect(models.Sandwich.create({
name: "TestSandwich",
price: 1.5
})).to.be.rejectedWith(models.Sequelize.ValidationError);
});
});
describe("Database User test", () => {
let models;
before(async () => {
models = await databaseEnter()
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("User creation", async () => {
expect(await models.User.create({
username: "test", username: "test",
email: "test2@test.fr",
firstName: "Test2",
lastName: "Test2",
passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError),
//Email
expect(models.User.create({
username: "test2",
email: "test@test.fr", email: "test@test.fr",
firstName: "Test2",
lastName: "Test2",
passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError),
//First & last name
expect(models.User.create({
username: "test2",
email: "test2@test.fr",
firstName: "Test", firstName: "Test",
lastName: "Test", lastName: "Test",
passwordHash: "test" passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError), })).to.be.instanceOf(models.User);
//Email token });
expect(models.User.create({ it("User password", async () => {
username: "test2", let testPassword = "test";
email: "test2@test.fr", let testUser = await models.User.create({
username: "test",
email: "test@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: testPassword
});
expect(testUser.checkPassword(testPassword)).to.be.equal(true);
});
it("User validation", async () => {
await models.User.create({
username: "test",
email: "test@test.fr",
emailToken: "Keyboard Cat", emailToken: "Keyboard Cat",
firstName: "Test2", firstName: "Test",
lastName: "Test2", lastName: "Test",
passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError),
//Password token
expect(models.User.create({
username: "test2",
email: "test2@test.fr",
firstName: "Test2",
lastName: "Test2",
passwordHash: "test", passwordHash: "test",
passwordToken: "Keyboard Cat" passwordToken: "Keyboard Cat"
})).to.be.rejectedWith(models.Sequelize.ValidationError) });
])
}); return Promise.all([
it("User associations", async () => { //Username
let testUser = await models.User.create({ expect(models.User.create({
username: "test", username: "test",
email: "test@test.fr", email: "test2@test.fr",
firstName: "Test", firstName: "Test2",
lastName: "Test", lastName: "Test2",
passwordHash: "test" passwordHash: "test"
}, { })).to.be.rejectedWith(models.Sequelize.ValidationError),
include: models.Department //Email
expect(models.User.create({
username: "test2",
email: "test@test.fr",
firstName: "Test2",
lastName: "Test2",
passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError),
//First & last name
expect(models.User.create({
username: "test2",
email: "test2@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError),
//Email token
expect(models.User.create({
username: "test2",
email: "test2@test.fr",
emailToken: "Keyboard Cat",
firstName: "Test2",
lastName: "Test2",
passwordHash: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError),
//Password token
expect(models.User.create({
username: "test2",
email: "test2@test.fr",
firstName: "Test2",
lastName: "Test2",
passwordHash: "test",
passwordToken: "Keyboard Cat"
})).to.be.rejectedWith(models.Sequelize.ValidationError)
])
}); });
let testDepartment = await models.Department.create({name: "TestDepartment"}); it("User associations", async () => {
let testUser = await models.User.create({
username: "test",
email: "test@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: "test"
}, {
include: models.Department
});
let testDepartment = await models.Department.create({name: "TestDepartment"});
await testUser.setDepartment(testDepartment); await testUser.setDepartment(testDepartment);
await testUser.reload(); await testUser.reload();
expect(testUser.Department).to.be.instanceOf(models.Department); expect(testUser.Department).to.be.instanceOf(models.Department);
expect(testUser.Department.name).to.be.equal(testDepartment.name); expect(testUser.Department.name).to.be.equal(testDepartment.name);
});
});
describe("Database Order tests", () => {
let models;
before(async () => {
models = await databaseEnter();
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Order creation", async () => {
expect(await models.Order.create({
firstName: "Test",
lastName: "Test",
price: 1.5
})).to.be.instanceOf(models.Order);
});
it("Order associations", async () => {
let testOrder = await models.Order.create({firstName: "Test", lastName: "Test", price: 1.5,},
{include: [models.Department, models.Sandwich, models.User]});
let testDepartment = await models.Department.create({name: "TestDepartment"});
let testSandwich = await models.Sandwich.create({name: "TestSandwich", price: 1.5});
let testUser = await models.User.create({
username: "test",
email: "test@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: "test"
});
await testOrder.setDepartment(testDepartment);
await testOrder.reload();
expect(testOrder.Department).to.be.instanceOf(models.Department);
expect(testOrder.Department.name).to.be.equal(testDepartment.name);
await testOrder.addSandwiches(testSandwich);
await testOrder.reload();
expect(testOrder.Sandwiches[0]).to.be.instanceOf(models.Sandwich);
expect(testOrder.Sandwiches[0].name).to.be.equal(testSandwich.name);
await testOrder.setUser(testUser);
await testOrder.reload();
expect(testOrder.User).to.be.instanceOf(models.User);
expect(testOrder.User.username).to.be.equal(testUser.username);
});
});
describe("Database Data tests", () => {
let models;
before(async () => {
models = await databaseEnter();
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Data creation", async () => {
expect(await models.Data.create({
key: "test",
value: "test"
})).to.be.instanceOf(models.Data);
});
it("Data validation", async () => {
await models.Data.create({key: "test", value: "test"});
return expect(models.Data.create({
key: "test",
value: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError);
})
}); });
}); });
describe("Database Order tests", () => {
let models;
before(async () => {
models = await databaseEnter();
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Order creation", async () => {
expect(await models.Order.create({
firstName: "Test",
lastName: "Test",
price: 1.5
})).to.be.instanceOf(models.Order);
});
it("Order associations", async () => {
let testOrder = await models.Order.create({firstName: "Test", lastName: "Test", price: 1.5, },
{include: [models.Department, models.Sandwich, models.User]});
let testDepartment = await models.Department.create({name: "TestDepartment"});
let testSandwich = await models.Sandwich.create({name: "TestSandwich", price: 1.5});
let testUser = await models.User.create({
username: "test",
email: "test@test.fr",
firstName: "Test",
lastName: "Test",
passwordHash: "test"});
await testOrder.setDepartment(testDepartment);
await testOrder.reload();
expect(testOrder.Department).to.be.instanceOf(models.Department);
expect(testOrder.Department.name).to.be.equal(testDepartment.name);
await testOrder.addSandwiches(testSandwich);
await testOrder.reload();
expect(testOrder.Sandwiches[0]).to.be.instanceOf(models.Sandwich);
expect(testOrder.Sandwiches[0].name).to.be.equal(testSandwich.name);
await testOrder.setUser(testUser);
await testOrder.reload();
expect(testOrder.User).to.be.instanceOf(models.User);
expect(testOrder.User.username).to.be.equal(testUser.username);
});
});
describe("Database Data tests", () => {
let models;
before(async () => {
models = await databaseEnter();
});
after(async () => {
await databaseExit(models);
});
afterEach(async () => {
await wipeDatabase(models);
});
it("Data creation", async () => {
expect(await models.Data.create({
key: "test",
value: "test"
})).to.be.instanceOf(models.Data);
});
it("Data validation", async () => {
await models.Data.create({key: "test", value: "test"});
return expect(models.Data.create({
key: "test",
value: "test"
})).to.be.rejectedWith(models.Sequelize.ValidationError);
})
});

View file

@ -39,239 +39,243 @@ async function getLoginAgent(app) {
} }
describe("Public pages test", () => { describe("Pages tests", () => {
let app; describe("Public pages test", () => {
let models;
before(async () => {
[app, models] = await setup();
});
after(() => {
return clean;
});
it("Responds to /", (done) => {
request(app)
.get("/")
.expect(200, done);
});
it("Responds to /login", (done) => {
request(app)
.get("/login")
.expect(200, done);
});
it("Responds to /forget", (done) => {
request(app)
.get("/forget")
.expect(200, done)
});
it("Responds to /register", (done) => {
request(app)
.get("/register")
.expect(200, done);
});
it("Responds to /check", (done) => {
request(app)
.get("/check")
.expect(400, done);
});
it("Responds to /logout", (done) => {
request(app)
.get("/logout")
.expect(302, done);
});
it("Response to /profile", (done) => {
request(app)
.get("/profile")
.expect(302, done);
});
it("Response to /sandwiches", (done) => {
request(app)
.get("/sandwiches")
.expect(302, done);
});
it("Response to /orders", (done) => {
request(app)
.get("/orders")
.expect(302, done);
});
it("Response to /admin", (done) => {
request(app)
.get("/admin")
.expect(302, done);
});
it("Response to /admin/orders", (done) => {
request(app)
.get("/admin/orders")
.expect(302, done);
});
it("Response to /admin/orders/date", done => {
request(app)
.get("/admin/orders/date")
.expect(302, done);
});
it("Reponse to /admin/sandwiches", done => {
request(app)
.get("/admin/sandwiches")
.expect(302, done);
});
it("Reponse to /admin/sandwiches/add", done => {
request(app)
.get("/admin/sandwiches/add")
.expect(302, done);
});
it("Reponse to /admin/sandwiches/edit", done => {
request(app)
.get("/admin/sandwiches/edit")
.expect(302, done);
});
it("Reponse to /admin/departments", done => {
request(app)
.get("/admin/departments")
.expect(302, done);
});
it("Reponse to /admin/departments/add", done => {
request(app)
.get("/admin/departments/add")
.expect(302, done);
});
it("Reponse to /admin/departments/edit", done => {
request(app)
.get("/admin/departments/edit")
.expect(302, done);
});
it("404 everything else", (done) => {
request(app)
.get("/foo/bar")
.expect(404, done);
});
});
describe("Global logged user pages", () => {
let app;
let models;
before(async () => {
[app, models] = await setup();
await createTestUser(models);
});
after( () => {
return clean;
});
it("Login user", async () => {
let res = await request(app)
.post("/login")
.send({username: "test", password: "test"})
.expect(302);
expect(res.headers.location).to.be.equal("/");
});
it("Login error", async () => {
let res = await request(app)
.post("/login")
.send({username: "wrong", password: "wrong"})
.expect(302);
expect(res.headers.location).to.be.equal("/login?err=true");
});
it("Forget page", async () => {
await (await getLoginAgent(app))
.get("/forget")
.expect(302);
});
it("Register page", async () => {
await (await getLoginAgent(app))
.get("/register")
.expect(302);
});
it("Logout page", async () => {
let agent = await getLoginAgent(app);
await agent
.get("/logout")
.expect(302);
//Check if user is correctly logout
await agent
.get("/login")
.expect(200);
});
it("Profile page", async () => {
await (await getLoginAgent(app))
.get("/profile")
.expect(200);
});
});
for (let [p, a] of Object.entries({
0: [403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403],
1: [200, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403],
2: [200, 200, 403, 403, 403, 403, 403, 403, 403, 403, 403],
3: [200, 200, 200, 200, 200, 200, 200, 400, 200, 200, 400]
}))
describe(`Permission ${p} pages`, () => {
let app; let app;
let models; let models;
before(async () => { before(async () => {
[app, models] = await setup(); [app, models] = await setup();
await createTestUser(models, p);
}); });
after( () => { after(() => {
return clean; return clean;
}); });
it("Sandwiches page", async () => { it("Responds to /", (done) => {
await (await getLoginAgent(app)) request(app)
.get("/")
.expect(200, done);
});
it("Responds to /login", (done) => {
request(app)
.get("/login")
.expect(200, done);
});
it("Responds to /forget", (done) => {
request(app)
.get("/forget")
.expect(200, done)
});
it("Responds to /register", (done) => {
request(app)
.get("/register")
.expect(200, done);
});
it("Responds to /check", (done) => {
request(app)
.get("/check")
.expect(400, done);
});
it("Responds to /logout", (done) => {
request(app)
.get("/logout")
.expect(302, done);
});
it("Response to /profile", (done) => {
request(app)
.get("/profile")
.expect(302, done);
});
it("Response to /sandwiches", (done) => {
request(app)
.get("/sandwiches") .get("/sandwiches")
.expect(a[0]); .expect(302, done);
}); });
it("Orders page", async () => { it("Response to /orders", (done) => {
await (await getLoginAgent(app)) request(app)
.get("/orders") .get("/orders")
.expect(a[1]); .expect(302, done);
}); });
it("Admin page", async () => { it("Response to /admin", (done) => {
await (await getLoginAgent(app)) request(app)
.get("/admin") .get("/admin")
.expect(a[2]); .expect(302, done);
}); });
it("Orders administration page", async () => { it("Response to /admin/orders", (done) => {
await (await getLoginAgent(app)) request(app)
.get("/admin/orders") .get("/admin/orders")
.expect(a[3]); .expect(302, done);
}); });
it("Orders date administration page", async () => { it("Response to /admin/orders/date", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/orders/date") .get("/admin/orders/date")
.expect(a[4]) .expect(302, done);
}); });
it("Sandwiches administration page", async () => { it("Reponse to /admin/sandwiches", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/sandwiches") .get("/admin/sandwiches")
.expect(a[5]) .expect(302, done);
}); });
it("Sandwiches add administration page", async () => { it("Reponse to /admin/sandwiches/add", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/sandwiches/add") .get("/admin/sandwiches/add")
.expect(a[6]) .expect(302, done);
}); });
it("Sandwiches edit administration page", async () => { it("Reponse to /admin/sandwiches/edit", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/sandwiches/edit?name=test") .get("/admin/sandwiches/edit")
.expect(a[7]) .expect(302, done);
}); });
it("Departments administration page", async () => { it("Reponse to /admin/departments", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/departments") .get("/admin/departments")
.expect(a[8]) .expect(302, done);
}); });
it("Departments add administration page", async () => { it("Reponse to /admin/departments/add", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/departments/add") .get("/admin/departments/add")
.expect(a[9]) .expect(302, done);
}); });
it("Departments edit administration page", async () => { it("Reponse to /admin/departments/edit", done => {
await (await getLoginAgent(app)) request(app)
.get("/admin/departments/edit?name=test") .get("/admin/departments/edit")
.expect(a[10]) .expect(302, done);
});
it("404 everything else", (done) => {
request(app)
.get("/foo/bar")
.expect(404, done);
}); });
}); });
describe("Global logged user pages", () => {
let app;
let models;
before(async () => {
[app, models] = await setup();
await createTestUser(models);
});
after(() => {
return clean;
});
it("Login user", async () => {
let res = await request(app)
.post("/login")
.send({username: "test", password: "test"})
.expect(302);
expect(res.headers.location).to.be.equal("/");
});
it("Login error", async () => {
let res = await request(app)
.post("/login")
.send({username: "wrong", password: "wrong"})
.expect(302);
expect(res.headers.location).to.be.equal("/login?err=true");
});
it("Forget page", async () => {
await (await getLoginAgent(app))
.get("/forget")
.expect(302);
});
it("Register page", async () => {
await (await getLoginAgent(app))
.get("/register")
.expect(302);
});
it("Logout page", async () => {
let agent = await getLoginAgent(app);
await agent
.get("/logout")
.expect(302);
//Check if user is correctly logout
await agent
.get("/login")
.expect(200);
});
it("Profile page", async () => {
await (await getLoginAgent(app))
.get("/profile")
.expect(200);
});
});
describe("Permissions pages tests", () => {
for (let [p, a] of Object.entries({
0: [403, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403],
1: [200, 403, 403, 403, 403, 403, 403, 403, 403, 403, 403],
2: [200, 200, 403, 403, 403, 403, 403, 403, 403, 403, 403],
3: [200, 200, 200, 200, 200, 200, 200, 400, 200, 200, 400]
}))
describe(`Permission ${p} pages`, () => {
let app;
let models;
before(async () => {
[app, models] = await setup();
await createTestUser(models, p);
});
after(() => {
return clean;
});
it("Sandwiches page", async () => {
await (await getLoginAgent(app))
.get("/sandwiches")
.expect(a[0]);
});
it("Orders page", async () => {
await (await getLoginAgent(app))
.get("/orders")
.expect(a[1]);
});
it("Admin page", async () => {
await (await getLoginAgent(app))
.get("/admin")
.expect(a[2]);
});
it("Orders administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/orders")
.expect(a[3]);
});
it("Orders date administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/orders/date")
.expect(a[4])
});
it("Sandwiches administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/sandwiches")
.expect(a[5])
});
it("Sandwiches add administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/sandwiches/add")
.expect(a[6])
});
it("Sandwiches edit administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/sandwiches/edit?name=test")
.expect(a[7])
});
it("Departments administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/departments")
.expect(a[8])
});
it("Departments add administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/departments/add")
.expect(a[9])
});
it("Departments edit administration page", async () => {
await (await getLoginAgent(app))
.get("/admin/departments/edit?name=test")
.expect(a[10])
});
});
});
});