gifted-baileys 1.5.6 → 1.5.7

package/src/Tests/test.event-buffer.ts

@@ -1,319 +0,0 @@
-import { proto } from '../../WAProto'
-import { Chat, WAMessageKey, WAMessageStatus, WAMessageStubType, WAMessageUpdate } from '../Types'
-import { delay, generateMessageID, makeEventBuffer, toNumber, unixTimestampSeconds } from '../Utils'
-import logger from '../Utils/logger'
-import { randomJid } from './utils'
-
-describe('Event Buffer Tests', () => {
-
-	let ev: ReturnType<typeof makeEventBuffer>
-	beforeEach(() => {
-		const _logger = logger.child({ })
-		_logger.level = 'trace'
-		ev = makeEventBuffer(_logger)
-	})
-
-	it('should buffer a chat upsert & update event', async() => {
-		const chatId = randomJid()
-
-		const chats: Chat[] = []
-
-		ev.on('chats.upsert', c => chats.push(...c))
-		ev.on('chats.update', () => fail('should not emit update event'))
-
-		ev.buffer()
-		await Promise.all([
-			(async() => {
-				ev.buffer()
-				await delay(100)
-				ev.emit('chats.upsert', [{ id: chatId, conversationTimestamp: 123, unreadCount: 1 }])
-				const flushed = ev.flush()
-				expect(flushed).toBeFalsy()
-			})(),
-			(async() => {
-				ev.buffer()
-				await delay(200)
-				ev.emit('chats.update', [{ id: chatId, conversationTimestamp: 124, unreadCount: 1 }])
-				const flushed = ev.flush()
-				expect(flushed).toBeFalsy()
-			})()
-		])
-
-		const flushed = ev.flush()
-		expect(flushed).toBeTruthy()
-
-		expect(chats).toHaveLength(1)
-		expect(chats[0].conversationTimestamp).toEqual(124)
-		expect(chats[0].unreadCount).toEqual(2)
-	})
-
-	it('should overwrite a chats.delete event', async() => {
-		const chatId = randomJid()
-		const chats: Partial<Chat>[] = []
-
-		ev.on('chats.update', c => chats.push(...c))
-		ev.on('chats.delete', () => fail('not should have emitted'))
-
-		ev.buffer()
-
-		ev.emit('chats.update', [{ id: chatId, conversationTimestamp: 123, unreadCount: 1 }])
-		ev.emit('chats.delete', [chatId])
-		ev.emit('chats.update', [{ id: chatId, conversationTimestamp: 124, unreadCount: 1 }])
-
-		ev.flush()
-
-		expect(chats).toHaveLength(1)
-	})
-
-	it('should overwrite a chats.update event', async() => {
-		const chatId = randomJid()
-		const chatsDeleted: string[] = []
-
-		ev.on('chats.delete', c => chatsDeleted.push(...c))
-		ev.on('chats.update', () => fail('not should have emitted'))
-
-		ev.buffer()
-
-		ev.emit('chats.update', [{ id: chatId, conversationTimestamp: 123, unreadCount: 1 }])
-		ev.emit('chats.delete', [chatId])
-
-		ev.flush()
-
-		expect(chatsDeleted).toHaveLength(1)
-	})
-
-	it('should release a conditional update at the right time', async() => {
-		const chatId = randomJid()
-		const chatId2 = randomJid()
-		const chatsUpserted: Chat[] = []
-		const chatsSynced: Chat[] = []
-
-		ev.on('chats.upsert', c => chatsUpserted.push(...c))
-		ev.on('messaging-history.set', c => chatsSynced.push(...c.chats))
-		ev.on('chats.update', () => fail('not should have emitted'))
-
-		ev.buffer()
-		ev.emit('chats.update', [{
-			id: chatId,
-			archived: true,
-			conditional(buff) {
-				if(buff.chatUpserts[chatId]) {
-					return true
-				}
-			}
-		}])
-		ev.emit('chats.update', [{
-			id: chatId2,
-			archived: true,
-			conditional(buff) {
-				if(buff.historySets.chats[chatId2]) {
-					return true
-				}
-			}
-		}])
-
-		ev.flush()
-
-		ev.buffer()
-		ev.emit('chats.upsert', [{
-			id: chatId,
-			conversationTimestamp: 123,
-			unreadCount: 1,
-			muteEndTime: 123
-		}])
-		ev.emit('messaging-history.set', {
-			chats: [{
-				id: chatId2,
-				conversationTimestamp: 123,
-				unreadCount: 1,
-				muteEndTime: 123
-			}],
-			contacts: [],
-			messages: [],
-			isLatest: false
-		})
-		ev.flush()
-
-		expect(chatsUpserted).toHaveLength(1)
-		expect(chatsUpserted[0].id).toEqual(chatId)
-		expect(chatsUpserted[0].archived).toEqual(true)
-		expect(chatsUpserted[0].muteEndTime).toEqual(123)
-
-		expect(chatsSynced).toHaveLength(1)
-		expect(chatsSynced[0].id).toEqual(chatId2)
-		expect(chatsSynced[0].archived).toEqual(true)
-	})
-
-	it('should discard a conditional update', async() => {
-		const chatId = randomJid()
-		const chatsUpserted: Chat[] = []
-
-		ev.on('chats.upsert', c => chatsUpserted.push(...c))
-		ev.on('chats.update', () => fail('not should have emitted'))
-
-		ev.buffer()
-		ev.emit('chats.update', [{
-			id: chatId,
-			archived: true,
-			conditional(buff) {
-				if(buff.chatUpserts[chatId]) {
-					return false
-				}
-			}
-		}])
-		ev.emit('chats.upsert', [{
-			id: chatId,
-			conversationTimestamp: 123,
-			unreadCount: 1,
-			muteEndTime: 123
-		}])
-
-		ev.flush()
-
-		expect(chatsUpserted).toHaveLength(1)
-		expect(chatsUpserted[0].archived).toBeUndefined()
-	})
-
-	it('should overwrite a chats.update event with a history event', async() => {
-		const chatId = randomJid()
-		let chatRecv: Chat | undefined
-
-		ev.on('messaging-history.set', ({ chats }) => {
-			chatRecv = chats[0]
-		})
-		ev.on('chats.update', () => fail('not should have emitted'))
-
-		ev.buffer()
-
-		ev.emit('messaging-history.set', {
-			chats: [{ id: chatId, conversationTimestamp: 123, unreadCount: 1 }],
-			messages: [],
-			contacts: [],
-			isLatest: true
-		})
-		ev.emit('chats.update', [{ id: chatId, archived: true }])
-
-		ev.flush()
-
-		expect(chatRecv).toBeDefined()
-		expect(chatRecv?.archived).toBeTruthy()
-	})
-
-	it('should buffer message upsert events', async() => {
-		const messageTimestamp = unixTimestampSeconds()
-		const msg: proto.IWebMessageInfo = {
-			key: {
-				remoteJid: randomJid(),
-				id: generateMessageID(),
-				fromMe: false
-			},
-			messageStubType: WAMessageStubType.CIPHERTEXT,
-			messageTimestamp
-		}
-
-		const msgs: proto.IWebMessageInfo[] = []
-
-		ev.on('messages.upsert', c => {
-			msgs.push(...c.messages)
-			expect(c.type).toEqual('notify')
-		})
-
-		ev.buffer()
-		ev.emit('messages.upsert', { messages: [proto.WebMessageInfo.fromObject(msg)], type: 'notify' })
-
-		msg.messageTimestamp = unixTimestampSeconds() + 1
-		msg.messageStubType = undefined
-		msg.message = { conversation: 'Test' }
-		ev.emit('messages.upsert', { messages: [proto.WebMessageInfo.fromObject(msg)], type: 'notify' })
-		ev.emit('messages.update', [{ key: msg.key, update: { status: WAMessageStatus.READ } }])
-
-		ev.flush()
-
-		expect(msgs).toHaveLength(1)
-		expect(msgs[0].message).toBeTruthy()
-		expect(toNumber(msgs[0].messageTimestamp!)).toEqual(messageTimestamp)
-		expect(msgs[0].status).toEqual(WAMessageStatus.READ)
-	})
-
-	it('should buffer a message receipt update', async() => {
-		const msg: proto.IWebMessageInfo = {
-			key: {
-				remoteJid: randomJid(),
-				id: generateMessageID(),
-				fromMe: false
-			},
-			messageStubType: WAMessageStubType.CIPHERTEXT,
-			messageTimestamp: unixTimestampSeconds()
-		}
-
-		const msgs: proto.IWebMessageInfo[] = []
-
-		ev.on('messages.upsert', c => msgs.push(...c.messages))
-		ev.on('message-receipt.update', () => fail('should not emit'))
-
-		ev.buffer()
-		ev.emit('messages.upsert', { messages: [proto.WebMessageInfo.fromObject(msg)], type: 'notify' })
-		ev.emit('message-receipt.update', [
-			{
-				key: msg.key,
-				receipt: {
-					userJid: randomJid(),
-					readTimestamp: unixTimestampSeconds()
-				}
-			}
-		])
-
-		ev.flush()
-
-		expect(msgs).toHaveLength(1)
-		expect(msgs[0].userReceipt).toHaveLength(1)
-	})
-
-	it('should buffer multiple status updates', async() => {
-		const key: WAMessageKey = {
-			remoteJid: randomJid(),
-			id: generateMessageID(),
-			fromMe: false
-		}
-
-		const msgs: WAMessageUpdate[] = []
-
-		ev.on('messages.update', c => msgs.push(...c))
-
-		ev.buffer()
-		ev.emit('messages.update', [{ key, update: { status: WAMessageStatus.DELIVERY_ACK } }])
-		ev.emit('messages.update', [{ key, update: { status: WAMessageStatus.READ } }])
-
-		ev.flush()
-
-		expect(msgs).toHaveLength(1)
-		expect(msgs[0].update.status).toEqual(WAMessageStatus.READ)
-	})
-
-	it('should remove chat unread counter', async() => {
-		const msg: proto.IWebMessageInfo = {
-			key: {
-				remoteJid: '12345@s.whatsapp.net',
-				id: generateMessageID(),
-				fromMe: false
-			},
-			message: {
-				conversation: 'abcd'
-			},
-			messageTimestamp: unixTimestampSeconds()
-		}
-
-		const chats: Partial<Chat>[] = []
-
-		ev.on('chats.update', c => chats.push(...c))
-
-		ev.buffer()
-		ev.emit('messages.upsert', { messages: [proto.WebMessageInfo.fromObject(msg)], type: 'notify' })
-		ev.emit('chats.update', [{ id: msg.key.remoteJid!, unreadCount: 1, conversationTimestamp: msg.messageTimestamp }])
-		ev.emit('messages.update', [{ key: msg.key, update: { status: WAMessageStatus.READ } }])
-
-		ev.flush()
-
-		expect(chats[0].unreadCount).toBeUndefined()
-	})
-})

package/src/Tests/test.key-store.js

@@ -1,76 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Utils_1 = require("../Utils");
-const logger_1 = __importDefault(require("../Utils/logger"));
-const utils_1 = require("./utils");
-logger_1.default.level = 'trace';
-describe('Key Store w Transaction Tests', () => {
-    const rawStore = (0, utils_1.makeMockSignalKeyStore)();
-    const store = (0, Utils_1.addTransactionCapability)(rawStore, logger_1.default, {
-        maxCommitRetries: 1,
-        delayBetweenTriesMs: 10
-    });
-    it('should use transaction cache when mutated', () => __awaiter(void 0, void 0, void 0, function* () {
-        const key = '123';
-        const value = new Uint8Array(1);
-        const ogGet = rawStore.get;
-        yield store.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield store.set({ 'session': { [key]: value } });
-            rawStore.get = () => {
-                throw new Error('should not have been called');
-            };
-            const { [key]: stored } = yield store.get('session', [key]);
-            expect(stored).toEqual(new Uint8Array(1));
-        }));
-        rawStore.get = ogGet;
-    }));
-    it('should not commit a failed transaction', () => __awaiter(void 0, void 0, void 0, function* () {
-        const key = 'abcd';
-        yield expect(store.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield store.set({ 'session': { [key]: new Uint8Array(1) } });
-            throw new Error('fail');
-        }))).rejects.toThrowError('fail');
-        const { [key]: stored } = yield store.get('session', [key]);
-        expect(stored).toBeUndefined();
-    }));
-    it('should handle overlapping transactions', () => __awaiter(void 0, void 0, void 0, function* () {
-        // promise to let transaction 2
-        // know that transaction 1 has started
-        let promiseResolve;
-        const promise = new Promise(resolve => {
-            promiseResolve = resolve;
-        });
-        store.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield store.set({
-                'session': {
-                    '1': new Uint8Array(1)
-                }
-            });
-            // wait for the other transaction to start
-            yield (0, Utils_1.delay)(5);
-            // reolve the promise to let the other transaction continue
-            promiseResolve();
-        }));
-        yield store.transaction(() => __awaiter(void 0, void 0, void 0, function* () {
-            yield promise;
-            yield (0, Utils_1.delay)(5);
-            expect(store.isInTransaction()).toBe(true);
-        }));
-        expect(store.isInTransaction()).toBe(false);
-        // ensure that the transaction were committed
-        const { ['1']: stored } = yield store.get('session', ['1']);
-        expect(stored).toEqual(new Uint8Array(1));
-    }));
-});

package/src/Tests/test.key-store.ts

@@ -1,92 +0,0 @@
-import { addTransactionCapability, delay } from '../Utils'
-import logger from '../Utils/logger'
-import { makeMockSignalKeyStore } from './utils'
-
-logger.level = 'trace'
-
-describe('Key Store w Transaction Tests', () => {
-
-	const rawStore = makeMockSignalKeyStore()
-	const store = addTransactionCapability(
-		rawStore,
-		logger,
-		{
-			maxCommitRetries: 1,
-			delayBetweenTriesMs: 10
-		}
-	)
-
-	it('should use transaction cache when mutated', async() => {
-		const key = '123'
-		const value = new Uint8Array(1)
-		const ogGet = rawStore.get
-		await store.transaction(
-			async() => {
-				await store.set({ 'session': { [key]: value } })
-
-				rawStore.get = () => {
-					throw new Error('should not have been called')
-				}
-
-				const { [key]: stored } = await store.get('session', [key])
-				expect(stored).toEqual(new Uint8Array(1))
-			}
-		)
-
-		rawStore.get = ogGet
-	})
-
-	it('should not commit a failed transaction', async() => {
-		const key = 'abcd'
-		await expect(
-			store.transaction(
-				async() => {
-					await store.set({ 'session': { [key]: new Uint8Array(1) } })
-					throw new Error('fail')
-				}
-			)
-		).rejects.toThrowError(
-			'fail'
-		)
-
-		const { [key]: stored } = await store.get('session', [key])
-		expect(stored).toBeUndefined()
-	})
-
-	it('should handle overlapping transactions', async() => {
-		// promise to let transaction 2
-		// know that transaction 1 has started
-		let promiseResolve: () => void
-		const promise = new Promise<void>(resolve => {
-			promiseResolve = resolve
-		})
-
-		store.transaction(
-			async() => {
-				await store.set({
-					'session': {
-						'1': new Uint8Array(1)
-					}
-				})
-				// wait for the other transaction to start
-				await delay(5)
-				// reolve the promise to let the other transaction continue
-				promiseResolve()
-			}
-		)
-
-		await store.transaction(
-			async() => {
-				await promise
-				await delay(5)
-
-				expect(store.isInTransaction()).toBe(true)
-			}
-		)
-
-		expect(store.isInTransaction()).toBe(false)
-		// ensure that the transaction were committed
-		const { ['1']: stored } = await store.get('session', ['1'])
-		expect(stored).toEqual(new Uint8Array(1))
-	})
-})

package/src/Tests/test.libsignal.js

@@ -1,141 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const libsignal_1 = require("../Signal/libsignal");
-const Utils_1 = require("../Utils");
-describe('Signal Tests', () => {
-    it('should correctly encrypt/decrypt 1 message', () => __awaiter(void 0, void 0, void 0, function* () {
-        const user1 = makeUser();
-        const user2 = makeUser();
-        const msg = Buffer.from('hello there!');
-        yield prepareForSendingMessage(user1, user2);
-        const result = yield user1.repository.encryptMessage({ jid: user2.jid, data: msg });
-        const dec = yield user2.repository.decryptMessage(Object.assign({ jid: user1.jid }, result));
-        expect(dec).toEqual(msg);
-    }));
-    it('should correctly override a session', () => __awaiter(void 0, void 0, void 0, function* () {
-        const user1 = makeUser();
-        const user2 = makeUser();
-        const msg = Buffer.from('hello there!');
-        for (let preKeyId = 2; preKeyId <= 3; preKeyId++) {
-            yield prepareForSendingMessage(user1, user2, preKeyId);
-            const result = yield user1.repository.encryptMessage({ jid: user2.jid, data: msg });
-            const dec = yield user2.repository.decryptMessage(Object.assign({ jid: user1.jid }, result));
-            expect(dec).toEqual(msg);
-        }
-    }));
-    it('should correctly encrypt/decrypt multiple messages', () => __awaiter(void 0, void 0, void 0, function* () {
-        const user1 = makeUser();
-        const user2 = makeUser();
-        const msg = Buffer.from('hello there!');
-        yield prepareForSendingMessage(user1, user2);
-        for (let i = 0; i < 10; i++) {
-            const result = yield user1.repository.encryptMessage({ jid: user2.jid, data: msg });
-            const dec = yield user2.repository.decryptMessage(Object.assign({ jid: user1.jid }, result));
-            expect(dec).toEqual(msg);
-        }
-    }));
-    it('should encrypt/decrypt messages from group', () => __awaiter(void 0, void 0, void 0, function* () {
-        const groupId = '123456@g.us';
-        const participants = [...Array(5)].map(makeUser);
-        const msg = Buffer.from('hello there!');
-        const sender = participants[0];
-        const enc = yield sender.repository.encryptGroupMessage({
-            group: groupId,
-            meId: sender.jid,
-            data: msg
-        });
-        for (const participant of participants) {
-            if (participant === sender) {
-                continue;
-            }
-            yield participant.repository.processSenderKeyDistributionMessage({
-                item: {
-                    groupId,
-                    axolotlSenderKeyDistributionMessage: enc.senderKeyDistributionMessage
-                },
-                authorJid: sender.jid
-            });
-            const dec = yield participant.repository.decryptGroupMessage({
-                group: groupId,
-                authorJid: sender.jid,
-                msg: enc.ciphertext
-            });
-            expect(dec).toEqual(msg);
-        }
-    }));
-});
-function makeUser() {
-    const store = makeTestAuthState();
-    const jid = `${Math.random().toString().replace('.', '')}@s.whatsapp.net`;
-    const repository = (0, libsignal_1.makeLibSignalRepository)(store);
-    return { store, jid, repository };
-}
-function prepareForSendingMessage(sender_1, receiver_1) {
-    return __awaiter(this, arguments, void 0, function* (sender, receiver, preKeyId = 2) {
-        const preKey = Utils_1.Curve.generateKeyPair();
-        yield sender.repository.injectE2ESession({
-            jid: receiver.jid,
-            session: {
-                registrationId: receiver.store.creds.registrationId,
-                identityKey: (0, Utils_1.generateSignalPubKey)(receiver.store.creds.signedIdentityKey.public),
-                signedPreKey: {
-                    keyId: receiver.store.creds.signedPreKey.keyId,
-                    publicKey: (0, Utils_1.generateSignalPubKey)(receiver.store.creds.signedPreKey.keyPair.public),
-                    signature: receiver.store.creds.signedPreKey.signature,
-                },
-                preKey: {
-                    keyId: preKeyId,
-                    publicKey: (0, Utils_1.generateSignalPubKey)(preKey.public),
-                }
-            }
-        });
-        yield receiver.store.keys.set({
-            'pre-key': {
-                [preKeyId]: preKey
-            }
-        });
-    });
-}
-function makeTestAuthState() {
-    const identityKey = Utils_1.Curve.generateKeyPair();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const store = {};
-    return {
-        creds: {
-            signedIdentityKey: identityKey,
-            registrationId: (0, Utils_1.generateRegistrationId)(),
-            signedPreKey: (0, Utils_1.signedKeyPair)(identityKey, 1),
-        },
-        keys: {
-            get(type, ids) {
-                const data = {};
-                for (const id of ids) {
-                    const item = store[getUniqueId(type, id)];
-                    if (typeof item !== 'undefined') {
-                        data[id] = item;
-                    }
-                }
-                return data;
-            },
-            set(data) {
-                for (const type in data) {
-                    for (const id in data[type]) {
-                        store[getUniqueId(type, id)] = data[type][id];
-                    }
-                }
-            },
-        }
-    };
-    function getUniqueId(type, id) {
-        return `${type}.${id}`;
-    }
-}