budibase/packages/core/test/indexApi.aggregates.spec.js

import {
  setupApphierarchy,
  basicAppHierarchyCreator_WithFields_AndIndexes,
} from "./specHelpers"
import { permission } from "../src/authApi/permissions"

describe("aggregates", () => {
  it("should calculate correct totals, when no condition supplied", async () => {
    const { createInvoice, indexApi } = await setup()
    await createInvoice(10)
    await createInvoice(20)
    await createInvoice(30)
    const result = await indexApi.aggregates("/Outstanding Invoices")

    expect(result.all_invoices_by_type.Important.count).toBe(3)
    expect(result.all_invoices_by_type.Important.totalIncVat.max).toBe(30)
    expect(result.all_invoices_by_type.Important.totalIncVat.min).toBe(10)
    expect(result.all_invoices_by_type.Important.totalIncVat.sum).toBe(60)
    expect(result.all_invoices_by_type.Important.totalIncVat.mean).toBe(60 / 3)
  })

  it("should split totals into correct groups", async () => {
    const { createInvoice, indexApi } = await setup()
    await createInvoice(10, 0, "Important")
    await createInvoice(20, 0, "NotImportant")
    await createInvoice(30, 0, "NotImportant")
    const result = await indexApi.aggregates("/Outstanding Invoices")

    expect(result.all_invoices_by_type.Important.count).toBe(1)
    expect(result.all_invoices_by_type.NotImportant.count).toBe(2)
    expect(result.all_invoices_by_type.Important.totalIncVat.sum).toBe(10)
    expect(result.all_invoices_by_type.NotImportant.totalIncVat.sum).toBe(50)
  })

  it("should include all when all match condition", async () => {
    const { createInvoice, indexApi } = await setup()
    await createInvoice(10, 0, "Important", true)
    await createInvoice(10, 0, "Important", true)
    await createInvoice(10, 0, "Important", true)
    const result = await indexApi.aggregates("/Outstanding Invoices")

    expect(result.written_off.Important.count).toBe(3)
    expect(result.written_off.Important.totalIncVat.sum).toBe(30)
  })

  it("should add to '(none)' when group is blank, null or undefined", async () => {
    const { createInvoice, indexApi } = await setup()
    await createInvoice(10, 0, "", true)
    await createInvoice(10, 0, null, true)
    const result = await indexApi.aggregates("/Outstanding Invoices")

    expect(result.all_invoices_by_type["(none)"].count).toBe(2)
    expect(result.all_invoices_by_type["(none)"].totalIncVat.sum).toBe(20)
  })

  it("should not include those that do not match condition", async () => {
    const { createInvoice, indexApi } = await setup()
    await createInvoice(10, 0, "Important", true)
    await createInvoice(10, 0, "Important", true)
    await createInvoice(10, 0, "Important", false)
    const result = await indexApi.aggregates("/Outstanding Invoices")

    expect(result.written_off.Important.count).toBe(2)
    expect(result.written_off.Important.totalIncVat.sum).toBe(20)
  })

  it("should have 'all' group when no grouping supplied", async () => {
    const { createInvoice, indexApi } = await setup()
    await createInvoice(10, 0, "Important", true)
    await createInvoice(20, 0, "Important", true)
    const result = await indexApi.aggregates("/Outstanding Invoices")

    expect(result.all_invoices.all.count).toBe(2)
  })

  it("should calculate correct totals, sharded index - all records", async () => {
    const { createInvoice, indexApi, invoicesByOutstandingKey } = await setup()
    await createInvoice(10, 0, "Important")
    await createInvoice(20, 20, "Important")
    await createInvoice(30, 30, "Important")
    const result = await indexApi.aggregates(invoicesByOutstandingKey)

    expect(result.all_invoices_by_type.Important.count).toBe(3)
    expect(result.all_invoices_by_type.Important.totalIncVat.max).toBe(30)
    expect(result.all_invoices_by_type.Important.totalIncVat.min).toBe(10)
    expect(result.all_invoices_by_type.Important.totalIncVat.sum).toBe(60)
    expect(result.all_invoices_by_type.Important.totalIncVat.mean).toBe(60 / 3)
  })

  it("should calculate correct totals, sharded index - bounded by sharding", async () => {
    const { createInvoice, indexApi, invoicesByOutstandingKey } = await setup()
    await createInvoice(10, 0, "Important")
    await createInvoice(20, 20, "Important")
    await createInvoice(30, 30, "Important")
    const result = await indexApi.aggregates(
      invoicesByOutstandingKey,
      { totalIncVat: 10, paidAmount: 10 },
      { totalIncVat: 10, paidAmount: 10 }
    )

    expect(result.all_invoices_by_type.Important.count).toBe(2)
    expect(result.all_invoices_by_type.Important.totalIncVat.max).toBe(30)
    expect(result.all_invoices_by_type.Important.totalIncVat.min).toBe(20)
    expect(result.all_invoices_by_type.Important.totalIncVat.sum).toBe(50)
    expect(result.all_invoices_by_type.Important.totalIncVat.mean).toBe(50 / 2)
  })

  it("should throw error when user user does not have permission", async () => {
    const { app, indexApi } = await setup()
    app.removePermission(permission.readIndex.get("/customer_index"))

    let err
    try {
      await indexApi.aggregates("/customer_index")
    } catch (e) {
      err = e
    }

    expect(err).toBeDefined()
    expect(err.message.startsWith("Unauthorized")).toBeTruthy()
    //expect(indexApi.aggregates("/customer_index")).rejects.toThrow(/Unauthorized/);
  })

  it("should not depend on having any other permissions", async () => {
    const { app, indexApi } = await setup()
    app.withOnlyThisPermission(permission.readIndex.get("/customer_index"))
    await indexApi.aggregates("/customer_index")
  })
})

const setup = async () => {
  const { recordApi, app, indexApi } = await setupApphierarchy(
    basicAppHierarchyCreator_WithFields_AndIndexes
  )

  const customer = recordApi.getNew("/customers", "customer")
  await recordApi.save(customer)

  const createInvoice = async (
    totalAmount = 10,
    paidAmount = 0,
    type = "Important",
    writtenOff = false
  ) => {
    const invoice = recordApi.getNew(
      `/customers/${customer.id}/invoices`,
      "invoice"
    )
    invoice.totalIncVat = totalAmount
    invoice.paidAmount = paidAmount
    invoice.invoiceType = type
    invoice.isWrittenOff = writtenOff
    return await recordApi.save(invoice)
  }

  const invoicesByOutstandingKey = `/customers/${customer.id}/invoicesByOutstanding`

  return { createInvoice, indexApi, invoicesByOutstandingKey, app }
}