152 lines
4.8 KiB
TypeScript
152 lines
4.8 KiB
TypeScript
import { before, describe, it } from "node:test";
|
|
import { OrderRepository } from "./OrderRepository.js";
|
|
import { CreateOrderDTO } from "../domain/Order.js";
|
|
import { postgresClient } from "../config/config.test.js";
|
|
import assert from "node:assert";
|
|
|
|
const order1 = <CreateOrderDTO>{
|
|
correlation_id: "fakeRMQid-1234",
|
|
exchange: "fake.ex",
|
|
routing_key: "test.order.idk",
|
|
order_type: "activate",
|
|
payload: { iccid: "1234", action: "activate" }
|
|
}
|
|
|
|
|
|
describe("Test OrderRepository", {}, () => {
|
|
const orderRepo = new OrderRepository(postgresClient)
|
|
let testId: number | undefined = undefined;
|
|
|
|
before(async () => {
|
|
const result = await orderRepo.createOrder(order1)
|
|
testId = result.data.id
|
|
})
|
|
|
|
it("Insert new Order", async () => {
|
|
const newOrder = order1
|
|
const result = await orderRepo.createOrder(newOrder)
|
|
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
|
|
const order = result.data!
|
|
|
|
assert(order.id != undefined)
|
|
assert(order.correlation_id == newOrder.correlation_id)
|
|
assert(order.status == 'pending')
|
|
|
|
console.log("[T] Creada Order", typeof (result.data.start_date))
|
|
})
|
|
|
|
it("Find by valid id should return the order", async () => {
|
|
const result = await orderRepo.getOrderById({ id: testId! })
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
|
|
const order = result.data
|
|
assert(order.id == testId)
|
|
})
|
|
|
|
it("Find by correlation id should return a valid order", async () => {
|
|
const result = await orderRepo.getOrderByQueueId({ correlation_id: order1.correlation_id })
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
|
|
const order = result.data
|
|
assert(order.correlation_id == order1.correlation_id)
|
|
})
|
|
|
|
it("Get pending orders should return all pending orders in ASC order", async () => {
|
|
// We already have 'testId' from before block
|
|
|
|
// Insert two more orders
|
|
const orderA = { ...order1, correlation_id: "pending-A" }
|
|
const orderB = { ...order1, correlation_id: "pending-B" }
|
|
|
|
const resA = await orderRepo.createOrder(orderA)
|
|
const resB = await orderRepo.createOrder(orderB)
|
|
|
|
const idA = resA.data.id
|
|
const idB = resB.data.id
|
|
|
|
const result = await orderRepo.getPendingOrders()
|
|
|
|
assert(result.error == undefined)
|
|
assert(Array.isArray(result.data))
|
|
|
|
// The list should contain at least our 3 orders (testId, idA, idB)
|
|
const ids = result.data.map(o => o.id)
|
|
assert(ids.includes(testId!))
|
|
assert(ids.includes(idA))
|
|
assert(ids.includes(idB))
|
|
|
|
// Verify ordering (ASC by start_date, which maps to ID order in this sequential test)
|
|
const indexTest = result.data.findIndex(o => o.id === testId)
|
|
const indexA = result.data.findIndex(o => o.id === idA)
|
|
const indexB = result.data.findIndex(o => o.id === idB)
|
|
|
|
assert(indexTest < indexA)
|
|
assert(indexA < indexB)
|
|
})
|
|
|
|
it("Update order status should change status and add history", async () => {
|
|
const newStatus = "running"
|
|
const reason = "Test update"
|
|
const result = await orderRepo.updateOrder({ id: testId!, new_status: newStatus, reason: reason })
|
|
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
assert(result.data.status === newStatus)
|
|
})
|
|
|
|
it("Finish order should set status to finished and set finish_date", async () => {
|
|
const result = await orderRepo.finishOrder({ id: testId!, reason: "Test finish" })
|
|
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
assert(result.data.status === "finished")
|
|
assert(result.data.finish_date != null)
|
|
})
|
|
|
|
it("Error order (failed) should increment retry_count and set status", async () => {
|
|
// Create another order for this test
|
|
const order2 = { ...order1, correlation_id: "fake-error-test" }
|
|
const createResult = await orderRepo.createOrder(order2)
|
|
const errTestId = createResult.data.id
|
|
|
|
const result = await orderRepo.errorOrder({
|
|
id: errTestId,
|
|
status: "failed",
|
|
reason: "Test failure",
|
|
error: "Some error",
|
|
stackTrace: "Some stack"
|
|
})
|
|
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
assert(result.data.status === "failed")
|
|
assert(result.data.retry_count > 0)
|
|
assert(result.data.finish_date == null)
|
|
})
|
|
|
|
it("Error order (dlx) should set finish_date", async () => {
|
|
// Create another order for this test
|
|
const order3 = { ...order1, correlation_id: "fake-dlx-test" }
|
|
const createResult = await orderRepo.createOrder(order3)
|
|
const dlxTestId = createResult.data.id
|
|
|
|
const result = await orderRepo.errorOrder({
|
|
id: dlxTestId,
|
|
status: "dlx",
|
|
reason: "Test DLX",
|
|
error: "Fatal error",
|
|
stackTrace: "Fatal stack"
|
|
})
|
|
|
|
assert(result.error == undefined)
|
|
assert(result.data != undefined)
|
|
assert(result.data.status === "dlx")
|
|
assert(result.data.finish_date != null)
|
|
})
|
|
})
|