protected override void ProcessRecord()
{
base.ProcessRecord();
long index;
if (!long.TryParse(Index, out index))
{
index = -1;
}
// TODO: Validate Operator
var newRule = new SeatClassificationRule
{
RuleName = RuleName,
Notes = Notes,
Order = index,
Field = Field,
Operator = Operator,
Value = Value,
Status = Status
};
var systemFile = SeatClassificationFile.Load(SeatClassificationFile.SystemRuleFile);
var experimentalFile = SeatClassificationFile.Load(SeatClassificationFile.ExperimentalFile);
var engine = new SeatClassificationEngine(systemFile, experimentalFile);
engine.AddRule(newRule, !_production);
systemFile.Save(SeatClassificationFile.SystemRuleFile);
experimentalFile.Save(SeatClassificationFile.ExperimentalFile);
}
public void GetMatchingRule_WhenMatchingRuleExists_ReturnsCorrectRule()
{
// Arrange
var sut = new SeatClassificationEngine();
sut.AddRule(new SeatClassificationRule
{
RuleName = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Sold
}, false);
var wantedRule = new SeatClassificationRule
{
RuleName = "Test 2",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "0",
Status = SeatStatus.Unknown
};
sut.AddRule(wantedRule, false);
var code = new EttCode("000004130000");
// Act
var res = sut.GetMatchingRule(code);
// Assert
res.Should().BeSameAs(wantedRule, "this is the rule that should match");
}
public void IsMatch_WhenRuleIsMatch_ReturnsTrue()
{
// Arrange
var sut = new SeatClassificationRule
{
RuleName = "Test rule",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1"
};
var code = new EttCode("000004130001");
// Act
var res = sut.IsMatch(code);
// Assert
res.Should().BeTrue("BaseType equals 1 in this case");
}
public void AddRule_WithNoExperimentalRule_AddsRuleToList()
{
// Arrange
var sut = new SeatClassificationEngine();
var rule = new SeatClassificationRule
{
RuleName = "Test rule",
Notes = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Reserved,
Order = 1
};
// Act
sut.AddRule(rule, false);
// Assert
sut.AllRules.Contains(rule).Should().BeTrue("we added it as a non-experimental rule");
}
public void AddRules_WhenCalled_ReturnsAllExpectedData()
{
// Arrange
var sut = new SeatClassificationEngine();
var normalRule = new SeatClassificationRule
{
RuleName = "Normal rule",
Notes = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Reserved,
Order = 1
};
var experimentalRule = new SeatClassificationRule
{
RuleName = "Experimental rule",
Notes = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Reserved,
Order = 1
};
sut.UseExperimentalRules = true;
sut.AddRule(normalRule, false);
sut.AddRule(experimentalRule, true);
// Act
var res = sut.AllRules.ToList();
// Assert
res.Should().NotBeNull("we should end up with a valid, populated list");
res.Count.Should().Be(2, "we added two rules to the engine");
res.Contains(normalRule).Should().BeTrue("this rule should be in the list");
res.Contains(experimentalRule).Should().BeTrue("this rule should be in the list");
}
public void UseExperimentalRules_WhenSetToFalse_HidesExperimentalRules()
{
// Arrange
var sut = new SeatClassificationEngine();
var rule = new SeatClassificationRule
{
RuleName = "Test rule",
Notes = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Reserved,
Order = 1
};
// Act
sut.AddRule(rule, true);
// Assert
sut.AllRules.Contains(rule).Should().BeFalse("we added it as an experimental rule");
sut.UseExperimentalRules = true;
sut.AllRules.Contains(rule).Should().BeTrue("the rule should now be visible");
}
public void ToggleExperimental_WhenCalledOnExistingRule_ActuallyTogglesExperimentalStatus()
{
// Arrange
var sut = new SeatClassificationEngine();
var rule = new SeatClassificationRule
{
RuleName = "Test rule",
Notes = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Reserved,
Order = 1
};
sut.AddRule(rule, false);
sut.AllRules.Count().Should().Be(1, "the rule should be added to the list");
// Act
sut.ToggleExperimental(rule);
// Assert
sut.AllRules.Contains(rule).Should().BeFalse("the rule should now not be visible");
}
public void RemoveRule_CalledWithProperRule_RemovesRuleFromList()
{
// Arrange
var sut = new SeatClassificationEngine();
var rule = new SeatClassificationRule
{
RuleName = "Test rule",
Notes = "Test",
Field = ClassificationRuleField.BaseType,
Operator = "Equals",
Value = "1",
Status = SeatStatus.Reserved,
Order = 1
};
sut.AddRule(rule, false);
sut.AllRules.Count().Should().Be(1, "the rule should be added to the list");
// Act
sut.RemoveRule(rule);
// Assert
sut.AllRules.Contains(rule).Should().BeFalse("we removed this rule");
}
