sf-sim/packages/sim-shared/infrastructure/OrderRepository.test.ts

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" }
}

const order2 = <CreateOrderDTO>{
  correlation_id: "fakeRMQid-5678",
  exchange: "fake.ex",
  routing_key: "test.order.idk",
  order_type: "activate",
  payload: { iccid: "5678", action: "activate" }
}


describe("Test OrderRepository", {}, (ctx) => {
  const orderRepo = new OrderRepository(postgresClient)
  let testIds: number[] = []
  before(async () => {
    // Order1
    const result1 = await orderRepo.createOrder(order1)
    assert.ok(result1.data != undefined, result1.error as string)
    testIds.push(result1.data.id)

    // Order2 -> Para el test de crearOrder
    // const result2 = await orderRepo.createOrder(order2)
    // assert(result2.data != undefined)
    // testIds.push(result2.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: testIds[0]! })
    assert(result.error == undefined)
    assert(result.data != undefined)

    const order = result.data
    assert(order.id == testIds[0])
    assert(order.correlation_id == order1.correlation_id)
  })

  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)

    assert(resA.data != undefined)
    assert(resB.data != undefined)

    const idA = resA.data.id
    const idB = resB.data.id

    const result = await orderRepo.getPendingOrders()

    assert(result.error == undefined)
    assert(Array.isArray(result.data))


    const ids = result.data.map(o => o.id)
    assert(ids.includes(testIds[0]!))
    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 === testIds[0])
    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: testIds[0]!, 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: testIds[0]!, 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)
    assert(createResult.data != undefined)
    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)
    assert(createResult.data != undefined)
    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)
  })
})