455 lines
16 KiB
Lua
455 lines
16 KiB
Lua
return function()
|
|
local CoreGui = game:GetService("CoreGui")
|
|
|
|
local Modules = CoreGui.RobloxGui.Modules
|
|
local LuaApp = Modules.LuaApp
|
|
local LuaChat = Modules.LuaChat
|
|
|
|
local ChangedParticipants = require(LuaChat.Actions.ChangedParticipants)
|
|
local Constants = require(LuaChat.Constants)
|
|
local Conversation = require(LuaChat.Models.Conversation)
|
|
local DateTime = require(LuaChat.DateTime)
|
|
local FetchedOldestMessage = require(LuaChat.Actions.FetchedOldestMessage)
|
|
local FetchingOlderMessages = require(LuaChat.Actions.FetchingOlderMessages)
|
|
local Message = require(LuaChat.Models.Message)
|
|
local MessageFailedToSend = require(LuaChat.Actions.MessageFailedToSend)
|
|
local MessageModerated = require(LuaChat.Actions.MessageModerated)
|
|
local MockId = require(LuaApp.MockId)
|
|
local ReadConversation = require(LuaChat.Actions.ReadConversation)
|
|
local ReceivedConversation = require(LuaChat.Actions.ReceivedConversation)
|
|
local ReceivedMessages = require(LuaChat.Actions.ReceivedMessages)
|
|
local RemovedConversation = require(LuaChat.Actions.RemovedConversation)
|
|
local RenamedGroupConversation = require(LuaChat.Actions.RenamedGroupConversation)
|
|
local SendingMessage = require(LuaChat.Actions.SendingMessage)
|
|
local SentMessage = require(LuaChat.Actions.SentMessage)
|
|
local SetConversationLoadingStatus = require(LuaChat.Actions.SetConversationLoadingStatus)
|
|
local SetPinnedGameForConversation = require(LuaChat.Actions.SetPinnedGameForConversation)
|
|
local SetUserTyping = require(LuaChat.Actions.SetUserTyping)
|
|
local User = require(LuaApp.Models.User)
|
|
|
|
local Conversations = require(script.Parent.Conversations)
|
|
|
|
describe("initial state", function()
|
|
it("should return an initial table when passed nil", function()
|
|
local state = Conversations(nil, {})
|
|
expect(state).to.be.a("table")
|
|
end)
|
|
end)
|
|
|
|
describe("Action ReceivedConversation", function()
|
|
it("should add a conversation to the store", function()
|
|
local conversation = Conversation.mock()
|
|
local state = nil
|
|
local action = ReceivedConversation(conversation)
|
|
|
|
state = Conversations(state, action)
|
|
|
|
expect(state).to.be.a("table")
|
|
expect(state[conversation.id]).to.be.a("table")
|
|
expect(state[conversation.id].id).to.equal(conversation.id)
|
|
end)
|
|
end)
|
|
|
|
describe("Action ReceivedMessages", function()
|
|
it("should add messages to an existing conversation", function()
|
|
local conversation = Conversation.mock()
|
|
local message = Message.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
local action = ReceivedMessages(conversation.id, {message})
|
|
|
|
state = Conversations(state, action)
|
|
|
|
local messages = state[conversation.id].messages
|
|
expect(#messages.keys).to.equal(1)
|
|
expect(messages.values[messages.keys[1]].id).to.equal(message.id)
|
|
end)
|
|
|
|
it("should insert messages in-order", function()
|
|
local conversation = Conversation.mock()
|
|
local message1 = Message.mock({ sent = DateTime.new(1992) })
|
|
local message2 = Message.mock({ sent = DateTime.new(1990) })
|
|
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local action = ReceivedMessages(conversation.id, { message1, message2 })
|
|
state = Conversations(state, action)
|
|
|
|
do
|
|
local messages = state[conversation.id].messages
|
|
expect(#messages.keys).to.equal(2)
|
|
expect(messages.values[messages.keys[1]].id).to.equal(message2.id)
|
|
expect(messages.values[messages.keys[2]].id).to.equal(message1.id)
|
|
end
|
|
|
|
local message3 = Message.mock({ sent = DateTime.new(1991) })
|
|
|
|
action = ReceivedMessages(conversation.id, { message3 })
|
|
state = Conversations(state, action)
|
|
|
|
do
|
|
local messages = state[conversation.id].messages
|
|
expect(#messages.keys).to.equal(3)
|
|
expect(messages.values[messages.keys[1]].id).to.equal(message2.id)
|
|
expect(messages.values[messages.keys[2]].id).to.equal(message3.id)
|
|
expect(messages.values[messages.keys[3]].id).to.equal(message1.id)
|
|
end
|
|
end)
|
|
|
|
it("should set hasUnreadMessages if action.shouldMarkConversationUnread is true", function()
|
|
local conversation = Conversation.mock()
|
|
local message1 = Message.mock({ read = true })
|
|
local message2 = Message.mock({ read = false })
|
|
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(false)
|
|
|
|
local action = ReceivedMessages(conversation.id, { message1, message2 }, true)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(true)
|
|
end)
|
|
|
|
it("should not change hasUnreadMessages if action.shouldMarkConversationUnread is false", function()
|
|
local conversation = Conversation.mock()
|
|
local message1 = Message.mock({ read = false })
|
|
local message2 = Message.mock({ read = false })
|
|
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(false)
|
|
|
|
local action = ReceivedMessages(conversation.id, { message1, message2 }, false)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(false)
|
|
end)
|
|
end)
|
|
|
|
describe("Action SendingMessage", function()
|
|
it("should add to the list of sending messages", function()
|
|
local conversation = Conversation.mock()
|
|
local message = Message.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local action = SendingMessage(conversation.id, message)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id)).to.be.ok()
|
|
end)
|
|
end)
|
|
|
|
describe("Action SentMessage", function()
|
|
it("should remove from the list of sending messages", function()
|
|
local conversation = Conversation.mock()
|
|
local message = Message.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local action1 = SendingMessage(conversation.id, message)
|
|
state = Conversations(state, action1)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id)).to.be.ok()
|
|
|
|
local action2 = SentMessage(conversation.id, message.id)
|
|
state = Conversations(state, action2)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id)).to.never.be.ok()
|
|
end)
|
|
end)
|
|
|
|
describe("Action RenamedGroupConversation", function()
|
|
it("should rename the conversation", function()
|
|
local conversation = Conversation.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
local action = RenamedGroupConversation(conversation.id, "Fleebledegoop, Ham Sammich and Lemur Face")
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].title).to.equal("Fleebledegoop, Ham Sammich and Lemur Face")
|
|
end)
|
|
|
|
it("should update isDefaultTitle value", function()
|
|
local conversation = Conversation.mock({
|
|
isDefaultTitle = true,
|
|
})
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
state = Conversations(state, RenamedGroupConversation(conversation.id, "test", false))
|
|
|
|
expect(state[conversation.id].isDefaultTitle).to.equal(false)
|
|
end)
|
|
|
|
it("should update lastUpdated value", function()
|
|
local oldTick = 0
|
|
local newTick = 1
|
|
local conversation = Conversation.mock({
|
|
isDefaultTitle = true,
|
|
lastUpdated = oldTick,
|
|
})
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
state = Conversations(state, RenamedGroupConversation(conversation.id, "test", nil, newTick))
|
|
|
|
expect(state[conversation.id].lastUpdated).to.equal(newTick)
|
|
end)
|
|
end)
|
|
|
|
describe("Action ChangedParticipants", function()
|
|
it("should update the participant list", function()
|
|
local conversation = Conversation.mock()
|
|
local user1 = User.mock()
|
|
local user2 = User.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local action = ChangedParticipants(conversation.id, { user1.id, user2.id })
|
|
state = Conversations(state, action)
|
|
|
|
expect(#state[conversation.id].participants).to.equal(2)
|
|
expect(state[conversation.id].participants[1]).to.equal(user1.id)
|
|
expect(state[conversation.id].participants[2]).to.equal(user2.id)
|
|
|
|
action = ChangedParticipants(conversation.id, { user2.id })
|
|
state = Conversations(state, action)
|
|
|
|
expect(#state[conversation.id].participants).to.equal(1)
|
|
expect(state[conversation.id].participants[1]).to.equal(user2.id)
|
|
end)
|
|
end)
|
|
|
|
describe("Action RemovedConversation", function()
|
|
it("should update the conversation list", function()
|
|
local conversation1 = Conversation.mock()
|
|
local conversation2 = Conversation.mock()
|
|
local state = {
|
|
[conversation1.id] = conversation1,
|
|
[conversation2.id] = conversation2
|
|
}
|
|
|
|
local action = RemovedConversation(conversation1.id)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation1.id]).to.equal(nil)
|
|
expect(state[conversation2.id]).to.be.a("table")
|
|
expect(state[conversation2.id].id).to.equal(conversation2.id)
|
|
end)
|
|
end)
|
|
|
|
describe("Action SetUserTyping", function()
|
|
it("should set userTyping flag for user", function()
|
|
local user = User.mock()
|
|
local conversation = Conversation.mock({ participants = { user.id } })
|
|
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
expect(state[conversation.id].usersTyping[user.id]).to.never.be.ok()
|
|
|
|
local action1 = SetUserTyping(conversation.id, user.id, true)
|
|
state = Conversations(state, action1)
|
|
|
|
expect(state[conversation.id].usersTyping[user.id]).to.equal(true)
|
|
|
|
local action2 = SetUserTyping(conversation.id, user.id, false)
|
|
state = Conversations(state, action2)
|
|
|
|
expect(state[conversation.id].usersTyping[user.id]).to.equal(false)
|
|
end)
|
|
end)
|
|
|
|
describe("Action FetchingOlderMessages", function()
|
|
it("sets the fetchingOlderMessages flag", function()
|
|
local conversation = Conversation.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
expect(state[conversation.id].fetchingOlderMessages).to.equal(false)
|
|
|
|
local action1 = FetchingOlderMessages(conversation.id, true)
|
|
state = Conversations(state, action1)
|
|
|
|
expect(state[conversation.id].fetchingOlderMessages).to.equal(true)
|
|
|
|
local action2 = FetchingOlderMessages(conversation.id, false)
|
|
state = Conversations(state, action2)
|
|
|
|
expect(state[conversation.id].fetchingOlderMessages).to.equal(false)
|
|
end)
|
|
end)
|
|
|
|
describe("Action FetchedOldestMessage", function()
|
|
it("sets the fetchedOldestMessage flag", function()
|
|
local conversation = Conversation.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
expect(state[conversation.id].fetchedOldestMessage).to.equal(false)
|
|
|
|
local action1 = FetchedOldestMessage(conversation.id, true)
|
|
state = Conversations(state, action1)
|
|
|
|
expect(state[conversation.id].fetchedOldestMessage).to.equal(true)
|
|
|
|
local action2 = FetchedOldestMessage(conversation.id, false)
|
|
state = Conversations(state, action2)
|
|
|
|
expect(state[conversation.id].fetchedOldestMessage).to.equal(false)
|
|
end)
|
|
end)
|
|
|
|
describe("Action ReadConversation", function()
|
|
it("should read messages and mark the conversation's unread state", function()
|
|
local message1 = Message.mock({ sent = DateTime.new(1992), read = true })
|
|
local message2 = Message.mock({ sent = DateTime.new(1993), read = false })
|
|
local message3 = Message.mock({ sent = DateTime.new(1994), read = false })
|
|
local message4 = Message.mock({ sent = DateTime.new(1995), read = false })
|
|
local message5 = Message.mock({ sent = DateTime.new(1996), read = false })
|
|
local conversation = Conversation.mock()
|
|
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local actionAddMessages = ReceivedMessages(conversation.id, { message1, message2, message3, message4 }, true)
|
|
state = Conversations(state, actionAddMessages)
|
|
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(true)
|
|
|
|
local actionReadAll = ReadConversation(conversation.id)
|
|
state = Conversations(state, actionReadAll)
|
|
|
|
do
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(false)
|
|
local messages = state[conversation.id].messages
|
|
expect(messages.values[message1.id].read).to.equal(true)
|
|
expect(messages.values[message2.id].read).to.equal(true)
|
|
expect(messages.values[message3.id].read).to.equal(true)
|
|
end
|
|
|
|
local action2 = ReceivedMessages(conversation.id, { message4, message5 }, true)
|
|
|
|
state = Conversations(state, action2)
|
|
|
|
do
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(true)
|
|
local messages = state[conversation.id].messages
|
|
expect(messages.values[message1.id].read).to.equal(true)
|
|
expect(messages.values[message2.id].read).to.equal(true)
|
|
expect(messages.values[message3.id].read).to.equal(true)
|
|
expect(messages.values[message4.id].read).to.equal(true)
|
|
expect(messages.values[message5.id].read).to.equal(false)
|
|
end
|
|
|
|
local actionReadAll2 = ReadConversation(conversation.id)
|
|
state = Conversations(state, actionReadAll2)
|
|
|
|
do
|
|
expect(state[conversation.id].hasUnreadMessages).to.equal(false)
|
|
local messages = state[conversation.id].messages
|
|
expect(messages.values[message1.id].read).to.equal(true)
|
|
expect(messages.values[message2.id].read).to.equal(true)
|
|
expect(messages.values[message3.id].read).to.equal(true)
|
|
expect(messages.values[message4.id].read).to.equal(true)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
describe("Action MessageModerated", function()
|
|
it("should mark the sending message as moderated", function()
|
|
local conversation = Conversation.mock()
|
|
local message = Message.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local action = SendingMessage(conversation.id, message)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id).moderated).to.never.be.ok()
|
|
|
|
action = MessageModerated(conversation.id, message.id)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id).moderated).to.equal(true)
|
|
end)
|
|
end)
|
|
|
|
describe("Action MessageFailedToSend", function()
|
|
it("should mark the sending message as failed", function()
|
|
local conversation = Conversation.mock()
|
|
local message = Message.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local action = SendingMessage(conversation.id, message)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id).failed).to.equal(nil)
|
|
|
|
action = MessageFailedToSend(conversation.id, message.id)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].sendingMessages:Get(message.id).failed).to.equal(true)
|
|
end)
|
|
end)
|
|
|
|
describe("Action SetConversationLoadingStatus", function()
|
|
it("should set the conversation loading status", function()
|
|
local conversation = Conversation.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
expect(state[conversation.id].initialLoadingStatus).to.never.be.ok()
|
|
|
|
local action = SetConversationLoadingStatus(conversation.id, Constants.ConversationLoadingState.LOADING)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].initialLoadingStatus).to.equal(Constants.ConversationLoadingState.LOADING)
|
|
|
|
action = SetConversationLoadingStatus(conversation.id, Constants.ConversationLoadingState.DONE)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].initialLoadingStatus).to.equal(Constants.ConversationLoadingState.DONE)
|
|
end)
|
|
end)
|
|
|
|
describe("Action SetPinnedGameForConversation", function()
|
|
it("should set the pinned game for conversation", function()
|
|
local conversation = Conversation.mock()
|
|
local state = {
|
|
[conversation.id] = conversation
|
|
}
|
|
|
|
local mockRootPlaceId = MockId()
|
|
local mockUniverseId = MockId()
|
|
|
|
local action = SetPinnedGameForConversation(mockUniverseId, mockRootPlaceId, conversation.id)
|
|
state = Conversations(state, action)
|
|
|
|
expect(state[conversation.id].pinnedGame.rootPlaceId).to.equal(mockRootPlaceId)
|
|
expect(state[conversation.id].pinnedGame.universeId).to.equal(mockUniverseId)
|
|
end)
|
|
end)
|
|
|
|
end |