@tenxyte/core 0.1.5 → 0.9.0

package/tests/modules/rbac.test.ts

@@ -1,95 +1,95 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { RbacModule } from '../../src/modules/rbac';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-// Helper to create a dummy JWT for testing
-function createDummyJwt(payload: any) {
-    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64');
-    return `header.${encodedPayload}.signature`;
-}
-
-describe('RbacModule', () => {
-    let client: TenxyteHttpClient;
-    let rbac: RbacModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        rbac = new RbacModule(client);
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    describe('Synchronous Decoding & Checks', () => {
-        const token = createDummyJwt({
-            roles: ['admin', 'manager'],
-            permissions: ['users.view', 'users.edit']
-        });
-
-        it('hasRole should return true if role exists', () => {
-            expect(rbac.hasRole('admin', token)).toBe(true);
-            expect(rbac.hasRole('user', token)).toBe(false);
-        });
-
-        it('hasAnyRole should return true if any role exists', () => {
-            expect(rbac.hasAnyRole(['admin', 'user'], token)).toBe(true);
-            expect(rbac.hasAnyRole(['user', 'guest'], token)).toBe(false);
-        });
-
-        it('hasAllRoles should return true if all roles exist', () => {
-            expect(rbac.hasAllRoles(['admin', 'manager'], token)).toBe(true);
-            expect(rbac.hasAllRoles(['admin', 'user'], token)).toBe(false);
-        });
-
-        it('hasPermission should return true if permission exists', () => {
-            expect(rbac.hasPermission('users.view', token)).toBe(true);
-            expect(rbac.hasPermission('users.delete', token)).toBe(false);
-        });
-
-        it('setToken should cache the token for parameter-less calls', () => {
-            rbac.setToken(token);
-            expect(rbac.hasRole('admin')).toBe(true);
-            expect(rbac.hasPermission('users.edit')).toBe(true);
-
-            rbac.setToken(null);
-            expect(rbac.hasRole('admin')).toBe(false);
-        });
-    });
-
-    describe('Roles CRUD & Permissions', () => {
-        it('listRoles should GET /api/v1/auth/roles/', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce([{ id: '1', name: 'admin' }]);
-            const result = await rbac.listRoles();
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/', { method: 'GET' });
-            expect(result.length).toBe(1);
-        });
-
-        it('createRole should POST /api/v1/auth/roles/', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce({ id: '2', name: 'newRole' });
-            const data = { name: 'newRole', permission_codes: ['a.b'] };
-            await rbac.createRole(data);
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/', {
-                method: 'POST',
-                body: data,
-            });
-        });
-
-        it('assignRoleToUser should POST to users/{id}/roles/', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce(undefined);
-            await rbac.assignRoleToUser('user123', 'admin');
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/users/user123/roles/', {
-                method: 'POST',
-                body: { role_code: 'admin' },
-            });
-        });
-
-        it('removePermissionsFromRole should DELETE with body payload if config allows', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce(undefined);
-            await rbac.removePermissionsFromRole('role123', ['users.view']);
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/role123/permissions/', {
-                method: 'DELETE',
-                body: { permission_codes: ['users.view'] },
-            } as any);
-        });
-    });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RbacModule } from '../../src/modules/rbac';
+import { TenxyteHttpClient } from '../../src/http/client';
+
+// Helper to create a dummy JWT for testing
+function createDummyJwt(payload: any) {
+    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64');
+    return `header.${encodedPayload}.signature`;
+}
+
+describe('RbacModule', () => {
+    let client: TenxyteHttpClient;
+    let rbac: RbacModule;
+
+    beforeEach(() => {
+        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
+        rbac = new RbacModule(client);
+        vi.spyOn(client, 'request').mockImplementation(async () => {
+            return {};
+        });
+    });
+
+    describe('Synchronous Decoding & Checks', () => {
+        const token = createDummyJwt({
+            roles: ['admin', 'manager'],
+            permissions: ['users.view', 'users.edit']
+        });
+
+        it('hasRole should return true if role exists', () => {
+            expect(rbac.hasRole('admin', token)).toBe(true);
+            expect(rbac.hasRole('user', token)).toBe(false);
+        });
+
+        it('hasAnyRole should return true if any role exists', () => {
+            expect(rbac.hasAnyRole(['admin', 'user'], token)).toBe(true);
+            expect(rbac.hasAnyRole(['user', 'guest'], token)).toBe(false);
+        });
+
+        it('hasAllRoles should return true if all roles exist', () => {
+            expect(rbac.hasAllRoles(['admin', 'manager'], token)).toBe(true);
+            expect(rbac.hasAllRoles(['admin', 'user'], token)).toBe(false);
+        });
+
+        it('hasPermission should return true if permission exists', () => {
+            expect(rbac.hasPermission('users.view', token)).toBe(true);
+            expect(rbac.hasPermission('users.delete', token)).toBe(false);
+        });
+
+        it('setToken should cache the token for parameter-less calls', () => {
+            rbac.setToken(token);
+            expect(rbac.hasRole('admin')).toBe(true);
+            expect(rbac.hasPermission('users.edit')).toBe(true);
+
+            rbac.setToken(null);
+            expect(rbac.hasRole('admin')).toBe(false);
+        });
+    });
+
+    describe('Roles CRUD & Permissions', () => {
+        it('listRoles should GET /api/v1/auth/roles/', async () => {
+            vi.mocked(client.request).mockResolvedValueOnce([{ id: '1', name: 'admin' }]);
+            const result = await rbac.listRoles();
+            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/', { method: 'GET' });
+            expect(result.length).toBe(1);
+        });
+
+        it('createRole should POST /api/v1/auth/roles/', async () => {
+            vi.mocked(client.request).mockResolvedValueOnce({ id: '2', name: 'newRole' });
+            const data = { name: 'newRole', permission_codes: ['a.b'] };
+            await rbac.createRole(data);
+            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/', {
+                method: 'POST',
+                body: data,
+            });
+        });
+
+        it('assignRoleToUser should POST to users/{id}/roles/', async () => {
+            vi.mocked(client.request).mockResolvedValueOnce(undefined);
+            await rbac.assignRoleToUser('user123', 'admin');
+            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/users/user123/roles/', {
+                method: 'POST',
+                body: { role_code: 'admin' },
+            });
+        });
+
+        it('removePermissionsFromRole should DELETE with body payload if config allows', async () => {
+            vi.mocked(client.request).mockResolvedValueOnce(undefined);
+            await rbac.removePermissionsFromRole('role123', ['users.view']);
+            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/role123/permissions/', {
+                method: 'DELETE',
+                body: { permission_codes: ['users.view'] },
+            } as any);
+        });
+    });
+});

package/tests/modules/security.test.ts

@@ -1,75 +1,85 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { SecurityModule } from '../../src/modules/security';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-describe('SecurityModule', () => {
-    let client: TenxyteHttpClient;
-    let security: SecurityModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        security = new SecurityModule(client);
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    it('requestOtp should POST to /api/v1/auth/otp/request/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        const data = { email: 'test@example.com', type: 'email_verification' as const };
-        await security.requestOtp(data);
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/otp/request/', {
-            method: 'POST',
-            body: data,
-        });
-    });
-
-    it('setup2FA should POST to /api/v1/auth/2fa/setup/', async () => {
-        const mockResponse = { secret: 'secret_key', qr_code_url: 'url', backup_codes: ['123'] };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-
-        const result = await security.setup2FA();
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/2fa/setup/', {
-            method: 'POST',
-            body: undefined
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('confirm2FA should POST to /api/v1/auth/2fa/confirm/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await security.confirm2FA('123456');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/2fa/confirm/', {
-            method: 'POST',
-            body: { totp_code: '123456' },
-        });
-    });
-
-    it('resetPasswordRequest should POST to /api/v1/auth/password/reset/request/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await security.resetPasswordRequest({ email: 'hello@example.com' });
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/password/reset/request/', {
-            method: 'POST',
-            body: { email: 'hello@example.com' },
-        });
-    });
-
-    it('authenticateWebAuthnBegin should POST to /api/v1/auth/webauthn/authenticate/begin/', async () => {
-        const mockResponse = { publicKey: {} };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-        const result = await security.authenticateWebAuthnBegin({ email: 'user@example.com' });
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/webauthn/authenticate/begin/', {
-            method: 'POST',
-            body: { email: 'user@example.com' },
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('deleteWebAuthnCredential should DELETE /api/v1/auth/webauthn/credentials/{credentialId}/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await security.deleteWebAuthnCredential('cred_123');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/webauthn/credentials/cred_123/', {
-            method: 'DELETE',
-        });
-    });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SecurityModule } from '../../src/modules/security';
+import { TenxyteHttpClient } from '../../src/http/client';
+
+describe('SecurityModule', () => {
+    let client: TenxyteHttpClient;
+    let security: SecurityModule;
+
+    beforeEach(() => {
+        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
+        security = new SecurityModule(client);
+        vi.spyOn(client, 'request').mockImplementation(async () => {
+            return {};
+        });
+    });
+
+    it('requestOtp should POST to /api/v1/auth/otp/request/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+        await security.requestOtp('email');
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/otp/request/', {
+            method: 'POST',
+            body: { type: 'email_verification' },
+        });
+    });
+
+    it('setup2FA should POST to /api/v1/auth/2fa/setup/', async () => {
+        const mockResponse = { secret: 'secret_key', qr_code_url: 'url', backup_codes: ['123'] };
+        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
+
+        const result = await security.setup2FA();
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/2fa/setup/', {
+            method: 'POST',
+            body: undefined
+        });
+        expect(result).toEqual(mockResponse);
+    });
+
+    it('confirm2FA should POST to /api/v1/auth/2fa/confirm/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+        await security.confirm2FA('123456');
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/2fa/confirm/', {
+            method: 'POST',
+            body: { totp_code: '123456' },
+        });
+    });
+
+    it('resetPasswordRequest should POST to /api/v1/auth/password/reset/request/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+        await security.resetPasswordRequest({ email: 'hello@example.com' });
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/password/reset/request/', {
+            method: 'POST',
+            body: { email: 'hello@example.com' },
+        });
+    });
+
+    it('authenticateWebAuthn should POST to /api/v1/auth/webauthn/authenticate/begin/', async () => {
+        const mockResponse = { publicKey: {} };
+        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
+        // We mock navigator to stop the promise from throwing regarding missing credentials API
+        vi.stubGlobal('navigator', {
+            credentials: {
+                get: vi.fn(),
+            }
+        });
+
+        try {
+            await security.authenticateWebAuthn('user@example.com');
+        } catch (e) { /* expected to throw because navigator mock returns undefined */ }
+
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/webauthn/authenticate/begin/', {
+            method: 'POST',
+            body: { email: 'user@example.com' },
+        });
+
+        vi.unstubAllGlobals();
+    });
+
+    it('deleteWebAuthnCredential should DELETE /api/v1/auth/webauthn/credentials/{credentialId}/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+        await security.deleteWebAuthnCredential(123);
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/webauthn/credentials/123/', {
+            method: 'DELETE',
+        });
+    });
+});

package/tests/modules/user.test.ts

@@ -1,76 +1,76 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { UserModule } from '../../src/modules/user';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-describe('UserModule', () => {
-    let client: TenxyteHttpClient;
-    let user: UserModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        user = new UserModule(client);
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    // --- Profile ---
-    it('getProfile should GET /api/v1/auth/me/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce({ id: 'me' });
-        const result = await user.getProfile();
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', { method: 'GET' });
-        expect(result.id).toBe('me');
-    });
-
-    it('updateProfile should PATCH /api/v1/auth/me/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce({ id: 'me' });
-        const data = { first_name: 'John' };
-        await user.updateProfile(data);
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', {
-            method: 'PATCH',
-            body: data,
-        });
-    });
-
-    it('uploadAvatar should PATCH /api/v1/auth/me/ with FormData', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-
-        // Mock global FormData if not in purely browser environment
-        const FormDataMock = class { append() { } };
-        const formData = new FormDataMock() as any;
-
-        await user.uploadAvatar(formData);
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', {
-            method: 'PATCH',
-            body: formData,
-        });
-    });
-
-    it('deleteAccount should POST to /api/v1/auth/request-account-deletion/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await user.deleteAccount('mypassword', '123456');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/request-account-deletion/', {
-            method: 'POST',
-            body: { password: 'mypassword', otp_code: '123456' },
-        });
-    });
-
-    // --- Admin Actions ---
-    it('listUsers should GET /api/v1/auth/admin/users/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce([]);
-        await user.listUsers({ page: 1 });
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/admin/users/', {
-            method: 'GET',
-            params: { page: 1 },
-        });
-    });
-
-    it('banUser should POST /api/v1/auth/admin/users/{id}/ban/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await user.banUser('user-1', 'spam');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/admin/users/user-1/ban/', {
-            method: 'POST',
-            body: { reason: 'spam' },
-        });
-    });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { UserModule } from '../../src/modules/user';
+import { TenxyteHttpClient } from '../../src/http/client';
+
+describe('UserModule', () => {
+    let client: TenxyteHttpClient;
+    let user: UserModule;
+
+    beforeEach(() => {
+        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
+        user = new UserModule(client);
+        vi.spyOn(client, 'request').mockImplementation(async () => {
+            return {};
+        });
+    });
+
+    // --- Profile ---
+    it('getProfile should GET /api/v1/auth/me/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce({ id: 'me' });
+        const result = await user.getProfile();
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', { method: 'GET' });
+        expect(result.id).toBe('me');
+    });
+
+    it('updateProfile should PATCH /api/v1/auth/me/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce({ id: 'me' });
+        const data = { first_name: 'John' };
+        await user.updateProfile(data);
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', {
+            method: 'PATCH',
+            body: data,
+        });
+    });
+
+    it('uploadAvatar should PATCH /api/v1/auth/me/ with FormData', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+
+        // Mock global FormData if not in purely browser environment
+        const FormDataMock = class { append() { } };
+        const formData = new FormDataMock() as any;
+
+        await user.uploadAvatar(formData);
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', {
+            method: 'PATCH',
+            body: formData,
+        });
+    });
+
+    it('deleteAccount should POST to /api/v1/auth/request-account-deletion/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+        await user.deleteAccount('mypassword', '123456');
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/request-account-deletion/', {
+            method: 'POST',
+            body: { password: 'mypassword', otp_code: '123456' },
+        });
+    });
+
+    // --- Admin Actions ---
+    it('listUsers should GET /api/v1/auth/admin/users/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce([]);
+        await user.listUsers({ page: 1 });
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/admin/users/', {
+            method: 'GET',
+            params: { page: 1 },
+        });
+    });
+
+    it('banUser should POST /api/v1/auth/admin/users/{id}/ban/', async () => {
+        vi.mocked(client.request).mockResolvedValueOnce(undefined);
+        await user.banUser('user-1', 'spam');
+        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/admin/users/user-1/ban/', {
+            method: 'POST',
+            body: { reason: 'spam' },
+        });
+    });
+});