public PropertiesMockingUnitTest()
{
_validator = new Mock <IFrequentFlyerNumberValidator>();
_validator.Setup(a => a.IsValid(It.IsAny <string>())).Returns(true);
_validator.Setup(a => a.LicenceKey).Returns("EXPIRED");
manager = new EvaluatorManager(_validator.Object);
}
public async Task Given_Instances_When_GetInstancesAndDispose_Then_ReceiveAllInOrder()
{
var instance1 = new ConditionInstance(TimeSpan.FromMilliseconds(1000), "ID1");
var instance2 = new ConditionInstance(TimeSpan.FromMilliseconds(2000), "ID2");
var manager = new EvaluatorManager();
Task <List <ConditionInstance> > getInstancesTask;
await using (var evaluator = await manager.CreateEvaluatorAsync())
{
getInstancesTask = Task.Run(() => evaluator.GetInstancesAsync().AsyncToListAsync());
var instanceHandler = (IConditionInstanceHandler)manager;
await instanceHandler.HandleInstanceAsync(instance1);
await instanceHandler.HandleInstanceAsync(instance2);
await Task.Delay(100);
Assert.That(manager.HasActiveEvaluators, Is.True);
}
var instances = await getInstancesTask;
Assert.That(instances, Is.Not.Null);
Assert.That(instances.Count, Is.EqualTo(2));
Assert.That(instances, Does.Contain(instance1));
Assert.That(instances, Does.Contain(instance2));
Assert.That(instances.First(), Is.SameAs(instance1));
Assert.That(instances.Last(), Is.SameAs(instance2));
}
public RunningTaskImpl(EvaluatorManager evaluatorManager, string taskId, EvaluatorContext evaluatorContext)
{
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "INIT: TaskRuntime id [{0}] on evaluator id [{1}]", taskId, evaluatorManager.Id));
_id = taskId;
_evaluatorManager = evaluatorManager;
_evaluatorContext = evaluatorContext;
}
public EvaluateChangeMoqPropertiesUnitTest()
{
_validator = new Mock <IFrequentFlyerNumberValidator>();
_validator.SetupAllProperties();
// _validator.SetupProperty(a => a.ValidationMode);
manager = new EvaluatorManager(_validator.Object);
}
public static SearchItem CreateSearchExpressionItem(string queryString, string alias = null)
{
var queryView = queryString.GetStringView();
return(CreateSearchExpressionItem(new SearchExpression(
SearchExpressionType.QueryString, queryView, queryView, alias.GetStringView(),
EvaluatorManager.GetConstantEvaluatorByName("query"))));
}
public MethodsWithOutParameterUnitTest()
{
_validator = new Mock <IFrequentFlyerNumberValidator>();
bool isValid = true;
_validator.Setup(a => a.IsValid(It.IsAny <string>(), out isValid));
manager = new EvaluatorManager(_validator.Object);
}
public EvaluatorManagerUnitTest()
{
_validator = new Mock <IFrequentFlyerNumberValidator>();
//_validator.Setup(a => a.IsValid("x")).Returns(true);
//_validator.Setup(x => x.IsValid(It.IsAny<string>())).Returns(true);
//_validator.Setup(x => x.IsValid(It.Is<string>(number => number.StartsWith('x')))).Returns(true);
//_validator.Setup(x => x.IsValid(It.IsIn("x", "y", "z"))).Returns(true);
//_validator.Setup(x => x.IsValid(It.IsInRange("b", "z", Range.Inclusive))).Returns(true);
_validator.Setup(x => x.IsValid(It.IsRegex("[a-z]", RegexOptions.None))).Returns(true);
manager = new EvaluatorManager(_validator.Object);
}
public LooseMockingUnitTest()
{
_validator = new Mock <IFrequentFlyerNumberValidator>(MockBehavior.Loose);
// _validator.Setup(a => a.IsValid(It.IsAny<string>())).Returns(false);
manager = new EvaluatorManager(_validator.Object);
}
public async Task Given_MultipleEvaluators_When_GetInstancesAndDispose_Then_ReceiveExcepted()
{
var instance1 = new ConditionInstance(TimeSpan.FromMilliseconds(1000), "ID1");
var instance2 = new ConditionInstance(TimeSpan.FromMilliseconds(2000), "ID2");
var instance3 = new ConditionInstance(TimeSpan.FromMilliseconds(3000), "ID2");
var evaluator1Expectation = new[] { instance1 };
var evaluator2Expectation = new[] { instance1, instance2 };
var evaluator3Expectation = new[] { instance1, instance2, instance3 };
var evaluator4Expectation = new[] { instance1, instance2, instance3 };
var manager = new EvaluatorManager();
var instanceHandler = (IConditionInstanceHandler)manager;
var evaluator1 = await manager.CreateEvaluatorAsync();
var getEvaluator1Tasks = Task.Run(() => evaluator1.GetInstancesAsync().AsyncToListAsync());
await instanceHandler.HandleInstanceAsync(instance1);
await Task.Delay(10);
await evaluator1.DisposeAsync();
var evaluator2 = await manager.CreateEvaluatorAsync();
var getEvaluator2Tasks = Task.Run(() => evaluator2.GetInstancesAsync().AsyncToListAsync());
await instanceHandler.HandleInstanceAsync(instance2);
await Task.Delay(10);
await evaluator2.DisposeAsync();
var evaluator3 = await manager.CreateEvaluatorAsync();
var getEvaluator3Tasks = Task.Run(() => evaluator3.GetInstancesAsync().AsyncToListAsync());
await instanceHandler.HandleInstanceAsync(instance3);
await Task.Delay(10);
await evaluator3.DisposeAsync();
var evaluator4 = await manager.CreateEvaluatorAsync();
var getEvaluator4Tasks = Task.Run(() => evaluator4.GetInstancesAsync().AsyncToListAsync());
await Task.Delay(10);
await evaluator4.DisposeAsync();
await Task.Delay(50); // Wait for manager to cleanup
var evaluator1Instances = await getEvaluator1Tasks;
var evaluator2Instances = await getEvaluator2Tasks;
var evaluator3Instances = await getEvaluator3Tasks;
var evaluator4Instances = await getEvaluator4Tasks;
Assert.That(evaluator1Expectation.Zip(evaluator1Instances).All(x => x.First == x.Second));
Assert.That(evaluator2Expectation.Zip(evaluator2Instances).All(x => x.First == x.Second));
Assert.That(evaluator3Expectation.Zip(evaluator3Instances).All(x => x.First == x.Second));
Assert.That(evaluator4Expectation.Zip(evaluator4Instances).All(x => x.First == x.Second));
Assert.That(manager.HasActiveEvaluators, Is.False);
}
