Rajeh Taher
645 lines
20 KiB
TypeScript
645 lines
20 KiB
TypeScript
import { Boom } from '@hapi/boom'
|
|
import { jest } from '@jest/globals'
|
|
import { readFileSync } from 'node:fs'
|
|
import P from 'pino'
|
|
import makeWASocket, {
|
|
DisconnectReason,
|
|
downloadContentFromMessage,
|
|
downloadMediaMessage,
|
|
jidNormalizedUser,
|
|
proto,
|
|
toBuffer,
|
|
useMultiFileAuthState,
|
|
type WAMessage
|
|
} from '../../index'
|
|
|
|
jest.setTimeout(30_000)
|
|
|
|
describe('E2E Tests', () => {
|
|
let sock: ReturnType<typeof makeWASocket>
|
|
let meJid: string | undefined
|
|
let meLid: string | undefined
|
|
let groupJid: string | undefined
|
|
|
|
beforeAll(async () => {
|
|
const { state, saveCreds } = await useMultiFileAuthState('baileys_auth_info')
|
|
const logger = P({ level: 'silent' })
|
|
|
|
sock = makeWASocket({
|
|
auth: state,
|
|
logger
|
|
})
|
|
|
|
sock.ev.on('creds.update', saveCreds)
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
sock.ev.on('connection.update', update => {
|
|
const { connection, lastDisconnect } = update
|
|
if (connection === 'open') {
|
|
meJid = jidNormalizedUser(sock.user?.id)
|
|
meLid = sock.user?.lid
|
|
|
|
sock
|
|
.groupFetchAllParticipating()
|
|
.then(groups => {
|
|
const group = Object.values(groups).find(g => g.subject === 'Baileys Group Test')
|
|
if (group) {
|
|
groupJid = group.id
|
|
console.log(`Found test group "${group.subject}" with JID: ${groupJid}`)
|
|
}
|
|
|
|
resolve()
|
|
})
|
|
.catch(reject)
|
|
} else if (connection === 'close') {
|
|
const reason = (lastDisconnect?.error as Boom)?.output?.statusCode
|
|
if (reason === DisconnectReason.loggedOut) {
|
|
console.error('Logged out, please delete the baileys_auth_info_e2e folder and re-run the test')
|
|
}
|
|
|
|
if (lastDisconnect?.error) {
|
|
reject(new Error(`Connection closed: ${DisconnectReason[reason] || 'unknown'}`))
|
|
}
|
|
}
|
|
})
|
|
})
|
|
})
|
|
|
|
afterAll(async () => {
|
|
if (sock) {
|
|
await sock.end(undefined)
|
|
}
|
|
})
|
|
|
|
test('should send a message', async () => {
|
|
const messageContent = `E2E Test Message ${Date.now()}`
|
|
const sentMessage = await sock.sendMessage(meJid!, { text: messageContent })
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent message:', sentMessage!.key.id)
|
|
expect(sentMessage!.key.id).toBeTruthy()
|
|
expect(sentMessage!.message?.extendedTextMessage?.text || sentMessage!.message?.conversation).toBe(messageContent)
|
|
})
|
|
|
|
test('should edit a message', async () => {
|
|
const messageContent = `E2E Test Message to Edit ${Date.now()}`
|
|
const sentMessage = await sock.sendMessage(meJid!, { text: messageContent })
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent message to edit:', sentMessage!.key.id)
|
|
|
|
const newContent = `E2E Edited Message ${Date.now()}`
|
|
const editedMessage = await sock.sendMessage(meJid!, {
|
|
text: newContent,
|
|
edit: sentMessage!.key
|
|
})
|
|
|
|
expect(editedMessage).toBeDefined()
|
|
console.log('Edited message response:', editedMessage!.key.id)
|
|
|
|
expect(editedMessage!.message?.protocolMessage?.type).toBe(proto.Message.ProtocolMessage.Type.MESSAGE_EDIT)
|
|
const editedContent = editedMessage!.message?.protocolMessage?.editedMessage
|
|
expect(editedContent?.extendedTextMessage?.text || editedContent?.conversation).toBe(newContent)
|
|
})
|
|
|
|
test('should react to a message', async () => {
|
|
const messageContent = `E2E Test Message to React to ${Date.now()}`
|
|
const sentMessage = await sock.sendMessage(meJid!, { text: messageContent })
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent message to react to:', sentMessage!.key.id)
|
|
|
|
const reaction = '👍'
|
|
const reactionMessage = await sock.sendMessage(meJid!, {
|
|
react: {
|
|
text: reaction,
|
|
key: sentMessage!.key
|
|
}
|
|
})
|
|
|
|
expect(reactionMessage).toBeDefined()
|
|
console.log('Sent reaction:', reactionMessage!.key.id)
|
|
|
|
expect(reactionMessage!.message?.reactionMessage?.text).toBe(reaction)
|
|
expect(reactionMessage!.message?.reactionMessage?.key?.id).toBe(sentMessage!.key.id)
|
|
})
|
|
|
|
test('should remove a reaction from a message', async () => {
|
|
const messageContent = `E2E Test Message to Remove Reaction from ${Date.now()}`
|
|
const sentMessage = await sock.sendMessage(meJid!, { text: messageContent })
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent message to remove reaction from:', sentMessage!.key.id)
|
|
|
|
await sock.sendMessage(meJid!, {
|
|
react: {
|
|
text: '😄',
|
|
key: sentMessage!.key
|
|
}
|
|
})
|
|
|
|
const removeReactionMessage = await sock.sendMessage(meJid!, {
|
|
react: {
|
|
text: '',
|
|
key: sentMessage!.key
|
|
}
|
|
})
|
|
|
|
expect(removeReactionMessage).toBeDefined()
|
|
console.log('Sent remove reaction:', removeReactionMessage!.key.id)
|
|
|
|
expect(removeReactionMessage!.message?.reactionMessage?.text).toBe('')
|
|
expect(removeReactionMessage!.message?.reactionMessage?.key?.id).toBe(sentMessage!.key.id)
|
|
})
|
|
|
|
test('should delete a message', async () => {
|
|
const messageContent = `E2E Test Message to Delete ${Date.now()}`
|
|
const sentMessage = await sock.sendMessage(meJid!, { text: messageContent })
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent message to delete:', sentMessage!.key.id)
|
|
|
|
const deleteMessage = await sock.sendMessage(meJid!, {
|
|
delete: sentMessage!.key
|
|
})
|
|
|
|
expect(deleteMessage).toBeDefined()
|
|
console.log('Sent delete message command:', deleteMessage!.key.id)
|
|
|
|
expect(deleteMessage!.message?.protocolMessage?.type).toBe(proto.Message.ProtocolMessage.Type.REVOKE)
|
|
expect(deleteMessage!.message?.protocolMessage?.key?.id).toBe(sentMessage!.key.id)
|
|
})
|
|
|
|
test('should forward a message', async () => {
|
|
const messageContent = `E2E Test Message to Forward ${Date.now()}`
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
text: messageContent
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent message to forward:', sentMessage!.key.id)
|
|
|
|
const forwardedMessage = await sock.sendMessage(meJid!, {
|
|
forward: sentMessage!
|
|
})
|
|
|
|
expect(forwardedMessage).toBeDefined()
|
|
console.log('Forwarded message:', forwardedMessage!.key.id)
|
|
|
|
const content = forwardedMessage!.message?.extendedTextMessage?.text || forwardedMessage!.message?.conversation
|
|
expect(content).toBe(messageContent)
|
|
expect(forwardedMessage!.key.id).not.toBe(sentMessage!.key.id)
|
|
})
|
|
|
|
test('should send an image message', async () => {
|
|
const image = readFileSync('./Media/cat.jpeg')
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
image: image,
|
|
caption: 'E2E Test Image'
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent image message:', sentMessage!.key.id)
|
|
expect(sentMessage!.message?.imageMessage).toBeDefined()
|
|
expect(sentMessage!.message?.imageMessage?.caption).toBe('E2E Test Image')
|
|
})
|
|
|
|
test('should send a video message with a thumbnail', async () => {
|
|
const video = readFileSync('./Media/ma_gif.mp4')
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
video: video,
|
|
caption: 'E2E Test Video'
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent video message:', sentMessage!.key.id)
|
|
expect(sentMessage!.message?.videoMessage).toBeDefined()
|
|
expect(sentMessage!.message?.videoMessage?.caption).toBe('E2E Test Video')
|
|
})
|
|
|
|
test('should send a PTT (push-to-talk) audio message', async () => {
|
|
const audio = readFileSync('./Media/sonata.mp3')
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
audio: audio,
|
|
ptt: true,
|
|
mimetype: 'audio/mp4'
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent PTT audio message:', sentMessage!.key.id)
|
|
expect(sentMessage!.message?.audioMessage).toBeDefined()
|
|
expect(sentMessage!.message?.audioMessage?.ptt).toBe(true)
|
|
})
|
|
|
|
test('should send a document message', async () => {
|
|
const document = readFileSync('./Media/ma_gif.mp4')
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
document: document,
|
|
mimetype: 'application/pdf',
|
|
fileName: 'E2E Test Document.pdf'
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent document message:', sentMessage!.key.id)
|
|
expect(sentMessage!.message?.documentMessage).toBeDefined()
|
|
expect(sentMessage!.message?.documentMessage?.fileName).toBe('E2E Test Document.pdf')
|
|
})
|
|
|
|
test('should send a sticker message', async () => {
|
|
const sticker = readFileSync('./Media/cat.jpeg')
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
sticker: sticker
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent sticker message:', sentMessage!.key.id)
|
|
expect(sentMessage!.message?.stickerMessage).toBeDefined()
|
|
})
|
|
|
|
test('should send a poll message and receive a vote', async () => {
|
|
const poll = {
|
|
name: 'E2E Test Poll',
|
|
values: ['Option 1', 'Option 2', 'Option 3'],
|
|
selectableCount: 1
|
|
}
|
|
const sentPoll = await sock.sendMessage(meJid!, { poll })
|
|
|
|
expect(sentPoll).toBeDefined()
|
|
console.log('Sent poll message:', sentPoll!.key.id)
|
|
expect(sentPoll?.message?.pollCreationMessageV3).toBeDefined()
|
|
expect(sentPoll?.message?.pollCreationMessageV3?.name).toBe('E2E Test Poll')
|
|
})
|
|
|
|
test('should send a contact (vCard) message', async () => {
|
|
const vcard =
|
|
'BEGIN:VCARD\n' +
|
|
'VERSION:3.0\n' +
|
|
'FN:E2E Test Contact\n' +
|
|
'ORG:Baileys Tests;\n' +
|
|
'TEL;type=CELL;type=VOICE;waid=1234567890:+1 234-567-890\n' +
|
|
'END:VCARD'
|
|
const sentMessage = await sock.sendMessage(meJid!, {
|
|
contacts: {
|
|
displayName: 'E2E Test Contact',
|
|
contacts: [{ vcard }]
|
|
}
|
|
})
|
|
|
|
expect(sentMessage).toBeDefined()
|
|
console.log('Sent contact message:', sentMessage!.key.id)
|
|
expect(sentMessage!.message?.contactMessage).toBeDefined()
|
|
expect(sentMessage!.message?.contactMessage?.vcard).toContain('FN:E2E Test Contact')
|
|
})
|
|
|
|
test('should send and download an image message', async () => {
|
|
const image = readFileSync('./Media/cat.jpeg')
|
|
const caption = 'E2E Test Image Download Success'
|
|
|
|
let listener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let timeoutId: NodeJS.Timeout | undefined
|
|
|
|
try {
|
|
const receivedMsgPromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
listener = ({ messages }) => {
|
|
const msg = messages.find(m => m.message?.imageMessage?.caption === caption)
|
|
if (msg) {
|
|
resolve(msg)
|
|
}
|
|
}
|
|
|
|
timeoutId = setTimeout(() => {
|
|
reject(new Error('Timed out waiting for the image message to be received'))
|
|
}, 30_000)
|
|
|
|
sock.ev.on('messages.upsert', listener)
|
|
})
|
|
|
|
await sock.sendMessage(meJid!, {
|
|
image: image,
|
|
caption: caption
|
|
})
|
|
|
|
const receivedMsg = await receivedMsgPromise
|
|
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
|
|
console.log('Received image message, attempting to download...')
|
|
|
|
const buffer = await downloadMediaMessage(
|
|
receivedMsg as WAMessage,
|
|
'buffer',
|
|
{},
|
|
{
|
|
logger: sock.logger,
|
|
reuploadRequest: m => sock.updateMediaMessage(m)
|
|
}
|
|
)
|
|
|
|
expect(Buffer.isBuffer(buffer)).toBe(true)
|
|
expect(buffer.length).toBeGreaterThan(0)
|
|
|
|
console.log('Successfully downloaded the image.')
|
|
} finally {
|
|
if (listener) {
|
|
sock.ev.off('messages.upsert', listener)
|
|
}
|
|
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId)
|
|
}
|
|
}
|
|
})
|
|
|
|
test('should send and download an image message via LID', async () => {
|
|
console.log(`Testing with self-LID: ${meLid}`)
|
|
|
|
const image = readFileSync('./Media/cat.jpeg')
|
|
const caption = 'E2E Test LID Image Download'
|
|
|
|
let listener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let timeoutId: NodeJS.Timeout | undefined
|
|
|
|
try {
|
|
const receivedMsgPromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
listener = ({ messages }) => {
|
|
const msg = messages.find(m => m.message?.imageMessage?.caption === caption)
|
|
if (msg) {
|
|
resolve(msg)
|
|
}
|
|
}
|
|
|
|
timeoutId = setTimeout(() => {
|
|
reject(new Error('Timed out waiting for the LID image message to be received'))
|
|
}, 30_000)
|
|
|
|
sock.ev.on('messages.upsert', listener)
|
|
})
|
|
|
|
await sock.sendMessage(meLid!, {
|
|
image: image,
|
|
caption: caption
|
|
})
|
|
|
|
const receivedMsg = await receivedMsgPromise
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
|
|
console.log('Received LID image message, attempting to download...')
|
|
|
|
const buffer = await downloadMediaMessage(
|
|
receivedMsg as WAMessage,
|
|
'buffer',
|
|
{},
|
|
{
|
|
logger: sock.logger,
|
|
reuploadRequest: m => sock.updateMediaMessage(m)
|
|
}
|
|
)
|
|
|
|
expect(Buffer.isBuffer(buffer)).toBe(true)
|
|
expect(buffer.length).toBeGreaterThan(0)
|
|
|
|
console.log('Successfully downloaded the image sent via LID.')
|
|
} finally {
|
|
if (listener) {
|
|
sock.ev.off('messages.upsert', listener)
|
|
}
|
|
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId)
|
|
}
|
|
}
|
|
})
|
|
|
|
test('should send and download an image using the low-level downloadContentFromMessage', async () => {
|
|
const image = readFileSync('./Media/cat.jpeg')
|
|
const caption = 'E2E Test Low-Level Download'
|
|
|
|
let listener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let timeoutId: NodeJS.Timeout | undefined
|
|
|
|
try {
|
|
const receivedMsgPromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
listener = ({ messages }) => {
|
|
const msg = messages.find(m => m.message?.imageMessage?.caption === caption)
|
|
if (msg) {
|
|
resolve(msg)
|
|
}
|
|
}
|
|
|
|
timeoutId = setTimeout(() => {
|
|
reject(new Error('Timed out waiting for the low-level test message'))
|
|
}, 30_000)
|
|
|
|
sock.ev.on('messages.upsert', listener)
|
|
})
|
|
|
|
await sock.sendMessage(meJid!, {
|
|
image: image,
|
|
caption: caption
|
|
})
|
|
|
|
const receivedMsg = await receivedMsgPromise
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
|
|
console.log('Received message for low-level download test, preparing to download...')
|
|
|
|
const imageMessage = receivedMsg.message?.imageMessage
|
|
expect(imageMessage).toBeDefined()
|
|
|
|
const downloadable: proto.Message.IImageMessage = {
|
|
url: imageMessage!.url,
|
|
mediaKey: imageMessage!.mediaKey,
|
|
directPath: imageMessage!.directPath
|
|
}
|
|
|
|
const stream = await downloadContentFromMessage(downloadable, 'image')
|
|
const buffer = await toBuffer(stream)
|
|
|
|
expect(Buffer.isBuffer(buffer)).toBe(true)
|
|
expect(buffer.length).toBeGreaterThan(0)
|
|
|
|
console.log('Successfully downloaded the image using downloadContentFromMessage.')
|
|
} finally {
|
|
if (listener) {
|
|
sock.ev.off('messages.upsert', listener)
|
|
}
|
|
|
|
if (timeoutId) {
|
|
clearTimeout(timeoutId)
|
|
}
|
|
}
|
|
})
|
|
|
|
test('should download a quoted image message using downloadContentFromMessage', async () => {
|
|
const image = readFileSync('./Media/cat.jpeg')
|
|
const originalCaption = 'This is the original media message'
|
|
const commandText = '-download'
|
|
|
|
let imageListener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let commandListener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let timeoutId: NodeJS.Timeout | undefined
|
|
|
|
try {
|
|
console.log('Sending initial image message...')
|
|
const receivedImagePromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
imageListener = ({ messages }) => {
|
|
const msg = messages.find(m => m.message?.imageMessage?.caption === originalCaption)
|
|
if (msg) resolve(msg)
|
|
}
|
|
|
|
sock.ev.on('messages.upsert', imageListener)
|
|
timeoutId = setTimeout(() => reject(new Error('Timed out waiting for initial image message')), 30_000)
|
|
})
|
|
|
|
const sentImageMessage = await sock.sendMessage(meJid!, {
|
|
image: image,
|
|
caption: originalCaption
|
|
})
|
|
await receivedImagePromise
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
|
|
if (imageListener) {
|
|
sock.ev.off('messages.upsert', imageListener)
|
|
}
|
|
|
|
console.log('Initial image message sent and received.')
|
|
|
|
console.log('Sending command message as a reply...')
|
|
const receivedCommandPromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
commandListener = ({ messages }) => {
|
|
const msg = messages.find(m => m.message?.extendedTextMessage?.text === commandText)
|
|
if (msg) resolve(msg)
|
|
}
|
|
|
|
sock.ev.on('messages.upsert', commandListener)
|
|
timeoutId = setTimeout(() => reject(new Error('Timed out waiting for command message')), 30_000)
|
|
})
|
|
|
|
await sock.sendMessage(meJid!, { text: commandText }, { quoted: sentImageMessage })
|
|
const receivedCommandMessage = await receivedCommandPromise
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
console.log('Command message received.')
|
|
|
|
console.log('Extracting quoted message and attempting download...')
|
|
|
|
const quotedMessage = receivedCommandMessage.message?.extendedTextMessage?.contextInfo?.quotedMessage
|
|
expect(quotedMessage).toBeDefined()
|
|
|
|
const quotedImage = quotedMessage!.imageMessage
|
|
expect(quotedImage).toBeDefined()
|
|
|
|
const downloadable: proto.Message.IImageMessage = {
|
|
url: quotedImage!.url,
|
|
mediaKey: quotedImage!.mediaKey,
|
|
directPath: quotedImage!.directPath
|
|
}
|
|
|
|
const stream = await downloadContentFromMessage(downloadable, 'image')
|
|
const buffer = await toBuffer(stream)
|
|
|
|
expect(Buffer.isBuffer(buffer)).toBe(true)
|
|
expect(buffer.length).toBeGreaterThan(0)
|
|
|
|
console.log('Successfully downloaded quoted image using downloadContentFromMessage.')
|
|
} finally {
|
|
if (imageListener) sock.ev.off('messages.upsert', imageListener)
|
|
if (commandListener) sock.ev.off('messages.upsert', commandListener)
|
|
if (timeoutId) clearTimeout(timeoutId)
|
|
}
|
|
})
|
|
|
|
test('should download a quoted videos message within a group', async () => {
|
|
if (!groupJid) {
|
|
console.warn('⚠️ Skipping group test because "Baileys Group Test" was not found.')
|
|
return
|
|
}
|
|
|
|
const video = readFileSync('./Media/ma_gif.mp4')
|
|
const originalCaption = 'This is the original media message for the group test'
|
|
const commandText = '-download group'
|
|
|
|
let videoListener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let commandListener: ((data: { messages: proto.IWebMessageInfo[] }) => void) | undefined
|
|
let timeoutId: NodeJS.Timeout | undefined
|
|
|
|
try {
|
|
console.log(`Sending initial video message to group ${groupJid}...`)
|
|
const receivedVideoPromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
videoListener = ({ messages }) => {
|
|
const msg = messages.find(
|
|
m => m.key!.remoteJid === groupJid && m.message?.videoMessage?.caption === originalCaption
|
|
)
|
|
if (msg) resolve(msg)
|
|
}
|
|
|
|
sock.ev.on('messages.upsert', videoListener)
|
|
timeoutId = setTimeout(() => reject(new Error('Timed out waiting for initial group image message')), 30_000)
|
|
})
|
|
|
|
const sentVideoMessage = await sock.sendMessage(groupJid, {
|
|
video: video,
|
|
caption: originalCaption
|
|
})
|
|
await receivedVideoPromise
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
if (videoListener) sock.ev.off('messages.upsert', videoListener)
|
|
console.log('Initial group image message sent and received.')
|
|
|
|
console.log('Sending command message as a reply in the group...')
|
|
const receivedCommandPromise = new Promise<proto.IWebMessageInfo>((resolve, reject) => {
|
|
commandListener = ({ messages }) => {
|
|
const msg = messages.find(
|
|
m => m.key!.remoteJid === groupJid && m.message?.extendedTextMessage?.text === commandText
|
|
)
|
|
if (msg) resolve(msg)
|
|
}
|
|
|
|
sock.ev.on('messages.upsert', commandListener)
|
|
timeoutId = setTimeout(() => reject(new Error('Timed out waiting for group command message')), 30_000)
|
|
})
|
|
|
|
await sock.sendMessage(groupJid, { text: commandText }, { quoted: sentVideoMessage })
|
|
const receivedCommandMessage = await receivedCommandPromise
|
|
clearTimeout(timeoutId)
|
|
timeoutId = undefined
|
|
console.log('Group command message received.')
|
|
|
|
console.log('Extracting quoted message from group chat and attempting download...')
|
|
|
|
const quotedMessage = receivedCommandMessage.message?.extendedTextMessage?.contextInfo?.quotedMessage
|
|
expect(quotedMessage).toBeDefined()
|
|
|
|
console.log('quotedMessage', JSON.stringify(quotedMessage, null, 2))
|
|
|
|
const quotedVideo = quotedMessage!.videoMessage
|
|
expect(quotedVideo).toBeDefined()
|
|
|
|
console.log('quotedVideo', JSON.stringify(quotedVideo, null, 2))
|
|
|
|
const downloadable: proto.Message.IVideoMessage = {
|
|
url: quotedVideo!.url,
|
|
mediaKey: quotedVideo!.mediaKey,
|
|
directPath: quotedVideo!.directPath
|
|
}
|
|
|
|
const stream = await downloadContentFromMessage(downloadable, 'video')
|
|
const buffer = await toBuffer(stream)
|
|
|
|
expect(Buffer.isBuffer(buffer)).toBe(true)
|
|
expect(buffer.length).toBeGreaterThan(0)
|
|
|
|
console.log('Successfully downloaded quoted image from group message.')
|
|
} finally {
|
|
if (videoListener) sock.ev.off('messages.upsert', videoListener)
|
|
if (commandListener) sock.ev.off('messages.upsert', commandListener)
|
|
if (timeoutId) clearTimeout(timeoutId)
|
|
}
|
|
})
|
|
})
|