@edifice.io/communities-tests 1.0.0-develop-pedago.9.1753990538887 → 1.1.3

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

@@ -0,0 +1,270 @@
+// @ts-ignore
+import { chai, describe } from "https://jslib.k6.io/k6chaijs/4.3.4.0/index.js";
+import { check } from "k6";
+
+import {
+  authenticateWeb,
+  getUsersOfSchool,
+  createAndSetRole,
+  linkRoleToUsers,
+  initStructure,
+  getRandomUserWithProfile,
+  getRolesOfStructure,
+  Structure,
+  logout,
+  UserInfo,
+  checkReturnCode,
+} from "../../node_modules/edifice-k6-commons/dist/index.js";
+
+// Import community API utils
+import {
+  createCommunityOrFail,
+  deleteCommunity,
+  CreateCommunityParams,
+  getCommunity,
+  Community,
+} from "./utils/_community-api.utils.ts";
+import {
+  countAnnouncements,
+  createAnnouncement,
+  deleteAnnouncement,
+  getAnnouncement,
+  listAnnouncements,
+  updateAnnouncement,
+} from "./utils/_announcements-api.utils.ts";
+import {
+  InvitationStatus,
+  listMyInvitations,
+  updateInvitationStatus,
+} from "./utils/_invitation-api.utils.ts";
+
+chai.config.logFailures = true;
+
+export const options = {
+  setupTimeout: "1h",
+  maxRedirects: 0,
+  thresholds: {
+    checks: ["rate == 1.00"],
+  },
+  scenarios: {
+    announcementsTest: {
+      exec: "testAnnouncementsApi",
+      executor: "per-vu-iterations",
+      vus: 1,
+      maxDuration: "1m",
+      gracefulStop: "5s",
+    },
+  },
+};
+
+const timestamp = new Date().toISOString();
+const schoolName = `IT Community`;
+
+function acceptInvitation(user: UserInfo) {
+  authenticateWeb(user.login, "password");
+  listMyInvitations()?.items.forEach((inv) =>
+    updateInvitationStatus(inv.id, InvitationStatus.ACCEPTED),
+  );
+  logout();
+}
+
+export function setup(): [UserInfo, UserInfo, UserInfo, Community] {
+  //Create structure
+  let structure: Structure = {} as Structure;
+  describe("[CommunityAnnouncements] 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),
+    );
+  });
+
+  // Get users from school
+  const users = getUsersOfSchool(structure);
+  const adminUser1 = getRandomUserWithProfile(users, "Teacher");
+  const adminUser2 = getRandomUserWithProfile(users, "Teacher", [adminUser1]);
+  const memberUser = getRandomUserWithProfile(users, "Student", [
+    adminUser1,
+    adminUser2,
+  ]);
+  logout();
+
+  //Create a test community with 2 admins and 1 member
+  const communityData: CreateCommunityParams = {
+    title: `AnnouncementTest - Community ${timestamp}`,
+    type: "FREE",
+    schoolYearStart: 2025,
+    schoolYearEnd: 2026,
+    discussionEnabled: true,
+    welcomeNote: "Test community for announcements API tests",
+    invitations: {
+      users: [
+        { userId: adminUser2.id, role: "ADMIN" },
+        { userId: memberUser.id, role: "MEMBER" },
+      ],
+    },
+  };
+  authenticateWeb(adminUser1.login, "password");
+  const communityId = Number(createCommunityOrFail(communityData));
+  const community = getCommunity(communityId);
+  logout();
+  acceptInvitation(adminUser2);
+  acceptInvitation(memberUser);
+
+  return [adminUser1, adminUser2, memberUser, community!];
+}
+
+export function testAnnouncementsApi(
+  data: [UserInfo, UserInfo, UserInfo, Community],
+) {
+  const [adminUser1, adminUser2, memberUser, community] = data;
+  const communityId = Number(community.id);
+
+  //Login as admin 1
+  authenticateWeb(adminUser1.login);
+
+  //Check list announcements initially empty
+  let announcements = listAnnouncements(communityId);
+  check(announcements, {
+    "Announcement list should be initially empty": (r) => r?.items.length == 0,
+  });
+
+  //Check announcement A creation
+  const mediaList = [
+    {
+      id: "1",
+      name: "media 1",
+      type: "audio",
+      mimeType: "foo",
+      url: "bar",
+    },
+    {
+      id: "2",
+      name: "media 2",
+      type: "image",
+      mimeType: "foo",
+      url: "bar",
+    },
+  ];
+  const createA = createAnnouncement(communityId, {
+    content: "Announcement A",
+    media: mediaList,
+  });
+  checkReturnCode(
+    createA,
+    `Admin 1 should be able to create announcement A`,
+    201,
+  );
+  const idA = Number(JSON.parse(<string>createA.body).id);
+  announcements = listAnnouncements(communityId);
+  check(announcements, {
+    "Announcement list should be of size 1": (r) => r?.items.length == 1,
+  });
+  const announcementA = getAnnouncement(communityId, idA);
+  check(announcementA, {
+    "Announcement A should be correct": (r) => {
+      return (
+        r?.author.entId == adminUser1.id &&
+        r.content == "Announcement A" &&
+        r.media.length == 2 &&
+        r.media.at(0)!.name == "media 1"
+      );
+    },
+  });
+  logout();
+
+  //Login as admin 2
+  authenticateWeb(adminUser2.login);
+
+  //Check announcement B creation
+  const timeBeforeB = new Date().toISOString();
+  const createB = createAnnouncement(communityId, {
+    content: "Announcement B",
+    media: [],
+  });
+  checkReturnCode(
+    createA,
+    `Admin 2 should be able to create announcement B`,
+    201,
+  );
+  const idB = Number(JSON.parse(<string>createB.body).id);
+  announcements = listAnnouncements(communityId);
+  check(announcements, {
+    "Announcement list should be of size 2": (r) => r?.items.length == 2,
+  });
+
+  //Check announcement A modification
+  const announcementAModif = updateAnnouncement(communityId, idA, {
+    content: "Oui bonjour",
+    media: mediaList.reverse(),
+  });
+  check(announcementAModif, {
+    "Admin 2 should be able to modify announcement": (r) => {
+      return (
+        r?.author.entId == adminUser1.id &&
+        r.content == "Oui bonjour" &&
+        Date.parse(r.modificationDate) > Date.parse(r.publicationDate) &&
+        r.modifier.entId == adminUser2.id &&
+        r.media.length == 2 &&
+        r.media.at(0)!.name == "media 2"
+      );
+    },
+  });
+  logout();
+
+  //Login as member
+  authenticateWeb(memberUser.login);
+
+  //Check filtering and ordering on GET requests
+  check(countAnnouncements(communityId), {
+    "Member should count 2 announcements": (n) => n?.count == 2,
+  });
+  check(countAnnouncements(communityId, timeBeforeB), {
+    "Member should count 1 announcement with filtering": (n) => n?.count == 1,
+  });
+  check(listAnnouncements(communityId, 1, 10, timeBeforeB), {
+    "Member should list 1 announcement with filtering": (n) =>
+      n?.meta.itemCount == 1,
+  });
+  check(listAnnouncements(communityId, 1, 10, null, "publicationDate", "ASC"), {
+    "List with ASC order should be in correct order": (li) =>
+      li?.items.at(0)?.id == idA && li?.items.at(1)?.id == idB,
+  });
+  check(listAnnouncements(communityId, 1, 10, null, "modificationDate"), {
+    "List by modification date should be in correct order": (li) =>
+      li?.items.at(0)?.id == idA && li?.items.at(1)?.id == idB,
+  });
+
+  //Check that member cannot create/update/delete announcements
+  checkReturnCode(
+    createAnnouncement(communityId, { content: "foo", media: [] }),
+    "Member should not be able to create announcement",
+    403,
+  );
+  check(updateAnnouncement(communityId, idB, { content: "foo", media: [] }), {
+    "Member should not be able to update announcement B": (b) => b == null,
+  });
+  check(deleteAnnouncement(communityId, idB), {
+    "Member should not be able to delete Announcement B": (b) => !b,
+  });
+  logout();
+
+  //Login as admin1
+  authenticateWeb(adminUser1.login);
+  check(deleteAnnouncement(communityId, idB), {
+    "Admin 1 should be able to delete Announcement B": (b) => b,
+  });
+  logout();
+}
+
+//Cleanup: delete test community
+export function teardown(data: [UserInfo, UserInfo, UserInfo, Community]) {
+  const [adminUser, , , community] = data;
+  authenticateWeb(adminUser.login, "password");
+  deleteCommunity(community.id);
+  logout();
+}

package/it/scenarios/api-community-role-check.spec.ts

@@ -80,7 +80,7 @@ export const options = {
   },
 };
 
-const schoolName = `IT Community Roles`;
+const schoolName = `IT Community`;
 
 // Setup function to create structure and configure roles
 export function setup(): Structure {

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

@@ -0,0 +1,306 @@
+// @ts-ignore
+import { chai, describe } from "https://jslib.k6.io/k6chaijs/4.3.4.0/index.js";
+import { check } from "k6";
+
+import {
+  authenticateWeb,
+  getUsersOfSchool,
+  createAndSetRole,
+  linkRoleToUsers,
+  initStructure,
+  getRandomUserWithProfile,
+  getRolesOfStructure,
+  Structure,
+  logout,
+  UserInfo,
+  checkReturnCode,
+} from "../../node_modules/edifice-k6-commons/dist/index.js";
+
+//Import community API utils
+import {
+  createCommunityOrFail,
+  deleteCommunity,
+  CreateCommunityParams,
+  getCommunity,
+  Community,
+} from "./utils/_community-api.utils.ts";
+import {
+  getFolders,
+  getRootFolders,
+  createFolder,
+  updateFolder,
+  getFolderContent,
+  removeFolder,
+  addResourceToFolder,
+  removeResourceFromFolder,
+  Folder,
+  PaginatedFolders,
+  FolderDetails,
+} from "./utils/_folders-api.utils.ts";
+import {
+  InvitationStatus,
+  listMyInvitations,
+  updateInvitationStatus,
+} from "./utils/_invitation-api.utils.ts";
+import {
+  AppName,
+  createResource,
+  ResourceType,
+} from "./utils/_resource-api.utils.ts";
+import { HttpError } from "./utils/_http-response.utils.ts";
+
+chai.config.logFailures = true;
+
+export const options = {
+  setupTimeout: "1h",
+  maxRedirects: 0,
+  thresholds: {
+    checks: ["rate == 1.00"],
+  },
+  scenarios: {
+    foldersTest: {
+      exec: "testFoldersApi",
+      executor: "per-vu-iterations",
+      vus: 1,
+      maxDuration: "1m",
+      gracefulStop: "5s",
+    },
+  },
+};
+
+const timestamp = new Date().toISOString();
+const schoolName = `IT Community`;
+
+function acceptInvitation(user: UserInfo) {
+  authenticateWeb(user.login, "password");
+  listMyInvitations()?.items.forEach((inv) =>
+    updateInvitationStatus(inv.id, InvitationStatus.ACCEPTED),
+  );
+  logout();
+}
+
+export function setup(): [UserInfo, UserInfo, Community] {
+  //Create structure
+  let structure: Structure = {} as Structure;
+  describe("[CommunityFolders] 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),
+    );
+  });
+
+  // Get users from school
+  const users = getUsersOfSchool(structure);
+  const adminUser = getRandomUserWithProfile(users, "Teacher");
+  const memberUser = getRandomUserWithProfile(users, "Student", [adminUser]);
+  logout();
+
+  //Create a test community with 2 admins and 1 member
+  const communityData: CreateCommunityParams = {
+    title: `FolderTest - Community ${timestamp}`,
+    type: "FREE",
+    schoolYearStart: 2025,
+    schoolYearEnd: 2026,
+    discussionEnabled: true,
+    welcomeNote: "Test community for folders API tests",
+    invitations: {
+      users: [{ userId: memberUser.id, role: "MEMBER" }],
+    },
+  };
+  authenticateWeb(adminUser.login, "password");
+  const communityId = Number(createCommunityOrFail(communityData));
+  const community = getCommunity(communityId);
+  logout();
+  acceptInvitation(memberUser);
+
+  return [adminUser, memberUser, community!];
+}
+
+export function testFoldersApi(data: [UserInfo, UserInfo, Community]) {
+  const [adminUser, memberUser, community] = data;
+  const communityId = Number(community.id);
+
+  //Login as admin
+  authenticateWeb(adminUser.login);
+
+  //Check list folders initially empty
+  let folders = getFolders(communityId).value as PaginatedFolders;
+  check(folders, {
+    "Folder list should be initially empty": (res) => res?.items.length == 0,
+  });
+
+  //Check folder creation
+  const folderA = createFolder(communityId, {
+    name: "Folder A",
+  }).value as Folder;
+  check(folderA, {
+    "Admin should be able to create root folder A": (res) => {
+      return res?.name == "Folder A" && res?.isRoot == true;
+    },
+  });
+  const idA = Number(folderA?.id);
+  folders = getFolders(communityId).value as PaginatedFolders;
+  check(folders, {
+    "Folder list should be of size 1": (res) => res?.items.length == 1,
+  });
+
+  //Check subfolder creation
+  const folderB = createFolder(communityId, {
+    name: "Folder B",
+    parentId: idA,
+  }).value as Folder;
+  check(folderB, {
+    "Admin should be able to create subfolder B": (res) => {
+      return (
+        res?.name == "Folder B" && res?.isRoot == false && res?.parentId == idA
+      );
+    },
+  });
+  const idB = Number(folderB?.id);
+  folders = getFolders(communityId).value as PaginatedFolders;
+  check(folders, {
+    "Folder list should be of size 2": (res) => res?.items.length == 2,
+  });
+  let rootFolders = getRootFolders(communityId).value as Folder[];
+  check(rootFolders, {
+    "Root folders list should still be of size 1": (res) => res?.length == 1,
+  });
+
+  //Check folder filtering by parent
+  let folderSearch = getFolders(communityId, 1, 10, undefined, idA)
+    .value as PaginatedFolders;
+  check(folderSearch, {
+    "Folder A should have 1 subfolder": (res) => res?.items.length == 1,
+  });
+  let folderDetails = getFolderContent(communityId, idA).value as FolderDetails;
+  check(folderDetails, {
+    "Folder details should show subfolder B": (res) =>
+      res?.subFolders?.at(0)?.id == idB,
+  });
+
+  //Check folder modification
+  const folderBModif = updateFolder(communityId, idB, {
+    name: "Root B",
+  }).value as Folder;
+  check(folderBModif, {
+    "Subfolder should be moved to the root": (res) => {
+      return (
+        Date.parse(res?.modificationDate!) > Date.parse(res?.creationDate!) &&
+        res?.modifier?.entId == adminUser.id &&
+        res?.isRoot
+      );
+    },
+  });
+  rootFolders = getRootFolders(communityId).value as Folder[];
+  check(rootFolders, {
+    "Root folders list should be of size 2": (res) => res?.length == 2,
+  });
+  //Check folder filtering by parent
+  folderSearch = getFolders(communityId, 1, 10, undefined, idA)
+    .value as PaginatedFolders;
+  check(folderSearch, {
+    "Folder A should now have 0 subfolder": (res) => res?.items.length == 0,
+  });
+
+  //Create test resources
+  const resourceCreate1 = {
+    type: ResourceType.EXTERNAL_LINK,
+    appName: AppName.EXTERNAL_LINK,
+    title: "coin coin",
+    resourceUrl: "duckduckgo.com",
+  };
+  const resource = createResource(communityId, resourceCreate1);
+  const resourceAdd = addResourceToFolder(communityId, idA, resource?.id!)
+    .value as boolean;
+  check(resourceAdd, {
+    "Resource should be added to folder A": (add) => add,
+  });
+  folderDetails = getFolderContent(communityId, idA).value as FolderDetails;
+  check(folderDetails, {
+    "Folder details should show resource, and no subfolder": (res) =>
+      res?.resources?.at(0)?.id == resource?.id && res?.subFolders?.length == 0,
+  });
+
+  //Move resources
+  const resourceMove = addResourceToFolder(communityId, idB, resource?.id!)
+    .value as boolean;
+  check(resourceMove, {
+    "Resource should be added to folder B": (add) => add,
+  });
+  folderDetails = getFolderContent(communityId, idB).value as FolderDetails;
+  check(folderDetails, {
+    "Folder details should show resource on folder B": (res) =>
+      res?.resources?.at(0)?.id == resource?.id,
+  });
+  folderDetails = getFolderContent(communityId, idA).value as FolderDetails;
+  check(folderDetails, {
+    "Resource should be removed from folder A": (res) =>
+      res?.resources?.length == 0,
+  });
+
+  //Delete resource
+  removeResourceFromFolder(communityId, idB, resource?.id!);
+  folderDetails = getFolderContent(communityId, idB).value as FolderDetails;
+  check(folderDetails, {
+    "Resource should be removed from folder B": (res) =>
+      res?.resources?.length == 0,
+  });
+
+  logout();
+
+  //Login as member
+  authenticateWeb(memberUser.login);
+
+  //Check GET requests
+  check(getFolders(communityId, 1, 10).value as PaginatedFolders, {
+    "Member should list 2 folders without filtering": (res) =>
+      res?.meta.itemCount == 2,
+  });
+  check(getFolders(communityId, 1, 10, "Folder").value as PaginatedFolders, {
+    "Member should list 1 folders with name filtering": (res) =>
+      res?.meta.itemCount == 1,
+  });
+
+  //Check that member cannot create/update/delete folders
+  checkReturnCode(
+    createFolder(communityId, { name: "foo" }).value as HttpError,
+    "Member should not be able to create folder",
+    403,
+  );
+  checkReturnCode(
+    updateFolder(communityId, idB, { name: "foo" }).value as HttpError,
+    "Member should not be able to update folder",
+    403,
+  );
+  checkReturnCode(
+    removeFolder(communityId, idB).value as HttpError,
+    "Member should not be able to delete folder",
+    403,
+  );
+
+  logout();
+
+  //Check folder deletion
+  authenticateWeb(adminUser.login);
+  const deleteFolder = removeFolder(communityId, idA).value as boolean;
+  check(deleteFolder, {
+    "Admin should be able to delete folder": (res) => res,
+  });
+  check(getFolders(communityId, 1, 10).value as PaginatedFolders, {
+    "Folder should be correctly deleted": (res) => res?.meta.itemCount == 1,
+  });
+  logout();
+}
+
+//Cleanup: delete test community
+export function teardown(data: [UserInfo, UserInfo, Community]) {
+  const [adminUser, , community] = data;
+  authenticateWeb(adminUser.login, "password");
+  deleteCommunity(community.id);
+  logout();
+}

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

@@ -57,7 +57,7 @@ export const options = {
 };
 
 const timestamp = new Date().toISOString();
-const schoolName = `IT Community Invitations Search Sort`;
+const schoolName = `IT Community`;
 
 export function setup(): Structure {
   let structure: Structure = {} as Structure;

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

@@ -67,7 +67,7 @@ export const options = {
 };
 
 const timestamp = new Date().toISOString();
-const schoolName = `IT Community Invitations`;
+const schoolName = `IT Community`;
 
 export function setup(): Structure {
   let structure: Structure = {} as Structure;
@@ -504,10 +504,14 @@ export function testInvitationsApi(structure: Structure) {
         message: "This invitation will be marked as see later",
       };
 
-      const seeLaterInvitations = createInvitations(communityId, seeLaterInvitationData);
+      const seeLaterInvitations = createInvitations(
+        communityId,
+        seeLaterInvitationData,
+      );
 
       check(seeLaterInvitations, {
-        "See-later test invitation created successfully": (r) => r !== null && r.length > 0,
+        "See-later test invitation created successfully": (r) =>
+          r !== null && r.length > 0,
       });
 
       if (!seeLaterInvitations || seeLaterInvitations.length === 0) {
@@ -516,7 +520,9 @@ export function testInvitationsApi(structure: Structure) {
       }
 
       const seeLaterInvitationId = seeLaterInvitations[0].id;
-      console.log(`Created invitation with ID: ${seeLaterInvitationId} for see-later test`);
+      console.log(
+        `Created invitation with ID: ${seeLaterInvitationId} for see-later test`,
+      );
 
       // Member logs in
       logout();
@@ -524,15 +530,22 @@ export function testInvitationsApi(structure: Structure) {
 
       // Check that the invitation exists in the member's list
       const initialInvitations = listMyInvitations();
-      const initialInvitation = findInvitationById(seeLaterInvitationId, initialInvitations);
+      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,
+        "See-later flag is initially false": (r) =>
+          r !== null && r.seeLater === false,
       });
 
       // Update the see-later flag to true
-      const updatedInvitation = updateInvitationSeeLater(seeLaterInvitationId, true);
+      const updatedInvitation = updateInvitationSeeLater(
+        seeLaterInvitationId,
+        true,
+      );
 
       check(updatedInvitation, {
         "See-later flag updated successfully": (r) => r !== null,
@@ -543,17 +556,23 @@ export function testInvitationsApi(structure: Structure) {
       const filteredInvitations = listMyInvitations({ seeLater: true });
 
       check(filteredInvitations, {
-        "Can filter invitations by see-later flag": (r) => r !== null && r.items.length > 0,
+        "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),
+          r !== null &&
+          r.items.some((inv: Invitation) => inv.id === seeLaterInvitationId),
       });
 
       // Change see-later flag back to false
-      const updatedAgainInvitation = updateInvitationSeeLater(seeLaterInvitationId, 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,
+        "See-later flag set back to false": (r) =>
+          r !== null && r.seeLater === false,
       });
 
       // Verify filtering with seeLater=false
@@ -562,7 +581,8 @@ export function testInvitationsApi(structure: Structure) {
       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),
+          r !== null &&
+          r.items.some((inv: Invitation) => inv.id === seeLaterInvitationId),
       });
     });
 
@@ -571,7 +591,7 @@ export function testInvitationsApi(structure: Structure) {
       // Assurez-vous que l'admin est connecté pour supprimer la communauté
       logout();
       authenticateWeb(adminUser.login, "password");
-      
+
       const deleted = deleteCommunity(communityId);
 
       check(deleted, {