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

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

@@ -36,10 +36,10 @@ import {
 } from "./utils/_membership-api.utils.ts";
 
 // Import invitation API utils for join workflow
-import { 
+import {
   joinCommunity,
   updateRequestStatus,
-  InvitationStatus 
+  InvitationStatus,
 } from "./utils/_invitation-api.utils.ts";
 
 chai.config.logFailures = true;
@@ -62,7 +62,7 @@ export const options = {
 };
 
 const timestamp = new Date().toISOString();
-const schoolName = `IT Community Memberships`;
+const schoolName = `IT Community`;
 
 export function setup(): Structure {
   let structure: Structure = {} as Structure;
@@ -131,7 +131,7 @@ export function testMembershipApi(structure: Structure) {
       console.log(`Retrieved secret code: ${secretCode}`);
     });
 
-    // Step 3: Member creates join request with secret code 
+    // Step 3: Member creates join request with secret code
     describe("Member creates join request with secret code", () => {
       // Authenticate as member
       logout();
@@ -144,29 +144,31 @@ export function testMembershipApi(structure: Structure) {
       const joinRequest = joinCommunity(secretCode);
       check(joinRequest, {
         "Join request created successfully": (r) => r !== null,
-        "Join request has REQUEST status": (r) => 
+        "Join request has REQUEST status": (r) =>
           r !== null && r.status === InvitationStatus.REQUEST,
       });
-      
+
       // Store the invitation ID and user ID for later approval
       const invitationId = joinRequest?.id;
       currentUserId = Number(joinRequest?.receiver?.id);
-      console.log(`Created join request with ID: ${invitationId} for user ID: ${currentUserId}`);
-      
+      console.log(
+        `Created join request with ID: ${invitationId} for user ID: ${currentUserId}`,
+      );
+
       // Step 4: Admin approves the join request
       logout();
       authenticateWeb(adminUser.login, "password");
-      
+
       // Approve join request
       const approvedRequest = updateRequestStatus(
-        communityId, 
-        invitationId!, 
-        InvitationStatus.REQUEST_ACCEPTED
+        communityId,
+        invitationId!,
+        InvitationStatus.REQUEST_ACCEPTED,
       );
-      
+
       check(approvedRequest, {
         "Join request approved successfully": (r) => r !== null,
-        "Status changed to REQUEST_ACCEPTED": (r) => 
+        "Status changed to REQUEST_ACCEPTED": (r) =>
           r !== null && r.status === InvitationStatus.REQUEST_ACCEPTED,
       });
     });
@@ -264,19 +266,19 @@ export function testMembershipApi(structure: Structure) {
       check(joinRequest, {
         "Join request created successfully": (r) => r !== null,
       });
-      
+
       // Store the invitation ID
       const invitationId = joinRequest?.id;
-      
+
       // Admin approves the request
       logout();
       authenticateWeb(adminUser.login, "password");
-      
+
       // Approve join request
       updateRequestStatus(
-        communityId, 
-        invitationId!, 
-        InvitationStatus.REQUEST_ACCEPTED
+        communityId,
+        invitationId!,
+        InvitationStatus.REQUEST_ACCEPTED,
       );
 
       // Admin removes the member
@@ -357,12 +359,12 @@ export function testMembershipApi(structure: Structure) {
       authenticateWeb(adminUser.login, "password");
       for (let i = 0; i < testMemberInvitationIds.length; i++) {
         updateRequestStatus(
-          communityId, 
-          testMemberInvitationIds[i], 
-          InvitationStatus.REQUEST_ACCEPTED
+          communityId,
+          testMemberInvitationIds[i],
+          InvitationStatus.REQUEST_ACCEPTED,
         );
       }
-      
+
       // Verify all users are now members
       const membersBeforeRemoval = listCommunityMembers(communityId);
       check(membersBeforeRemoval, {

package/it/scenarios/api-permission-check.spec.ts

@@ -84,7 +84,7 @@ export const options = {
   },
 };
 
-const schoolName = `IT Community Permissions Tests V2`;
+const schoolName = `IT Community`;
 // Setup function to create structure and configure roles
 export function setup(): StructureWithRole {
   let structure: StructureWithRole = {} as StructureWithRole;

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

@@ -38,6 +38,7 @@ import {
   SortDirection,
   listResourcesWithSearch,
 } from "./utils/_resource-api.utils.ts";
+import { createFolder, Folder } from "./utils/_folders-api.utils.ts";
 
 chai.config.logFailures = true;
 
@@ -60,7 +61,7 @@ export const options = {
 
 // Generate unique timestamp for test resources
 const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-const schoolName = `Resources Search Sort Test ${timestamp}`;
+const schoolName = `IT Community`;
 
 /**
  * Setup function to prepare test environment and assign permissions
@@ -102,7 +103,7 @@ export function testResourcesSearchSort(structure: Structure) {
   };
 
   // Resource test data
-  const resourceTestData = [
+  let resourceTestData = [
     {
       type: ResourceType.ENT,
       appName: AppName.EXTERNAL_LINK,
@@ -136,6 +137,7 @@ export function testResourcesSearchSort(structure: Structure) {
       appName: AppName.EXTERNAL_LINK,
       title: "Epsilon Blog Resource",
       resourceUrl: "https://example.com/delta",
+      folderId: -1, // Placeholder. Folder id will be updated once the test folder is created
     },
   ];
 
@@ -143,6 +145,7 @@ export function testResourcesSearchSort(structure: Structure) {
   let adminUser: UserInfo;
   let memberUser: UserInfo;
   const resourceIds: number[] = [];
+  let folderId: number;
 
   describe("[Resource Search and Sort API Test]", () => {
     // Get test users as admin
@@ -163,6 +166,18 @@ export function testResourcesSearchSort(structure: Structure) {
       communityId = Number(createCommunityOrFail(communityData));
       console.log(`Created community with ID: ${communityId}`);
 
+      const folder = createFolder(communityId, { name: "Test Folder" })
+        .value as Folder;
+      folderId = folder.id;
+      console.log(`Created folder with ID: ${folderId}`);
+      // Assign correct folder id to resource data with folderId property
+      resourceTestData = resourceTestData.map((resource) => {
+        if (typeof resource.folderId !== "undefined") {
+          resource.folderId = folderId;
+        }
+        return resource;
+      });
+
       // Create test resources with small delay between them for reliable date sorting
       for (const data of resourceTestData) {
         const resource = createResource(communityId, data);
@@ -310,6 +325,30 @@ export function testResourcesSearchSort(structure: Structure) {
       });
     });
 
+    // Test filtering by folder ID
+    group("Filter by folder ID", () => {
+      const folderSearch = listResourcesWithSearch(communityId, {
+        folderId,
+      });
+      check(folderSearch, {
+        "Filtering by folder ID returns results": (r) =>
+          r !== null && r.items && r.items.length > 0,
+        "All results are in correct folder": (r) =>
+          r !== null &&
+          r.items &&
+          r.items.every((item) => item.folderId == folderId),
+      });
+      const rootResources = listResourcesWithSearch(communityId);
+      check(rootResources, {
+        "Not providing folder ID returns results": (r) =>
+          r !== null && r.items && r.items.length > 0,
+        "All results have no folder defined": (r) =>
+          r !== null &&
+          r.items &&
+          r.items.every((item) => item.folderId === undefined),
+      });
+    });
+
     // Test sorting capabilities
     group("Sort resources by different fields", () => {
       // Test sorting by addedDate ASC
@@ -325,22 +364,29 @@ export function testResourcesSearchSort(structure: Structure) {
 
       // Verify ASC order - first item should have earliest date
       if (dateAsc && dateAsc.items && dateAsc.items.length > 1) {
-        const dateArray = dateAsc.items.map(item => new Date(item.addedDate).getTime());
-        
+        const dateArray = dateAsc.items.map((item) =>
+          new Date(item.addedDate).getTime(),
+        );
+
         // Log dates to help debug sorting issues
-        console.log("Dates in ASC order:", dateArray.map(d => new Date(d).toISOString()));
-        
+        console.log(
+          "Dates in ASC order:",
+          dateArray.map((d) => new Date(d).toISOString()),
+        );
+
         const sortedCorrectly = dateArray.slice(1).every((curr, i) => {
           const prev = dateArray[i];
           const isCorrectlySorted = curr >= prev;
-          
+
           if (!isCorrectlySorted) {
-            console.log(`Sorting issue at index ${i}: ${new Date(prev).toISOString()} should be <= ${new Date(curr).toISOString()}`);
+            console.log(
+              `Sorting issue at index ${i}: ${new Date(prev).toISOString()} should be <= ${new Date(curr).toISOString()}`,
+            );
           }
-          
+
           return isCorrectlySorted;
         });
-        
+
         check(dateAsc, {
           "Resources are correctly sorted by date ASC": () => sortedCorrectly,
         });
@@ -465,7 +511,10 @@ export function testResourcesSearchSort(structure: Structure) {
           "First page returns correct number of items": (r) =>
             r !== null && r.items && r.items.length === 2,
           [`First page has correct pagination metadata`]: (r) =>
-            r !== null && r.meta && r.meta.currentPage === 1 && r.meta.itemCount === 2,
+            r !== null &&
+            r.meta &&
+            r.meta.currentPage === 1 &&
+            r.meta.itemCount === 2,
         });
 
         // Get second page
@@ -477,7 +526,10 @@ export function testResourcesSearchSort(structure: Structure) {
         check(secondPage, {
           "Second page returns results": (r) => r !== null && !!r.items,
           "Second page has correct pagination metadata": (r) =>
-            r !== null && r.meta && r.meta.currentPage === 2 && r.meta.itemCount === 2,
+            r !== null &&
+            r.meta &&
+            r.meta.currentPage === 2 &&
+            r.meta.itemCount === 2,
           "Pages return different resources": (r) => {
             if (!r || !r.items || !firstPage || !firstPage.items) return false;
 

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

@@ -59,7 +59,7 @@ export const options = {
 };
 
 const timestamp = new Date().toISOString();
-const schoolName = `IT Resources Test`;
+const schoolName = `IT Community`;
 
 // List of app types to test
 // You can adjust this list based on which app types you want to test
@@ -156,12 +156,7 @@ export function testResourcesApi(structure: Structure) {
     for (const appType of APP_TYPES_TO_TEST) {
       group(`Testing ${appType} resources`, () => {
         const resource = DEFAULT_TEST_CONFIGS[appType];
-        testResourceManagement(
-          communityId,
-          resource,
-          adminUser,
-          memberUser,
-        );
+        testResourceManagement(communityId, resource, adminUser, memberUser);
       });
     }
 

package/it/scenarios/utils/_announcements-api.utils.ts

@@ -0,0 +1,195 @@
+import http, { RefinedResponse } from "k6/http";
+import { getHeaders } from "../../../node_modules/edifice-k6-commons/dist/index.js";
+
+//Types
+export type User = {
+  id: number;
+  displayName: string;
+  entId: string;
+  profile: string;
+};
+
+export type Media = {
+  id: string;
+  name: string;
+  type: string;
+  mimeType: string;
+  url: string;
+};
+
+export type Announcement = {
+  id: number;
+  content: string;
+  media: Media[];
+  publicationDate: string;
+  modificationDate: string;
+  author: User;
+  modifier: User;
+  communityId: number;
+};
+
+export type AnnouncementCount = {
+  count: number;
+};
+
+export type CreateAnnouncementParams = {
+  content: string;
+  media: Media[];
+};
+
+export type UpdateAnnouncementParams = {
+  content: string;
+  media: Media[];
+};
+
+export type PaginatedAnnouncements = {
+  items: Announcement[];
+  meta: {
+    totalItems: number;
+    currentPage: number;
+    itemCount: number;
+    totalPages: number;
+  };
+};
+
+const rootUrl = __ENV.ROOT_URL || "";
+function baseUrl(id: number): string {
+  return `${rootUrl}/communities/api/communities/${id}/announcements`;
+}
+function makeHeaders(): object {
+  return {
+    headers: { ...getHeaders(), "Content-Type": "application/json" },
+  };
+}
+
+/**
+ * Create a new announcement
+ * @param communityId Community ID
+ * @param announcementData announcement creation data
+ * @returns HTTP response
+ */
+export function createAnnouncement(
+  communityId: number,
+  announcementData: CreateAnnouncementParams,
+): RefinedResponse<undefined> {
+  return http.post<undefined>(
+    `${baseUrl(communityId)}`,
+    JSON.stringify(announcementData),
+    makeHeaders(),
+  );
+}
+
+/**
+ * List all announcements with pagination
+ * @param communityId Community ID
+ * @param page Page number (default: 1)
+ * @param limit Items per page (default: 10)
+ * @param publishedAfter Date to filter announcements from (optional)
+ * @param sortBy 'publicationDate' or 'ModificationDate' (optional)
+ * @param sortDirection 'ASC' or 'DESC' (optional)
+ * @returns List of announcements or null if failed
+ */
+export function listAnnouncements(
+  communityId: number,
+  page: number = 1,
+  limit: number = 10,
+  publishedAfter: string | null = null,
+  sortBy: string | null = null,
+  sortDirection: string | null = null,
+): PaginatedAnnouncements | null {
+  let urlParams: string = "";
+  if (publishedAfter != null) urlParams += `&publishedAfter=${publishedAfter}`;
+  if (sortBy != null) urlParams += `&sortBy=${sortBy}`;
+  if (sortDirection != null) urlParams += `&sortDirection=${sortDirection}`;
+  const response = http.get(
+    `${baseUrl(communityId)}?page=${page}&limit=${limit}${urlParams}`,
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return JSON.parse(<string>response.body);
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Count all announcements
+ * @param communityId Community ID
+ * @param publishedAfter Date to filter announcements from (optional)
+ * @returns List of announcements or null if failed
+ */
+export function countAnnouncements(
+  communityId: number,
+  publishedAfter: string | null = null,
+): AnnouncementCount | null {
+  const urlParams =
+    publishedAfter == null ? "" : `?publishedAfter=${publishedAfter}`;
+  const response = http.get(
+    `${baseUrl(communityId)}/count${urlParams}`,
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return JSON.parse(<string>response.body);
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Get a specific announcement by ID
+ * @param communityId Community ID
+ * @param announcementId Announcement ID
+ * @returns Announcement or null if not found
+ */
+export function getAnnouncement(
+  communityId: number,
+  announcementId: number,
+): Announcement | null {
+  const response = http.get(
+    `${baseUrl(communityId)}/${announcementId}`,
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return JSON.parse(<string>response.body);
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Update an announcement
+ * @param communityId Community ID
+ * @param announcementId Announcement ID
+ * @param updateData Update data
+ * @returns Updated announcement or null if failed
+ */
+export function updateAnnouncement(
+  communityId: number,
+  announcementId: number,
+  updateData: UpdateAnnouncementParams,
+): Announcement | null {
+  const response = http.put(
+    `${baseUrl(communityId)}/${announcementId}`,
+    JSON.stringify(updateData),
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return JSON.parse(<string>response.body);
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Delete an announcement
+ * @param communityId Community ID
+ * @param announcementId Announcement ID
+ * @returns True if deletion was successful, false otherwise
+ */
+export function deleteAnnouncement(
+  communityId: number,
+  announcementId: number,
+): boolean {
+  const response = http.del(`${baseUrl(communityId)}/${announcementId}`);
+  return response.status === 204;
+}

package/it/scenarios/utils/_folders-api.utils.ts

@@ -0,0 +1,199 @@
+import http from "k6/http";
+import { getHeaders } from "../../../node_modules/edifice-k6-commons/dist/index.js";
+import { Resource } from "./_resource-api.utils.js";
+import { HttpResponse, success, failure } from "./_http-response.utils.ts";
+
+//Types
+export type User = {
+  id: number;
+  displayName: string;
+  entId: string;
+  profile: string;
+};
+
+export type Folder = {
+  id: number;
+  name: string;
+  creationDate: string;
+  modificationDate: string;
+  isRoot: boolean;
+  creator: User;
+  modifier?: User;
+  parentId?: number;
+  communityId: number;
+  stats?: FolderStats;
+};
+
+export type FolderStats = {
+  childCount: number;
+};
+
+export type FolderDetails = {
+  id: number;
+  name: string;
+  creationDate: string;
+  modificationDate: string;
+  isRoot: boolean;
+  creator: User;
+  modifier?: User;
+  parentId?: number;
+  communityId: number;
+  stats?: FolderStats;
+  subFolders?: Folder[];
+  resources?: Resource[];
+};
+
+export type CreateFolderParams = {
+  name: string;
+  parentId?: number;
+};
+
+export type UpdateFolderParams = {
+  name: string;
+  parentId?: number;
+};
+
+export type PaginatedFolders = {
+  items: Folder[];
+  meta: {
+    totalItems: number;
+    currentPage: number;
+    itemCount: number;
+    totalPages: number;
+  };
+};
+
+const rootUrl = __ENV.ROOT_URL || "";
+function baseUrl(id: number): string {
+  return `${rootUrl}/communities/api/communities/${id}/folders`;
+}
+function makeHeaders(): object {
+  return {
+    headers: { ...getHeaders(), "Content-Type": "application/json" },
+  };
+}
+
+export function getFolders(
+  communityId: number,
+  page: number = 1,
+  limit: number = 10,
+  name: string | undefined = undefined,
+  parent: number | undefined = undefined,
+  rootOnly: boolean = false,
+): HttpResponse<PaginatedFolders> {
+  let urlParams: string = name ? `&name=${name}` : "";
+  if (parent) {
+    urlParams += `&parentId=${parent}`;
+  }
+  if (rootOnly) {
+    urlParams += `&rootOnly=${rootOnly}`;
+  }
+  const response = http.get(
+    `${baseUrl(communityId)}?page=${page}&limit=${limit}${urlParams}`,
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return success(JSON.parse(<string>response.body));
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function getRootFolders(communityId: number): HttpResponse<Folder[]> {
+  const response = http.get(`${baseUrl(communityId)}/root`, makeHeaders());
+  if (response.status === 200) {
+    return success(JSON.parse(<string>response.body));
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function createFolder(
+  communityId: number,
+  createData: CreateFolderParams,
+): HttpResponse<Folder> {
+  const response = http.post(
+    `${baseUrl(communityId)}`,
+    JSON.stringify(createData),
+    makeHeaders(),
+  );
+  if (response.status === 201) {
+    return success(JSON.parse(<string>response.body));
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function updateFolder(
+  communityId: number,
+  folderId: number,
+  updateData: UpdateFolderParams,
+): HttpResponse<Folder> {
+  const response = http.put(
+    `${baseUrl(communityId)}/${folderId}`,
+    JSON.stringify(updateData),
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return success(JSON.parse(<string>response.body));
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function getFolderContent(
+  communityId: number,
+  folderId: number,
+): HttpResponse<FolderDetails> {
+  const response = http.get(
+    `${baseUrl(communityId)}/${folderId}`,
+    makeHeaders(),
+  );
+  if (response.status === 200) {
+    return success(JSON.parse(<string>response.body));
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function removeFolder(
+  communityId: number,
+  folderId: number,
+): HttpResponse<boolean> {
+  const response = http.del(`${baseUrl(communityId)}/${folderId}`);
+  if (response.status === 204) {
+    return success(true);
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function addResourceToFolder(
+  communityId: number,
+  folderId: number,
+  resourceId: number,
+): HttpResponse<boolean> {
+  const response = http.post(
+    `${baseUrl(communityId)}/${folderId}/resources/${resourceId}`,
+  );
+  if (response.status === 204) {
+    return success(true);
+  } else {
+    return failure(response.status);
+  }
+}
+
+export function removeResourceFromFolder(
+  communityId: number,
+  folderId: number,
+  resourceId: number,
+): HttpResponse<boolean> {
+  const response = http.del(
+    `${baseUrl(communityId)}/${folderId}/resources/${resourceId}`,
+  );
+  if (response.status === 204) {
+    return success(true);
+  } else {
+    return failure(response.status);
+  }
+}