From 05c22811780f801255e94a4180c1613438af6319 Mon Sep 17 00:00:00 2001
From: Marcelo Pires <thesyncim@gmail.com>
Date: Fri, 15 May 2020 12:56:47 +0100
Subject: [PATCH] add tests for message.{flagged,unflagged} webhook events
 (#328)

* add tests for message.{flagged,unflagged} webhook events
update flag function signature to allow server side flag

* make options optional

* set default options value
---
 src/client.js                | 12 ++++++----
 test/webhook.js              | 43 ++++++++++++++++++++++++++++++++++++
 types/stream-chat/index.d.ts |  8 +++----
 3 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/src/client.js b/src/client.js
index 75c64b528..6d4f816ba 100644
--- a/src/client.js
+++ b/src/client.js
@@ -1184,27 +1184,31 @@ export class StreamChat {
 		});
 	}
 
-	async flagMessage(messageID) {
+	async flagMessage(messageID, options = {}) {
 		return await this.post(this.baseURL + '/moderation/flag', {
 			target_message_id: messageID,
+			...options,
 		});
 	}
 
-	async flagUser(userID) {
+	async flagUser(userID, options = {}) {
 		return await this.post(this.baseURL + '/moderation/flag', {
 			target_user_id: userID,
+			...options,
 		});
 	}
 
-	async unflagMessage(messageID) {
+	async unflagMessage(messageID, options = {}) {
 		return await this.post(this.baseURL + '/moderation/unflag', {
 			target_message_id: messageID,
+			...options,
 		});
 	}
 
-	async unflagUser(userID) {
+	async unflagUser(userID, options = {}) {
 		return await this.post(this.baseURL + '/moderation/unflag', {
 			target_user_id: userID,
+			...options,
 		});
 	}
 
diff --git a/test/webhook.js b/test/webhook.js
index 095079bc8..517c58980 100644
--- a/test/webhook.js
+++ b/test/webhook.js
@@ -99,6 +99,49 @@ describe('Webhooks', function() {
 		expect(event.channel_id).to.eq(chan.id);
 	});
 
+	it('should receive message flagged/unflagged event', async function() {
+		await chan.create();
+
+		// send a message
+		let sendMessageResp;
+		let [events] = await Promise.all([
+			promises.waitForEvents('message.new'),
+			(sendMessageResp = await chan.sendMessage({
+				text: 'flag candidate',
+				user: { id: tommasoID },
+			})),
+		]);
+		const msgNewEvent = events.pop();
+		expect(msgNewEvent).to.not.be.null;
+		expect(msgNewEvent.type).to.eq('message.new');
+		expect(msgNewEvent.channel_type).to.eq(chan.type);
+		expect(msgNewEvent.channel_id).to.eq(chan.id);
+
+		// expect message.flagged event
+		[events] = await Promise.all([
+			promises.waitForEvents('message.flagged'),
+			client.flagMessage(sendMessageResp.message.id, { user_id: tommasoID }),
+		]);
+		const msgFlagEvent = events.pop();
+		expect(msgFlagEvent).to.not.be.null;
+		expect(msgFlagEvent.type).to.eq('message.flagged');
+		expect(msgFlagEvent.channel_type).to.eq(chan.type);
+		expect(msgFlagEvent.channel_id).to.eq(chan.id);
+		expect(msgFlagEvent.message.id).to.eq(sendMessageResp.message.id);
+
+		// expect message.unflagged event
+		[events] = await Promise.all([
+			promises.waitForEvents('message.unflagged'),
+			client.unflagMessage(sendMessageResp.message.id, { user_id: tommasoID }),
+		]);
+		const msgUnFlagEvent = events.pop();
+		expect(msgUnFlagEvent).to.not.be.null;
+		expect(msgUnFlagEvent.type).to.eq('message.unflagged');
+		expect(msgUnFlagEvent.channel_type).to.eq(chan.type);
+		expect(msgUnFlagEvent.channel_id).to.eq(chan.id);
+		expect(msgUnFlagEvent.message.id).to.eq(sendMessageResp.message.id);
+	});
+
 	it('should receive new message event with members included', async function() {
 		await Promise.all([chan.addMembers([thierryID]), chan.addMembers([tommasoID])]);
 		const [events] = await Promise.all([
diff --git a/types/stream-chat/index.d.ts b/types/stream-chat/index.d.ts
index 12388f115..8146838da 100644
--- a/types/stream-chat/index.d.ts
+++ b/types/stream-chat/index.d.ts
@@ -296,10 +296,10 @@ export class StreamChat {
   muteUser(targetUserID: string): Promise<MuteAPIResponse>;
   unmuteUser(targetUserID: string): Promise<UnmuteAPIResponse>;
 
-  flagUser(userID: string): Promise<FlagAPIResponse>;
-  unflagUser(userID: string): Promise<UnflagAPIResponse>;
-  flagMessage(messageID: string): Promise<FlagAPIResponse>;
-  unflagMessage(messageID: string): Promise<UnflagAPIResponse>;
+  flagUser(userID: string, options?: object): Promise<FlagAPIResponse>;
+  unflagUser(userID: string, options?: object): Promise<UnflagAPIResponse>;
+  flagMessage(messageID: string, options?: object): Promise<FlagAPIResponse>;
+  unflagMessage(messageID: string, options?: object): Promise<UnflagAPIResponse>;
 
   createChannelType(data: ChannelData): Promise<CreateChannelTypeAPIResponse>;
   getChannelType(channelType: string): Promise<GetChannelTypeAPIResponse>;