expressCart/test/test.js

460 lines
13 KiB
JavaScript
Raw Normal View History

2018-02-23 03:41:24 +10:00
const test = require('ava');
const fs = require('fs');
2019-06-15 11:53:14 +10:00
const _ = require('lodash');
2018-02-23 03:41:24 +10:00
const app = require('../app');
2019-06-15 14:46:08 +10:00
const { runIndexing, fixProductDates } = require('../lib/indexing');
2019-06-11 15:12:07 +10:00
const session = require('supertest-session');
2018-02-23 03:41:24 +10:00
// Get test data to compare in tests
const rawTestData = fs.readFileSync('./bin/testdata.json', 'utf-8');
2019-06-09 22:32:28 +10:00
const jsonData = JSON.parse(rawTestData);
2018-02-23 03:41:24 +10:00
2018-02-24 05:28:05 +10:00
// Setup some global DB objects for comparison
2018-02-23 03:41:24 +10:00
let db;
2018-02-24 05:28:05 +10:00
let config;
2018-02-23 03:41:24 +10:00
let products;
let customers;
let users;
2019-06-11 15:12:07 +10:00
let request = null;
2018-02-23 03:41:24 +10:00
2019-06-15 11:53:14 +10:00
function setup(db){
2019-06-09 22:32:28 +10:00
return Promise.all([
2019-10-29 18:26:30 +10:00
db.cart.deleteMany({}, {}),
db.users.deleteMany({}, {}),
db.customers.deleteMany({}, {}),
db.products.deleteMany({}, {}),
db.orders.deleteMany({}, {})
2019-06-09 22:32:28 +10:00
])
.then(() => {
return Promise.all([
db.users.insertMany(jsonData.users),
db.customers.insertMany(jsonData.customers),
2019-06-15 14:46:08 +10:00
db.products.insertMany(fixProductDates(jsonData.products))
2019-06-09 22:32:28 +10:00
]);
});
}
2018-02-24 05:28:05 +10:00
2019-06-09 22:32:28 +10:00
// Start up app and wait for it to be ready
test.before(async () => {
2019-06-11 15:12:07 +10:00
// Create a session
request = session(app);
await new Promise(resolve => {
2019-06-09 22:32:28 +10:00
app.on('appStarted', async () => {
// Set some stuff now we have the app started
config = app.config;
db = app.db;
2019-06-15 11:53:14 +10:00
await setup(db);
2019-06-09 22:32:28 +10:00
// Get some data from DB to use in compares
products = await db.products.find({}).toArray();
customers = await db.customers.find({}).toArray();
users = await db.users.find({}).toArray();
2019-06-15 11:53:14 +10:00
// Insert orders using product ID's
_(jsonData.orders).each(async (order) => {
order.orderProducts.push({
productId: products[0]._id,
title: products[0].productTitle,
quantity: 1,
totalItemPrice: products[0].productPrice,
options: {
size: '7.5'
},
productImage: products[0].productImage,
productComment: null
});
order.orderDate = new Date();
2019-10-29 18:26:30 +10:00
await db.orders.insertOne(order);
2019-06-15 11:53:14 +10:00
});
2019-06-15 21:30:04 +10:00
// Index everything
await runIndexing(app);
2019-06-09 22:32:28 +10:00
resolve();
});
2018-02-23 03:41:24 +10:00
});
});
2019-06-09 22:32:28 +10:00
test.serial('[Success] Get products JSON', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2018-02-24 05:28:05 +10:00
.get('?json=true')
2019-06-11 15:12:07 +10:00
.expect(200);
2019-06-09 22:32:28 +10:00
if(res.body.length < config.productsPerPage){
2019-06-11 15:12:07 +10:00
t.is(res.body.length, products.length);
2019-06-09 22:32:28 +10:00
}else{
t.is(res.body.length, config.productsPerPage);
}
2018-02-23 03:41:24 +10:00
});
2019-06-09 22:32:28 +10:00
test.serial('[Success] User Login', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2018-02-24 05:28:05 +10:00
.post('/admin/login_action')
.send({
2018-02-23 03:41:24 +10:00
email: users[0].userEmail,
password: 'test'
})
2019-06-11 15:12:07 +10:00
.expect(200);
2019-06-09 22:32:28 +10:00
t.deepEqual(res.body.message, 'Login successful');
2018-02-23 03:41:24 +10:00
});
2019-11-07 16:36:20 +10:00
test.serial('[Fail] Incorrect user password', async t => {
const res = await request
.post('/admin/login_action')
.send({
email: users[0].userEmail,
password: 'test1'
})
.expect(400);
t.deepEqual(res.body.message, 'Access denied. Check password and try again.');
});
2019-06-15 11:53:14 +10:00
test.serial('[Success] Create API key', async t => {
const res = await request
.post('/admin/createApiKey')
.expect(200);
users[0].apiKey = res.body.apiKey;
t.deepEqual(res.body.message, 'API Key generated');
t.deepEqual(res.body.apiKey.length, 24);
});
2019-11-07 16:36:20 +10:00
test.serial('[Fail] Delete own user account', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2019-11-07 16:36:20 +10:00
.get(`/admin/user/delete/${users[0]._id}`)
.expect(302);
t.deepEqual(res.header['location'], '/admin/users');
});
test.serial('[Fail] Delete invalid user ID', async t => {
const res = await request
.get('/admin/user/delete/invalid_user_id')
.expect(302);
t.deepEqual(res.header['location'], '/admin/users');
2018-02-23 03:41:24 +10:00
});
2019-06-09 22:32:28 +10:00
test.serial('[Fail] Customer login with incorrect email', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2018-02-24 05:28:05 +10:00
.post('/customer/login_action')
.send({
2018-02-23 03:41:24 +10:00
loginEmail: 'test1@test.com',
loginPassword: 'test'
})
2019-06-11 15:12:07 +10:00
.expect(400);
2019-06-09 22:32:28 +10:00
t.deepEqual(res.body.message, 'A customer with that email does not exist.');
2018-02-23 03:41:24 +10:00
});
2019-06-09 22:32:28 +10:00
test.serial('[Success] Customer login with correct email', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2018-02-24 05:28:05 +10:00
.post('/customer/login_action')
.send({
2019-06-09 22:32:28 +10:00
loginEmail: customers[0].email,
2018-02-23 03:41:24 +10:00
loginPassword: 'test'
})
2019-06-11 15:12:07 +10:00
.expect(200);
2019-06-09 22:32:28 +10:00
t.deepEqual(res.body.message, 'Successfully logged in');
2018-02-23 03:41:24 +10:00
});
test.serial('[Success] Add subscripton product to cart', async t => {
const res = await request
.post('/product/addtocart')
.send({
productId: products[7]._id,
productQuantity: 1,
productOptions: {}
})
.expect(200);
const sessions = await db.cart.find({}).toArray();
if(!sessions || sessions.length === 0){
t.fail();
}
t.deepEqual(res.body.message, 'Cart successfully updated');
});
test.serial('[Fail] Add product to cart when subscription already added', async t => {
const res = await request
.post('/product/addtocart')
.send({
productId: products[1]._id,
productQuantity: 100,
productOptions: JSON.stringify(products[1].productOptions)
})
.expect(400);
t.deepEqual(res.body.message, 'Subscription already existing in cart. You cannot add more.');
});
test.serial('[Success] Empty cart', async t => {
const res = await request
.post('/product/emptycart')
.expect(200);
t.deepEqual(res.body.message, 'Cart successfully emptied');
});
2019-06-09 22:32:28 +10:00
test.serial('[Success] Add product to cart', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2018-02-24 05:28:05 +10:00
.post('/product/addtocart')
.send({
2018-02-23 03:41:24 +10:00
productId: products[0]._id,
productQuantity: 1,
productOptions: JSON.stringify(products[0].productOptions)
})
2019-06-11 15:12:07 +10:00
.expect(200);
const sessions = await db.cart.find({}).toArray();
if(!sessions || sessions.length === 0){
t.fail();
}
2019-06-09 22:32:28 +10:00
t.deepEqual(res.body.message, 'Cart successfully updated');
2018-02-23 03:41:24 +10:00
});
test.serial('[Fail] Cannot add subscripton when other product in cart', async t => {
const res = await request
.post('/product/addtocart')
.send({
productId: products[7]._id,
productQuantity: 1,
productOptions: {}
})
.expect(400);
t.deepEqual(res.body.message, 'You cannot combine scubscription products with existing in your cart. Empty your cart and try again.');
});
2019-06-09 22:49:50 +10:00
test.serial('[Fail] Add product to cart with not enough stock', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2019-06-09 22:49:50 +10:00
.post('/product/addtocart')
.send({
productId: products[0]._id,
productQuantity: 100,
productOptions: JSON.stringify(products[0].productOptions)
})
2019-06-11 15:12:07 +10:00
.expect(400);
2019-06-09 22:49:50 +10:00
t.deepEqual(res.body.message, 'There is insufficient stock of this product.');
});
2019-06-09 22:32:28 +10:00
test.serial('[Fail] Add incorrect product to cart', async t => {
2019-06-11 15:12:07 +10:00
const res = await request
2018-02-24 05:28:05 +10:00
.post('/product/addtocart')
.send({
id: 'fake_product_id',
state: false
2018-02-23 03:41:24 +10:00
})
2019-06-11 15:12:07 +10:00
.expect(400);
2019-06-09 22:32:28 +10:00
t.deepEqual(res.body.message, 'Error updating cart. Please try again.');
2018-02-23 03:41:24 +10:00
});
2019-06-11 15:12:07 +10:00
test.serial('[Success] Remove item previously added to cart', async t => {
const res = await request
.post('/product/removefromcart')
.send({
cartId: products[0]._id
})
.expect(200);
t.deepEqual(res.body.message, 'Product successfully removed');
});
test.serial('[Fail] Try remove an item which is not in the cart', async t => {
const res = await request
.post('/product/removefromcart')
.send({
cartId: 'bogus_product_id'
})
.expect(400);
t.deepEqual(res.body.message, 'Product not found in cart');
});
2019-06-11 20:03:56 +10:00
test.serial('[Success] Search products', async t => {
const res = await request
.get('/category/backpack?json=true')
.expect(200);
// Should be two backpack products
t.deepEqual(res.body.length, 2);
});
2019-06-12 19:18:48 +10:00
2019-06-15 10:56:27 +10:00
test.serial('[Success] Check for sitemap.xml', async t => {
2019-06-12 19:18:48 +10:00
const res = await request
.get('/sitemap.xml')
.expect(200);
if(!res.text){
t.fail();
}
// Document should start with XML tag
t.deepEqual(res.text.substring(0, 5), '<?xml');
});
2019-06-15 10:56:27 +10:00
test.serial('[Success] Create a customer', async t => {
2019-06-12 19:18:48 +10:00
const customer = {
email: 'sarah.jones@test.com',
firstName: 'Sarah',
lastName: 'Jones',
address1: '1 Sydney Street',
address2: '',
country: 'Australia',
state: 'NSW',
postcode: '2000',
phone: '0400000000',
password: 'password'
};
const res = await request
.post('/customer/create')
.send(customer)
.expect(200);
t.deepEqual(res.body.message, 'Successfully logged in');
});
2019-06-15 11:53:14 +10:00
test.serial('[Success] Get orders', async t => {
const res = await request
.get('/admin/orders')
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned order length
2019-06-15 11:57:12 +10:00
t.deepEqual(jsonData.orders.length, res.body.orders.length);
2019-06-15 11:53:14 +10:00
});
test.serial('[Fail] Try get orders with a bogus apiKey', async t => {
2019-06-15 11:53:14 +10:00
const res = await request
.get('/admin/orders')
.set('apiKey', '123456789012345678901234')
.expect(400);
t.deepEqual(res.body.message, 'Access denied');
});
test.serial('[Success] Get orders by <Paid> status', async t => {
const res = await request
.get('/admin/orders/bystatus/Paid')
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned order length
t.deepEqual(1, res.body.orders.length);
});
2019-07-12 17:59:51 +10:00
test.serial.skip('[Success] Filter orders', async t => {
2019-06-15 21:30:04 +10:00
const res = await request
2019-07-12 17:34:12 +10:00
.get('/admin/orders/filter/test@test.com')
2019-06-15 21:30:04 +10:00
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned order length
t.deepEqual(2, res.body.orders.length);
});
2019-06-15 10:56:27 +10:00
test.serial('[Fail] Try create a duplicate customer', async t => {
2019-06-12 19:18:48 +10:00
const customer = {
email: 'sarah.jones@test.com',
firstName: 'Sarah',
lastName: 'Jones',
address1: '1 Sydney Street',
address2: '',
country: 'Australia',
state: 'NSW',
postcode: '2000',
phone: '0400000000',
password: 'password'
};
const res = await request
.post('/customer/create')
.send(customer)
.expect(400);
t.deepEqual(res.body.err, 'A customer already exists with that email address');
});
test.serial('[Success] Get customer list', async t => {
const res = await request
.get('/admin/customers')
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned customers length
t.deepEqual(2, res.body.length);
});
test.serial('[Success] Filter customers', async t => {
const res = await request
.get('/admin/customers')
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned customers length
t.deepEqual(2, res.body.length);
});
test.serial('[Success] Get single customer', async t => {
const res = await request
.get('/admin/customer/view/' + customers[0]._id)
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned customer matches ID
t.deepEqual(customers[0]._id.toString(), res.body._id);
});
2019-06-20 13:14:04 +10:00
test.serial('[Success] Add a product', async t => {
const product = {
productPermalink: 'test-jacket',
productTitle: 'Test Jacket',
productPrice: 100,
productDescription: 'Test desc',
productPublished: true,
productTags: 'organic, jacket',
productOptions: {
Size: {
optName: 'Size',
optLabel: 'Select size',
optType: 'select',
optOptions: ['S', 'M', 'L', 'XL']
}
},
productComment: 'test comment',
productStock: 50
};
const res = await request
.post('/admin/product/insert')
.send(product)
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned message
t.deepEqual(res.body.message, 'New product successfully created');
});
test.serial('[Success] Update a product', async t => {
const product = {
productId: products[0]._id,
productTitle: 'Test Jacket',
productPrice: 200,
productDescription: 'Test desc',
productPublished: true,
productTags: 'organic, jacket',
productOptions: {
Size: {
optName: 'Size',
optLabel: 'Select size',
optType: 'select',
optOptions: ['S', 'M', 'L', 'XL']
}
},
productComment: 'test comment',
productStock: 50
};
const res = await request
.post('/admin/product/update')
.send(product)
.set('apiKey', users[0].apiKey)
.expect(200);
// Check the returned message
t.deepEqual(res.body.message, 'Successfully saved');
t.deepEqual(res.body.product.productTitle, product.productTitle);
t.deepEqual(res.body.product.productPrice, product.productPrice);
});