pagaris
Version:
Pagaris API client for Node
235 lines (204 loc) • 7.53 kB
JavaScript
const { errors, assert, Order } = require('./helpers')
describe('Order', function() {
it('is accessible', function() {
assert.doesNotThrow(function() {
Order
})
assert(Order instanceof Function)
})
it('can be initialized and has attributes', function () {
context('without passing options when initializing', function () {
let order = new Order
assert(order)
assert.equal(order.constructor.name, 'Order')
assert(!order.amount)
order.amount = 9876
assert.equal(order.amount, 9876)
})
context('passing options when initializing', function () {
let order = new Order({
amount: 9182.33,
metadata: { a: { b: 'c' } },
products: [{ sku: 'a', quantity: 1 }, { sku: 'b', quantity: 2 }],
redirectUrl: 'http://some.redirect/url',
// This should be ignored
id: 'some id'
})
assert(order)
assert.equal(order.constructor.name, 'Order')
assert.equal(order.amount, 9182.33)
assert(order.metadata)
assert.equal(order.metadata.a.b, 'c')
assert(order.products)
assert(!order.id)
})
})
describe('all', function () {
it('returns an array with Orders', async function () {
let orders = await Order.all()
assert(orders)
assert(orders.length)
let order = orders[0]
assert(order)
assert(order.amount)
order = orders.find(o => o.id === 'ef11be32-1f3c-41d8-aac4-5e7a966ddd90')
assert.equal(2000, order.amount)
assert(order.fee)
assert(order.payoutAmount)
assert.equal('confirmed', order.status)
assert(order.metadata)
assert.equal(order.metadata.cart_id, 11)
assert(!order.products)
assert(order.redirectUrl)
let diff = order.createdAt.getTime() -
new Date('2020-04-16T19:18:56-05:00').getTime()
assert(diff < 1000, diff)
diff = order.updatedAt.getTime() -
new Date('2020-04-16T19:49:57-05:00').getTime()
assert(diff < 1000, diff)
assert(order.url)
})
})
describe('get', function() {
it('returns error when id is not found', async function () {
await Order.get('not-an-id').catch(err => {
assert(() => { err instanceof Errors.NotFoundError })
})
})
it('returns an order from a given id', async function () {
let order = await Order.get('ef11be32-1f3c-41d8-aac4-5e7a966ddd90')
assert.equal(2000, order.amount)
assert(order.fee)
assert(order.payoutAmount)
assert.equal('confirmed', order.status)
assert(order.metadata)
assert.equal(order.metadata.cart_id, 11)
assert(!order.products)
assert(order.redirectUrl)
let diff = order.createdAt.getTime() -
new Date('2020-04-16T19:18:56-05:00').getTime()
assert(diff < 1000, diff)
diff = order.updatedAt.getTime() -
new Date('2020-04-16T19:49:57-05:00').getTime()
assert(diff < 1000, diff)
assert(order.url)
})
})
describe('create', function () {
context('with instance method', function () {
it('creates and returns an order', async function () {
let order = new Order({ amount: 9812.48 })
let metadata = {
special_test_case: 'instantly_approved',
a: { b: 'c' }
}
order.metadata = metadata
let products = [
{ name: 'A', quantity: 1, unit_price: 12345.99 }
]
order.products = products
order.redirectUrl = 'https://some.redirect/url/test'
assert(!order.id)
assert(!order.fee)
assert(!order.payoutAmount)
assert(!order.status)
assert(!order.createdAt)
assert(!order.updatedAt)
assert(!order.url)
await order.create()
assert.equal(order.amount, 9812.48)
assert.deepEqual(order.metadata, metadata)
assert.deepEqual(order.products, products)
assert.equal(order.redirectUrl, 'https://some.redirect/url/test')
assert(order.id)
assert(order.fee)
assert.equal(order.fee.constructor.name, 'Number')
assert(order.payoutAmount)
assert.equal(order.payoutAmount.constructor.name, 'Number')
assert.equal(order.status, 'approved')// From metadata special test case
assert(order.createdAt)
assert.equal(order.createdAt.constructor.name, 'Date')
assert(order.updatedAt)
assert.equal(order.updatedAt.constructor.name, 'Date')
assert(order.url)
})
it('also works with chainable then', async function () {
let order = new Order({ amount: 8723.91 })
// Note: we are not using the argument from then(), but existing order
await order.create().then(function() {
assert(order.id)
assert.equal(order.amount, 8723.91)
})
})
})
context('with static method', async function () {
it('returns error if invalid', async function () {
await Order.create({ metadata: { no_amount: 'was_given' } })
.catch(err => {
assert(() => { err instanceof Errors.UnprocessableEntityError })
})
})
it('creates and returns order', async function () {
let order = await Order.create({
amount: 4398.01,
metadata: { special_test_case: 'instantly_rejected' },
redirect_url: 'https://red.url/a'
})
assert.equal(order.amount, 4398.01)
assert.equal(order.status, 'rejected')
})
})
})
describe('confirm', function () {
context('not confirmable order', function () {
it('returns unauthorized error', async function () {
let order = await Order.get('77490733-a293-4cd5-bf2c-8438df772399')
assert.equal(order.status, 'cancelled')
await order.confirm().catch(err => {
assert(() => { err instanceof Errors.UnauthorizedError })
})
})
})
context('confirmable order', function () {
it('confirms and returns order', async function () {
let order = await Order.create({
amount: 4433.22,
metadata: {
special_test_case: 'instantly_approved'
}
}).catch(assert.fail)
assert.equal(order.status, 'approved')
await order.confirm().catch(assert.fail)
assert.equal(order.status, 'confirmed')
let reloadedOrder = await Order.get(order.id).catch(assert.fail)
assert.equal(reloadedOrder.status, 'confirmed')
})
})
})
describe('cancel', function () {
context('not cancellable order', function () {
it('returns unauthorized error', async function () {
let order = await Order.get('8d4f09de-f13b-431a-aca4-827a9f0eb40d')
assert.equal(order.status, 'confirmed')
await order.cancel().catch(err => {
assert(() => { err instanceof Errors.UnauthorizedError })
})
})
})
context('cancellable order', function () {
it('cancels and returns order', async function () {
let order = await Order.create({
amount: 4433.22,
metadata: {
special_test_case: 'instantly_approved'
}
}).catch(assert.fail)
assert.equal(order.status, 'approved')
await order.cancel().catch(assert.fail)
assert.equal(order.status, 'cancelled')
let reloadedOrder = await Order.get(order.id).catch(assert.fail)
assert.equal(reloadedOrder.status, 'cancelled')
})
})
})
})