diff --git a/src/api/__tests__/request.test.js b/src/api/__tests__/request.test.js
new file mode 100644
index 0000000..a1a553f
--- /dev/null
+++ b/src/api/__tests__/request.test.js
@@ -0,0 +1,217 @@
+// src/api/__tests__/request.test.js
+const axios = require('axios');
+const {
+    createRequest,
+    updateMoney,
+    updateLoaduserByName,
+    updateTorrentid,
+    getTorrentid,
+    deleteRequest,
+    findByName,
+    findByUserid,
+    findByLoaduser,
+    getTotalMoneyByName,
+    getAllRequests,
+    getInfoByRequestId,
+} = require('../request');
+
+jest.mock('axios');
+
+describe('Request API Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('createRequest should post form data with correct headers', async () => {
+        const formData = new FormData();
+        formData.append('title', 'Help');
+        axios.post.mockResolvedValue({ data: { success: true } });
+
+        const res = await createRequest(formData);
+
+        expect(axios.post).toHaveBeenCalledWith(
+            'http://localhost:8080/request/create',
+            formData,
+            { headers: { 'Content-Type': 'multipart/form-data' } }
+        );
+        expect(res.data).toEqual({ success: true });
+    });
+
+    test('updateMoney should send PUT request with money param', async () => {
+        axios.put.mockResolvedValue({ data: true });
+
+        const res = await updateMoney(1, 100);
+
+        expect(axios.put).toHaveBeenCalledWith(
+            'http://localhost:8080/request/updateMoney/1',
+            null,
+            { params: { money: 100 } }
+        );
+        expect(res.data).toBe(true);
+    });
+
+    test('updateLoaduserByName should send POST request with params', async () => {
+        axios.post.mockResolvedValue({ data: true });
+
+        const res = await updateLoaduserByName('testname', 10);
+
+        expect(axios.post).toHaveBeenCalledWith(
+            'http://localhost:8080/request/updateLoaduserByName',
+            null,
+            { params: { name: 'testname', loaduser: 10 } }
+        );
+        expect(res.data).toBe(true);
+    });
+
+    test('updateTorrentid should send PUT request with params', async () => {
+        axios.put.mockResolvedValue({ data: true });
+
+        const res = await updateTorrentid(5, 'torrent123');
+
+        expect(axios.put).toHaveBeenCalledWith(
+            'http://localhost:8080/request/updateTorrentid/5',
+            null,
+            { params: { torrentid: 'torrent123' } }
+        );
+        expect(res.data).toBe(true);
+    });
+
+    test('getTorrentid should fetch torrentid successfully', async () => {
+        axios.get.mockResolvedValue({ data: 'torrent123' });
+
+        const res = await getTorrentid(5);
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/getTorrentid/5');
+        expect(res).toBe('torrent123');
+    });
+
+    test('getTorrentid should return null on error', async () => {
+        axios.get.mockRejectedValue(new Error('fail'));
+
+        const res = await getTorrentid(5);
+
+        expect(res).toBeNull();
+    });
+
+    test('deleteRequest should send DELETE request', async () => {
+        axios.delete.mockResolvedValue({ data: true });
+
+        const res = await deleteRequest(3);
+
+        expect(axios.delete).toHaveBeenCalledWith('http://localhost:8080/request/delete/3');
+        expect(res.data).toBe(true);
+    });
+
+    test('findByName should return array on success', async () => {
+        axios.get.mockResolvedValue({ data: [{ id: 1 }] });
+
+        const res = await findByName('Alice');
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/findByName', {
+            params: { name: 'Alice' },
+        });
+        expect(res).toEqual([{ id: 1 }]);
+    });
+
+    test('findByName should return empty array on error', async () => {
+        axios.get.mockRejectedValue(new Error('fail'));
+
+        const res = await findByName('Alice');
+
+        expect(res).toEqual([]);
+    });
+
+    test('findByUserid should return array on success', async () => {
+        axios.get.mockResolvedValue({ data: [{ id: 2 }] });
+
+        const res = await findByUserid(10);
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/findByUserid', {
+            params: { userid: 10 },
+        });
+        expect(res).toEqual([{ id: 2 }]);
+    });
+
+    test('findByUserid should return empty array on error', async () => {
+        axios.get.mockRejectedValue(new Error('fail'));
+
+        const res = await findByUserid(10);
+
+        expect(res).toEqual([]);
+    });
+
+    test('findByLoaduser should return array on success', async () => {
+        axios.get.mockResolvedValue({ data: [{ id: 3 }] });
+
+        const res = await findByLoaduser(20);
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/findByLoaduser', {
+            params: { loaduser: 20 },
+        });
+        expect(res).toEqual([{ id: 3 }]);
+    });
+
+    test('findByLoaduser should return empty array on error', async () => {
+        axios.get.mockRejectedValue(new Error('fail'));
+
+        const res = await findByLoaduser(20);
+
+        expect(res).toEqual([]);
+    });
+
+    test('getTotalMoneyByName should return number on success', async () => {
+        axios.get.mockResolvedValue({ data: 123 });
+
+        const res = await getTotalMoneyByName('Bob');
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/totalMoneyByName', {
+            params: { name: 'Bob' },
+        });
+        expect(res).toBe(123);
+    });
+
+    test('getTotalMoneyByName should return 0 on error or invalid data', async () => {
+        axios.get.mockResolvedValue({ data: 'NaN' });
+
+        const res1 = await getTotalMoneyByName('Bob');
+        expect(res1).toBe(0);
+
+        axios.get.mockRejectedValue(new Error('fail'));
+        const res2 = await getTotalMoneyByName('Bob');
+        expect(res2).toBe(0);
+    });
+
+    test('getAllRequests should return array on success', async () => {
+        axios.get.mockResolvedValue({ data: [{ id: 4 }] });
+
+        const res = await getAllRequests();
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/all');
+        expect(res).toEqual([{ id: 4 }]);
+    });
+
+    test('getAllRequests should return empty array on error', async () => {
+        axios.get.mockRejectedValue(new Error('fail'));
+
+        const res = await getAllRequests();
+
+        expect(res).toEqual([]);
+    });
+
+    test('getInfoByRequestId should return object on success', async () => {
+        axios.get.mockResolvedValue({ data: { torrentid: 'abc', money: 100, loaduser: 10 } });
+
+        const res = await getInfoByRequestId(8);
+
+        expect(axios.get).toHaveBeenCalledWith('http://localhost:8080/request/info/8');
+        expect(res).toEqual({ torrentid: 'abc', money: 100, loaduser: 10 });
+    });
+
+    test('getInfoByRequestId should return empty object on error', async () => {
+        axios.get.mockRejectedValue(new Error('fail'));
+
+        const res = await getInfoByRequestId(8);
+
+        expect(res).toEqual({});
+    });
+});