testing cont use updates

server/tests/contUse/entities/entity1.ts

@@ -0,0 +1,213 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { addPrefixToProducts, runAttachTest } from "../../attach/utils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { expectSubQuantityCorrect } from "../../attach/entities/expectEntity.js";
+import { addWeeks } from "date-fns";
+import { timeout } from "@/utils/genUtils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "entity1";
+
+// Pro is $20 / month, Seat is $50 / user
+
+describe(`${chalk.yellowBright(`attach/entities/${testCase}: Testing create / delete entities`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  let firstEntities = [
+    {
+      id: "1",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create entity, then attach pro", async function () {
+    await autumn.entities.create(customerId, firstEntities);
+    usage += 1;
+
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: 1,
+        },
+      ],
+    });
+  });
+
+  const entities = [
+    {
+      id: "2",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "3",
+      name: "test2",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create 2 entities and have correct invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(new Date(), 2).getTime(),
+      waitForSeconds: 10,
+    });
+
+    await autumn.entities.create(customerId, entities);
+    usage += entities.length;
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      itemQuantity: usage,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+    expect(invoices[0].total).to.equal(userItem.price! * entities.length);
+  });
+
+  it("should delete 1 entity and have no new invoice", async function () {
+    await autumn.entities.delete(customerId, entities[0].id);
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: 1,
+      itemQuantity: usage - 1,
+    });
+  });
+
+  const newEntities = [
+    {
+      id: "4",
+      name: "test3",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "5",
+      name: "test4",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create 2 entities and have correct invoice (only pay for 1)", async function () {
+    await autumn.entities.create(customerId, newEntities);
+    await timeout(3000);
+    usage += 1;
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+
+    expect(invoices.length).to.equal(3);
+    expect(invoices[0].total).to.equal(userItem.price!);
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      itemQuantity: usage,
+    });
+  });
+});

server/tests/contUse/entities/entity3.ts

@@ -0,0 +1,186 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { addPrefixToProducts, runAttachTest } from "../../attach/utils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { expectSubQuantityCorrect } from "../../attach/entities/expectEntity.js";
+import { addHours, addMonths, addWeeks } from "date-fns";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { hoursToFinalizeInvoice } from "tests/utils/constants.js";
+import { getBasePrice } from "tests/utils/testProductUtils/testProductUtils.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "entity3";
+
+describe(`${chalk.yellowBright(`attach/entities/${testCase}: Testing create / delete entities`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  let firstEntities = [
+    {
+      id: "1",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "2",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "3",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create three entities, then attach pro", async function () {
+    await autumn.entities.create(customerId, firstEntities);
+    usage += firstEntities.length;
+
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: usage,
+        },
+      ],
+    });
+  });
+
+  it("should delete 2 entities and have no new invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(new Date(), 2).getTime(),
+      waitForSeconds: 10,
+    });
+
+    await autumn.entities.delete(customerId, firstEntities[0].id);
+    await autumn.entities.delete(customerId, firstEntities[1].id);
+
+    const numReplaceables = 2;
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables,
+      itemQuantity: usage - numReplaceables,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+
+  it("should advance clock to next cycle and have correct invoice", async function () {
+    await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addHours(
+        addMonths(new Date(), 1),
+        hoursToFinalizeInvoice,
+      ).getTime(),
+    });
+
+    usage -= 2; // 2 entities deleted
+
+    const customer = await autumn.customers.get(customerId);
+    const invoices = customer.invoices;
+
+    let basePrice = getBasePrice({ product: pro });
+    expect(invoices.length).to.equal(2);
+    expect(invoices[0].total).to.equal(basePrice); // 0 entities
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      itemQuantity: usage,
+      numReplaceables: 0,
+    });
+  });
+});

server/tests/contUse/entities/entity4.ts

@@ -0,0 +1 @@
+// Handling per entity features!

server/tests/contUse/entities/entity5.ts

@@ -0,0 +1,3 @@
+// test payment failures
+
+// test update product / delete entity mix -- should have correct sub item quantity...

server/tests/contUse/track/track1.ts

@@ -0,0 +1,182 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  entities,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { addWeeks } from "date-fns";
+import { timeout } from "@/utils/genUtils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addPrefixToProducts } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "track1";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing track usage for cont use`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  it("should attach pro", async function () {
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  it("should create track +3 usage and have correct invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(new Date(), 2).getTime(),
+      waitForSeconds: 5,
+    });
+
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: 3,
+    });
+
+    await timeout(15000);
+
+    usage += 3;
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+    expect(invoices[0].total).to.equal(userItem.price! * 2);
+  });
+
+  it("should track -3 and have no new invoice", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: -3,
+    });
+
+    await timeout(5000);
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: 3,
+    });
+  });
+
+  it("should track +3 and have no new invoice", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: 3,
+    });
+
+    await timeout(5000);
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+  });
+});

server/tests/contUse/track/track2.ts

@@ -0,0 +1,143 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  entities,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { addWeeks } from "date-fns";
+import { timeout } from "@/utils/genUtils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addPrefixToProducts } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "track2";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing track usage for cont use (without overage)`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  it("should attach pro", async function () {
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  it("should track +1 and have no new invoice", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: 1,
+    });
+
+    usage += 1;
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+
+  it("should track -1 and have no new invoice", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: -1,
+    });
+
+    usage -= 1;
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+  });
+});

server/tests/contUse/track/track3.ts

@@ -0,0 +1,218 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { addWeeks } from "date-fns";
+import { timeout } from "@/utils/genUtils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addPrefixToProducts } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+import { expectUpcomingItemsCorrect } from "tests/utils/expectUtils/expectContUseUtils.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.ProrateNextCycle,
+    on_decrease: OnDecrease.ProrateNextCycle,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "track3";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing track usage for cont use, prorate next cycle`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  it("should attach pro", async function () {
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  it("should create track +3 usage and have correct invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(new Date(), 2).getTime(),
+      waitForSeconds: 5,
+    });
+
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: 3,
+    });
+
+    await timeout(15000);
+
+    usage += 3;
+
+    let { stripeSubs, cusProduct, fullCus } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    await expectUpcomingItemsCorrect({
+      stripeCli,
+      fullCus,
+      stripeSubs,
+      curUnix,
+      expectedNumItems: 1,
+      unitPrice: userItem.price!,
+      quantity: 2,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+
+  it("should track -1 and have no new invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(curUnix, 1).getTime(),
+      waitForSeconds: 5,
+    });
+
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: -1,
+    });
+
+    usage -= 1;
+
+    let { stripeSubs, cusProduct, fullCus } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    await expectUpcomingItemsCorrect({
+      stripeCli,
+      fullCus,
+      stripeSubs,
+      unitPrice: userItem.price!,
+      curUnix,
+      expectedNumItems: 2,
+      quantity: -1,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+
+  it("should track -1 and have no new invoice", async function () {
+    let quantity = 2;
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: quantity,
+    });
+
+    usage += quantity;
+
+    let { stripeSubs, cusProduct, fullCus } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    await expectUpcomingItemsCorrect({
+      stripeCli,
+      fullCus,
+      stripeSubs,
+      unitPrice: userItem.price!,
+      curUnix,
+      expectedNumItems: 3,
+      quantity,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+});

server/tests/contUse/track/track4.ts

@@ -0,0 +1,220 @@
+import chalk from "chalk";
+import Stripe from "stripe";
+
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { addWeeks } from "date-fns";
+import { timeout } from "@/utils/genUtils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addPrefixToProducts } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+import { expectUpcomingItemsCorrect } from "tests/utils/expectUtils/expectContUseUtils.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.ProrateNextCycle,
+    on_decrease: OnDecrease.ProrateNextCycle,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "track4";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing set usage for cont use, prorate next cycle`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  it("should attach pro", async function () {
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  it("should create set usage to 3 and have correct invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(curUnix, 2).getTime(),
+      waitForSeconds: 5,
+    });
+
+    await autumn.usage({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: 3,
+    });
+
+    await timeout(15000);
+
+    usage += 3;
+
+    let { stripeSubs, cusProduct, fullCus } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    await expectUpcomingItemsCorrect({
+      stripeCli,
+      fullCus,
+      stripeSubs,
+      curUnix,
+      expectedNumItems: 1,
+      unitPrice: userItem.price!,
+      quantity: 2,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+
+  it("should set usage to 2 and have no new invoice", async function () {
+    let newUsage = 2;
+
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(curUnix, 1).getTime(),
+      waitForSeconds: 5,
+    });
+
+    await autumn.usage({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: newUsage,
+    });
+
+    let { stripeSubs, cusProduct, fullCus } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage: newUsage,
+    });
+
+    await expectUpcomingItemsCorrect({
+      stripeCli,
+      fullCus,
+      stripeSubs,
+      unitPrice: userItem.price!,
+      curUnix,
+      expectedNumItems: 2,
+      quantity: -1,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+
+  it("should set usage to 4 and have no new invoice", async function () {
+    let newUsage = 4;
+    await autumn.usage({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: newUsage,
+    });
+
+    usage = newUsage;
+
+    let { stripeSubs, cusProduct, fullCus } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+    });
+
+    await expectUpcomingItemsCorrect({
+      stripeCli,
+      fullCus,
+      stripeSubs,
+      unitPrice: userItem.price!,
+      curUnix,
+      expectedNumItems: 3,
+      quantity: 2,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(1);
+  });
+});

server/tests/contUse/update/updateContUse1.ts

@@ -0,0 +1,207 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { addWeeks } from "date-fns";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addPrefixToProducts, replaceItems } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "updateContUse1";
+
+describe(`${chalk.yellowBright(`attach/entities/${testCase}: Testing update contUse, add included usage`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  let firstEntities = [
+    {
+      id: "1",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "2",
+      name: "test2",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "3",
+      name: "test3",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create entity, then attach pro", async function () {
+    await autumn.entities.create(customerId, firstEntities);
+    usage += 3;
+
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: usage,
+        },
+      ],
+    });
+  });
+
+  let extraUsage = 2;
+  let newItem = constructArrearProratedItem({
+    featureId: TestFeature.Users,
+    pricePerUnit: 50,
+    includedUsage: (userItem.included_usage as number) + extraUsage,
+    config: {
+      on_increase: OnIncrease.BillImmediately,
+      on_decrease: OnDecrease.None,
+    },
+  });
+
+  it("should update product with extra included usage", async function () {
+    let customItems = replaceItems({
+      featureId: TestFeature.Users,
+      items: pro.items,
+      newItem,
+    });
+
+    usage += extraUsage;
+
+    await autumn.attach({
+      customer_id: customerId,
+      product_id: pro.id,
+      is_custom: true,
+      items: customItems,
+    });
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: extraUsage,
+    });
+
+    // Will have 1 invoice because price is replaced...
+  });
+
+  const entities = [
+    {
+      id: "4",
+      name: "test4",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "5",
+      name: "test5",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create 2 entities and have no invoice", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(new Date(), 2).getTime(),
+      waitForSeconds: 10,
+    });
+
+    await autumn.entities.create(customerId, entities);
+
+    // Usage won't change since using replaceables...
+    // usage += entities.length;
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: 0,
+    });
+
+    let customer = await autumn.customers.get(customerId);
+    let invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+  });
+});

server/tests/contUse/update/updateContUse2.ts

@@ -0,0 +1,182 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { expect } from "chai";
+import { addWeeks } from "date-fns";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addPrefixToProducts, replaceItems } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "updateContUse2";
+
+describe(`${chalk.yellowBright(`contUse/update/${testCase}: Testing update cont use, remove included usage`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  let usage = 0;
+  let firstEntities = [
+    {
+      id: "1",
+      name: "test",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "2",
+      name: "test2",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "3",
+      name: "test3",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  it("should create entity, then attach pro", async function () {
+    await autumn.entities.create(customerId, firstEntities);
+    usage += 3;
+
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: usage,
+        },
+      ],
+    });
+  });
+
+  let reduceUsageBy = 1;
+  let newItem = constructArrearProratedItem({
+    featureId: TestFeature.Users,
+    pricePerUnit: 50,
+    includedUsage: (userItem.included_usage as number) - reduceUsageBy,
+    config: {
+      on_increase: OnIncrease.BillImmediately,
+      on_decrease: OnDecrease.None,
+    },
+  });
+
+  it("should update product with reduced included usage", async function () {
+    await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(new Date(), 1).getTime(),
+      waitForSeconds: 5,
+    });
+
+    const customItems = replaceItems({
+      featureId: TestFeature.Users,
+      items: pro.items,
+      newItem,
+    });
+
+    const preview = await autumn.attachPreview({
+      customer_id: customerId,
+      product_id: pro.id,
+      is_custom: true,
+      items: customItems,
+    });
+
+    await autumn.attach({
+      customer_id: customerId,
+      product_id: pro.id,
+      is_custom: true,
+      items: customItems,
+    });
+
+    const customer = await autumn.customers.get(customerId);
+    const invoices = customer.invoices;
+    expect(invoices.length).to.equal(2);
+    expect(invoices[0].total).to.equal(preview.due_today.total);
+
+    // Usage stays the same...
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: 0,
+    });
+  });
+  return;
+});

server/tests/contUse/update/updateContUse3.ts

@@ -0,0 +1,138 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { addPrefixToProducts, replaceItems } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+import { attachNewContUseAndExpectCorrect } from "tests/utils/expectUtils/expectContUse/expectUpdateContUse.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "updateContUse3";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing update contUse included usage when no entities created`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  it("should attach pro", async function () {
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  let extraUsage = 2;
+  let newItem = constructArrearProratedItem({
+    featureId: TestFeature.Users,
+    pricePerUnit: 50,
+    includedUsage: (userItem.included_usage as number) + extraUsage,
+    config: {
+      on_increase: OnIncrease.BillImmediately,
+      on_decrease: OnDecrease.None,
+    },
+  });
+
+  it("should update product with extra included usage", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Users,
+      value: 1,
+    });
+
+    let customItems = replaceItems({
+      featureId: TestFeature.Users,
+      items: pro.items,
+      newItem,
+    });
+
+    await attachNewContUseAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      customItems,
+      numInvoices: 2,
+    });
+
+    await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage: 1,
+      numReplaceables: 0,
+    });
+  });
+});

server/tests/contUse/update/updateContUse4.ts

@@ -0,0 +1,246 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { addPrefixToProducts, replaceItems } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { expectSubQuantityCorrect } from "tests/attach/entities/expectEntity.js";
+import { attachNewContUseAndExpectCorrect } from "tests/utils/expectUtils/expectContUse/expectUpdateContUse.js";
+import { expect } from "chai";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addWeeks } from "date-fns";
+import { calculateProrationAmount } from "@/internal/invoices/prorationUtils.js";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.ProrateImmediately,
+    on_decrease: OnDecrease.ProrateImmediately,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+
+const testCase = "updateContUse4";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing update contUse included usage, prorate now`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  const firstEntities = [
+    {
+      id: "1",
+      name: "entity1",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "2",
+      name: "entity2",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  let usage = 0;
+  it("should attach pro", async function () {
+    await autumn.entities.create(customerId, firstEntities);
+    usage += firstEntities.length;
+
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: usage,
+        },
+      ],
+    });
+  });
+
+  let extraUsage = 2;
+  let newItem = constructArrearProratedItem({
+    featureId: TestFeature.Users,
+    pricePerUnit: 50,
+    includedUsage: (userItem.included_usage as number) + extraUsage,
+    config: {
+      on_increase: OnIncrease.ProrateImmediately,
+      on_decrease: OnDecrease.ProrateImmediately,
+    },
+  });
+
+  it("should update product with extra included usage", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(curUnix, 2).getTime(),
+      waitForSeconds: 5,
+    });
+
+    let customItems = replaceItems({
+      featureId: TestFeature.Users,
+      items: pro.items,
+      newItem,
+    });
+
+    const { invoices } = await attachNewContUseAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      customItems,
+      numInvoices: 2,
+    });
+
+    const { stripeSubs } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: 0,
+    });
+
+    // Do own calculation too..
+    let sub = stripeSubs[0];
+    let amount = -userItem.price!;
+    let proratedAmount = calculateProrationAmount({
+      amount,
+      periodStart: sub.current_period_start * 1000,
+      periodEnd: sub.current_period_end * 1000,
+      now: curUnix,
+      allowNegative: true,
+    });
+    proratedAmount = Number(proratedAmount.toFixed(2));
+
+    expect(invoices[0].total).to.equal(
+      proratedAmount,
+      "invoice is equal to calculated prorated amount",
+    );
+  });
+
+  const reducedUsage = 3;
+  const newItem2 = constructArrearProratedItem({
+    featureId: TestFeature.Users,
+    pricePerUnit: 50,
+    includedUsage: (newItem.included_usage as number) - reducedUsage,
+    config: {
+      on_increase: OnIncrease.ProrateImmediately,
+      on_decrease: OnDecrease.ProrateImmediately,
+    },
+  });
+
+  it("should update product with reduced included usage", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(curUnix, 1).getTime(),
+      waitForSeconds: 5,
+    });
+
+    let customItems = replaceItems({
+      featureId: TestFeature.Users,
+      items: pro.items,
+      newItem: newItem2,
+    });
+
+    const { invoices } = await attachNewContUseAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      customItems,
+      numInvoices: 3,
+    });
+
+    const { stripeSubs } = await expectSubQuantityCorrect({
+      stripeCli,
+      productId: pro.id,
+      db,
+      org,
+      env,
+      customerId,
+      usage,
+      numReplaceables: 0,
+    });
+
+    // Do own calculation too..
+    let sub = stripeSubs[0];
+    let amount = Math.min(reducedUsage, usage) * userItem.price!;
+
+    let proratedAmount = calculateProrationAmount({
+      amount,
+      periodStart: sub.current_period_start * 1000,
+      periodEnd: sub.current_period_end * 1000,
+      now: curUnix,
+      allowNegative: true,
+    });
+    proratedAmount = Number(proratedAmount.toFixed(2));
+
+    expect(invoices[0].total).to.equal(
+      proratedAmount,
+      "invoice is equal to calculated prorated amount",
+    );
+  });
+});

server/tests/contUse/update/updateContUse5.ts

@@ -0,0 +1,162 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  OnDecrease,
+  OnIncrease,
+  Organization,
+} from "@autumn/shared";
+import chalk from "chalk";
+import Stripe from "stripe";
+import { DrizzleCli } from "@/db/initDrizzle.js";
+import { setupBefore } from "tests/before.js";
+import { createProducts } from "tests/utils/productUtils.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+import { constructArrearProratedItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { addPrefixToProducts } from "tests/attach/utils.js";
+import { attachAndExpectCorrect } from "tests/utils/expectUtils/expectAttach.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addWeeks } from "date-fns";
+
+let userItem = constructArrearProratedItem({
+  featureId: TestFeature.Users,
+  pricePerUnit: 50,
+  includedUsage: 1,
+  config: {
+    on_increase: OnIncrease.BillImmediately,
+    on_decrease: OnDecrease.None,
+  },
+});
+
+export let pro = constructProduct({
+  items: [userItem],
+  type: "pro",
+});
+export let proAnnual = constructProduct({
+  items: [
+    constructArrearProratedItem({
+      featureId: TestFeature.Users,
+      pricePerUnit: 50,
+      includedUsage: 2,
+      config: {
+        on_increase: OnIncrease.BillImmediately,
+        on_decrease: OnDecrease.None,
+      },
+    }),
+  ],
+  type: "pro",
+  isAnnual: true,
+});
+
+const testCase = "updateContUse5";
+
+describe(`${chalk.yellowBright(`contUse/${testCase}: Testing update contUse included usage, prorate now`)}`, () => {
+  let customerId = testCase;
+  let autumn: AutumnInt = new AutumnInt({ version: APIVersion.v1_4 });
+  let testClockId: string;
+  let db: DrizzleCli, org: Organization, env: AppEnv;
+  let stripeCli: Stripe;
+  let curUnix = new Date().getTime();
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    addPrefixToProducts({
+      products: [pro, proAnnual],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro, proAnnual],
+      customerId,
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  const firstEntities = [
+    {
+      id: "1",
+      name: "entity1",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "2",
+      name: "entity2",
+      featureId: TestFeature.Users,
+    },
+    {
+      id: "3",
+      name: "entity3",
+      featureId: TestFeature.Users,
+    },
+  ];
+
+  let usage = 0;
+  it("should attach pro", async function () {
+    await autumn.entities.create(customerId, firstEntities);
+    usage += firstEntities.length;
+
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: usage,
+        },
+      ],
+    });
+  });
+
+  it("should upgrade to pro annual", async function () {
+    curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addWeeks(curUnix, 2).getTime(),
+      waitForSeconds: 5,
+    });
+
+    await attachAndExpectCorrect({
+      autumn,
+      customerId,
+      product: proAnnual,
+      stripeCli,
+      db,
+      org,
+      env,
+      usage: [
+        {
+          featureId: TestFeature.Users,
+          value: usage,
+        },
+      ],
+    });
+  });
+});