[PB-4148] feature/Integrate meet endpoints

.env.template

@@ -1,5 +1,7 @@
 DRIVE_API_URL=http://drive-server:8000/api
 DRIVE_NEW_API_URL=http://drive-server-wip:3004/api
+PAYMENTS_API_URL=http://payments-server:8003
+MEET_API_URL=http://meet-server:3006
 CRYPTO_SECRET=6KYQBP847D4ATSFA
 MAGIC_IV=d139cb9a2cd17092e79e1861cf9d7023
 MAGIC_SALT=38dce0391b49efba88dbc8c39ebf868f0267eb110bb0012ab27dc52a528d61b1d1ed9d76f400ff58e3240028442b1eab9bb84e111d9dadd997982dbde9dbd25e

package.json

@@ -27,7 +27,7 @@
         "@internxt/css-config": "^1.0.2",
         "@internxt/eslint-config-internxt": "^2.0.0",
         "@internxt/lib": "^1.2.0",
-        "@internxt/sdk": "=1.9.8",
+        "@internxt/sdk": "=1.9.13",
         "@internxt/ui": "^0.0.22",
         "@jitsi/excalidraw": "https://github.com/jitsi/excalidraw/releases/download/v0.0.17/jitsi-excalidraw-0.0.17.tgz",
         "@jitsi/js-utils": "2.2.1",

react/features/base/meet/services/__tests__/payments.service.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, it, MockInstance, vi } from "vitest";
+import { PaymentsService } from "../payments.service";
+import { SdkManager } from "../sdk-manager.service";
+
+vi.mock("../sdk-manager.service", () => {
+    return {
+        SdkManager: {
+            instance: {
+                getPayments: vi.fn(),
+            },
+        },
+    };
+});
+
+describe("PaymentsService", () => {
+    const originalConsoleError = console.error;
+
+    beforeEach(() => {
+        console.error = vi.fn();
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        console.error = originalConsoleError;
+    });
+
+    describe("instance", () => {
+        it("When accessing the instance, then a singleton instance is returned", () => {
+            const instance = PaymentsService.instance;
+
+            expect(instance).toBeDefined();
+            expect(instance).toBeInstanceOf(PaymentsService);
+        });
+    });
+
+    describe("checkMeetAvailability", () => {
+        it("When checking meet availability with meet features, then meet object is returned", async () => {
+            const mockMeetObject = {
+                allowed: true,
+                maxHours: 10,
+                maxParticipants: 5,
+            };
+
+            const mockUserTier = {
+                featuresPerService: {
+                    meet: mockMeetObject,
+                },
+            };
+
+            const mockPaymentsClient = {
+                getUserTier: vi.fn().mockResolvedValue(mockUserTier),
+            };
+
+            const getPaymentsMock = SdkManager.instance.getPayments as unknown as MockInstance;
+            getPaymentsMock.mockReturnValue(mockPaymentsClient);
+
+            const result = await PaymentsService.instance.checkMeetAvailability();
+
+            expect(getPaymentsMock).toHaveBeenCalledTimes(1);
+            expect(getPaymentsMock).toHaveBeenCalledWith();
+            expect(getPaymentsMock.mock.calls[0].length).toBe(0);
+
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledTimes(1);
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledWith();
+            expect(mockPaymentsClient.getUserTier.mock.calls[0].length).toBe(0);
+
+            expect(result).toEqual(mockMeetObject);
+        });
+
+        it("When checking meet availability without meet features, then undefined is returned", async () => {
+            const mockUserTier = {
+                featuresPerService: {
+                    drive: { allowed: true },
+                },
+            };
+
+            const mockPaymentsClient = {
+                getUserTier: vi.fn().mockResolvedValue(mockUserTier),
+            };
+
+            const getPaymentsMock = SdkManager.instance.getPayments as unknown as MockInstance;
+            getPaymentsMock.mockReturnValue(mockPaymentsClient);
+
+            const result = await PaymentsService.instance.checkMeetAvailability();
+
+            expect(getPaymentsMock).toHaveBeenCalledTimes(1);
+            expect(getPaymentsMock).toHaveBeenCalledWith();
+            expect(getPaymentsMock.mock.calls[0].length).toBe(0);
+
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledTimes(1);
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledWith();
+            expect(mockPaymentsClient.getUserTier.mock.calls[0].length).toBe(0);
+
+            expect(result).toBeUndefined();
+        });
+
+        it("When checking meet availability with empty featuresPerService, then undefined is returned", async () => {
+            const mockUserTier = {
+                featuresPerService: {},
+            };
+
+            const mockPaymentsClient = {
+                getUserTier: vi.fn().mockResolvedValue(mockUserTier),
+            };
+
+            const getPaymentsMock = SdkManager.instance.getPayments as unknown as MockInstance;
+            getPaymentsMock.mockReturnValue(mockPaymentsClient);
+
+            const result = await PaymentsService.instance.checkMeetAvailability();
+
+            expect(getPaymentsMock).toHaveBeenCalledTimes(1);
+            expect(getPaymentsMock).toHaveBeenCalledWith();
+            expect(getPaymentsMock.mock.calls[0].length).toBe(0);
+
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledTimes(1);
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledWith();
+            expect(mockPaymentsClient.getUserTier.mock.calls[0].length).toBe(0);
+
+            expect(result).toBeUndefined();
+        });
+
+        it("When getUserTier throws an error, then the error is propagated", async () => {
+            const mockError = new Error("Failed to get user tier");
+
+            const mockPaymentsClient = {
+                getUserTier: vi.fn().mockRejectedValue(mockError),
+            };
+
+            const getPaymentsMock = SdkManager.instance.getPayments as unknown as MockInstance;
+            getPaymentsMock.mockReturnValue(mockPaymentsClient);
+
+            await expect(PaymentsService.instance.checkMeetAvailability()).rejects.toThrow(mockError);
+
+            expect(getPaymentsMock).toHaveBeenCalledTimes(1);
+            expect(getPaymentsMock).toHaveBeenCalledWith();
+            expect(getPaymentsMock.mock.calls[0].length).toBe(0);
+
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledTimes(1);
+            expect(mockPaymentsClient.getUserTier).toHaveBeenCalledWith();
+            expect(mockPaymentsClient.getUserTier.mock.calls[0].length).toBe(0);
+        });
+
+        it("When getPayments throws an error, then the error is propagated", async () => {
+            const mockError = new Error("Failed to get payments client");
+
+            const getPaymentsMock = SdkManager.instance.getPayments as unknown as MockInstance;
+            getPaymentsMock.mockImplementation(() => {
+                throw mockError;
+            });
+
+            await expect(PaymentsService.instance.checkMeetAvailability()).rejects.toThrow(mockError);
+
+            expect(getPaymentsMock).toHaveBeenCalledTimes(1);
+            expect(getPaymentsMock).toHaveBeenCalledWith();
+            expect(getPaymentsMock.mock.calls[0].length).toBe(0);
+        });
+    });
+});

react/features/base/meet/services/__tests__/sdk-manager.service.test.ts

@@ -1,8 +1,8 @@
+import { Auth, Drive, Meet } from "@internxt/sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import "../../__tests__/setup";
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { SdkManager } from "../sdk-manager.service";
 import { ConfigService } from "../config.service";
-import { Auth, Drive } from "@internxt/sdk";
+import { SdkManager } from "../sdk-manager.service";
 
 vi.mock("@internxt/sdk", () => ({
     Auth: {
@@ -22,9 +22,41 @@ vi.mock("@internxt/sdk", () => ({
                 unauthorizedCallback: vi.fn(),
             })),
         },
+        Payments: {
+            client: vi.fn().mockImplementation((baseUrl, appDetails, security) => ({
+                baseUrl,
+                appDetails,
+                security,
+                unauthorizedCallback: vi.fn(),
+            })),
+        },
+    },
+    Meet: {
+        client: vi.fn().mockImplementation((baseUrl, appDetails, security) => ({
+            baseUrl,
+            appDetails,
+            security,
+            unauthorizedCallback: vi.fn(),
+        })),
     },
 }));
 
+const mockLocalStorage = {
+    getItem: vi.fn().mockImplementation((key) => {
+        if (key === "xNewToken") return "mock-new-token";
+        return null;
+    }),
+    clearCredentials: vi.fn(),
+};
+
+Object.defineProperty(global, "localStorage", {
+    value: mockLocalStorage,
+    writable: true,
+});
+
+// @ts-ignore - Ignore TypeScript error for test purposes
+SdkManager.instance.localStorage = mockLocalStorage;
+
 describe("SdkManager", () => {
     beforeEach(() => {
         SdkManager.clean();
@@ -89,18 +121,13 @@ describe("SdkManager", () => {
                 const config: Record<string, string> = {
                     DRIVE_API_URL: "https://test-drive-api.com",
                     DRIVE_NEW_API_URL: "https://test-drive-new-api.com",
+                    PAYMENTS_API_URL: "https://test-payments-api.com",
+                    MEET_API_URL: "https://test-meet-api.com",
                 };
                 return config[key];
             });
         });
 
-        it("When getting auth client, then the correct client is returned with proper configuration", () => {
-            SdkManager.init(mockApiSecurity);
-            const authClient = SdkManager.instance.getAuth();
-            expect(authClient).toBeDefined();
-            expect(Auth.client).toHaveBeenCalledWith("https://test-drive-api.com", expect.any(Object), mockApiSecurity);
-        });
-
         it("When getting new auth client, then the correct client is returned with proper configuration", () => {
             SdkManager.init(mockApiSecurity);
             const newAuthClient = SdkManager.instance.getNewAuth();
@@ -123,18 +150,57 @@ describe("SdkManager", () => {
             );
         });
 
+        it("When getting payments client, then the correct client is returned with proper configuration", () => {
+            const getItemSpy = vi.spyOn(global.localStorage, "getItem");
+
+            const paymentsClient = SdkManager.instance.getPayments();
+            expect(paymentsClient).toBeDefined();
+
+            expect(getItemSpy).toHaveBeenCalledWith("xNewToken");
+
+            expect(Drive.Payments.client).toHaveBeenCalledWith(
+                "https://test-payments-api.com",
+                expect.any(Object),
+                expect.objectContaining({
+                    token: "mock-new-token",
+                })
+            );
+        });
+
+        it("When getting meet client, then the correct client is returned with proper configuration", () => {
+            const getItemSpy = vi.spyOn(global.localStorage, "getItem");
+
+            const meetClient = SdkManager.instance.getMeet();
+            expect(meetClient).toBeDefined();
+
+            expect(getItemSpy).toHaveBeenCalledWith("xNewToken");
+
+            expect(Meet.client).toHaveBeenCalledWith(
+                "https://test-meet-api.com",
+                expect.any(Object),
+                expect.objectContaining({
+                    token: "mock-new-token",
+                })
+            );
+        });
+
         it("When getting clients without api security, then they are created with undefined security", () => {
-            SdkManager.instance.getAuth();
             SdkManager.instance.getNewAuth();
             SdkManager.instance.getUsers();
 
-            expect(Auth.client).toHaveBeenCalledWith("https://test-drive-api.com", expect.any(Object), undefined);
             expect(Auth.client).toHaveBeenCalledWith("https://test-drive-new-api.com", expect.any(Object), undefined);
             expect(Drive.Users.client).toHaveBeenCalledWith(
                 "https://test-drive-api.com",
                 expect.any(Object),
                 undefined
             );
         });
+
+        it("Tests the unauthorizedCallback in getNewTokenApiSecurity", () => {
+            SdkManager.instance.getPayments();
+            const securityArg = (Drive.Payments.client as any).mock.calls[0][2];
+            securityArg.unauthorizedCallback();
+            expect(mockLocalStorage.clearCredentials).toHaveBeenCalled();
+        });
     });
 });