void ShouldSaveAndLoadRules()
{
var blacklist = BlacklistFactory.CreateBlacklist();
List <Rule> rules = new List <Rule>();
for (int i = 0; i < 100; i++)
{
var rule = new Rule("r" + i, i.ToString());
blacklist.AddRule(rule);
}
((IBlacklistStorage)blacklist).Save("blacklist_test");
var blacklist2 = BlacklistFactory.CreateBlacklist();
blacklist2.AddRule(new Rule()
{
Name = "extra"
});
((IBlacklistStorage)blacklist2).Load("blacklist_test");
foreach (var expected in rules)
{
var actual = blacklist2.GetRule(expected.Id);
AssertRulesEqual(expected, actual);
}
var loadedRules = new List <Rule>();
for (int i = 0; i < blacklist2.GetRulePageCount(); i++)
{
loadedRules.AddRange(blacklist2.GetRules(i));
}
Assert.True(loadedRules.Count == 100);
}
public void ShouldAddRulesIgnoreId()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var expected1 = new Rule()
{
Name = "rule 1",
Pattern = "123456",
Id = Guid.NewGuid(),
};
var expected2 = (Rule)expected1.Clone();
Assert.Equal(expected1.Id, expected2.Id);
var returnedRule1 = blacklist.AddRule(expected1);
var returnedRule2 = blacklist.AddRule(expected2);
var actual1 = blacklist.GetRule(returnedRule1.Id);
AssertRulesEqual(expected1, actual1, false);
AssertRulesEqual(expected1, returnedRule1, false);
AssertRulesEqual(returnedRule1, actual1, false);
var actual2 = blacklist.GetRule(returnedRule2.Id);
AssertRulesEqual(expected2, actual2, false);
AssertRulesEqual(expected2, returnedRule2, false);
AssertRulesEqual(returnedRule2, actual2, false);
}
public void ShouldThrowExceptionWhenRuleNotFound()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var one = new Rule()
{
Name = "rule 1",
Pattern = "123456",
};
blacklist.AddRule(one);
Assert.Throws <InvalidOperationException>(() => { blacklist.GetRule(Guid.NewGuid()); });
}
public void ShouldNotAddRuleWithoutName()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var expected = new Rule()
{
Name = "",
Pattern = "123456",
};
Assert.Throws <ArgumentException>(() => {
blacklist.AddRule(expected);
});
}
public void ShouldThrowOnUpdateWhenNameEmpty()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var one = new Rule()
{
Name = "rule 1",
Pattern = "123456",
};
blacklist.AddRule(one);
Assert.Throws <ArgumentException>(() => { blacklist.UpdateRule(Guid.NewGuid(), new Rule()
{
Name = ""
}); });
}
public void ShouldReturnPageCountPrecise()
{
var blacklist = BlacklistFactory.CreateBlacklist();
for (int i = 0; i < 20; i++)
{
blacklist.AddRule(new Rule {
Name = "r" + i,
Pattern = "r" + i
});
}
var pageCount = blacklist.GetRulePageCount();
Assert.Equal(2, pageCount);
}
public void ShouldReturnEmptyPageWithRules()
{
var blacklist = BlacklistFactory.CreateBlacklist();
for (int i = 0; i < 15; i++)
{
blacklist.AddRule(new Rule {
Name = "r" + i,
Pattern = "r" + i
});
}
var rules = blacklist.GetRules(2);
Assert.True(0 == rules.Length);
}
public void ShouldAddandGetRule()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var expected = new Rule()
{
Name = "rule 1",
Pattern = "123456",
};
var returnedRule = blacklist.AddRule(expected);
var actual = blacklist.GetRule(returnedRule.Id);
AssertRulesEqual(expected, actual, false);
AssertRulesEqual(expected, returnedRule, false);
AssertRulesEqual(returnedRule, actual, false);
}
public void ShouldThrowWhenDeletingRuleThatDoesNotExist()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var one = new Rule()
{
Name = "r1"
};
var two = new Rule()
{
Name = "r2"
};
blacklist.AddRule(one);
var twoStored = blacklist.AddRule(two);
Assert.Throws <InvalidOperationException>(() => { blacklist.DeleteRule(Guid.NewGuid()); });
}
public void ShouldDeleteRule()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var one = new Rule()
{
Name = "r1"
};
var two = new Rule()
{
Name = "r2"
};
var oneStored = blacklist.AddRule(one);
var twoStored = blacklist.AddRule(two);
blacklist.DeleteRule(twoStored.Id);
Assert.Throws <InvalidOperationException>(() => { blacklist.GetRule(twoStored.Id); });
var oneRet = blacklist.GetRule(oneStored.Id);
Assert.Equal(oneRet.Name, oneStored.Name);
}
public void ShouldReturnPage1WithRules()
{
var blacklist = BlacklistFactory.CreateBlacklist();
for (int i = 0; i < 15; i++)
{
blacklist.AddRule(new Rule {
Name = "r" + i,
Pattern = "r" + i
});
}
var rules = blacklist.GetRules(1);
Assert.Equal(5, rules.Length);
for (int i = 0, j = 10; i < 5; i++, j++)
{
Assert.Equal("r" + j, rules[i].Name);
Assert.Equal("r" + j, rules[i].Name);
}
}
public void ShouldUpdateRule()
{
var blacklist = BlacklistFactory.CreateBlacklist();
var one = new Rule()
{
Name = "rule 1",
Pattern = "123456",
};
var oneStored = blacklist.AddRule(one);
var expected = new Rule()
{
Name = "update",
Pattern = "654321",
};
var updated = blacklist.UpdateRule(oneStored.Id, expected);
var actual = blacklist.GetRule(oneStored.Id);
AssertRulesEqual(expected, actual, true);
AssertRulesEqual(expected, updated, true);
}
