@terreno/api 0.10.0 → 0.11.0

package/src/syncConsents.test.ts

@@ -121,4 +121,149 @@ describe("syncConsents", () => {
     expect(forms[0].slug).toBe("terms");
     expect(forms[1].slug).toBe("privacy");
   });
+
+  it("publishes new version when type changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated: ConsentFormDefinition = {...baseDef, type: "privacy"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when order changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, order: 99};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when required changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, required: false};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when requireScrollToBottom changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, requireScrollToBottom: true};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when captureSignature changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, captureSignature: true};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when agreeButtonText changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, agreeButtonText: "Consent"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when allowDecline changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, allowDecline: true};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when declineButtonText changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, allowDecline: true, declineButtonText: "No Thanks"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when defaultLocale changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, defaultLocale: "es"};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when content locale count changes", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, content: {en: baseDef.content.en, es: "# Términos"}};
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when checkbox count changes", async () => {
+    await syncConsents({
+      terms: {
+        ...baseDef,
+        checkboxes: [{label: "Agree", required: true}],
+      },
+    });
+    const updated = {
+      ...baseDef,
+      checkboxes: [
+        {label: "Agree", required: true},
+        {label: "Also agree", required: false},
+      ],
+    };
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when checkbox label changes", async () => {
+    await syncConsents({
+      terms: {
+        ...baseDef,
+        checkboxes: [{label: "Agree", required: true}],
+      },
+    });
+    const updated = {
+      ...baseDef,
+      checkboxes: [{label: "I Agree", required: true}],
+    };
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("publishes new version when checkbox confirmationPrompt changes", async () => {
+    await syncConsents({
+      terms: {
+        ...baseDef,
+        checkboxes: [{confirmationPrompt: "Sure?", label: "Agree", required: true}],
+      },
+    });
+    const updated = {
+      ...baseDef,
+      checkboxes: [{confirmationPrompt: "Are you sure?", label: "Agree", required: true}],
+    };
+    const result = await syncConsents({terms: updated});
+    expect(result.updated).toEqual(["terms"]);
+  });
+
+  it("leaves unchanged forms alone with checkboxes present", async () => {
+    const withCheckboxes = {
+      ...baseDef,
+      checkboxes: [{confirmationPrompt: "Sure?", label: "Agree", required: true}],
+    };
+    await syncConsents({terms: withCheckboxes});
+    const result = await syncConsents({terms: withCheckboxes});
+    expect(result.unchanged).toEqual(["terms"]);
+  });
+
+  it("dry run does not create new versions", async () => {
+    await syncConsents({terms: baseDef});
+    const updated = {...baseDef, title: "Updated"};
+    const result = await syncConsents({terms: updated}, {dryRun: true});
+    expect(result.updated).toEqual(["terms"]);
+    const forms = await ConsentForm.find({slug: "terms"});
+    expect(forms).toHaveLength(1); // No new version created
+  });
+
+  it("dry run does not deactivate forms", async () => {
+    await syncConsents({privacy: {...baseDef, title: "Privacy", type: "privacy"}, terms: baseDef});
+    const result = await syncConsents({terms: baseDef}, {deactivateRemoved: true, dryRun: true});
+    expect(result.deactivated).toEqual(["privacy"]);
+    const privacy = await ConsentForm.findOne({slug: "privacy"});
+    expect(privacy?.active).toBe(true); // Still active
+  });
 });

package/src/tests.ts

@@ -162,7 +162,7 @@ const requiredSchema = new Schema<RequiredField>({
 });
 export const RequiredModel = model<RequiredField>("Required", requiredSchema);
 
-export function getBaseServer(): Express {
+export const getBaseServer = (): Express => {
   const app = express();
   app.set("query parser", (str: string) => qs.parse(str, {arrayLimit: 200}));
 
@@ -186,12 +186,12 @@ export function getBaseServer(): Express {
   });
   app.use(express.json());
   return app;
-}
+};
 
-export async function authAsUser(
+export const authAsUser = async (
   app: express.Application,
   type: "admin" | "notAdmin"
-): Promise<TestAgent> {
+): Promise<TestAgent> => {
   const email = type === "admin" ? "admin@example.com" : "notAdmin@example.com";
   const password = type === "admin" ? "securePassword" : "password";
 
@@ -199,9 +199,9 @@ export async function authAsUser(
   const res = await agent.post("/auth/login").send({email, password}).expect(200);
   await agent.set("authorization", `Bearer ${res.body.data.token}`);
   return agent;
-}
+};
 
-export async function setupDb() {
+export const setupDb = async () => {
   await mongoose
     .connect("mongodb://127.0.0.1/terreno?&connectTimeoutMS=360000")
     .catch(logger.catch);
@@ -233,7 +233,7 @@ export async function setupDb() {
 
     return [admin, notAdmin, adminOther];
   } catch (error) {
-    console.error("Error setting up DB", error);
+    logger.error("Error setting up DB", error);
     throw error;
   }
-}
+};

package/src/utils.ts

@@ -4,14 +4,14 @@ import {logger} from "./logger";
 
 // A better version of mongoose's ObjectId.isValid,
 // which falsely will say any 12 character string is valid.
-export function isValidObjectId(id: string): boolean {
+export const isValidObjectId = (id: string): boolean => {
   try {
     return new Types.ObjectId(id).toString() === id;
   } catch (error) {
     logger.error(`Error validating object id ${id}: ${error}`);
     return false;
   }
-}
+};
 
 export const timeout = async (ms: number): Promise<NodeJS.Timeout> => {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -25,7 +25,7 @@ export const timeout = async (ms: number): Promise<NodeJS.Timeout> => {
  * @param ignoredModels - Array of model names to skip validation for
  * @throws Error if any model is not set to strict mode or missing virtual settings
  */
-export function checkModelsStrict(ignoredModels: string[] = []): void {
+export const checkModelsStrict = (ignoredModels: string[] = []): void => {
   const models = mongoose.modelNames();
   for (const model of models) {
     const schema = mongoose.model(model).schema;
@@ -44,4 +44,4 @@ export function checkModelsStrict(ignoredModels: string[] = []): void {
       throw new Error(`Model ${model} is not set to strict mode.`);
     }
   }
-}
+};