test: update test expectations for new Telegram API response format

- Update e2e tests to handle new response structure with result field
- Fix test expectations for error status codes (404 instead of 500)
- Update unit tests to use fetch mocks instead of node-telegram-bot-api
- All 45 tests now passing with real Telegram API integration

Author: SeddikBellamine

dapp/tests/_test_outputs_/iexec_out/result.txt

@@ -1,4 +1,24 @@
 {
   "message": "Your telegram message has been sent successfully.",
-  "status": 200
+  "status": 200,
+  "result": {
+    "ok": true,
+    "result": {
+      "message_id": 1476,
+      "from": {
+        "id": 7045386731,
+        "is_bot": true,
+        "first_name": "Web3Telegram",
+        "username": "Web3Telegram_Bot"
+      },
+      "chat": {
+        "id": 6064290146,
+        "first_name": "Arty",
+        "username": "Arty3824",
+        "type": "private"
+      },
+      "date": 1754654654,
+      "text": "Message from: e2e test\nweb3mail test : encrypted email content"
+    }
+  }
 }

dapp/tests/e2e/app.test.js

@@ -161,10 +161,10 @@ describe('sendTelegram', () => {
       'utf-8'
     );
 
-    expect(JSON.parse(resultTxt)).toStrictEqual({
-      message: 'Failed to send Telegram message.',
-      status: 500,
-    });
+    const result = JSON.parse(resultTxt);
+    expect(result.message).toBe('Failed to send Telegram message.');
+    expect(result.status).toBe(404);
+    expect(result.error).toBeDefined();
     expect(JSON.parse(computedJson)).toStrictEqual({
       'deterministic-output-path': `${IEXEC_OUT}/result.txt`,
     });
@@ -183,10 +183,10 @@ describe('sendTelegram', () => {
       'utf-8'
     );
 
-    expect(JSON.parse(resultTxt)).toStrictEqual({
-      message: 'Your telegram message has been sent successfully.',
-      status: 200,
-    });
+    const result = JSON.parse(resultTxt);
+    expect(result.message).toBe('Your telegram message has been sent successfully.');
+    expect(result.status).toBe(200);
+    expect(result.result).toBeDefined();
     expect(JSON.parse(computedJson)).toStrictEqual({
       'deterministic-output-path': `${IEXEC_OUT}/result.txt`,
     });

dapp/tests/unit/telegramService.test.js

@@ -1,13 +1,8 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { jest } from '@jest/globals';
 
-await jest.unstable_mockModule('node-telegram-bot-api', () => ({
-  default: jest.fn().mockImplementation(() => ({
-    sendMessage: jest.fn().mockResolvedValue({}),
-  })),
-}));
-
-const TelegramBot = (await import('node-telegram-bot-api')).default;
+// Mock fetch globally
+global.fetch = jest.fn();
 
 const sendTelegram = (await import('../../src/telegramService')).default;
 
@@ -22,10 +17,11 @@ describe('sendTelegram', () => {
   });
 
   it('sends a Telegram message successfully', async () => {
-    const mockSendMessage = jest.fn().mockResolvedValue({});
-    TelegramBot.mockImplementation(() => ({
-      sendMessage: mockSendMessage,
-    }));
+    const mockResponse = {
+      ok: true,
+      json: jest.fn().mockResolvedValue({ ok: true, result: {} }),
+    };
+    global.fetch.mockResolvedValue(mockResponse);
 
     const response = await sendTelegram({
       chatId,
@@ -34,29 +30,38 @@ describe('sendTelegram', () => {
       senderName,
     });
 
-    expect(TelegramBot).toHaveBeenCalledWith(botToken);
-
-    expect(mockSendMessage).toHaveBeenCalledWith(
-      chatId,
-      `Message from: ${senderName}\n${message}`
+    expect(global.fetch).toHaveBeenCalledWith(
+      `https://api.telegram.org/bot${botToken}/sendMessage`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          chat_id: chatId,
+          text: `Message from: ${senderName}\n${message}`,
+          parse_mode: 'HTML'
+        })
+      }
     );
 
     expect(response).toEqual({
       message: 'Your telegram message has been sent successfully.',
       status: 200,
+      result: { ok: true, result: {} }
     });
   });
 
   it('handles errors when sending a Telegram message', async () => {
-    const mockSendMessage = jest
-      .fn()
-      .mockRejectedValue(new Error('Network error'));
-
-    TelegramBot.mockImplementation(() => ({
-      sendMessage: mockSendMessage,
-    }));
-
-    console.error = jest.fn();
+    const mockResponse = {
+      ok: false,
+      status: 400,
+      json: jest.fn().mockResolvedValue({ 
+        ok: false, 
+        description: 'Bad Request' 
+      }),
+    };
+    global.fetch.mockResolvedValue(mockResponse);
 
     const response = await sendTelegram({
       chatId,
@@ -65,21 +70,27 @@ describe('sendTelegram', () => {
       senderName,
     });
 
-    // ✅ Fix: Only check `botToken` in the expectation
-    expect(TelegramBot).toHaveBeenCalledWith(botToken);
+    expect(response).toEqual({
+      message: 'Failed to send Telegram message.',
+      status: 400,
+      error: 'Bad Request'
+    });
+  });
 
-    expect(mockSendMessage).toHaveBeenCalledWith(
-      chatId,
-      `Message from: ${senderName}\n${message}`
-    );
+  it('handles network errors', async () => {
+    global.fetch.mockRejectedValue(new Error('Network error'));
 
-    expect(console.error).toHaveBeenCalledWith(
-      'Failed to send Telegram message.'
-    );
+    const response = await sendTelegram({
+      chatId,
+      message,
+      botToken,
+      senderName,
+    });
 
     expect(response).toEqual({
       message: 'Failed to send Telegram message.',
       status: 500,
+      error: 'Network error'
     });
   });
 
@@ -102,24 +113,14 @@ describe('sendTelegram', () => {
   });
 
   it('should not throw an error when sender name is undefined', async () => {
-    const mockSendMessage = jest.fn().mockResolvedValue({});
-    TelegramBot.mockImplementation(() => ({
-      sendMessage: mockSendMessage,
-    }));
+    const mockResponse = {
+      ok: true,
+      json: jest.fn().mockResolvedValue({ ok: true, result: {} }),
+    };
+    global.fetch.mockResolvedValue(mockResponse);
 
     await expect(
       sendTelegram({ chatId, message, botToken })
     ).resolves.not.toThrow();
   });
-
-  it('should not throw an error when sender name is undefined', async () => {
-    const mockSendMessage = jest.fn().mockResolvedValue({});
-    TelegramBot.mockImplementation(() => ({
-      sendMessage: mockSendMessage,
-    }));
-
-    await expect(
-      sendTelegram({ chatId, message, botToken, senderName: undefined })
-    ).resolves.not.toThrow();
-  });
 });