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

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

@@ -0,0 +1,858 @@
+// @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,
+  CreateCommunityParams,
+} from "./utils/_community-api.utils.ts";
+
+// Import invitation API utils
+import {
+  createInvitations,
+  listCommunityInvitations,
+  updateInvitationStatus,
+  CreateInvitationParams,
+  Invitation,
+  InvitationStatus,
+  MembershipRole,
+  InvitationSortField,
+  SortDirection,
+  updateLastVisit,
+  CommunitySection,
+} from "./utils/_invitation-api.utils.ts";
+
+chai.config.logFailures = true;
+
+export const options = {
+  setupTimeout: "1h",
+  maxRedirects: 0,
+  thresholds: {
+    checks: ["rate == 1.00"],
+  },
+  scenarios: {
+    invitationsSearchSortTest: {
+      exec: "testInvitationsSearchSort",
+      executor: "per-vu-iterations",
+      vus: 1,
+      maxDuration: "1m",
+      gracefulStop: "5s",
+    },
+  },
+};
+
+const timestamp = new Date().toISOString();
+const schoolName = `IT Community Invitations Search Sort`;
+
+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 testInvitationsSearchSort(structure: Structure) {
+  // Community data
+  const communityData: CreateCommunityParams = {
+    title: `InvitationSearchSort - Test ${timestamp}`,
+    type: "FREE",
+    schoolYearStart: 2025,
+    schoolYearEnd: 2026,
+    discussionEnabled: true,
+    welcomeNote: "Test community for invitation search and sort 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 Search and Sort Test]", () => {
+    // Initial setup - Get users and authenticate admin
+    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();
+
+    // Admin authenticates
+    const adminAuthenticated = authenticateWeb(adminUser.login, "password");
+    if (!adminAuthenticated) {
+      fail("Admin authentication failed");
+    }
+
+    // Create a community for testing
+    describe("Create community and invitations for search/sort tests", () => {
+      // Create community
+      communityId = Number(createCommunityOrFail(communityData));
+      console.log(`Created community with ID: ${communityId}`);
+
+      // Create first invitation (will be accepted later)
+      const invitationData: CreateInvitationParams = {
+        users: [{ userId: memberUser.id, role: MembershipRole.MEMBER }],
+        message: "You are invited to join our test community",
+      };
+
+      const invitations = createInvitations(communityId, invitationData);
+      invitationId = invitations![0].id;
+      console.log(`Created invitation with ID: ${invitationId}`);
+
+      // Create additional invitations for different users to test search/sort
+      for (let i = 0; i < 2; i++) {
+        const additionalData: CreateInvitationParams = {
+          users: [
+            {
+              userId: i === 0 ? member2User.id : member3User.id,
+              role: i === 0 ? MembershipRole.MEMBER : MembershipRole.ADMIN,
+            },
+          ],
+          message: `Test invitation ${i + 1} for search/sort`,
+        };
+        createInvitations(communityId, additionalData);
+      }
+    });
+
+    // Have the first user accept their invitation to ensure mixed statuses
+    describe("Member accepts invitation to create mixed statuses", () => {
+      // Member logs in
+      logout();
+      authenticateWeb(memberUser.login, "password");
+
+      // Accept invitation
+      updateInvitationStatus(invitationId, InvitationStatus.ACCEPTED);
+
+      // Log back in as admin
+      logout();
+      authenticateWeb(adminUser.login, "password");
+    });
+
+    // Test user search with ILIKE on displayName
+    describe("Admin searches for invitations by user displayName", () => {
+      // First, we need to get the user's display name to search for
+      const memberDisplayName = `${memberUser.lastName} ${memberUser.firstName}`;
+      console.log(
+        `Searching for invitations with user displayName containing: ${memberDisplayName}`,
+      );
+
+      // Try searching with full displayName
+      const fullNameSearch = listCommunityInvitations(communityId, {
+        searchTerm: memberDisplayName,
+      });
+
+      check(fullNameSearch, {
+        "can search invitations by full displayName": (r) =>
+          r !== null && r.length > 0,
+        "search results contain the right invitation": (r) => {
+          return (
+            r !== null &&
+            r.some(
+              (inv: Invitation) =>
+                inv.id === invitationId &&
+                inv.receiver?.displayName === memberDisplayName,
+            )
+          );
+        },
+      });
+
+      // Try searching with partial displayName (if displayName has multiple parts)
+      if (memberDisplayName && memberDisplayName.includes(" ")) {
+        // Take just the first part of the name (typically last name)
+        const partialName = memberDisplayName.split(" ")[0];
+
+        const partialNameSearch = listCommunityInvitations(communityId, {
+          searchTerm: partialName,
+        });
+
+        check(partialNameSearch, {
+          "can search invitations by partial displayName": (r) =>
+            r !== null && r.length > 0,
+          "partial name search finds correct invitation": (r) => {
+            return (
+              r !== null &&
+              r.some(
+                (inv: Invitation) =>
+                  inv.id === invitationId &&
+                  inv.receiver?.displayName.includes(partialName),
+              )
+            );
+          },
+        });
+      }
+
+      // Test search with lowercase (testing case insensitivity)
+      if (memberDisplayName) {
+        const lowercaseSearch = listCommunityInvitations(communityId, {
+          searchTerm: memberDisplayName.toLowerCase(),
+        });
+
+        check(lowercaseSearch, {
+          "search is case-insensitive": (r) => r !== null && r.length > 0,
+          "case-insensitive search finds correct invitation": (r) => {
+            return (
+              r !== null && r.some((inv: Invitation) => inv.id === invitationId)
+            );
+          },
+        });
+      }
+
+      // Test with a non-matching search term
+      const nonMatchingSearch = listCommunityInvitations(communityId, {
+        searchTerm: "ThisUserDoesNotExist12345",
+      });
+
+      check(nonMatchingSearch, {
+        "non-matching search returns empty results": (r) =>
+          r !== null && r.length === 0,
+      });
+    });
+
+    // Test sorting capabilities
+    describe("Admin tests invitation sorting capabilities", () => {
+      // First create multiple invitations to ensure we have data for meaningful sorting
+      console.log("Creating additional invitations for sorting tests");
+
+      // Send multiple invitations for sorting tests
+      const sortTestUsers = [member2User, member3User];
+
+      // Track the new invitation IDs
+      const sortInvitationIds: number[] = [];
+
+      // Create invitations with different messages to sort on
+      for (let i = 0; i < sortTestUsers.length; i++) {
+        const sortInvitationData: CreateInvitationParams = {
+          users: [{ userId: sortTestUsers[i].id, role: MembershipRole.MEMBER }],
+          message: `Sort test invitation ${String.fromCharCode(65 + i)}`, // "A", "B", etc.
+        };
+
+        const invs = createInvitations(communityId, sortInvitationData);
+        if (invs && invs.length > 0) {
+          sortInvitationIds.push(invs[0].id);
+        }
+      }
+
+      // Test sorting
+      describe("Sort invitations ", () => {
+        // Test sorting by status
+        const statusSortAsc = listCommunityInvitations(communityId, {
+          sortBy: InvitationSortField.STATUS,
+          sortDirection: SortDirection.ASC,
+        });
+        // We are sorting according workflow order, not alphabetically
+
+        check(statusSortAsc, {
+          "sort by status ASC works": (r) => r !== null && r.length > 0,
+
+          // Verify enum order using JavaScript simulation of PostgreSQL enum ordering
+          "Status ASC sort follows PostgreSQL enum definition order": (r) => {
+            if (!r || r.length <= 1) return true;
+
+            // Define expected order based on enum definition in database
+            const enumOrder = {
+              [InvitationStatus.PENDING]: 1, // First position in enum
+              [InvitationStatus.REQUEST]: 2, // Second position
+              [InvitationStatus.ACCEPTED]: 3, // Third position
+              [InvitationStatus.REJECTED]: 4, // Fourth position
+              [InvitationStatus.REQUEST_ACCEPTED]: 5, // Fifth position
+              [InvitationStatus.REQUEST_REJECTED]: 6, // Sixth position
+            };
+
+            // Create a manual sort using the enum order
+            const manualSort = [...r].sort((a, b) => {
+              return enumOrder[a.status] - enumOrder[b.status];
+            });
+
+            // Check if API results match our manual sort
+            const orderMatches = r.every(
+              (invitation, index) => invitation.id === manualSort[index].id,
+            );
+
+            if (!orderMatches) {
+              console.log(
+                "Warning: Status ASC order does not match expected enum order",
+              );
+              console.log(
+                "Expected order:",
+                manualSort.map((inv) => inv.status),
+              );
+              console.log(
+                "Actual order:",
+                r.map((inv) => inv.status),
+              );
+            }
+
+            return orderMatches;
+          },
+
+          // Check specific status order relationships if we have multiple statuses
+          "Status values are correctly ordered in ASC sort": (r) => {
+            if (!r || r.length <= 1) return true;
+
+            // Get indexes of various statuses
+            const pendingIndex = r.findIndex(
+              (inv) => inv.status === InvitationStatus.PENDING,
+            );
+            const requestIndex = r.findIndex(
+              (inv) => inv.status === InvitationStatus.REQUEST,
+            );
+            const acceptedIndex = r.findIndex(
+              (inv) => inv.status === InvitationStatus.ACCEPTED,
+            );
+            const rejectedIndex = r.findIndex(
+              (inv) => inv.status === InvitationStatus.REJECTED,
+            );
+            const requestAcceptedIndex = r.findIndex(
+              (inv) => inv.status === InvitationStatus.REQUEST_ACCEPTED,
+            );
+            const requestRejectedIndex = r.findIndex(
+              (inv) => inv.status === InvitationStatus.REQUEST_REJECTED,
+            );
+
+            // Check all possible pairs that exist in the results
+            // PENDING should come before all others
+            if (pendingIndex !== -1) {
+              if (requestIndex !== -1 && pendingIndex > requestIndex)
+                return false;
+              if (acceptedIndex !== -1 && pendingIndex > acceptedIndex)
+                return false;
+              if (rejectedIndex !== -1 && pendingIndex > rejectedIndex)
+                return false;
+              if (
+                requestAcceptedIndex !== -1 &&
+                pendingIndex > requestAcceptedIndex
+              )
+                return false;
+              if (
+                requestRejectedIndex !== -1 &&
+                pendingIndex > requestRejectedIndex
+              )
+                return false;
+            }
+
+            // REQUEST should come after PENDING but before others
+            if (requestIndex !== -1) {
+              if (acceptedIndex !== -1 && requestIndex > acceptedIndex)
+                return false;
+              if (rejectedIndex !== -1 && requestIndex > rejectedIndex)
+                return false;
+              if (
+                requestAcceptedIndex !== -1 &&
+                requestIndex > requestAcceptedIndex
+              )
+                return false;
+              if (
+                requestRejectedIndex !== -1 &&
+                requestIndex > requestRejectedIndex
+              )
+                return false;
+            }
+            return true;
+          },
+        });
+
+        // Verify we get the same results for DESC
+        const statusSortDesc = listCommunityInvitations(communityId, {
+          sortBy: InvitationSortField.STATUS,
+          sortDirection: SortDirection.DESC,
+        });
+        // We are sorting according workflow order, not alphabetically
+        check(statusSortDesc, {
+          "sort by status DESC works": (r) => r !== null && r.length > 0,
+
+          // Verify enum order using JavaScript simulation of PostgreSQL DESC enum ordering
+          "Status DESC sort follows reverse PostgreSQL enum definition order": (
+            r,
+          ) => {
+            if (!r || r.length <= 1) return true;
+
+            // Define expected order based on enum definition in database
+            const enumOrder = {
+              [InvitationStatus.PENDING]: 1,
+              [InvitationStatus.REQUEST]: 2,
+              [InvitationStatus.ACCEPTED]: 3,
+              [InvitationStatus.REJECTED]: 4,
+              [InvitationStatus.REQUEST_ACCEPTED]: 5,
+              [InvitationStatus.REQUEST_REJECTED]: 6,
+            };
+
+            // Create a manual sort using the enum order (reversed for DESC)
+            const manualSort = [...r].sort((a, b) => {
+              return enumOrder[b.status] - enumOrder[a.status];
+            });
+
+            // Check if API results match our manual sort
+            const orderMatches = r.every(
+              (invitation, index) => invitation.id === manualSort[index].id,
+            );
+
+            if (!orderMatches) {
+              console.log(
+                "Warning: Status DESC order does not match expected enum order",
+              );
+              console.log(
+                "Expected order:",
+                manualSort.map((inv) => inv.status),
+              );
+              console.log(
+                "Actual order:",
+                r.map((inv) => inv.status),
+              );
+            }
+
+            return orderMatches;
+          },
+        });
+
+        // Test sorting by userName
+        const userNameSortAsc = listCommunityInvitations(communityId, {
+          sortBy: InvitationSortField.USER_NAME,
+          sortDirection: SortDirection.ASC,
+        });
+
+        check(userNameSortAsc, {
+          "sort by userName ASC works": (r) => r !== null && r.length > 0,
+          // Add JavaScript-based validation of server-side sorting
+          "API userName ASC sort matches JavaScript sort": (r) => {
+            if (!r || r.length <= 1) return true; // Nothing to validate with 0-1 items
+
+            // Create a copy and sort manually by displayName using JavaScript's sort
+            const manualSort = [...r].sort((a, b) => {
+              const nameA = a.receiver?.displayName || "";
+              const nameB = b.receiver?.displayName || "";
+              return nameA.localeCompare(nameB); // Use localeCompare for proper string comparison
+            });
+            // Log the original and manually sorted displayNames for debugging
+            console.log(
+              "API sorted names:",
+              r.map((inv) => inv.receiver?.displayName),
+            );
+            console.log(
+              "JS sorted names:",
+              manualSort.map((inv) => inv.receiver?.displayName),
+            );
+
+            // Check if the order matches by comparing IDs at each position
+            const orderMatches = r.every(
+              (invitation, index) => invitation.id === manualSort[index].id,
+            );
+            if (!orderMatches) {
+              console.log(
+                "Warning: API sort order does not match JavaScript sort order",
+              );
+            }
+            return orderMatches;
+          },
+        });
+
+        const userNameSortDesc = listCommunityInvitations(communityId, {
+          sortBy: InvitationSortField.USER_NAME,
+          sortDirection: SortDirection.DESC,
+        });
+
+        check(userNameSortDesc, {
+          "sort by userName DESC works": (r) => r !== null && r.length > 0,
+          "userName DESC returns different order than ASC": (r) => {
+            // This only works if we have multiple results
+            if (
+              !r ||
+              !userNameSortAsc ||
+              r.length <= 1 ||
+              userNameSortAsc.length <= 1
+            )
+              return true;
+
+            // Check first user in each list - should be different for different sort directions
+            return r[0].id !== userNameSortAsc[0].id;
+          },
+          // Add JavaScript-based validation of server-side sorting for DESC
+          "API userName DESC sort matches JavaScript sort": (r) => {
+            if (!r || r.length <= 1) return true;
+
+            // Create a copy and sort manually by displayName in descending order
+            const manualSort = [...r].sort((a, b) => {
+              const nameA = a.receiver?.displayName || "";
+              const nameB = b.receiver?.displayName || "";
+              return nameB.localeCompare(nameA); // Reversed comparison for DESC sort
+            });
+
+            // Check if the order matches
+            return r.every(
+              (invitation, index) => invitation.id === manualSort[index].id,
+            );
+          },
+        });
+      });
+
+      // Test sorting by currentRole
+      const roleSortAsc = listCommunityInvitations(communityId, {
+        sortBy: InvitationSortField.CURRENT_ROLE,
+        sortDirection: SortDirection.ASC,
+      });
+
+      console.log(
+        "Role sort ASC result:",
+        roleSortAsc?.map((inv) => ({
+          id: inv.id,
+          role: inv.currentRole,
+          user: inv.receiver?.displayName,
+        })),
+      );
+
+      check(roleSortAsc, {
+        "sort by currentRole ASC works": (r) => r !== null && r.length > 0,
+
+        // Add verification of correct role order for ASC
+        "Role ASC sort follows PostgreSQL enum definition order": (r) => {
+          if (!r || r.length <= 1) return true;
+
+          // Define expected order based on enum definition in database
+          // In PostgreSQL, ADMIN is defined before MEMBER
+          const enumOrder = {
+            [MembershipRole.ADMIN]: 1, // First position in enum
+            [MembershipRole.MEMBER]: 2, // Second position in enum
+          };
+
+          // Create a manual sort using the enum order
+          const manualSort = [...r].sort((a, b) => {
+            // Use initial_role for entries without current_role (non-accepted invitations)
+            const roleA = a.currentRole || a.initialRole;
+            const roleB = b.currentRole || b.initialRole;
+
+            return enumOrder[roleA!] - enumOrder[roleB!];
+          });
+
+          // Check if API results match our manual sort
+          const orderMatches = r.every(
+            (invitation, index) => invitation.id === manualSort[index].id,
+          );
+
+          if (!orderMatches) {
+            console.log(
+              "Warning: Role ASC order does not match expected enum order",
+            );
+            console.log(
+              "Expected order:",
+              manualSort.map((inv) => inv.currentRole || inv.initialRole),
+            );
+            console.log(
+              "Actual order:",
+              r.map((inv) => inv.currentRole || inv.initialRole),
+            );
+          }
+
+          return orderMatches;
+        },
+
+        // Add specific check for ADMIN appearing before MEMBER
+        "ADMIN appears before MEMBER in ASC sort": (r) => {
+          if (!r || r.length <= 1) return true;
+
+          const adminIndex = r.findIndex(
+            (inv) =>
+              (inv.currentRole || inv.initialRole) === MembershipRole.ADMIN,
+          );
+
+          const memberIndex = r.findIndex(
+            (inv) =>
+              (inv.currentRole || inv.initialRole) === MembershipRole.MEMBER,
+          );
+
+          // If both roles exist, ADMIN should appear first in ASC order
+          // since that's the PostgreSQL enum definition order
+          if (adminIndex !== -1 && memberIndex !== -1) {
+            return adminIndex < memberIndex;
+          }
+
+          // If only one role exists or none, test passes
+          return true;
+        },
+      });
+
+      // Test with DESC
+      const roleSortDesc = listCommunityInvitations(communityId, {
+        sortBy: InvitationSortField.CURRENT_ROLE,
+        sortDirection: SortDirection.DESC,
+      });
+
+      console.log(
+        "Role sort DESC result:",
+        roleSortDesc?.map((inv) => ({
+          id: inv.id,
+          role: inv.currentRole,
+          user: inv.receiver?.displayName,
+        })),
+      );
+
+      check(roleSortDesc, {
+        "sort by currentRole DESC works": (r) => r !== null && r.length > 0,
+
+        // Add verification of correct role order for DESC (reversed)
+        "Role DESC sort follows reverse PostgreSQL enum definition order": (
+          r,
+        ) => {
+          if (!r || r.length <= 1) return true;
+
+          // Define expected order based on enum definition in database
+          const enumOrder = {
+            [MembershipRole.ADMIN]: 1, // First position in enum
+            [MembershipRole.MEMBER]: 2, // Second position in enum
+          };
+
+          // Create a manual sort using the reversed enum order for DESC
+          const manualSort = [...r].sort((a, b) => {
+            // Use initial_role for entries without current_role
+            const roleA = a.currentRole || a.initialRole;
+            const roleB = b.currentRole || b.initialRole;
+
+            return enumOrder[roleB!] - enumOrder[roleA!]; // Notice the reversed order for DESC
+          });
+
+          // Check if API results match our manual sort
+          const orderMatches = r.every(
+            (invitation, index) => invitation.id === manualSort[index].id,
+          );
+
+          if (!orderMatches) {
+            console.log(
+              "Warning: Role DESC order does not match expected enum order",
+            );
+            console.log(
+              "Expected order:",
+              manualSort.map((inv) => inv.currentRole || inv.initialRole),
+            );
+            console.log(
+              "Actual order:",
+              r.map((inv) => inv.currentRole || inv.initialRole),
+            );
+          }
+
+          return orderMatches;
+        },
+
+        // Add specific check for MEMBER appearing before ADMIN in DESC
+        "MEMBER appears before ADMIN in DESC sort": (r) => {
+          if (!r || r.length <= 1) return true;
+
+          const adminIndex = r.findIndex(
+            (inv) =>
+              (inv.currentRole || inv.initialRole) === MembershipRole.ADMIN,
+          );
+
+          const memberIndex = r.findIndex(
+            (inv) =>
+              (inv.currentRole || inv.initialRole) === MembershipRole.MEMBER,
+          );
+
+          // If both roles exist, MEMBER should come first in DESC order
+          if (adminIndex !== -1 && memberIndex !== -1) {
+            return memberIndex < adminIndex;
+          }
+
+          // If only one role exists or none, test passes
+          return true;
+        },
+      });
+
+      // Add this section before testing lastVisit sorting
+
+      // Set up lastVisit data for accepted invitations
+      describe("Add lastVisit data for sorting tests", () => {
+        // Get all accepted invitations
+        const allInvitations = listCommunityInvitations(communityId);
+        console.log(`Found ${allInvitations?.length || 0} total invitations`);
+
+        // Find the accepted invitation for our test user
+        const acceptedInvitation = allInvitations?.find(
+          (inv) => inv.status === InvitationStatus.ACCEPTED,
+        );
+
+        if (acceptedInvitation) {
+          console.log(
+            `Found accepted invitation for user ${acceptedInvitation.receiver?.displayName}`,
+          );
+
+          // Login as this user to update lastVisit
+          logout();
+          authenticateWeb(memberUser.login, "password");
+
+          // Create a timestamp to ensure we have data for sorting
+          console.log(`Updating lastVisit data for user ${memberUser.login}`);
+
+          // Visit different sections with different timestamps
+          // This will update lastVisit in the membership entity
+          const result = updateLastVisit(
+            communityId,
+            CommunitySection.ANNOUNCEMENTS,
+          );
+          check(result, {
+            "updateLastVisit successfully sets lastVisit date": (r) =>
+              r !== null,
+          });
+
+          // Log back in as admin to proceed with tests
+          logout();
+          authenticateWeb(adminUser.login, "password");
+        } else {
+          console.log("No accepted invitations found to update lastVisit");
+        }
+
+        // Test sorting by lastVisit
+        const lastVisitSortAsc = listCommunityInvitations(communityId, {
+          sortBy: InvitationSortField.LAST_VISIT,
+          sortDirection: SortDirection.ASC,
+        });
+
+        console.log(
+          "LastVisit ASC sorting results:",
+          lastVisitSortAsc?.map((inv) => ({
+            id: inv.id,
+            status: inv.status,
+            user: inv.receiver?.displayName,
+            lastVisit: inv.lastVisit || "null",
+          })),
+        );
+
+        check(lastVisitSortAsc, {
+          "sort by lastVisit ASC works": (r) => r !== null && r.length > 0,
+          "lastVisit ASC sort handles null values correctly": (r) => {
+            if (!r || r.length <= 1) return true;
+
+            // Create a manual sort using JavaScript - PostgreSQL uses NULLS LAST behavior
+            const manualSort = [...r].sort((a, b) => {
+              // If both have lastVisit, compare dates
+              if (a.lastVisit && b.lastVisit) {
+                return (
+                  new Date(a.lastVisit).getTime() -
+                  new Date(b.lastVisit).getTime()
+                );
+              }
+              // Handle null cases (NULLS LAST behavior)
+              if (!a.lastVisit && b.lastVisit) return 1; // a (null) goes after b
+              if (a.lastVisit && !b.lastVisit) return -1; // a goes before b (null)
+              return 0; // Both null, keep original order
+            });
+
+            // Check if the order matches by comparing IDs at each position
+            const orderMatches = r.every(
+              (invitation, index) => invitation.id === manualSort[index].id,
+            );
+
+            if (!orderMatches) {
+              console.log(
+                "Warning: API lastVisit ASC sort order does not match JavaScript sort",
+              );
+              console.log(
+                "Expected order:",
+                manualSort.map((inv) => ({
+                  id: inv.id,
+                  lastVisit: inv.lastVisit,
+                })),
+              );
+              console.log(
+                "Actual order:",
+                r.map((inv) => ({ id: inv.id, lastVisit: inv.lastVisit })),
+              );
+            }
+
+            return orderMatches;
+          },
+        });
+
+        // Test with DESC
+        const lastVisitSortDesc = listCommunityInvitations(communityId, {
+          sortBy: InvitationSortField.LAST_VISIT,
+          sortDirection: SortDirection.DESC,
+        });
+
+        check(lastVisitSortDesc, {
+          "sort by lastVisit DESC works": (r) => r !== null && r.length > 0,
+          "lastVisit DESC reverses non-null values but maintains null placement":
+            (r) => {
+              if (!r || !lastVisitSortAsc || r.length <= 1) return true;
+
+              // Get entries with lastVisit from both sorts
+              const withLastVisitAsc = lastVisitSortAsc.filter(
+                (inv) => inv.lastVisit,
+              );
+              const withLastVisitDesc = r.filter((inv) => inv.lastVisit);
+
+              // If we don't have enough entries with lastVisit, test passes
+              if (withLastVisitAsc.length <= 1 || withLastVisitDesc.length <= 1)
+                return true;
+
+              // In DESC, the non-null values should be in reversed order compared to ASC
+              // Use JavaScript's sorting implementation to verify
+              const manualSort = [...withLastVisitAsc].sort((a, b) => {
+                return (
+                  new Date(b.lastVisit!).getTime() -
+                  new Date(a.lastVisit!).getTime()
+                );
+              });
+
+              // Check if the DESC API results match our manually reversed sort
+              const orderMatches = withLastVisitDesc.every(
+                (invitation, index) => invitation.id === manualSort[index].id,
+              );
+
+              if (!orderMatches) {
+                console.log(
+                  "Warning: API lastVisit DESC sort does not reverse ASC correctly",
+                );
+              }
+
+              return orderMatches;
+            },
+        });
+      });
+
+      // Cleanup - Delete the community
+      describe("Cleanup - Delete test community", () => {
+        const deleted = deleteCommunity(communityId);
+
+        check(deleted, {
+          "community deleted successfully": (r) => r === true,
+        });
+      });
+    });
+  });
+}