@proconnect-gouv/proconnect.identite 1.7.1 → 2.0.0

package/src/managers/user/assign-user-verification-type-to-domain.test.ts

@@ -1,97 +1,106 @@
 //
 
+import { context, emptyDatabase, migrate, pg } from "#testing";
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
+import { before, beforeEach, describe, it } from "node:test";
 import { assignUserVerificationTypeToDomainFactory } from "./assign-user-verification-type-to-domain.js";
 
 //
 
+const assignUserVerificationTypeToDomain =
+  assignUserVerificationTypeToDomainFactory(context);
+
 describe("assignUserVerificationTypeToDomain", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
   it("should update some organization members", async () => {
-    const updateUserOrganizationLink = mock.fn(() =>
-      Promise.resolve({} as any),
-    );
-    const assignUserVerificationTypeToDomain =
-      assignUserVerificationTypeToDomainFactory({
-        getUsers: () =>
-          Promise.resolve([
-            { email: "foo@bar.world" },
-            { email: "foo@darkangels.world" },
-            {
-              email: "foo@darkangels.world",
-              verification_type: "verified",
-            },
-            {
-              id: 42,
-              email: "lion.eljonson@darkangels.world",
-              verification_type: "no_validation_means_available",
-            },
-            {
-              id: 43,
-              email: "cat.eljonson@darkangels.world",
-              verification_type:
-                "no_verification_means_for_entreprise_unipersonnelle",
-            },
-            {
-              id: 44,
-              email: "tiger.eljonson@darkangels.world",
-              verification_type: "no_verification_means_for_small_association",
-            },
-            {
-              id: 45,
-              email: "mouse.eljonson@darkangels.world",
-              verification_type: "domain_not_verified_yet",
-            },
-          ] as any),
-        updateUserOrganizationLink,
-      });
+    await pg.sql`
+      INSERT INTO organizations
+        (id, cached_libelle, cached_nom_complet, siret, created_at, updated_at)
+      VALUES
+        (1, 'Dark Angels', 'Dark Angels Legion', '🦁', '4444-04-04', '4444-04-04')
+      ;
+    `;
+    // user from a different domain — should not be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (1, 'foo@bar.world', '4444-04-04', '4444-04-04', 'Foo', 'Bar', '0', 'None')
+    `;
+    // user matching domain but already "verified" — should not be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (2, 'foo@darkangels.world', '4444-04-04', '4444-04-04', 'Foo', 'DA', '0', 'None')
+    `;
+    // user with no_validation_means_available — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (3, 'lion.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Lion', 'El''Jonson', '0', 'Primarque')
+    `;
+    // user with no_verification_means_for_entreprise_unipersonnelle — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (4, 'cat.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Cat', 'El''Jonson', '0', 'Scout')
+    `;
+    // user with no_verification_means_for_small_association — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (5, 'tiger.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Tiger', 'El''Jonson', '0', 'Scout')
+    `;
+    // user with domain_not_verified_yet — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (6, 'mouse.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Mouse', 'El''Jonson', '0', 'Scout')
+    `;
 
-    await assignUserVerificationTypeToDomain(111, "darkangels.world");
+    // link all users to the organization
+    await pg.sql`
+      INSERT INTO users_organizations
+        (user_id, organization_id, created_at, updated_at, is_external, verification_type, needs_official_contact_email_verification, official_contact_email_verification_token, official_contact_email_verification_sent_at)
+      VALUES
+        (1, 1, '4444-04-04', '4444-04-04', false, 'no_validation_means_available', false, null, null),
+        (2, 1, '4444-04-04', '4444-04-04', false, 'verified', false, null, null),
+        (3, 1, '4444-04-04', '4444-04-04', false, 'no_validation_means_available', false, null, null),
+        (4, 1, '4444-04-04', '4444-04-04', false, 'no_verification_means_for_entreprise_unipersonnelle', false, null, null),
+        (5, 1, '4444-04-04', '4444-04-04', false, 'no_verification_means_for_small_association', false, null, null),
+        (6, 1, '4444-04-04', '4444-04-04', false, 'domain_not_verified_yet', false, null, null)
+      ;
+    `;
 
-    const [lion, cat, tiger, mouse] = updateUserOrganizationLink.mock.calls;
-    assert.deepEqual(lion.arguments, [
-      111,
-      42,
-      {
-        verification_type: "domain",
-      },
-    ]);
-    assert.deepEqual(cat.arguments, [
-      111,
-      43,
-      {
-        verification_type: "domain",
-      },
-    ]);
-    assert.deepEqual(tiger.arguments, [
-      111,
-      44,
-      {
-        verification_type: "domain",
-      },
-    ]);
-    assert.deepEqual(mouse.arguments, [
-      111,
-      45,
-      {
-        verification_type: "domain",
-      },
+    await assignUserVerificationTypeToDomain(1, "darkangels.world");
+
+    // verify that the 4 matching users were updated to "domain"
+    const { rows } = await pg.sql`
+      SELECT user_id, verification_type
+      FROM users_organizations
+      WHERE organization_id = 1
+      ORDER BY user_id
+    `;
+
+    assert.deepEqual(rows, [
+      { user_id: 1, verification_type: "no_validation_means_available" }, // different domain
+      { user_id: 2, verification_type: "verified" }, // already verified
+      { user_id: 3, verification_type: "domain" },
+      { user_id: 4, verification_type: "domain" },
+      { user_id: 5, verification_type: "domain" },
+      { user_id: 6, verification_type: "domain" },
     ]);
-    assert.equal(updateUserOrganizationLink.mock.callCount(), 4);
   });
 
   it("❎ should update nothing if no organization members", async () => {
-    const updateUserOrganizationLink = mock.fn(() =>
-      Promise.reject(new Error("💣")),
-    );
-    const assignUserVerificationTypeToDomain =
-      assignUserVerificationTypeToDomainFactory({
-        getUsers: () => Promise.resolve([]),
-        updateUserOrganizationLink,
-      });
+    await pg.sql`
+      INSERT INTO organizations
+        (id, cached_libelle, cached_nom_complet, siret, created_at, updated_at)
+      VALUES
+        (1, 'Empty', 'Empty Org', '🫥', '4444-04-04', '4444-04-04')
+      ;
+    `;
 
-    await assignUserVerificationTypeToDomain(42, "darkangels.world");
+    await assignUserVerificationTypeToDomain(1, "darkangels.world");
 
-    assert.deepEqual(updateUserOrganizationLink.mock.calls, []);
+    const { rows } = await pg.sql`
+      SELECT * FROM users_organizations WHERE organization_id = 1
+    `;
+    assert.deepEqual(rows, []);
   });
 });

package/src/managers/user/assign-user-verification-type-to-domain.ts

@@ -1,27 +1,20 @@
 //
 
-import type { GetUsersByOrganizationHandler } from "#src/repositories/organization";
-import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
+import type { Context } from "#src/connectors";
 import { LinkTypes, SuperWeakLinkTypes, UnverifiedLinkTypes } from "#src/types";
 import { getEmailDomain } from "@proconnect-gouv/proconnect.core/services/email";
 import { match } from "ts-pattern";
 
 //
 
-type FactoryDependencies = {
-  getUsers: GetUsersByOrganizationHandler;
-  updateUserOrganizationLink: UpdateUserOrganizationLinkHandler;
-};
-
 export function assignUserVerificationTypeToDomainFactory({
-  getUsers,
-  updateUserOrganizationLink,
-}: FactoryDependencies) {
+  repository: { organizations, users_organizations },
+}: Context) {
   return async function assignUserVerificationTypeToDomain(
     organization_id: number,
     domain: string,
   ) {
-    const usersInOrganization = await getUsers(organization_id);
+    const usersInOrganization = await organizations.getUsers(organization_id);
 
     await Promise.all(
       usersInOrganization.map(
@@ -33,7 +26,7 @@ export function assignUserVerificationTypeToDomainFactory({
               .with(...UnverifiedLinkTypes, ...SuperWeakLinkTypes, () => true)
               .otherwise(() => false)
           ) {
-            return updateUserOrganizationLink(organization_id, id, {
+            return users_organizations.update(organization_id, id, {
               verification_type: LinkTypes.enum.domain,
             });
           }
@@ -44,7 +37,3 @@ export function assignUserVerificationTypeToDomainFactory({
     );
   };
 }
-
-export type AssignUserVerificationTypeToDomainFactoryHandler = ReturnType<
-  typeof assignUserVerificationTypeToDomainFactory
->;

package/testing/index.ts

@@ -4,10 +4,12 @@ import { PGlite } from "@electric-sql/pglite";
 import { noop } from "lodash-es";
 import { runner } from "node-pg-migrate";
 import { join } from "path";
+import { createContext } from "../src/connectors/index.js";
 
 //
 
 export const pg = new PGlite();
+export const context = createContext(pg as any);
 
 export function migrate() {
   return runner({