public void EnsureMetadata_Invalidates_WhenCalculationChanged()
{
EntityType type = null;
Field field = null;
Field calcField = null;
try
{
// Create scenario
type = new EntityType();
type.Name = "CFType";
field = new StringField().As <Field>();
field.Name = "CFField";
field.Save();
calcField = new StringField().As <Field>();
calcField.Name = "CFCalcField";
calcField.FieldCalculation = "'A'+CFField";
calcField.IsCalculatedField = true;
calcField.Save();
type.Fields.Add(field);
type.Fields.Add(calcField);
type.Save();
// Get provider
ICalculatedFieldMetadataProvider provider = Factory.CalculatedFieldMetadataProvider;
// Run
CalculatedFieldMetadata res1 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
CalculatedFieldMetadata res2 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure same instance was returned (came from cache)
Assert.That(res2, Is.SameAs(res1));
// Delete the field
calcField.FieldCalculation = "'B'+CFField";
calcField.Save();
// Rerun
CalculatedFieldMetadata res3 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure different instance was returned (not from cache)
Assert.That(res3, Is.Not.SameAs(res1));
Assert.That(res3.Calculation, Is.EqualTo("'B'+CFField")); // because the script is now invalid
}
finally
{
if (field != null)
{
field.Delete();
}
if (calcField != null)
{
calcField.Delete();
}
if (type != null)
{
type.Delete();
}
}
}
public void CalculatedFieldMetadataProvider_Instance()
{
ICalculatedFieldMetadataProvider instance = Factory.CalculatedFieldMetadataProvider;
Assert.That(instance, Is.InstanceOf <CachingCalculatedFieldMetadataProvider>());
CachingCalculatedFieldMetadataProvider provider = instance as CachingCalculatedFieldMetadataProvider;
Assert.That(provider.InnerProvider, Is.InstanceOf <CalculatedFieldMetadataProvider>());
}
/// <summary>
/// Create a new <see cref="CachingCalculatedFieldMetadataProvider"/>.
/// </summary>
/// <param name="innerProvider">
/// The <see cref="ICalculatedFieldMetadataProvider"/> that will actually calculate the result. This cannot be null.
/// </param>
public CachingCalculatedFieldMetadataProvider(ICalculatedFieldMetadataProvider innerProvider)
: base("CalculatedFieldMetadata", cacheFactory)
{
if (innerProvider == null)
{
throw new ArgumentNullException("innerProvider");
}
InnerProvider = innerProvider;
// Note: this class manages two caches:
// 1. a full cache service for GetCalculatedFieldMetadata
// 2. a simple unmanaged, non-invalidated, cache for IsCalculatedField.
_isCalculatedFieldCache = CacheFactory.CreateSimpleCache <long, bool>("IsCalculatedFieldCache", false, 0);
}
/// <summary>
/// Fetch metadata for a single calculated field.
/// </summary>
/// <param name="provider">The calculated field metadata provider being extended.</param>
/// <param name="fieldId">The field to load.</param>
/// <param name="settings">Additional settings.</param>
/// <returns>Calculation results.</returns>
public static CalculatedFieldMetadata GetCalculatedFieldMetadata(this ICalculatedFieldMetadataProvider provider, long fieldId, CalculatedFieldSettings settings)
{
if (provider == null)
{
throw new ArgumentNullException("provider"); // assert false
}
var fields = new[] { fieldId };
// Call provider
var metadatas = provider.GetCalculatedFieldMetadata(fields, settings);
// Extract results
CalculatedFieldMetadata metadata = metadatas.FirstOrDefault();
return(metadata);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="metadataProvider">The calculated field metadata provider.</param>
/// <param name="expressionRunner">Runner that gets used by the field evaluator that will be generated with the metadata.</param>
/// <param name="entityRepository">Source of entity data, both for the calculated field metadata, and also passed into the evaluator for actual data.</param>
public CalculatedFieldProvider(ICalculatedFieldMetadataProvider metadataProvider, IExpressionRunner expressionRunner, IEntityRepository entityRepository)
{
if (metadataProvider == null)
{
throw new ArgumentNullException("metadataProvider");
}
if (expressionRunner == null)
{
throw new ArgumentNullException("expressionRunner");
}
if (entityRepository == null)
{
throw new ArgumentNullException("entityRepository");
}
_metadataProvider = metadataProvider;
_expressionRunner = expressionRunner;
_entityRepository = entityRepository;
}
public void EnsureMetadata_Invalidates_WhenFieldRenamedToCorrectName()
{
EntityType type = null;
Field field = null;
Field calcField = null;
try
{
// Create scenario
type = new EntityType();
type.Name = "CFType";
field = new StringField().As <Field>();
field.Name = "CFFieldWrongName";
field.Save();
calcField = new StringField().As <Field>();
calcField.Name = "CFCalcField";
calcField.FieldCalculation = "'A'+CFFieldRightName";
calcField.IsCalculatedField = true;
calcField.Save();
type.Fields.Add(field);
type.Fields.Add(calcField);
type.Save();
// Get provider
ICalculatedFieldMetadataProvider provider = Factory.CalculatedFieldMetadataProvider;
// Run
CalculatedFieldMetadata res1 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
CalculatedFieldMetadata res2 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure same instance was returned (came from cache)
Assert.That(res1.Exception, Is.Not.Null, "res1 should have error"); // because the script is invalid
Assert.That(res2, Is.SameAs(res1), "res2 should be same as res1");
// Rename the field
field.Name = "CFFieldRightName";
field.Save();
// Rerun
CalculatedFieldMetadata res3 = provider.GetCalculatedFieldMetadata(calcField.Id, CalculatedFieldSettings.Default);
// Ensure different instance was returned (not from cache)
Assert.That(res3, Is.Not.SameAs(res1), "res3 should be != res1");
Assert.That(res3.Exception, Is.Null, "res3 should not have error"); // because the script is now fixed
Assert.That(res3.Expression, Is.Not.Null, "res3 should have expression"); // because the script is now fixed
}
finally
{
if (field != null)
{
field.Delete();
}
if (calcField != null)
{
calcField.Delete();
}
if (type != null)
{
type.Delete();
}
}
}
