public void EagerLoadingTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var uoW = new EfUnitOfWork(new DSNY_EngineEntities());
var repository = new GenericRepository <StatusTransition>(uoW);
var include = new[] { "tblTransitionSpecification.tblRuleStatements.tblRuleSets.tblRules" };
var statusTransition = repository.GetFirst(x => x.VehicleStatusId == 3, include);
const bool expected = false;
if (statusTransition == null)
{
Assert.Inconclusive("StatusTransition object not returned.");
}
else
{
var actual = statusTransition.IsTransitioned();
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);
}
/// ---------------------------------------------------------------
/// <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 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 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);
}
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 IsSatisfiedServiceNullTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var target = new RuleStatement();
const bool expected = false;
var actual = target.IsSatisfied(new RuleValidationService(vehicle));
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 EagerLoadingTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var uoW = new EfUnitOfWork(new DSNY_EngineEntities());
var repository = new GenericRepository <TransitionSpecification>(uoW);
var include = new[] { "tblRuleStatements.tblRuleSets.tblRules" };
var specification = repository.GetFirst(x => x.Id == 1, include);
const bool expected = false;
var actual = specification.IsSatisfied(new RuleValidationService(vehicle));
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);
}
public void GetRuleSetRecordTest()
{
var vehicle = new VehicleModelProxy
{
Plate = "123-abc",
TransSN = "2343678",
OMBYear = 3000
};
var uoW = new EfUnitOfWork(new DSNY_EngineEntities());
/*
* var repository = new RuleSetRepository(uoW);
* var ruleSet = repository.GetRuleSet(3);
*
* var target = new RuleValidationService(vehicle);
* const bool expected = false;
* var actual = target.IsSatisfied(ruleSet);
* Assert.AreEqual(expected, actual);
* */
}
