adding tests

server/tests/advanced/customInterval/customInteral2.ts

@@ -0,0 +1,120 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import { APIVersion, AppEnv, 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 { constructArrearItem } from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { constructRawProduct } from "@/utils/scriptUtils/createTestProducts.js";
+
+import { addPrefixToProducts, runAttachTest } from "tests/attach/utils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addHours, addMonths } from "date-fns";
+import { expect } from "chai";
+import { hoursToFinalizeInvoice } from "tests/utils/constants.js";
+import { getBasePrice } from "tests/utils/testProductUtils/testProductUtils.js";
+import { getExpectedInvoiceTotal } from "tests/utils/expectUtils/expectInvoiceUtils.js";
+
+const testCase = "customInterval2";
+
+export let pro = constructRawProduct({
+  id: "pro",
+  items: [
+    constructArrearItem({
+      includedUsage: 0,
+      featureId: TestFeature.Words,
+      intervalCount: 2,
+    }),
+  ],
+});
+
+describe(`${chalk.yellowBright(`${testCase}: Testing custom interval on arrear prorated price`)}`, () => {
+  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;
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    addPrefixToProducts({
+      products: [pro],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro],
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  it("should attach pro product", async function () {
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  let usage = 100012;
+  it("should upgrade to premium product and have correct invoice next cycle", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Words,
+      value: usage,
+    });
+
+    const curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addHours(
+        addMonths(new Date(), 2),
+        hoursToFinalizeInvoice
+      ).getTime(),
+      waitForSeconds: 30,
+    });
+
+    const invoiceAmount = await getExpectedInvoiceTotal({
+      customerId,
+      productId: pro.id,
+      usage: [{ featureId: TestFeature.Words, value: usage }],
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+
+    const customer = await autumn.customers.get(customerId);
+    expect(customer.invoices.length).to.equal(2);
+    expect(invoiceAmount).to.equal(customer.invoices[0].total);
+  });
+});

server/tests/advanced/customInterval/customInterval1 copy.ts

@@ -0,0 +1,164 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import { APIVersion, AppEnv, 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 "tests/attach/utils.js";
+import {
+  constructArrearItem,
+  constructArrearProratedItem,
+} from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+
+import { expectAutumnError } from "tests/utils/expectUtils/expectErrUtils.js";
+import { attachFailedPaymentMethod } from "@/external/stripe/stripeCusUtils.js";
+import { CusService } from "@/internal/customers/CusService.js";
+import { timeout } from "@/utils/genUtils.js";
+import { expectProductAttached } from "tests/utils/expectUtils/expectProductAttached.js";
+import { expectSubItemsCorrect } from "tests/utils/expectUtils/expectSubUtils.js";
+import { expectFeaturesCorrect } from "tests/utils/expectUtils/expectFeaturesCorrect.js";
+
+const testCase = "upgrade6";
+
+export let pro = constructProduct({
+  items: [
+    constructArrearItem({ featureId: TestFeature.Words }),
+    constructArrearProratedItem({
+      featureId: TestFeature.Users,
+      pricePerUnit: 20,
+    }),
+  ],
+  type: "pro",
+});
+
+export let premium = constructProduct({
+  items: [
+    constructArrearItem({ featureId: TestFeature.Words }),
+    constructArrearProratedItem({
+      featureId: TestFeature.Users,
+      pricePerUnit: 30,
+    }),
+  ],
+  type: "premium",
+});
+
+describe(`${chalk.yellowBright(`${testCase}: Testing failed upgrades`)}`, () => {
+  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;
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    addPrefixToProducts({
+      products: [pro, premium],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro, premium],
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  it("should attach pro product", async function () {
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  let usage = 100012;
+  it("should upgrade to premium product and fail", async function () {
+    await autumn.track({
+      customer_id: customerId,
+      feature_id: TestFeature.Words,
+      value: usage,
+    });
+    await timeout(4000);
+
+    let cus = await CusService.get({
+      db,
+      orgId: org.id,
+      idOrInternalId: customerId,
+      env,
+    });
+
+    await attachFailedPaymentMethod({ stripeCli, customer: cus! });
+    await timeout(2000);
+
+    await expectAutumnError({
+      func: async () => {
+        await runAttachTest({
+          autumn,
+          customerId,
+          product: premium,
+          stripeCli,
+          db,
+          org,
+          env,
+        });
+      },
+      errMessage: "Failed to update subscription. Your card was declined.",
+    });
+
+    await timeout(4000);
+    let customer = await autumn.customers.get(customerId);
+
+    expectProductAttached({
+      customer,
+      product: pro,
+    });
+
+    expectFeaturesCorrect({
+      customer,
+      product: pro,
+      usage: [
+        {
+          featureId: TestFeature.Words,
+          value: usage,
+        },
+      ],
+    });
+
+    await expectSubItemsCorrect({
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+});

server/tests/advanced/customInterval/customInterval1.ts

@@ -0,0 +1,157 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import { APIVersion, AppEnv, 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 {
+  constructArrearItem,
+  constructArrearProratedItem,
+  constructFeatureItem,
+} from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import { constructProduct } from "@/utils/scriptUtils/createTestProducts.js";
+
+import { expectAutumnError } from "tests/utils/expectUtils/expectErrUtils.js";
+import { attachFailedPaymentMethod } from "@/external/stripe/stripeCusUtils.js";
+import { CusService } from "@/internal/customers/CusService.js";
+import { timeout } from "@/utils/genUtils.js";
+import { expectProductAttached } from "tests/utils/expectUtils/expectProductAttached.js";
+import { expectSubItemsCorrect } from "tests/utils/expectUtils/expectSubUtils.js";
+import { expectFeaturesCorrect } from "tests/utils/expectUtils/expectFeaturesCorrect.js";
+import { addPrefixToProducts, runAttachTest } from "tests/attach/utils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addHours, addMonths } from "date-fns";
+import { expect } from "chai";
+import { hoursToFinalizeInvoice } from "tests/utils/constants.js";
+import { getBasePrice } from "tests/utils/testProductUtils/testProductUtils.js";
+
+const testCase = "customInterval1";
+
+export let pro = constructProduct({
+  items: [
+    constructFeatureItem({
+      featureId: TestFeature.Words,
+      intervalCount: 200,
+    }),
+    // constructArrearItem({ featureId: TestFeature.Words }),
+    // constructArrearProratedItem({
+    //   featureId: TestFeature.Users,
+    //   pricePerUnit: 20,
+    // }),
+  ],
+  intervalCount: 2,
+  type: "pro",
+});
+
+export let premium = constructProduct({
+  items: [
+    constructFeatureItem({
+      featureId: TestFeature.Words,
+      intervalCount: 500,
+    }),
+    // constructArrearItem({ featureId: TestFeature.Words }),
+    // constructArrearProratedItem({
+    //   featureId: TestFeature.Users,
+    //   pricePerUnit: 30,
+    // }),
+  ],
+  intervalCount: 2,
+  type: "premium",
+});
+
+describe(`${chalk.yellowBright(`${testCase}: Testing failed upgrades`)}`, () => {
+  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;
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    addPrefixToProducts({
+      products: [pro, premium],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro, premium],
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  it("should attach pro product", async function () {
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  let usage = 100012;
+  it("should upgrade to premium product and have correct invoice next cycle", async function () {
+    const curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addMonths(new Date(), 1).getTime(),
+      waitForSeconds: 15,
+    });
+
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: premium,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+
+    const customer = await autumn.customers.get(customerId);
+    expect(customer.invoices.length).to.equal(2);
+
+    const nextUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addHours(
+        addMonths(new Date(curUnix), 1),
+        hoursToFinalizeInvoice
+      ).getTime(),
+      waitForSeconds: 30,
+    });
+
+    const customer2 = await autumn.customers.get(customerId);
+    const invoices = customer2.invoices;
+    expect(invoices.length).to.equal(3);
+    expect(invoices[0].product_ids).to.include(premium.id);
+    expect(invoices[0].total).to.equal(getBasePrice({ product: premium }));
+  });
+});

server/tests/advanced/customInterval/customInterval3.ts

@@ -0,0 +1,173 @@
+import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { initCustomer } from "@/utils/scriptUtils/initCustomer.js";
+import {
+  APIVersion,
+  AppEnv,
+  BillingInterval,
+  LimitedItem,
+  Organization,
+  Product,
+} 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 {
+  constructArrearItem,
+  constructFeatureItem,
+  constructPrepaidItem,
+} from "@/utils/scriptUtils/constructItem.js";
+import { TestFeature } from "tests/setup/v2Features.js";
+import {
+  constructProduct,
+  constructRawProduct,
+} from "@/utils/scriptUtils/createTestProducts.js";
+
+import { addPrefixToProducts, runAttachTest } from "tests/attach/utils.js";
+import { advanceTestClock } from "tests/utils/stripeUtils.js";
+import { addDays, addHours, addMonths } from "date-fns";
+import { expect } from "chai";
+import { hoursToFinalizeInvoice } from "tests/utils/constants.js";
+import { getBasePrice } from "tests/utils/testProductUtils/testProductUtils.js";
+import { getExpectedInvoiceTotal } from "tests/utils/expectUtils/expectInvoiceUtils.js";
+import { expectProductAttached } from "tests/utils/expectUtils/expectProductAttached.js";
+import { calculateProrationAmount } from "@/internal/invoices/prorationUtils.js";
+import { getProration } from "@/internal/invoices/previewItemUtils/getItemsForNewProduct.js";
+
+const testCase = "customInterval3";
+
+export let pro = constructProduct({
+  type: "pro",
+  items: [
+    constructFeatureItem({
+      featureId: TestFeature.Words,
+      intervalCount: 2,
+    }),
+  ],
+  intervalCount: 2,
+});
+
+const prepaidWordsItem = constructPrepaidItem({
+  featureId: TestFeature.Words,
+  price: 10,
+  billingUnits: 1,
+  includedUsage: 0,
+});
+
+export const addOn = constructRawProduct({
+  id: "addOn",
+  items: [prepaidWordsItem],
+  isAddOn: true,
+});
+
+describe(`${chalk.yellowBright(`${testCase}: Testing custom interval on arrear prorated price`)}`, () => {
+  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;
+
+  before(async function () {
+    await setupBefore(this);
+    const { autumnJs } = this;
+    db = this.db;
+    org = this.org;
+    env = this.env;
+
+    stripeCli = this.stripeCli;
+
+    const { testClockId: testClockId1 } = await initCustomer({
+      autumn: autumnJs,
+      customerId,
+      db,
+      org,
+      env,
+      attachPm: "success",
+    });
+
+    addPrefixToProducts({
+      products: [pro, addOn],
+      prefix: testCase,
+    });
+
+    await createProducts({
+      autumn,
+      products: [pro, addOn],
+      db,
+      orgId: org.id,
+      env,
+    });
+
+    testClockId = testClockId1!;
+  });
+
+  it("should attach pro product", async function () {
+    await runAttachTest({
+      autumn,
+      customerId,
+      product: pro,
+      stripeCli,
+      db,
+      org,
+      env,
+    });
+  });
+
+  it("should upgrade to premium product and have correct invoice next cycle", async function () {
+    const curUnix = await advanceTestClock({
+      stripeCli,
+      testClockId,
+      advanceTo: addDays(new Date(), 20).getTime(),
+      waitForSeconds: 15,
+    });
+
+    const wordBillingSets = 2;
+    const wordsBillingUnits = prepaidWordsItem.billing_units! * wordBillingSets;
+    await autumn.attach({
+      customer_id: customerId,
+      product_id: addOn.id,
+      options: [
+        {
+          feature_id: TestFeature.Words,
+          quantity: wordsBillingUnits,
+        },
+      ],
+    });
+
+    const customer = await autumn.customers.get(customerId);
+    const proProduct = customer.products.find((p) => p.id === pro.id);
+    const invoices = customer.invoices;
+    expectProductAttached({
+      customer,
+      product: pro,
+    });
+
+    expectProductAttached({
+      customer,
+      product: addOn,
+    });
+
+    let expectedPrice = wordsBillingUnits * prepaidWordsItem.price!;
+    expect(invoices[0].product_ids).to.include(addOn.id);
+    expect(invoices[0].total).to.approximately(
+      calculateProrationAmount({
+        amount: expectedPrice,
+        periodStart: curUnix!,
+        periodEnd: addMonths(curUnix!, 1).getTime(),
+        now: curUnix!,
+      }),
+      0.1
+    );
+
+    const expectedAddonEnd = addMonths(curUnix, 1);
+    const approximate = 1000 * 60 * 60 * 24; // +- 1 day
+    const addOnProduct = customer.products.find((p) => p.id === addOn.id);
+
+    expect(addOnProduct?.current_period_end).to.be.closeTo(
+      expectedAddonEnd.getTime(),
+      approximate
+    );
+  });
+});