resolve conflicts

src/utils/auth/login.js

@@ -1,4 +1,4 @@
-import getXSRFToken from "./getXSRF.js";
+import getXSRFToken from "../getXSRF.js";
 
 export default async function login(email, password) {
     const csrfToken = await getXSRFToken();
@@ -15,17 +15,18 @@ export default async function login(email, password) {
             body: JSON.stringify({ email, password })
         });
 
-        console.log('Code HTTP :', response.status);
+        const data = await response.json();
 
         if (!response.ok) {
-            throw new Error(`Erreur HTTP ${response.status}`);
+            return {
+                status: response.status,
+                errors: data.errors || data.message
+            };
         }
 
-        const data = await response.json();
-        console.log('Connexion réussie ! Données utilisateur :', data);
-
         return { status: response.status, data };
+
     } catch (error) {
-        return error;
+        return { status: 500, error };
     }
 }

src/utils/auth/login.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import login from './login';
+
+vi.mock('../getXSRF.js', () => ({
+    default: vi.fn(() => Promise.resolve('fake-csrf-token'))
+}));
+
+describe('login()', () => {
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        global.fetch = vi.fn();
+    });
+
+    it('envoie la requête de login et retourne les données utilisateur', async () => {
+        global.fetch.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({ id: 1, name: 'John Doe' })
+        });
+
+        const result = await login('test@example.com', 'secret');
+
+        expect(global.fetch).toHaveBeenCalledOnce();
+        expect(global.fetch).toHaveBeenCalledWith(
+            `http://${import.meta.env.VITE_API_URL}/api/users/login`,
+            {
+                method: 'POST',
+                credentials: 'include',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-XSRF-TOKEN': 'fake-csrf-token',
+                    'Accept': 'application/json'
+                },
+                body: JSON.stringify({ email: 'test@example.com', password: 'secret' })
+            }
+        );
+
+        expect(result).toEqual({
+            status: 200,
+            data: { id: 1, name: 'John Doe' }
+        });
+    });
+
+    it('retourne un objet avec status et erreurs quand la réponse HTTP est mauvaise', async () => {
+        global.fetch.mockResolvedValue({
+            ok: false,
+            status: 401,
+            json: async () => ({ message: 'Unauthorized' })
+        });
+
+        const result = await login('x', 'y');
+
+        expect(result).toEqual({
+            status: 401,
+            errors: 'Unauthorized'
+        });
+    });
+
+    it('retourne un objet avec status 500 en cas d’exception', async () => {
+        global.fetch.mockImplementation(() => { throw new Error('Network Error') });
+
+        const result = await login('x', 'y');
+
+        expect(result.status).toBe(500);
+        expect(result.error).toBeInstanceOf(Error);
+        expect(result.error.message).toBe('Network Error');
+    });
+});

src/utils/auth/logout.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import logout from './logout';
+
+vi.mock('../getXSRF.js', () => {
+    return {
+        default: vi.fn(() => Promise.resolve('fake-csrf-token'))
+    };
+});
+
+describe('logout()', () => {
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        global.fetch = vi.fn();
+    });
+
+    it('envoie bien la requête de logout', async () => {
+        global.fetch.mockResolvedValue({
+            ok: true,
+            status: 200
+        });
+
+        const result = await logout();
+
+        expect(global.fetch).toHaveBeenCalledOnce();
+        expect(global.fetch).toHaveBeenCalledWith(
+            `http://${import.meta.env.VITE_API_URL}/api/users/logout`,
+            {
+                method: 'POST',
+                credentials: 'include',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'X-XSRF-TOKEN': 'fake-csrf-token'
+                },
+            }
+        );
+
+        expect(result).toEqual({ status: 200 });
+    });
+
+    it('renvoie une erreur quand la réponse HTTP est mauvaise', async () => {
+        global.fetch.mockResolvedValue({
+            ok: false,
+            status: 500
+        });
+
+        const result = await logout();
+
+        expect(result).toBeInstanceOf(Error);
+        expect(result.message).toBe('Erreur HTTP 500');
+    });
+});

src/utils/event/createEvent.js

@@ -0,0 +1,36 @@
+import getXSRFToken from "../getXSRF.js";
+
+export default async function createEvent(name, description) {
+    const csrfToken = await getXSRFToken();
+
+    try {
+        const response = await fetch(`http://${import.meta.env.VITE_API_URL}/api/events/create`, {
+            method: 'POST',
+            credentials: 'include',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-XSRF-TOKEN': csrfToken,
+                'Accept': 'application/json'
+            },
+            body: JSON.stringify({ name, description }),
+        });
+
+        const data = await response.json();
+
+        if (!response.ok) {
+            if (response.status === 422) {
+                return {
+                    status: 422,
+                    errors: data.errors
+                };
+            }
+
+            throw new Error(`Erreur HTTP ${response.status}`);
+        }
+
+        return { status: response.status, data };
+
+    } catch (error) {
+        return { status: "error", error };
+    }
+}

src/utils/users/getUserById.js

@@ -1,4 +1,4 @@
-export default async function getUserById (id) {
+export default async function getUserById(id) {
     try {
         const res = await fetch(`http://${import.meta.env.VITE_API_URL}/api/users/${id}`, {
             method: 'GET',
@@ -9,12 +9,15 @@ export default async function getUserById (id) {
         });
 
         if (!res.ok) {
+            if (res.status === 404) {
+                return { error: 'not_found' };
+            }
             throw new Error(`Erreur serveur : ${res.status}`);
         }
 
         return await res.json();
     } catch (err) {
         console.error('Erreur :', err);
-        return null;
+        return { error: 'server_error' };
     }
-}
+}