only automatically collect payments from users if their balance goes below the minimum payment size; also, only cancel subscriptions if the amount owed in pending payments goes $1 below min payment size. unit tested.

Author: williamstein

src/packages/server/purchases/maintain-automatic-payments.test.ts

@@ -199,11 +199,7 @@ describe("testing automatic payments in several situations", () => {
     );
     collect.length = 0;
     await maintainAutomaticPayments();
-    expect(collect).toEqual([
-      {
-        account_id,
-        amount: pay_as_you_go_min_payment,
-      },
-    ]);
+    // DO NOT collect whne amount is less than pay as you go min
+    expect(collect).toEqual([]);
   });
 });

src/packages/server/purchases/maintain-automatic-payments.ts

@@ -126,15 +126,16 @@ export default async function maintainAutomaticPayments() {
         logger.debug(
           "Since amount ",
           amount,
-          " is positive, will try to collect automatically",
+          " is positive, may try to collect automatically",
         );
 
         if (amount < pay_as_you_go_min_payment) {
           logger.debug(
-            "amount is below min payment, so we instead charge the min payment amount of ",
+            "amount is below min payment, so we do not charge anything for now. the min payment amount is ",
             pay_as_you_go_min_payment,
           );
-          amount = pay_as_you_go_min_payment;
+          // amount = pay_as_you_go_min_payment;
+          continue;
         }
 
         // Now make the attempt.  This might work quickly, it might take a day, it might

src/packages/server/purchases/maintain-subscriptions.test.ts

@@ -96,7 +96,7 @@ describe("test renewSubscriptions", () => {
     expect(
       Math.abs(subs[0].current_period_start.valueOf() - Date.now()),
     ).toBeLessThan(1000 * 3600 * 24 * 2);
-    // the purchase should be pending so we don't have any money.
+    // the purchase should be pending, since we don't have any money.
     const pool = getPool();
     const { rows } = await pool.query(
       "SELECT pending FROM purchases where id=$1",
@@ -316,3 +316,93 @@ describe("testing cancelAllPendingSubscriptions works as it should", () => {
     expect(subs[0].status).toBe("canceled");
   });
 });
+
+describe("test renewSubscriptions doesn't cancel tiny subscription", () => {
+  const account_id = uuid();
+  const x: any = {};
+  it("creates an account, license and subscription", async () => {
+    await createAccount({
+      email: "",
+      password: "xyz",
+      firstName: "Test",
+      lastName: "User",
+      account_id,
+    });
+    const info = getPurchaseInfo(license0);
+    x.license_id = await createLicense(account_id, info);
+    x.subscription_id = await createSubscription(
+      {
+        account_id,
+        cost: 1, // way less than min payment
+        interval: "month",
+        current_period_start: dayjs().toDate(),
+        current_period_end: dayjs().add(1, "month").toDate(),
+        status: "active",
+        metadata: { type: "license", license_id: x.license_id },
+        latest_purchase_id: 0,
+      },
+      null,
+    );
+  });
+
+  it("modifies our subscription so the start date is a month ago and the end date is 12 hours from now", async () => {
+    const pool = getPool();
+    await pool.query(
+      "UPDATE subscriptions SET current_period_start=$1, current_period_end=$2 WHERE id=$3",
+      [
+        dayjs().subtract(1, "month").toDate(),
+        dayjs().add(12, "hour").toDate(),
+        x.subscription_id,
+      ],
+    );
+  });
+
+  it("runs renewSubscriptions and checks that our subscription did renew", async () => {
+    await test.renewSubscriptions();
+    const subs = await getSubscriptions({ account_id });
+    // within 3 days of a month from now:
+    expect(
+      Math.abs(
+        subs[0].current_period_end.valueOf() -
+          dayjs().add(1, "month").toDate().valueOf(),
+      ),
+    ).toBeLessThan(1000 * 3600 * 24 * 2);
+    // within 3 days of now:
+    expect(
+      Math.abs(subs[0].current_period_start.valueOf() - Date.now()),
+    ).toBeLessThan(1000 * 3600 * 24 * 2);
+    // the purchase should be pending, since we don't have any money.
+    const pool = getPool();
+    const { rows } = await pool.query(
+      "SELECT pending FROM purchases where id=$1",
+      [subs[0].latest_purchase_id],
+    );
+    expect(rows[0].pending).toBe(true);
+  });
+
+  it("changes time of purchase back to slightly more than grace period and verifies that cancelAllPendingSubscriptions does NOT cancel the subscription", async () => {
+    const grace = await test.getGracePeriodDays();
+    const pool = getPool();
+    await pool.query(
+      `UPDATE purchases SET time=NOW() - interval '${
+        grace + 1
+      } days' WHERE id=$1`,
+      [x.purchase_id],
+    );
+    await test.cancelAllPendingSubscriptions();
+    const subs = await getSubscriptions({ account_id });
+    expect(subs.length).toBe(1);
+    expect(subs[0].status).toBe("active");
+  });
+
+  it("changes amount of pending purchase to also be BIG, and then subscription should get canceled", async () => {
+    const pool = getPool();
+    await pool.query(`UPDATE purchases SET cost=1000 WHERE id=$1`, [
+      x.purchase_id,
+    ]);
+    await test.cancelAllPendingSubscriptions();
+    const subs = await getSubscriptions({ account_id });
+    expect(subs.length).toBe(1);
+    expect(subs[0].status).toBe("active");
+  });
+});

src/packages/server/purchases/maintain-subscriptions.ts

@@ -5,6 +5,7 @@ import renewSubscription from "@cocalc/server/purchases/renew-subscription";
 import cancelSubscription from "./cancel-subscription";
 import sendSubscriptionRenewalEmails from "./subscription-renewal-emails";
 import { isEmailConfigured } from "@cocalc/server/email/send-email";
+import { getPendingBalance } from "./get-balance";
 
 const logger = getLogger("purchases:maintain-subscriptions");
 
@@ -147,9 +148,10 @@ async function cancelAllPendingSubscriptions() {
   const grace = await getGracePeriodDays();
 
   const pool = getPool();
-  const { rows } = await pool.query(`
-SELECT account_id, id as purchase_id FROM purchases WHERE pending=true AND time <= NOW() - interval '${grace} days' AND service = 'edit-license';
-`);
+  const { rows } = await pool.query(
+    `
+SELECT account_id, id as purchase_id FROM purchases WHERE pending=true AND time <= NOW() - interval '${grace} days' AND service = 'edit-license'`,
+  );
   logger.debug(
     "cancelPendingSubscriptions -- pending subscription purchases = ",
     rows,
@@ -173,6 +175,15 @@ SELECT account_id, id as purchase_id FROM purchases WHERE pending=true AND time
 // [ ] TODO: send email when canceling a subscription/license this way
 // with instructions to restart it?
 async function cancelOnePendingSubscription({ account_id, purchase_id }) {
+  // Do NOT both canceling any user subscription if their pending payments
+  // total up to less than the pay as you go minimum (with a little slack).
+  // This is because we don't automatically collect payments in such cases.
+  // They might manually pay anyways, but we don't want to count on that.
+  const pendingBalance = await getPendingBalance(account_id);
+  const { pay_as_you_go_min_payment } = await getServerSettings();
+  if (Math.abs(pendingBalance) <= pay_as_you_go_min_payment + 1) {  // pandingBalance is actually <=0.
+    return;
+  }
   const client = await getTransactionClient();
   try {
     const x = await client.query(

src/packages/server/purchases/renew-subscription.test.ts

@@ -36,7 +36,7 @@ describe("create a subscription, then renew it", () => {
     try {
       await renewSubscription({ account_id, subscription_id });
     } catch (e) {
-      expect(e.message).toMatch("do not have enough credits");
+      expect(e.message).toMatch("Please add");
     }
     //const sub = await getSubscription(subscription_id);
   });

src/packages/server/purchases/resume-subscription.test.ts

@@ -99,7 +99,7 @@ describe("create a subscription, cancel it, then resume it", () => {
     try {
       await resumeSubscription({ account_id, subscription_id });
     } catch (e) {
-      expect(e.message).toMatch("do not have enough credits");
+      expect(e.message).toMatch("Please add at least $7.90 to your account.");
     }
   });
 });

src/packages/server/purchases/student-pay.test.ts

@@ -76,7 +76,7 @@ describe("test studentPay behaves at it should in various scenarios", () => {
     try {
       await studentPay({ account_id, project_id });
     } catch (e) {
-      expect(e.message).toMatch("do not have enough");
+      expect(e.message).toMatch("Please add at least $21.20 to your account.");
     }
   });