public void TextMuteIsCorrectlyMatched()
{
// Arrange
var muteConfig = new MuteConfig();
muteConfig.Entries.Add(new MuteEntry {
Filter = "test"
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
var status = new Status
{
Text = "Will not match"
};
// Act
var noMatch = muter.IsMuted(status);
status.Text = "Will match since test is contained";
var match = muter.IsMuted(status);
// Assert
Assert.IsFalse(noMatch);
Assert.IsTrue(match);
}
public void RemoveCommandsNeedsSelection()
{
// Arrange
var muteCfg = new MuteConfig();
muteCfg.Entries.Add(new MuteEntry {
Filter = "test", EndDate = DateTime.Now
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteCfg);
var vm = new MuteSettings(config.Object);
// Act
bool withoutSelection = vm.RemoveCommand.CanExecute(null);
vm.SelectedEntry = vm.Entries.First();
bool withSelection = vm.RemoveCommand.CanExecute(null);
// Assert
Assert.IsFalse(withoutSelection);
Assert.IsTrue(withSelection);
}
public void SaveWritesCorrectValues()
{
// Arrange
var muteCfg = new MuteConfig();
muteCfg.Entries.Add(new MuteEntry {
Filter = "test", EndDate = DateTime.Now
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteCfg);
var vm = new MuteSettings(config.Object);
// Act
vm.Entries.Clear();
vm.Entries.Add(new MuteEntry {
Filter = "filter", EndDate = new DateTime(2020, 1, 2)
});
vm.SaveTo(config.Object);
// Assert
Assert.AreEqual(1, muteCfg.Entries.Count);
Assert.AreEqual("filter", muteCfg.Entries[0].Filter);
Assert.AreEqual(new DateTime(2020, 1, 2), muteCfg.Entries[0].EndDate);
}
public void UserMutesAreCorrectlyMatched()
{
// Arrange
var muteConfig = new MuteConfig();
muteConfig.Entries.Add(new MuteEntry {
Filter = "@sameUser"
});
muteConfig.Entries.Add(new MuteEntry {
Filter = "@differentUser"
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
// Act
bool noUser = muter.IsMuted(new Status
{
Entities = new LinqToTwitter.Entities
{
UserMentionEntities = new List <UserMentionEntity>()
}
});
bool otherUser = muter.IsMuted(new Status
{
Entities = new LinqToTwitter.Entities
{
UserMentionEntities = new List <UserMentionEntity>
{
new UserMentionEntity {
ScreenName = "otherUser"
}
}
}
});
bool sameUser = muter.IsMuted(new Status
{
Entities = new LinqToTwitter.Entities
{
UserMentionEntities = new List <UserMentionEntity>
{
new UserMentionEntity {
ScreenName = "sameUser"
}
}
}
});
// Assert
Assert.IsFalse(noUser);
Assert.IsFalse(otherUser);
Assert.IsTrue(sameUser);
}
public void HashtagMutesAreCorrectlyMatched()
{
// Arrange
var muteConfig = new MuteConfig();
muteConfig.Entries.Add(new MuteEntry {
Filter = "#sameTag"
});
muteConfig.Entries.Add(new MuteEntry {
Filter = "#differentTag"
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
// Act
bool noTag = muter.IsMuted(new Status
{
Entities = new LinqToTwitter.Entities
{
HashTagEntities = new List <HashTagEntity>()
}
});
bool otherTag = muter.IsMuted(new Status
{
Entities = new LinqToTwitter.Entities
{
HashTagEntities = new List <HashTagEntity>
{
new HashTagEntity {
Tag = "otherTag"
}
}
}
});
bool sameTag = muter.IsMuted(new Status
{
Entities = new LinqToTwitter.Entities
{
HashTagEntities = new List <HashTagEntity>
{
new HashTagEntity {
Tag = "sameTag"
}
}
}
});
// Assert
Assert.IsFalse(noTag);
Assert.IsFalse(otherTag);
Assert.IsTrue(sameTag);
}
public void CasingIsAppliedForHashtags()
{
// Arrange
var muteConfig = new MuteConfig();
muteConfig.Entries.Add(new MuteEntry {
Filter = "#Text", CaseSensitive = true
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
var upperStatus = new Status
{
Entities = new LinqToTwitter.Entities
{
HashTagEntities = new List <HashTagEntity>
{
new HashTagEntity
{
Tag = "Text"
}
}
}
};
var lowerStatus = new Status
{
Entities = new LinqToTwitter.Entities
{
HashTagEntities = new List <HashTagEntity>
{
new HashTagEntity
{
Tag = "text"
}
}
}
};
// Act
bool matchedCaseWhenSensitive = muter.IsMuted(upperStatus);
bool unmatchedCaseWhenSensitive = muter.IsMuted(lowerStatus);
muteConfig.Entries[0].CaseSensitive = false;
bool matchedCaseWhenInsensitive = muter.IsMuted(upperStatus);
bool unmatchedCaseWhenInsensitive = muter.IsMuted(lowerStatus);
// Assert
Assert.IsTrue(matchedCaseWhenInsensitive);
Assert.IsTrue(matchedCaseWhenSensitive);
Assert.IsTrue(unmatchedCaseWhenInsensitive);
Assert.IsFalse(unmatchedCaseWhenSensitive);
}
public void NullStatusIsRejected()
{
// Arrange
var muteConfig = new MuteConfig();
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
// Act
bool match = muter.IsMuted(null);
// Assert
Assert.IsTrue(match);
}
private MuteState CreateNextMuteState(IGuildUser user, MuteType muteType)
{
// set default state
_logger.LogDebug($"{user.Username} mute conf");
var ms = new MuteState(_defaultVCProps[user.Id]);
if (muteType == MuteType.Default)
{
return(ms);
}
_logger.LogDebug($"{user.Username} dead state set");
// Set dead state
bool isDead = true;
var cnvInfo = _idConversionDict.FirstOrDefault(u => u.Value == user.Id);
if (cnvInfo.Value == user.Id)
{
try
{
_logger.LogDebug($"{user.Username} found in conversion list");
isDead = _isDead[cnvInfo.Key];
var name = _players[cnvInfo.Key].Client.Name;
_logger.LogDebug($"Player => {name}({user.Username}) is dead: {isDead}");
}
catch (Exception e)
{
LogStackTrace(e, "CreateNextMuteState");
}
}
else
{
_logger.LogInformation($"Spectator => {user.Username}");
}
// Apply mute rule
MuteConfig m = _config.TaskPhaseMuteRules;
if (muteType == MuteType.MeetingPhase)
{
m = _config.MeetingPhaseMuteRules;
}
ms.Mute = isDead ? m.Mute.Dead : m.Mute.Alive;
ms.Deaf = isDead ? m.Deaf.Dead : m.Deaf.Alive;
return(ms);
}
public void EmptyMutingsWillNotMatchAnything()
{
// Arrange
var muteConfig = new MuteConfig();
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
var status = new Status
{
Text = "Hello World"
};
// Act
bool match = muter.IsMuted(status);
// Assert
Assert.IsFalse(match);
}
public void CorrectDataIsLoaded()
{
// Arrange
var muteCfg = new MuteConfig();
muteCfg.Entries.Add(new MuteEntry {
Filter = "test", EndDate = DateTime.Now
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteCfg);
// Act
var vm = new MuteSettings(config.Object);
// Assert
Assert.AreEqual(1, vm.Entries.Count);
Assert.AreEqual("test", vm.Entries.First().Filter);
Assert.IsTrue(vm.Entries.First().HasEndDate);
Assert.AreNotEqual(string.Empty, vm.HelpDocument);
}
public void CasingIsAppliedDuringTextMuting()
{
// Arrange
var muteConfig = new MuteConfig();
muteConfig.Entries.Add(new MuteEntry {
Filter = "Text", CaseSensitive = true
});
var config = new Mock <IConfig>();
config.SetupGet(c => c.Mute).Returns(muteConfig);
var muter = new StatusMuter(config.Object);
// Act
bool matchedCaseWhenSensitive = muter.IsMuted(new Status {
Text = "This is a Text"
});
bool unmatchedCaseWhenSensitive = muter.IsMuted(new Status {
Text = "This is a text"
});
muteConfig.Entries[0].CaseSensitive = false;
bool matchedCaseWhenInsensitive = muter.IsMuted(new Status {
Text = "This is a Text"
});
bool unmatchedCaseWhenInsensitive = muter.IsMuted(new Status {
Text = "This is a text"
});
// Assert
Assert.IsTrue(matchedCaseWhenInsensitive);
Assert.IsTrue(matchedCaseWhenSensitive);
Assert.IsTrue(unmatchedCaseWhenInsensitive);
Assert.IsFalse(unmatchedCaseWhenSensitive);
}
