public void TestAddNickname()
{
var message = new Message();
var room = new Room();
message.Body = "nick add bob";
handler.Receive(message, room);
Mock<INicknameService>()
.Verify(call => call.Add("bob"));
}
public void TestAddNickname()
{
var message = new Message();
var room = new Room();
message.Body = "nick remove tracy";
handler.Receive(message, room);
Mock<INicknameService>()
.Verify(call => call.Remove("tracy"));
}
public void TestHandleMessageWhenNotAddressedToBot()
{
var room = new Room();
var message = new Message { Body = "two" };
Mock<INicknameService>()
.Setup(call => call.IsAddressedToMe(message))
.Returns(false);
service.Handle(message, room);
Assert.IsFalse(((FakeHandler)service.Handlers[0]).Fired);
Assert.IsFalse(((FakeHandler)service.Handlers[1]).Fired);
Assert.IsFalse(((FakeHandler)service.Handlers[2]).Fired);
}
/// <summary>
/// Occurs when an incoming message is received
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="msg">The MSG.</param>
void ConnectionOnMessage(object sender, Msg msg)
{
// Prevent loop-back
if (msg.From.Resource == current.Name)
{
return;
}
// Ignore composing messages
if (msg.Chatstate == Chatstate.composing)
{
return;
}
// Construct message
var message = new Message
{
From = msg.From.Resource,
Room = msg.From.User,
Body = msg.Body,
To = msg.To.Resource,
Received = DateTime.Now
};
var room = new Room
{
JabberId = msg.From.User,
IsChat = msg.Type == MessageType.chat
};
if (room.IsChat)
{
room.JabberId = msg.From.User;
}
// Construct args
var args = new MessageEventArgs
{
Message = message,
Room = room
};
// Fire
OnMessage(this, args);
}
public void TestHandleMessageWhenAliasedButBypassed()
{
var room = new Room();
var message = new Message { Body = "!two" };
Mock<INicknameService>()
.Setup(call => call.IsAddressedToMe(message))
.Returns(true);
Mock<IAliasService>()
.Setup(call => call.IsAlias("!two"))
.Returns(false);
service.Handle(message, room);
Assert.IsFalse(((FakeHandler)service.Handlers[0]).Fired);
Assert.IsTrue(((FakeHandler)service.Handlers[1]).Fired);
Assert.IsFalse(((FakeHandler)service.Handlers[2]).Fired);
}
/// <summary>
/// Determines whether the specified message is addressed to me.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>
/// <c>true</c> if the specified message is addressed to me; otherwise, <c>false</c>.
/// </returns>
public bool IsAddressedToMe(Message message)
{
// Ignore empty messages
if (string.IsNullOrWhiteSpace(message.Body))
{
return false;
}
// Check each list
foreach (var nick in List())
{
if (message.Body.IndexOf("@" + nick + " ", 0, StringComparison.InvariantCultureIgnoreCase) == 0)
{
return true;
}
};
return false;
}
/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="room"></param>
public void Handle(Message message, Room room)
{
// Check bot can handle this message
if (!CanHandle(message, room))
{
return;
}
// Check for aliases
if (AliasService.IsAlias(message.Body))
{
message.Body = AliasService.GetAlias(message.Body);
}
// Remove Alias bypass
if (message.Body.StartsWith("!"))
{
message.Body = message.Body.Substring(1);
}
var handled = false;
// Check each handler
foreach (var handler in Handlers)
{
if (!handler.CanHandle(message)) continue;
handler.Receive(message, room);
handled = true;
break;
}
if (!handled)
{
HipChatService.Say(room, "I didn't understand: {0}", message.Body);
}
}
/// <summary>
/// Occurs when an incoming message is received
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="msg">The MSG.</param>
void ConnectionOnMessage(object sender, Msg msg)
{
// Prevent loop-back
if (msg.From.Resource == current.Name) return;
// Ignore composing messages
if (msg.Chatstate == Chatstate.composing) return;
// Construct message
var message = new Message
{
From = msg.From.Resource,
Room = msg.From.User,
Body = msg.Body,
To = msg.To.Resource,
Received = DateTime.Now
};
var room = new Room
{
JabberId = msg.From.User,
IsChat = msg.Type == MessageType.chat
};
if (room.IsChat)
{
room.JabberId = msg.From.User;
}
// Construct args
var args = new MessageEventArgs
{
Message = message,
Room = room
};
// Fire
OnMessage(this, args);
}
/// <summary>
/// Determines whether this instance can handle the specified message in the room.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="room">The room.</param>
/// <returns>
/// <c>true</c> if this instance can handle the specified room; otherwise, <c>false</c>.
/// </returns>
private bool CanHandle(Message message, Room room)
{
var canHandle = message.Body != null;
// Check message is not one-on-one message
if (!room.IsChat)
{
// Check message is addressed to this bot
if (!NicknameService.IsAddressedToMe(message))
{
canHandle = false;
}
// Strip Bot name from message
if (message.Body == null)
return false;
var index = message.Body.IndexOf(" ");
message.Body = message.Body.Substring(index + 1);
}
return canHandle;
}
public void Receive(Message message, Room room)
{
Fired = true;
}
public bool CanHandle(Message message)
{
return message.Body == respondsTo;
}
