public void IsSatisfiedComparisonDateGreaterTanTest()
{
var vehicle = new VehicleModelProxy
{
CondemDate = new DateTime(2012, 07, 31),
AcceptedDate = new DateTime(2012, 08, 01)
};
var ruleList = new List <Rule> {
//true
new Rule
{
RuleType = RuleType.ComparisonRule,
LeftPropertyName = "AcceptedDate",
RightPropertyName = "CondemDate",
ComparisonOperator = LogicOperator.GreaterThan
},
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = Convert.ToInt32(BoolOperator.AND)
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = true;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedRuleSetNullTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var service = new RuleValidationService(vehicle);
var rsBracketNo = new List <int> {
0
};
var ruleConnectors = new List <int> {
BoolOperator.AND
};
var target = new RuleStatement()
{
RsBracketNo = String.Join(",", rsBracketNo),
RuleConnectors = String.Join(",", ruleConnectors)
};
const bool expected = false;
var actual = target.IsSatisfied(service);
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedHasValueTest()
{
var vehicle = new VehicleModelProxy
{
C511Date = new DateTime(2012, 10, 2),
TransSN = "2343678",
OMBYear = 0
};
var ruleList = new List <Rule> {
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "OMBYear",
ComparisonOperator = LogicOperator.IsNullOrEmpty,
ExpectedValue = "123-abc"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = true;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedComparisonHasValueStringTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var ruleList = new List <Rule> {
//true
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "TransSN",
RightPropertyName = null,
ComparisonOperator = LogicOperator.HasValue
},
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = Convert.ToInt32(BoolOperator.AND)
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = true;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedANDDateTimeTypeFalseTest()
{
var vehicle = new VehicleModelProxy
{
AcceptedDate = new DateTime(2012, 7, 31)
};
var ruleList = new List <Rule> {
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "AcceptedDate",
ComparisonOperator = LogicOperator.NotEqual,
ExpectedValue = "07/31/2012"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = Convert.ToInt32(BoolOperator.AND)
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = false;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedANDBoolTypeFalseTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
Formalized = false
};
var ruleList = new List <Rule> {
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "Formalized",
ComparisonOperator = LogicOperator.Equal,
ExpectedValue = "false"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = Convert.ToInt32(BoolOperator.AND)
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = true;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
/// ---------------------------------------------------------------
/// <summary>
/// Create StatusTransition Object.
/// </summary>
/// <param name="vehicle">VehicleModelProxy object</param>
/// <returns>StatusTransition object</returns>
/// --------------------------------------------------------------
public StatusTransition CreateStatusTransitionObject(VehicleModelProxy vehicle)
{
if (vehicle == null)
{
throw new ArgumentNullException("vehicle", "Required argument not provided.");
}
var include = new[] { "tblTransitionSpecification.tblRuleStatements.tblRuleSets.tblRules" };
var statusTransition = _repository.GetFirst(x => x.VehicleStatusId == vehicle.VehicleStatus, include);
if (statusTransition == null)
{
return(null);
}
var service = new RuleValidationService(vehicle);
if (service == null)
{
throw new NullReferenceException("Unable to create RuleValidationService object.");
}
statusTransition.ValidationService = service;
return(statusTransition);
}
public void IsSatisfiedNullVehicleTest()
{
var target = new RuleValidationService(null);
const bool expected = true;
const bool actual = false;
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedTwoRuleSetsTandTandTTrueTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var ruleConnectors = new List <int> {
BoolOperator.AND, BoolOperator.AND
};
var rsBracketNo = new List <int> {
0, 0, 0
};
var ruleList = new List <Rule> {
new Rule
{
RuleType = Convert.ToInt32(RuleType.UnaryRule),
LeftPropertyName = "Plate",
ComparisonOperator = LogicOperator.Equal,
ExpectedValue = "123-abc"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = BoolOperator.AND
};
var ruleList1 = new List <Rule>
{
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "TransSN",
ComparisonOperator = LogicOperator.NotEqual,
ExpectedValue = "23483678"
}
};
var ruleSet1 = new RuleSet {
tblRules = ruleList1, Operation = BoolOperator.AND
};
var ruleSets = new List <RuleSet> {
ruleSet, ruleSet1, ruleSet1
};
var service = new RuleValidationService(vehicle);
var statement = new RuleStatement()
{
tblRuleSets = ruleSets,
RsBracketNo = String.Join(",", rsBracketNo),
RuleConnectors = String.Join(",", ruleConnectors)
};
const bool expected = true;
var actual = statement.IsSatisfied(service);
Assert.AreEqual(expected, actual);
}
public void IsSatisfied_RuleSet_OneGreaterThan_RuleConnector_Test()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var ruleConnectors = new List <int> {
BoolOperator.AND, BoolOperator.AND
};
var rsBracketNo = new List <int> {
0
};
var ruleList = new List <Rule> {
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "OMBYear",
ComparisonOperator = LogicOperator.GreaterThan,
ExpectedValue = "2000"
},
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "Miles",
ComparisonOperator = LogicOperator.GreaterThan,
ExpectedValue = "2000"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = BoolOperator.AND
};
var ruleSets = new List <RuleSet> {
ruleSet
};
var service = new RuleValidationService(vehicle);
var statement = new RuleStatement()
{
tblRuleSets = ruleSets,
RsBracketNo = String.Join(",", rsBracketNo),
RuleConnectors = String.Join(",", ruleConnectors)
};
const bool expected = false;
var actual = statement.IsSatisfied(service);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void IsSatisfiedRuleSetNotEqualRsBracketNoTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var ruleConnectors = new List <int> {
BoolOperator.AND
};
var rsBracketNo = new List <int>();
var ruleList = new List <Rule> {
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "OBMYear",
ComparisonOperator = LogicOperator.GreaterThan,
ExpectedValue = "2000"
},
new Rule
{
RuleType = Convert.ToInt32(RuleType.UnaryRule),
LeftPropertyName = "OBMYear",
ComparisonOperator = LogicOperator.GreaterThan,
ExpectedValue = "2000"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = BoolOperator.AND
};
var ruleSets = new List <RuleSet> {
ruleSet
};
var service = new RuleValidationService(vehicle);
var statement = new RuleStatement()
{
tblRuleSets = ruleSets,
RsBracketNo = String.Join(",", rsBracketNo),
RuleConnectors = String.Join(",", ruleConnectors)
};
const bool expected = false;
var actual = statement.IsSatisfied(service);
Assert.AreEqual(expected, actual);
}
public void RuleStatementConstructorTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var service = new RuleValidationService(vehicle);
var target = new RuleStatement();
Assert.IsTrue(target != null);
}
public void IsSatisfiedComparisonFalseTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000,
Fuel = 4000
};
var ruleList = new List <Rule> {
//true
new Rule
{
RuleType = RuleType.ComparisonRule,
LeftPropertyName = "OMBYear",
RightPropertyName = "Fuel",
ComparisonOperator = LogicOperator.Equal
},
//true
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "TransSN",
ComparisonOperator = LogicOperator.Equal,
ExpectedValue = "2343678"
},
//true
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "OMBYear",
ComparisonOperator = LogicOperator.GreaterThan,
ExpectedValue = "2000"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = Convert.ToInt32(BoolOperator.AND)
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = false;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
public void IsSatisfiedANDTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var ruleList = new List <Rule> {
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "Plate",
ComparisonOperator = LogicOperator.Equal,
ExpectedValue = "123-abc"
},
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "TransSN",
ComparisonOperator = LogicOperator.NotEqual,
ExpectedValue = "2345678"
},
new Rule
{
RuleType = RuleType.UnaryRule,
LeftPropertyName = "OMBYear",
ComparisonOperator = LogicOperator.GreaterThan,
ExpectedValue = "2000"
}
};
var ruleSet = new RuleSet {
tblRules = ruleList, Operation = BoolOperator.AND
};
var target = new RuleValidationService(vehicle);
target.IsSatisfied(ruleSet);
const bool expected = true;
var actual = target.IsSatisfied(ruleSet);
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
// Would use DI
IParkingService ps = new ParkingService();
IRuleValidationService rvs = new RuleValidationService();
var floor = new Dictionary <int, int>()
{
{ -2, 5 },
{ -1, 0 },
{ 0, 1 },
{ 1, 3 },
{ 2, 1 },
};
var result = ps.GetFloor(floor, -1, rvs.ValidateFloorSpace);
Console.WriteLine(result);
}
public ParkingServiceTests()
{
_classUnderTest = new ParkingService();
_validationService = new RuleValidationService();
}
