public void GetCalculatedFieldValues_SingleField_Valid()
{
long fieldId = 123;
long[] entityIDs = new long[] { 456, 789 };
CalculatedFieldSettings settings = new CalculatedFieldSettings();
Mock <ICalculatedFieldProvider> mockProvider;
IReadOnlyCollection <CalculatedFieldSingleResult> mockEvaluatorResult;
IReadOnlyCollection <CalculatedFieldResult> mockProviderResult;
CalculatedFieldResult actualResult;
// Mock provider
mockEvaluatorResult = entityIDs.Select(id => new CalculatedFieldSingleResult(id, "a")).ToArray();
mockProviderResult = new[] { new CalculatedFieldResult(fieldId, mockEvaluatorResult) };
mockProvider = new Mock <ICalculatedFieldProvider>(MockBehavior.Strict);
mockProvider
.Setup(p => p.GetCalculatedFieldValues(
It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == fieldId),
entityIDs,
settings))
.Returns(mockProviderResult);
// Test extension method
actualResult = mockProvider.Object.GetCalculatedFieldValues(fieldId, entityIDs, settings);
// Verify
Assert.That(actualResult, Is.Not.Null);
Assert.That(actualResult.FieldId, Is.EqualTo(fieldId));
Assert.That(actualResult.Entities, Is.Not.Null);
Assert.That(actualResult.Entities, Is.EqualTo(mockEvaluatorResult));
mockProvider.VerifyAll();
}
public void GetCalculatedFieldValues_SingleEntity_EvaluationException()
{
long fieldId = 123;
long entityId = 456;
CalculatedFieldSettings settings = new CalculatedFieldSettings();
Mock <ICalculatedFieldProvider> mockProvider;
IReadOnlyCollection <CalculatedFieldSingleResult> mockEvaluatorResult;
IReadOnlyCollection <CalculatedFieldResult> mockProviderResult;
EvaluationException exception;
object actualResult;
// Mock provider
exception = new EvaluationException("Test error");
mockEvaluatorResult = new[] { new CalculatedFieldSingleResult(entityId, exception) };
mockProviderResult = new[] { new CalculatedFieldResult(fieldId, mockEvaluatorResult) };
mockProvider = new Mock <ICalculatedFieldProvider>(MockBehavior.Strict);
mockProvider
.Setup(p => p.GetCalculatedFieldValues(
It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == fieldId),
It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == entityId),
settings))
.Returns(mockProviderResult);
// Test extension method
actualResult = mockProvider.Object.GetCalculatedFieldValue(fieldId, entityId, settings);
// Verify
// (Parse exception causes fields to return null)
Assert.That(actualResult, Is.Null);
mockProvider.VerifyAll();
}
public void GetCalculatedFieldMetadata_SingleField_ParseException()
{
long fieldId = 123;
CalculatedFieldSettings settings = new CalculatedFieldSettings();
Mock <ICalculatedFieldMetadataProvider> mockProvider;
CalculatedFieldMetadata mockSingleResult;
IReadOnlyCollection <CalculatedFieldMetadata> mockProviderResult;
CalculatedFieldMetadata actualResult;
ParseException parseException = new ParseException("Test");
// Mock provider
mockSingleResult = new CalculatedFieldMetadata(fieldId, "calc", null, parseException);
mockProviderResult = new[] { mockSingleResult };
mockProvider = new Mock <ICalculatedFieldMetadataProvider>(MockBehavior.Strict);
mockProvider
.Setup(p => p.GetCalculatedFieldMetadata(It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == fieldId), settings))
.Returns(mockProviderResult);
// Test extension method
actualResult = mockProvider.Object.GetCalculatedFieldMetadata(fieldId, settings);
// Verify
Assert.That(actualResult, Is.EqualTo(mockSingleResult));
mockProvider.VerifyAll();
}
public void GetCalculatedFieldValues_SingleEntity_Valid()
{
long fieldId = 123;
long entityId = 456;
CalculatedFieldSettings settings = new CalculatedFieldSettings();
Mock <ICalculatedFieldProvider> mockProvider;
IReadOnlyCollection <CalculatedFieldSingleResult> mockEvaluatorResult;
IReadOnlyCollection <CalculatedFieldResult> mockProviderResult;
object mockResult = "a";
object actualResult;
// Mock provider
mockEvaluatorResult = new[] { new CalculatedFieldSingleResult(entityId, mockResult) };
mockProviderResult = new[] { new CalculatedFieldResult(fieldId, mockEvaluatorResult) };
mockProvider = new Mock <ICalculatedFieldProvider>(MockBehavior.Strict);
mockProvider
.Setup(p => p.GetCalculatedFieldValues(
It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == fieldId),
It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == entityId),
settings))
.Returns(mockProviderResult);
// Test extension method
actualResult = mockProvider.Object.GetCalculatedFieldValue(fieldId, entityId, settings);
// Verify
Assert.That(actualResult, Is.EqualTo(mockResult));
mockProvider.VerifyAll();
}
public void GetCalculatedFieldValues_SingleField_ParseException()
{
long fieldId = 123;
long[] entityIDs = new long[] { 456, 789 };
CalculatedFieldSettings settings = new CalculatedFieldSettings();
Mock <ICalculatedFieldProvider> mockProvider;
IReadOnlyCollection <CalculatedFieldResult> mockProviderResult;
ParseException exception;
CalculatedFieldResult actualResult;
// Mock provider
exception = new ParseException("Test error");
mockProviderResult = new[] { new CalculatedFieldResult(fieldId, exception) };
mockProvider = new Mock <ICalculatedFieldProvider>(MockBehavior.Strict);
mockProvider
.Setup(p => p.GetCalculatedFieldValues(
It.Is <IReadOnlyCollection <long> >(fields => fields.Count == 1 && fields.First() == fieldId),
entityIDs,
settings))
.Returns(mockProviderResult);
// Test extension method
// (evaluation exceptions should not cause the bulk-entity mechanism to throw)
actualResult = mockProvider.Object.GetCalculatedFieldValues(fieldId, entityIDs, settings);
// Verify
Assert.That(actualResult, Is.Not.Null);
Assert.That(actualResult.FieldId, Is.EqualTo(fieldId));
Assert.That(actualResult.Entities, Is.Null);
mockProvider.VerifyAll();
}
public void GetEvaluationSettings_FromCalcSettings()
{
CalculatedFieldSettings calcSettings = new CalculatedFieldSettings();
calcSettings.TimeZone = "Japan/Tokyo";
EvaluationSettings evalSettings = CalculatedFieldProvider.CreateEvaluationSettings(calcSettings);
Assert.That(evalSettings.TimeZoneName, Is.EqualTo("Japan/Tokyo"));
}
public void GetEvaluationSettings_Both()
{
try
{
RequestContext.SetContext(null, null, null, "Japan/Tokyo");
CalculatedFieldSettings calcSettings = new CalculatedFieldSettings();
calcSettings.TimeZone = "Australia/Brisbane";
EvaluationSettings evalSettings = CalculatedFieldProvider.CreateEvaluationSettings(calcSettings);
Assert.That(evalSettings.TimeZoneName, Is.EqualTo("Australia/Brisbane"));
}
finally
{
RequestContext.FreeContext();
}
}
public void Test_ParseException()
{
long[] fieldIds = new long[] { 11, 22 };
long[] entityIds = new long[] { 33, 44, 55 };
CalculatedFieldSettings settings = new CalculatedFieldSettings {
TimeZone = "Australia/Sydney"
};
CalculatedFieldProvider provider;
Mock <ICalculatedFieldMetadataProvider> mockMetadataProvider;
Mock <IEntityRepository> mockEntityRepository;
Mock <IExpressionRunner> mockExpressionRunner;
IReadOnlyCollection <CalculatedFieldMetadata> mockMetadata;
IReadOnlyCollection <CalculatedFieldResult> actualResult;
IReadOnlyCollection <IEntity> mockEntities;
int mockFirstResult = 100;
Mock <IExpression> mockExpression;
ParseException exception = new ParseException("Test error");
// Mock metadata provider
mockExpression = new Mock <IExpression>();
mockMetadata = new[] { new CalculatedFieldMetadata(11, "abc", null, exception), new CalculatedFieldMetadata(22, "abc", mockExpression.Object, null) };
mockMetadataProvider = new Mock <ICalculatedFieldMetadataProvider>(MockBehavior.Strict);
mockMetadataProvider
.Setup(p => p.GetCalculatedFieldMetadata(fieldIds, settings))
.Returns(mockMetadata);
// Mock entity repository
mockEntities = entityIds.Select(id => new Mock <IEntity>().Object).ToArray();
mockEntityRepository = new Mock <IEntityRepository>(MockBehavior.Strict);
mockEntityRepository.Setup(er => er.Get(entityIds)).Returns(mockEntities);
// Mock expression runner
mockExpressionRunner = new Mock <IExpressionRunner>(MockBehavior.Strict);
int runResult = mockFirstResult;
foreach (IEntity entity in mockEntities)
{
mockExpressionRunner
.Setup(exprRun => exprRun.Run(
mockExpression.Object,
It.Is <EvaluationSettings>(evalSetting => evalSetting.ContextEntity == entity)))
.Returns(() => new ExpressionRunResult(runResult++));
}
// Run test
provider = new CalculatedFieldProvider(mockMetadataProvider.Object, mockExpressionRunner.Object, mockEntityRepository.Object);
actualResult = provider.GetCalculatedFieldValues(fieldIds, entityIds, settings);
// Verify
Assert.That(actualResult, Has.Count.EqualTo(2));
var firstField = actualResult.First();
Assert.That(firstField, Is.Not.Null);
Assert.That(firstField.FieldId, Is.EqualTo(fieldIds.First()));
Assert.That(firstField.ParseException, Is.EqualTo(exception));
Assert.That(firstField.Entities, Is.Null);
var lastField = actualResult.Last();
var lastResult = lastField.Entities.Last();
Assert.That(lastResult, Is.Not.Null);
Assert.That(lastResult.EvaluationException, Is.Null);
Assert.That(lastResult.Result, Is.EqualTo(mockFirstResult + 2));
mockMetadataProvider.VerifyAll();
mockEntityRepository.VerifyAll();
mockExpressionRunner.VerifyAll();
}
