@edifice.io/communities-tests 1.0.0-develop-pedago.20250725171105

package/it/scenarios/api-invitations.spec.ts

@@ -0,0 +1,582 @@
+// @ts-ignore
+import { chai, describe } from "https://jslib.k6.io/k6chaijs/4.3.4.0/index.js";
+import { fail, check } from "k6";
+
+import {
+  authenticateWeb,
+  getUsersOfSchool,
+  createAndSetRole,
+  linkRoleToUsers,
+  initStructure,
+  getRandomUserWithProfile,
+  getRolesOfStructure,
+  Structure,
+  logout,
+  UserInfo,
+} from "../../node_modules/edifice-k6-commons/dist/index.js";
+
+// Import community API utils
+import {
+  createCommunityOrFail,
+  deleteCommunity,
+  getSecretCode,
+  CreateCommunityParams,
+} from "./utils/_community-api.utils.ts";
+
+// Import invitation API utils
+import {
+  createInvitations,
+  listCommunityInvitations,
+  listMyInvitations,
+  updateInvitationStatus,
+  deleteInvitation,
+  findInvitationById,
+  CreateInvitationParams,
+  Invitation,
+  InvitationStatus,
+  MembershipRole,
+  deleteInvitationsBatch,
+  joinCommunity,
+  updateRequestStatus,
+  updateInvitationSeeLater,
+} from "./utils/_invitation-api.utils.ts";
+
+// Import membership API utils for verification
+import {
+  listCommunityMembers,
+  findMembershipByUserId,
+} from "./utils/_membership-api.utils.ts";
+
+chai.config.logFailures = true;
+
+export const options = {
+  setupTimeout: "1h",
+  maxRedirects: 0,
+  thresholds: {
+    checks: ["rate == 1.00"],
+  },
+  scenarios: {
+    invitationsTest: {
+      exec: "testInvitationsApi",
+      executor: "per-vu-iterations",
+      vus: 1,
+      maxDuration: "1m",
+      gracefulStop: "5s",
+    },
+  },
+};
+
+const timestamp = new Date().toISOString();
+const schoolName = `IT Community Invitations`;
+
+export function setup(): Structure {
+  let structure: Structure = {} as Structure;
+  describe("[CommunityInvitations] Initialize data", () => {
+    authenticateWeb(__ENV.ADMC_LOGIN, __ENV.ADMC_PASSWORD);
+    structure = initStructure(schoolName, "tiny");
+    const role = createAndSetRole("Communities");
+    const groups = getRolesOfStructure(structure.id);
+    linkRoleToUsers(
+      structure,
+      role,
+      groups.map((g: any) => g.name),
+    );
+  });
+  return structure;
+}
+
+export function testInvitationsApi(structure: Structure) {
+  // Community data
+  const communityData: CreateCommunityParams = {
+    title: `InvitationTest - Community  ${timestamp}`,
+    type: "FREE",
+    schoolYearStart: 2025,
+    schoolYearEnd: 2026,
+    discussionEnabled: true,
+    welcomeNote: "Test community for invitation API  tests",
+    invitations: {
+      users: [],
+    },
+  };
+
+  let communityId: number;
+  let invitationId: number;
+  let adminUser: UserInfo;
+  let memberUser: UserInfo;
+  let member2User: UserInfo;
+  let member3User: UserInfo;
+
+  describe("[Community Invitations API Test with Authentication]", () => {
+    // Step 1: Admin logs in via Web
+    authenticateWeb(__ENV.ADMC_LOGIN, __ENV.ADMC_PASSWORD);
+
+    // Get users from school
+    const users = getUsersOfSchool(structure);
+    adminUser = getRandomUserWithProfile(users, "Teacher");
+    memberUser = getRandomUserWithProfile(users, "Student", [adminUser]);
+    member2User = getRandomUserWithProfile(users, "Student", [
+      adminUser,
+      memberUser,
+    ]);
+    member3User = getRandomUserWithProfile(users, "Student", [
+      adminUser,
+      memberUser,
+      member2User,
+    ]);
+
+    logout();
+
+    // Step 2: Admin authenticates
+    const adminAuthenticated = authenticateWeb(adminUser.login, "password");
+    if (!adminAuthenticated) {
+      fail("Admin authentication failed");
+    }
+
+    // Step 3: Admin creates a community
+    describe("Create community for invitation tests", () => {
+      // Use the utility function to create a community
+      communityId = Number(createCommunityOrFail(communityData));
+      console.log(`Created community with ID: ${communityId}`);
+    });
+
+    // Step 4: Admin invites member to community
+    describe("Create invitation for member", () => {
+      // Use the invitation API utility to create an invitation
+      const invitationData: CreateInvitationParams = {
+        users: [{ userId: memberUser.id, role: MembershipRole.MEMBER }],
+        message: "You are invited to join our test community",
+      };
+
+      const invitations = createInvitations(communityId, invitationData);
+
+      check(invitations, {
+        "invitation created successfully": (r) => r !== null && r.length > 0,
+      });
+
+      invitationId = invitations![0].id;
+      console.log(`Created invitation with ID: ${invitationId}`);
+    });
+
+    // 5.1: Get specific invitation from community invitations list
+    describe("Find invitation in community invitations list", () => {
+      const invitations = listCommunityInvitations(communityId);
+      const invitation = findInvitationById(invitationId, invitations);
+
+      check(invitation, {
+        "invitation found in community list": (r) => r !== null,
+        "invitation has correct ID": (r) => r !== null && r.id === invitationId,
+        "invitation has correct status": (r) =>
+          r !== null && r.status === InvitationStatus.PENDING,
+      });
+    });
+
+    // 5.2: List invitations for a community
+    describe("List invitations for community", () => {
+      const invitations = listCommunityInvitations(communityId);
+
+      check(invitations, {
+        "list invitations successful": (r) => r !== null,
+        "invitations list contains data": (r) => r !== null && r.length > 0,
+        "created invitation is in the list": (r) => {
+          return (
+            r !== null && r.some((inv: Invitation) => inv.id === invitationId)
+          );
+        },
+      });
+    });
+
+    // Step 6: Member authenticates
+    logout();
+    const memberAuthenticated = authenticateWeb(memberUser.login, "password");
+    if (!memberAuthenticated) {
+      fail("Member authentication failed");
+    }
+
+    // Step 7: Member lists their invitations
+    describe("Member lists received invitations", () => {
+      const myInvitations = listMyInvitations();
+      const invitation = findInvitationById(invitationId, myInvitations);
+
+      check(myInvitations, {
+        "member can see invitations": (r) => r !== null,
+      });
+
+      check(invitation, {
+        "invitation is in the member's list": (r) => r !== null,
+        "invitation has correct status": (r) =>
+          r !== null && r.status === InvitationStatus.PENDING,
+      });
+    });
+
+    // Step 8: Member accepts invitation
+    describe("Member accepts invitation", () => {
+      const updatedInvitation = updateInvitationStatus(
+        invitationId,
+        InvitationStatus.ACCEPTED,
+      );
+
+      check(updatedInvitation, {
+        "invitation accepted successfully": (r) => r !== null,
+        "status changed to ACCEPTED": (r) =>
+          r !== null && r.status === InvitationStatus.ACCEPTED,
+      });
+    });
+
+    // Step 9: Admin logs back in to check invitation status
+    logout();
+    authenticateWeb(adminUser.login, "password");
+
+    describe("Admin verifies invitation was accepted", () => {
+      const invitations = listCommunityInvitations(communityId);
+      const invitation = findInvitationById(invitationId, invitations);
+
+      check(invitation, {
+        "invitation found in list": (r) => r !== null,
+        "invitation status is ACCEPTED": (r) =>
+          r !== null && r.status === InvitationStatus.ACCEPTED,
+      });
+    });
+
+    // Test deletion of an invitation
+    describe("Admin tries to delete an invitation", () => {
+      // First create a new invitation for deletion test
+      const newInvitationData: CreateInvitationParams = {
+        users: [{ userId: member2User.id, role: MembershipRole.MEMBER }],
+        message: "This invitation will be deleted",
+      };
+
+      const newInvitations = createInvitations(communityId, newInvitationData);
+      const newInvitationId = newInvitations![0].id;
+
+      // Now delete the invitation
+      const deleted = deleteInvitation(communityId, newInvitationId);
+
+      check(deleted, {
+        "invitation deleted successfully": (r) => r === true,
+      });
+
+      // Verify the invitation is actually deleted by looking for it in the list
+      const updatedInvitations = listCommunityInvitations(communityId);
+      const deletedInvitation = findInvitationById(
+        newInvitationId,
+        updatedInvitations,
+      );
+
+      check(deletedInvitation, {
+        "invitation no longer exists in list": (r) => r === null,
+      });
+    });
+
+    // Test deletion of a PENDING invitation
+    describe("Admin deletes a PENDING invitation", () => {
+      // First create a new invitation for deletion test using a different user
+      const newInvitationData: CreateInvitationParams = {
+        users: [{ userId: member3User.id, role: MembershipRole.MEMBER }],
+        message: "This invitation will be deleted",
+      };
+
+      const newInvitations = createInvitations(communityId, newInvitationData);
+      const newInvitationId = newInvitations![0].id;
+
+      // Verify the new invitation is indeed in PENDING status before attempting deletion
+      const pendingInvitation = findInvitationById(
+        newInvitationId,
+        listCommunityInvitations(communityId),
+      );
+
+      check(pendingInvitation, {
+        "invitation is in PENDING status before deletion": (r) =>
+          r !== null && r.status === InvitationStatus.PENDING,
+      });
+
+      // Skip deletion if invitation is not in PENDING status
+      if (pendingInvitation?.status !== InvitationStatus.PENDING) {
+        console.error(
+          `Cannot proceed with deletion: invitation ${newInvitationId} status is ${pendingInvitation?.status}`,
+        );
+        return;
+      }
+
+      // Now delete the invitation
+      const deleted = deleteInvitation(communityId, newInvitationId);
+
+      check(deleted, {
+        "invitation deleted successfully": (r) => r === true,
+      });
+
+      // Verify the invitation is actually deleted
+      const updatedInvitations = listCommunityInvitations(communityId);
+      const deletedInvitation = findInvitationById(
+        newInvitationId,
+        updatedInvitations,
+      );
+
+      check(deletedInvitation, {
+        "invitation no longer exists in list": (r) => r === null,
+      });
+    });
+
+    // Test batch deletion of invitations
+    describe("Admin deletes multiple invitations in batch", () => {
+      // Create multiple invitations for batch deletion test
+      const batchInvitationData: CreateInvitationParams = {
+        users: [
+          { userId: member2User.id, role: MembershipRole.MEMBER },
+          { userId: member3User.id, role: MembershipRole.MEMBER },
+        ],
+        message: "These invitations will be deleted in batch",
+      };
+
+      const batchInvitations = createInvitations(
+        communityId,
+        batchInvitationData,
+      );
+      const batchInvitationIds = batchInvitations!.map((inv) => inv.id);
+
+      // Verify all invitations are in PENDING status
+      const pendingInvitations = listCommunityInvitations(communityId);
+      check(pendingInvitations, {
+        "all new invitations are in PENDING status": (r) => {
+          if (!r) return false;
+          const foundInvitations = batchInvitationIds.map((id) =>
+            findInvitationById(id, r),
+          );
+          return foundInvitations.every(
+            (inv) => inv !== null && inv.status === InvitationStatus.PENDING,
+          );
+        },
+      });
+
+      // Now delete the invitations in batch
+      const batchDeleted = deleteInvitationsBatch(
+        communityId,
+        batchInvitationIds,
+      );
+
+      check(batchDeleted, {
+        "batch deletion successful": (r) => r === true,
+      });
+
+      // Verify all invitations are deleted
+      const remainingInvitations = listCommunityInvitations(communityId);
+      check(remainingInvitations, {
+        "all batch-deleted invitations are gone": (r) => {
+          if (!r) return false;
+          return batchInvitationIds.every(
+            (id) => findInvitationById(id, r) === null,
+          );
+        },
+      });
+    });
+
+    // NEW SECTION: Testing the join request workflow with admin approval/rejection
+    describe("Secret code join requests and admin approval/rejection", () => {
+      // Get the secret code for the community
+      const secretCode = getSecretCode(communityId) || "";
+      check(secretCode, {
+        "Secret code retrieved successfully": (code) =>
+          code !== null && code !== "",
+      });
+
+      let acceptedUserId: number | null = null;
+      let rejectedUserId: number | null = null;
+      let acceptRequestId: number;
+      let rejectRequestId: number;
+
+      // Member 2 creates a join request (to be approved)
+      logout();
+      authenticateWeb(member2User.login, "password");
+
+      const joinRequest1 = joinCommunity(secretCode);
+      check(joinRequest1, {
+        "Member2 join request created successfully": (r) => r !== null,
+        "Member2 request has REQUEST status": (r) =>
+          r !== null && r.status === InvitationStatus.REQUEST,
+      });
+
+      if (joinRequest1 && joinRequest1.receiver) {
+        acceptedUserId = Number(joinRequest1.receiver.id);
+        acceptRequestId = joinRequest1.id;
+        console.log(`Member2 created join request ${acceptRequestId}`);
+      }
+
+      // Member 3 creates a join request (to be rejected)
+      logout();
+      authenticateWeb(member3User.login, "password");
+
+      const joinRequest2 = joinCommunity(secretCode);
+      check(joinRequest2, {
+        "Member3 join request created successfully": (r) => r !== null,
+        "Member3 request has REQUEST status": (r) =>
+          r !== null && r.status === InvitationStatus.REQUEST,
+      });
+
+      if (joinRequest2 && joinRequest2.receiver) {
+        rejectedUserId = Number(joinRequest2.receiver.id!);
+        rejectRequestId = joinRequest2.id!;
+        console.log(`Member3 created join request ${rejectRequestId}`);
+      }
+
+      // Admin approves first request and rejects second request
+      logout();
+      authenticateWeb(adminUser.login, "password");
+
+      // Admin verifies join requests appear in the community's invitations list
+      const pendingRequests = listCommunityInvitations(communityId);
+      const foundRequest1 = findInvitationById(
+        acceptRequestId!,
+        pendingRequests,
+      );
+      const foundRequest2 = findInvitationById(
+        rejectRequestId!,
+        pendingRequests,
+      );
+
+      check(foundRequest1, {
+        "Member2 join request found in invitations list": (r) => r !== null,
+        "Member2 join request has REQUEST status": (r) =>
+          r !== null && r.status === InvitationStatus.REQUEST,
+      });
+
+      check(foundRequest2, {
+        "Member3 join request found in invitations list": (r) => r !== null,
+        "Member3 join request has REQUEST status": (r) =>
+          r !== null && r.status === InvitationStatus.REQUEST,
+      });
+
+      // Admin approves the first request
+      const approvedRequest = updateRequestStatus(
+        communityId,
+        acceptRequestId!,
+        InvitationStatus.REQUEST_ACCEPTED,
+      );
+
+      check(approvedRequest, {
+        "Join request approved successfully": (r) => r !== null,
+        "Status changed to REQUEST_ACCEPTED": (r) =>
+          r !== null && r.status === InvitationStatus.REQUEST_ACCEPTED,
+      });
+
+      // Admin rejects the second request
+      const rejectedRequest = updateRequestStatus(
+        communityId,
+        rejectRequestId!,
+        InvitationStatus.REQUEST_REJECTED,
+      );
+
+      check(rejectedRequest, {
+        "Join request rejected successfully": (r) => r !== null,
+        "Status changed to REQUEST_REJECTED": (r) =>
+          r !== null && r.status === InvitationStatus.REQUEST_REJECTED,
+      });
+
+      // Verify that Member2 is now a member
+      const memberships = listCommunityMembers(communityId);
+      const member2Membership = acceptedUserId
+        ? findMembershipByUserId(memberships, acceptedUserId)
+        : null;
+
+      check(member2Membership, {
+        "Approved user is now a member": (m) => m !== null,
+        "Member has correct role": (m) =>
+          m !== null && m.role === MembershipRole.MEMBER,
+      });
+
+      // Verify that Member3 is NOT a member
+      const member3Membership = rejectedUserId
+        ? findMembershipByUserId(memberships, rejectedUserId)
+        : null;
+
+      check(member3Membership, {
+        "Rejected user is not a member": (m) => m === null,
+      });
+    });
+
+    // Test see-later flag functionality
+    describe("Member tests see-later flag functionality", () => {
+      // First, login as admin
+      logout();
+      authenticateWeb(adminUser.login, "password");
+
+      // Create a new invitation to test see-later flag
+      const seeLaterInvitationData: CreateInvitationParams = {
+        users: [{ userId: member3User.id, role: MembershipRole.MEMBER }],
+        message: "This invitation will be marked as see later",
+      };
+
+      const seeLaterInvitations = createInvitations(communityId, seeLaterInvitationData);
+
+      check(seeLaterInvitations, {
+        "See-later test invitation created successfully": (r) => r !== null && r.length > 0,
+      });
+
+      if (!seeLaterInvitations || seeLaterInvitations.length === 0) {
+        console.error("Failed to create see-later test invitation");
+        return;
+      }
+
+      const seeLaterInvitationId = seeLaterInvitations[0].id;
+      console.log(`Created invitation with ID: ${seeLaterInvitationId} for see-later test`);
+
+      // Member logs in
+      logout();
+      authenticateWeb(member3User.login, "password");
+
+      // Check that the invitation exists in the member's list
+      const initialInvitations = listMyInvitations();
+      const initialInvitation = findInvitationById(seeLaterInvitationId, initialInvitations);
+
+      check(initialInvitation, {
+        "See-later invitation found in member's list": (r) => r !== null,
+        "See-later flag is initially false": (r) => r !== null && r.seeLater === false,
+      });
+
+      // Update the see-later flag to true
+      const updatedInvitation = updateInvitationSeeLater(seeLaterInvitationId, true);
+
+      check(updatedInvitation, {
+        "See-later flag updated successfully": (r) => r !== null,
+        "See-later flag set to true": (r) => r !== null && r.seeLater === true,
+      });
+
+      // Verify the see-later flag is persisted when listing invitations again
+      const filteredInvitations = listMyInvitations({ seeLater: true });
+
+      check(filteredInvitations, {
+        "Can filter invitations by see-later flag": (r) => r !== null && r.items.length > 0,
+        "Filtered list contains our marked invitation": (r) =>
+          r !== null && r.items.some((inv: Invitation) => inv.id === seeLaterInvitationId),
+      });
+
+      // Change see-later flag back to false
+      const updatedAgainInvitation = updateInvitationSeeLater(seeLaterInvitationId, false);
+
+      check(updatedAgainInvitation, {
+        "See-later flag turned off successfully": (r) => r !== null,
+        "See-later flag set back to false": (r) => r !== null && r.seeLater === false,
+      });
+
+      // Verify filtering with seeLater=false
+      const nonSeeLaterInvitations = listMyInvitations({ seeLater: false });
+
+      check(nonSeeLaterInvitations, {
+        "Can filter invitations by see-later=false": (r) => r !== null,
+        "Filtered list contains our unmarked invitation": (r) =>
+          r !== null && r.items.some((inv: Invitation) => inv.id === seeLaterInvitationId),
+      });
+    });
+
+    // Final Step: Cleanup - Delete the community
+    describe("Cleanup - Delete test community", () => {
+      // Assurez-vous que l'admin est connecté pour supprimer la communauté
+      logout();
+      authenticateWeb(adminUser.login, "password");
+      
+      const deleted = deleteCommunity(communityId);
+
+      check(deleted, {
+        "community deleted successfully": (r) => r === true,
+      });
+    });
+  });
+}