public void DoesntPingWhenThereIsActivity()
{
var selfData = new SelfBotData { Id = "BOTID" };
var mockState = new Mock<IBotState>();
mockState.Setup(m => m.Connected).Returns(true).Verifiable();
var mockService = new Mock<IBotServices>();
mockService.Setup(m => m.SendRawMessage(It.Is<OutputMessage>(om => om.Type == "ping")))
.Verifiable();
var handler = new PingHandler
{
BotState = mockState.Object,
BotServices = mockService.Object,
PingFrequencyMs = 200
};
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "<@BOTID>: pingdom"
};
Thread.Sleep(250);
foreach (var loop in Enumerable.Range(1, 6))
{
handler.CanHandle(message);
Thread.Sleep(100);
}
mockService.Verify(m => m.SendRawMessage(It.Is<OutputMessage>(om => om.Type == "ping")), Times.Exactly(1));
}
public void CanHandleImPingMessages()
{
var ims = new List<DirectMessageChannel>
{
new DirectMessageChannel { Id = "IMID" }
};
var mockState = new Mock<IBotState>();
mockState.Setup(m => m.Ims).Returns(ims).Verifiable();
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Channel = "IMID",
Text = "ping"
};
var handler = new UserPingHandler();
handler.BotState = mockState.Object;
var result = handler.CanHandle(message);
Assert.True(result);
}
public void IsActivePlainMessageShouldNotMatchWrongSubType()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.MeMessage,
};
var result = EventMessageExtensions.IsActivePlainMessage(message);
Assert.False(result);
}
public void IsActivePlainMessageShouldMatch()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
};
var result = EventMessageExtensions.IsActivePlainMessage(message);
Assert.True(result);
}
public void IsActivePlainMessageShouldNotMatchHistoric()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Historic = true
};
var result = EventMessageExtensions.IsActivePlainMessage(message);
Assert.False(result);
}
public void CanNotHandleInvalidPingMessages()
{
var selfData = new SelfBotData { Id = "BOTID" };
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "<@BOTID>: pingdom"
};
var handler = new PingHandler();
var result = handler.CanHandle(message);
Assert.False(result);
}
public void CanNotHandleInvalidPingMessages()
{
var selfData = new SelfBotData { Id = "BOTID" };
var mockState = new Mock<IBotState>();
mockState.Setup(m => m.Ims).Returns(new List<DirectMessageChannel>()).Verifiable();
mockState.Setup(m => m.Self).Returns(selfData).Verifiable();
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "<@BOTID>: pingdom"
};
var handler = new UserPingHandler();
handler.BotState = mockState.Object;
var result = handler.CanHandle(message);
Assert.False(result);
}
public async void HandlesChannelMessage()
{
var selfData = new SelfBotData { Id = "BOTID" };
var mockState = new Mock<IBotState>();
mockState.Setup(m => m.Ims).Returns(new List<DirectMessageChannel>()).Verifiable();
string channelResult = "";
string messageResult = "";
var mockService = new Mock<IBotServices>();
mockService.Setup(s => s.SendMessage(It.IsAny<string>(), It.IsAny<string>()))
.Callback<string, string>((c, m) =>
{
channelResult = c;
messageResult = m;
})
.Returns(1)
.Verifiable();
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "<@BOTID>: ping",
Channel = "CHANID",
User = "******"
};
var handler = new UserPingHandler();
handler.BotState = mockState.Object;
handler.BotServices = mockService.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
mockService.Verify();
Assert.Equal(ProcessingChainResult.Continue, result);
Assert.Equal("CHANID", channelResult);
Assert.Equal("<@USERID>: pong", messageResult);
}
public void IsImShouldMatchDirectMessage()
{
var ims = new List<DirectMessageChannel>()
{
new DirectMessageChannel { Id = "BADID1" },
new DirectMessageChannel { Id = "BADID2" },
new DirectMessageChannel { Id = "TESTID" },
new DirectMessageChannel { Id = "BADID3" }
};
var mockState = new Mock<IBotState>();
mockState.Setup(m => m.Ims).Returns(ims).Verifiable();
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Channel = "TESTID"
};
var result = EventMessageExtensions.IsIm(message, mockState.Object);
mockState.Verify();
Assert.True(result);
}
public void IsOneOfShouldNotMatchInvalidList()
{
var message = new PlainMessage() { Type = EventType.ChannelCreated };
var matches = new[]
{
EventType.ImClose,
EventType.PinAdded,
EventType.ChannelLeft,
EventType.CommandsChanged,
EventType.ManualPresenceChange
};
var result = EventMessageExtensions.IsOneOf(message, matches);
Assert.False(result);
}
public void ShouldNotMatchInvalidText()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "test message"
};
var result = EventMessageExtensions.MatchesText(message, @"testing");
Assert.False(result);
}
public void ShouldNotCastToInvalidType()
{
EventMessageBase message = new PlainMessage();
Assert.Throws<InvalidCastException>(() => EventMessageExtensions.CastTo<Hello>(message));
}
public void ShouldMatchValidText()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "test message"
};
var result = EventMessageExtensions.MatchesText(message, @"\btest\b");
Assert.True(result);
}
public void ShouldCastToType()
{
EventMessageBase message = new PlainMessage();
var result = EventMessageExtensions.CastTo<PlainMessage>(message);
Assert.Same(message, result);
}
public void IsToMeShouldNotMatchWhenNotNamed()
{
var selfData = new SelfBotData { Id = "BOTID" };
var mockState = new Mock<IBotState>();
mockState.Setup(m => m.Ims).Returns(new List<DirectMessageChannel>()).Verifiable();
mockState.Setup(m => m.Self).Returns(selfData).Verifiable();
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Channel = "TESTID",
Text = "<@OTHERID>: test message"
};
var result = EventMessageExtensions.IsToMe(message, mockState.Object);
mockState.Verify();
Assert.False(result);
}
public void ShouldRemapMessagesToConcreteTypes()
{
var meMessage = new MeMessage
{
Type = EventType.Message,
Subtype = MessageSubType.MeMessage,
Text = "me",
Team = "team1"
};
var topicMessage = new ChannelTopic
{
Type = EventType.Message,
Subtype = MessageSubType.ChannelTopic,
Topic = "topic"
};
var plainMessage = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "text"
};
var parser = new ResponseParser();
var messages = new List<MessageBase>
{
parser.Deserialize<MessageBase>(parser.SerializeMessage(meMessage)),
parser.Deserialize<MessageBase>(parser.SerializeMessage(topicMessage)),
parser.Deserialize<MessageBase>(parser.SerializeMessage(plainMessage))
};
var concreteMessages = parser.RemapMessagesToConcreteTypes(messages).ToList();
Assert.IsType<MeMessage>(concreteMessages[0]);
Assert.IsType<ChannelTopic>(concreteMessages[1]);
Assert.IsType<PlainMessage>(concreteMessages[2]);
Assert.Equal(EventType.Message, concreteMessages[0].Type);
Assert.Equal(MessageSubType.MeMessage, concreteMessages[0].Subtype);
Assert.Equal("me", concreteMessages[0].Text);
Assert.Equal("team1", concreteMessages[0].Team);
Assert.Equal(EventType.Message, concreteMessages[1].Type);
Assert.Equal("topic", ((ChannelTopic)concreteMessages[1]).Topic);
}
public void IsOneOfShouldMatchValidList()
{
var message = new PlainMessage() { Type = EventType.Hello };
var matches = new[]
{
EventType.AccountsChanged,
EventType.ChannelCreated,
EventType.ChannelLeft,
EventType.CommandsChanged,
EventType.Hello
};
var result = EventMessageExtensions.IsOneOf(message, matches);
Assert.True(result);
result = EventMessageExtensions.IsOneOf(message, EventType.Hello);
Assert.True(result);
}
