@kyyinfinite/baileys 2.0.0 → 2.1.0

package/test/simple-api.test.js

@@ -0,0 +1,183 @@
+import assert from 'node:assert/strict'
+import { createKyyinfinite, attachKyyinfinite } from '../lib/Kyyinfinite/Simple/index.js'
+import { TextBuilder } from '../lib/Kyyinfinite/Simple/TextBuilder.js'
+import { MediaBuilder } from '../lib/Kyyinfinite/Simple/MediaBuilder.js'
+import { MessageBuilder } from '../lib/Kyyinfinite/Simple/MessageBuilder.js'
+import { KyyMessage } from '../lib/Kyyinfinite/Simple/KyyMessage.js'
+import { parseMessage } from '../lib/Kyyinfinite/Simple/parseMessage.js'
+import { parseJid, makeJid, isGroupJid, isPrivateJid, isLidJid } from '../lib/Kyyinfinite/Simple/jid.js'
+import { extractMentions, applyAutoMentions, resolveMediaContent } from '../lib/Kyyinfinite/Simple/messageUtils.js'
+
+const sent = []
+const sock = {
+  text: 'NATIVE_TEXT_MUST_SURVIVE',
+  sendMessage: async (jid, content, options = {}) => {
+    const result = { jid, content, options }
+    sent.push(result)
+    return result
+  }
+}
+
+function test(name, fn) {
+  try {
+    fn()
+    console.log(`PASS  ${name}`)
+  } catch (error) {
+    console.error(`FAIL  ${name}`)
+    throw error
+  }
+}
+
+async function testAsync(name, fn) {
+  try {
+    await fn()
+    console.log(`PASS  ${name}`)
+  } catch (error) {
+    console.error(`FAIL  ${name}`)
+    throw error
+  }
+}
+
+test('JID parse + classify', () => {
+  assert.deepEqual(parseJid('12345:7@s.whatsapp.net'), {
+    user: '12345', device: '7', server: 's.whatsapp.net', jid: '12345:7@s.whatsapp.net'
+  })
+  assert.equal(makeJid(12345), '12345@s.whatsapp.net')
+  assert.equal(isPrivateJid('12345@s.whatsapp.net'), true)
+  assert.equal(isGroupJid('123-456@g.us'), true)
+  assert.equal(isLidJid('12345@lid'), true)
+})
+
+test('Mention extraction + dedupe', () => {
+  assert.deepEqual(extractMentions('Hi @628123456789 @628123456789!'), ['628123456789@s.whatsapp.net'])
+  assert.deepEqual(applyAutoMentions({ text: 'Hi @628123456789' }).mentions, ['628123456789@s.whatsapp.net'])
+  assert.equal(applyAutoMentions({ text: 'Hi @628123456789' }, false).mentions, undefined)
+})
+
+test('Media resolver', () => {
+  assert.deepEqual(resolveMediaContent({ image: 'https://example.com/a.jpg', caption: 'x' }), {
+    image: { url: 'https://example.com/a.jpg' }, caption: 'x'
+  })
+})
+
+test('Simple API contract exposes final public methods', () => {
+  const api = createKyyinfinite(sock)
+  const methods = [
+    'text', 'media', 'send', 'quoted', 'mentions', 'resolveMedia', 'resolveMediaContent',
+    'wrapMessage', 'parseMessage', 'jid', 'parseJid', 'jidUser', 'jidServer', 'jidDevice',
+    'isGroup', 'isPrivate', 'isBroadcast', 'isStatus', 'isNewsletter', 'isLid', 'makeJid',
+    'reply', 'reactTo', 'editMessage', 'deleteMessage', 'forwardMessage', 'downloadMessage',
+    'image', 'video', 'audio', 'voice', 'document', 'sticker', 'ptv', 'gif', 'message',
+    'poll', 'event', 'album', 'contacts', 'location', 'buttonReply', 'listReply', 'react',
+    'groupInvite', 'product', 'requestPhoneNumber', 'sharePhoneNumber', 'pin', 'forward',
+    'delete', 'disappearing', 'limitSharing', 'button', 'buttonV2', 'carousel', 'ai', 'foad', 'foad2'
+  ]
+  for (const name of methods) assert.equal(typeof api[name], 'function', `missing ${name}()`)
+  for (const name of ['Toolkit', 'Button', 'ButtonV2', 'Carousel', 'AIRich', 'Foad', 'Foad2']) {
+    assert.ok(api.raw[name], `missing raw.${name}`)
+  }
+})
+
+test('createKyyinfinite is non-mutating', () => {
+  const local = { sendMessage: sock.sendMessage }
+  const api = createKyyinfinite(local)
+  assert.equal(local.text, undefined)
+  assert.equal(typeof api.text, 'function')
+  assert.equal(typeof api.send, 'function')
+})
+
+test('attachKyyinfinite preserves native collisions', () => {
+  const local = { text: 'native', sendMessage: sock.sendMessage }
+  const result = attachKyyinfinite(local)
+  assert.equal(result, local)
+  assert.equal(local.text, 'native')
+  assert.equal(typeof local.image, 'function')
+})
+
+await testAsync('Simple text send + auto mentions', async () => {
+  sent.length = 0
+  const api = createKyyinfinite(sock)
+  const result = await api.text('Hello @628123456789').send('628000@g.us')
+  assert.equal(result.jid, '628000@g.us')
+  assert.deepEqual(result.content.mentions, ['628123456789@s.whatsapp.net'])
+  assert.equal(result.content.text, 'Hello @628123456789')
+})
+
+await testAsync('Unified send', async () => {
+  sent.length = 0
+  const api = createKyyinfinite(sock)
+  const result = await api.send('123@s.whatsapp.net', 'Hello')
+  assert.deepEqual(result.content, { text: 'Hello' })
+
+  const media = await api.send('123@s.whatsapp.net', {
+    image: 'https://example.com/a.jpg',
+    caption: 'Photo @628123456789'
+  })
+  assert.deepEqual(media.content.image, { url: 'https://example.com/a.jpg' })
+  assert.deepEqual(media.content.mentions, ['628123456789@s.whatsapp.net'])
+})
+
+await testAsync('quoted + message shortcuts', async () => {
+  sent.length = 0
+  const api = createKyyinfinite(sock)
+  const message = { key: { id: 'ABC', remoteJid: '123@g.us', fromMe: false }, message: { conversation: 'old' } }
+  await api.quoted(message, 'reply')
+  assert.equal(sent[0].options.quoted, message)
+
+  const wrapped = new KyyMessage(sock, message)
+  await wrapped.reply('reply 2')
+  await wrapped.react('ok')
+  assert.equal(sent[1].options.quoted, message)
+  assert.deepEqual(sent[2].content.react, { text: 'ok', key: message.key })
+})
+
+test('Builder state isolation', () => {
+  const api = createKyyinfinite(sock)
+  const a = api.text('A').footer('one')
+  const b = api.text('B').footer('two')
+  assert.equal(a.build().text, 'A')
+  assert.equal(a.build().footer, 'one')
+  assert.equal(b.build().text, 'B')
+  assert.equal(b.build().footer, 'two')
+})
+
+test('Universal media builder type switching', () => {
+  const api = createKyyinfinite(sock)
+  assert.deepEqual(api.media('x').asDocument().build(), { document: { url: 'x' } })
+  assert.deepEqual(api.media('x').asImage().build(), { image: { url: 'x' } })
+})
+
+test('parseMessage command + group metadata', () => {
+  const parsed = parseMessage({
+    key: { remoteJid: '123-456@g.us', participant: '628111@s.whatsapp.net', fromMe: false, id: 'M1' },
+    message: { conversation: '.ping one two' }
+  }, { prefix: '.' })
+  assert.equal(parsed.text, '.ping one two')
+  assert.equal(parsed.command, 'ping')
+  assert.deepEqual(parsed.args, ['one', 'two'])
+  assert.equal(parsed.isGroup, true)
+  assert.equal(parsed.sender, '628111@s.whatsapp.net')
+})
+
+await testAsync('Fluent builder quoted() + send options', async () => {
+  sent.length = 0
+  const api = createKyyinfinite(sock)
+  const quoted = { key: { id: 'Q1' }, message: { conversation: 'quoted' } }
+  const result = await api.text('reply').quoted(quoted).send('123@s.whatsapp.net', { ephemeralExpiration: 3600 })
+  assert.equal(result.options.quoted, quoted)
+  assert.equal(result.options.ephemeralExpiration, 3600)
+})
+
+await testAsync('Builder send forwards native sendMessage', async () => {
+  sent.length = 0
+  const api = createKyyinfinite(sock)
+  const result = await new TextBuilder(sock, 'builder').send('123@s.whatsapp.net', { quoted: 'q' })
+  assert.equal(result.options.quoted, 'q')
+  const media = await new MediaBuilder(sock, 'image', 'x.jpg').caption('x').send('123@s.whatsapp.net')
+  assert.deepEqual(media.content.image, { url: 'x.jpg' })
+  const message = await new MessageBuilder(sock, { text: 'm' }).send('123@s.whatsapp.net')
+  assert.equal(message.content.text, 'm')
+  void api
+})
+
+console.log(`\n2.1.0 Simple API test suite: ${'PASS'}`)