public void RemoveUnusedColumns_WithCount_Ensure_AggregateExpressionWithGrouping_Removed( )
{
ResourceEntity resNode = new ResourceEntity( );
AggregateEntity aggNode = new AggregateEntity {
GroupedEntity = resNode
};
aggNode.GroupBy.Add(new ResourceDataColumn( ));
SelectColumn col1 = new SelectColumn {
Expression = new ResourceDataColumn( )
};
SelectColumn col2 = new SelectColumn {
Expression = new AggregateExpression {
NodeId = aggNode.NodeId
}
};
StructuredQuery query = new StructuredQuery( );
query.RootEntity = aggNode;
query.SelectColumns.Add(col1);
query.SelectColumns.Add(col2);
ClientAggregate agg = new ClientAggregate( );
agg.AggregatedColumns.Add(new ReportAggregateField {
AggregateMethod = AggregateMethod.Count
});
StructuredQuery result = ReportRollupHelper.RemoveUnusedColumns(query, agg);
Assert.That(result.SelectColumns.Count, Is.EqualTo(2));
Assert.That(result.SelectColumns [0].Expression, Is.TypeOf <IdExpression>( ));
Assert.That(result.SelectColumns [1].Expression, Is.TypeOf <AggregateExpression>( ));
}
void Apply(Created e)
{
entity_ = new AggregateEntity();
AddEntity(entity_);
id_ = e.ID;
}
public static ProjectedAggregate Project(AggregateEntity aggregate, Layer layer, Matrix4 transform)
{
var loc = transform.Transform(aggregate.Location);
var newOrigin = transform.Transform(Point.Origin);
var offset = (Point)loc - (Point)newOrigin;
return(new ProjectedAggregate(aggregate, layer, offset, aggregate.Children.Select(c => Project(c, layer, transform))));
}
internal virtual ILexical CreateILexical()
{
ILexical target = new AggregateEntity(
new PersonalPronoun("him"),
new ProperSingularNoun("Patrick"),
new NounPhrase(new ProperSingularNoun("Brittany"))
);
return(target);
}
public void AggregateEntityConstructorTest1()
{
IEntity americans = new NounPhrase(new ProperPluralNoun("Americans"));
IEntity canadians = new NounPhrase(new ProperPluralNoun("Canadians"));
var target = new AggregateEntity(americans, canadians);
Check.That(target).Contains(americans);
Check.That(target).Contains(canadians);
}
public void JoinedRightTest()
{
var target = new Conjunction("and");
ILexical expected = new AggregateEntity(new ProperSingularNoun("Jacob"), new ProperSingularNoun("Jessica"));
ILexical actual;
target.JoinedRight = expected;
actual = target.JoinedRight;
Check.That(actual).IsEqualTo(expected);
}
private async Task Aggregate(TPHEntity reading)
{
var aggregateTable = new GenericTableStorage(connString, "Aggregates");
var dayEntityTask = aggregateTable.GetSingle <AggregateEntity>(reading.PartitionKey + "D", reading.ReadAt.ToString("yyMMdd"));
var hourEntityTask = aggregateTable.GetSingle <AggregateEntity>(reading.PartitionKey + "H", reading.ReadAt.ToString("yyMMddHH"));
var monthEntityTask = aggregateTable.GetSingle <AggregateEntity>(reading.PartitionKey + "M", reading.ReadAt.ToString("yyMM"));
var dayEntity = await dayEntityTask;
if (dayEntity == null)
{
dayEntity = new AggregateEntity()
{
PartitionKey = reading.PartitionKey + "D", RowKey = reading.ReadAt.ToString("yyMMdd")
};
}
var dayRecord = Mapper.Map <AggregateEntity, IAggregateRecord>(dayEntity);
UpdateAggregateValues(reading.Temperature, dayRecord.Temperature);
UpdateAggregateValues(reading.Pressure, dayRecord.Pressure);
UpdateAggregateValues(reading.Humidity, dayRecord.Humidity);
await aggregateTable.InsertOrReplaceAsync(Mapper.Map <IAggregateRecord, AggregateEntity>(dayRecord));
var hourEntity = await hourEntityTask;
if (hourEntity == null)
{
hourEntity = new AggregateEntity()
{
PartitionKey = reading.PartitionKey + "H", RowKey = reading.ReadAt.ToString("yyMMddHH")
};
}
var hourRecord = Mapper.Map <AggregateEntity, IAggregateRecord>(hourEntity);
UpdateAggregateValues(reading.Temperature, hourRecord.Temperature);
UpdateAggregateValues(reading.Pressure, hourRecord.Pressure);
UpdateAggregateValues(reading.Humidity, hourRecord.Humidity);
await aggregateTable.InsertOrReplaceAsync(Mapper.Map <IAggregateRecord, AggregateEntity>(hourRecord));
var monthEntity = await monthEntityTask;
if (monthEntity == null)
{
monthEntity = new AggregateEntity()
{
PartitionKey = reading.PartitionKey + "M", RowKey = reading.ReadAt.ToString("yyMM")
};
}
var monthRecord = Mapper.Map <AggregateEntity, IAggregateRecord>(monthEntity);
UpdateAggregateValues(reading.Temperature, monthRecord.Temperature);
UpdateAggregateValues(reading.Pressure, monthRecord.Pressure);
UpdateAggregateValues(reading.Humidity, monthRecord.Humidity);
await aggregateTable.InsertOrReplaceAsync(Mapper.Map <IAggregateRecord, AggregateEntity>(monthRecord));
}
public void AggregateEntityConstructorTest()
{
IEntity[] members =
{
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
};
var target = new AggregateEntity(members);
Check.That(target).Contains(members);
}
public static bool EquivalentTo(this AggregateEntity agg, Entity entity)
{
if (entity is AggregateEntity other)
{
return(agg.Location.CloseTo(other.Location) &&
agg.Children.Count == other.Children.Count &&
agg.Children.Zip(other.Children, (a, b) => a.EquivalentTo(b)).All(x => x));
}
return(false);
}
public void MetaWeightTest()
{
IEnumerable <IEntity> members = new IEntity[] { };
var target = new AggregateEntity(members);
var expected = new Random().NextDouble();
double actual;
target.MetaWeight = expected;
actual = target.MetaWeight;
Check.That(actual).IsEqualTo(expected);
}
public void WeightTest()
{
var members = Empty <IEntity>();
var target = new AggregateEntity(members);
var expected = new Random().NextDouble();
double actual;
target.Weight = expected;
actual = target.Weight;
Check.That(actual).IsEqualTo(expected);
}
public void AddPossessionTest()
{
var target = new AggregateEntity(
new NounPhrase(new CommonPluralNoun("cats")),
new NounPhrase(new CommonPluralNoun("dogs"))
);
IPossessable possession = new NounPhrase(new CommonSingularNoun("fur"));
target.AddPossession(possession);
Check.That(target.Possessions).Contains(possession);
}
public void TextTest()
{
var target = new AggregateEntity(
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
);
var expected = "Americans ," + " Canadians";
string actual;
actual = target.Text;
Check.That(actual).IsEqualTo(expected);
}
public void ToStringTest()
{
var target = new AggregateEntity(
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
);
var expected = "[ 2 ] NounPhrase \"Americans\" NounPhrase \"Canadians\"";
string actual;
actual = target.ToString();
Check.That(actual).IsEqualTo(expected);
}
public void BindDescriptorTest()
{
var target = new AggregateEntity(
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
);
IDescriptor descriptor = new Adjective("rambunctious");
target.BindDescriptor(descriptor);
Check.That(target.Descriptors).Contains(descriptor);
}
public void AggregateIndirectObjectTest()
{
var target = CreateIInderectObjectTaker();
IAggregateEntity actual =
new AggregateEntity(new IEntity[] {
new PersonalPronoun("him"),
new ProperSingularNoun("Patrick"),
new NounPhrase(new ProperSingularNoun("Brittany"))
});
actual = target.AggregateIndirectObject;
Assert.True(target.AggregateIndirectObject.SequenceEqual(actual));
}
public void PossessorTest()
{
var target = new AggregateEntity(
new NounPhrase(new CommonPluralNoun("cats")),
new NounPhrase(new CommonPluralNoun("dogs"))
);
IPossessor expected = new NounPhrase(new ProperPluralNoun("Americans"));
target.Possessor = expected;
var actual = target.Possessor;
Check.That(actual).IsEqualTo(expected);
}
public void SubjectOfTest()
{
var target = new AggregateEntity(
new NounPhrase(new CommonPluralNoun("cats")),
new NounPhrase(new CommonPluralNoun("dogs"))
);
IVerbal expected = new BaseVerb("eat");
IVerbal actual;
target.BindAsSubjectOf(expected);
actual = target.SubjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void IndirectObjectOfTest()
{
var target = new AggregateEntity(
new CommonSingularNoun("spoon"),
new CommonSingularNoun("fork")
);
IVerbal expected = new VerbPhrase(new PastTenseVerb("were"), new PastParticiple("eaten"));
IVerbal actual;
target.BindAsIndirectObjectOf(expected);
actual = target.IndirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void GetEnumeratorTest()
{
var members = Empty <IEntity>();
var target = new AggregateEntity(members);
using (var expected = members.GetEnumerator())
using (var actual = target.GetEnumerator())
{
while (expected.MoveNext() | actual.MoveNext())
{
Check.That(actual.Current).IsEqualTo(expected.Current);
}
}
}
public void AggregateDirectObjectTest()
{
var target = new BaseVerb("slay");
IAggregateEntity aggregateObject = new AggregateEntity(
new NounPhrase(new ProperSingularNoun("John"), new ProperSingularNoun("Smith")),
new NounPhrase(new PossessivePronoun("his"), new CommonPluralNoun("cats"))
);
target.BindDirectObject(aggregateObject);
var actual = target.AggregateDirectObject;
Check.That(actual).ContainsExactly(aggregateObject).And.Not.IsNull().And.Not.IsEmpty();
}
public void AggregateDirectObjectTest()
{
var target = CreateVerbPhrase();
IAggregateEntity directObject = new AggregateEntity(
new NounPhrase(new ProperSingularNoun("John"), new ProperSingularNoun("Smith")),
new NounPhrase(new PossessivePronoun("his"), new CommonPluralNoun("cats"))
);
target.BindDirectObject(directObject);
IAggregateEntity actual;
actual = target.AggregateDirectObject;
Check.That(directObject.Except(actual)).IsEmpty();
}
public void DirectObjectOfTest()
{
var target = new AggregateEntity(
new NounPhrase(new CommonPluralNoun("cats")),
new NounPhrase(new CommonPluralNoun("dogs"))
);
var expected = new VerbPhrase(new BaseVerb("eat"));
target.BindAsDirectObjectOf(expected);
var actual = target.DirectObjectOf;
Check.That(actual).IsEqualTo(expected);
}
public void Test_WalkNodes_RootAggregate( )
{
StructuredQuery sq = new StructuredQuery( );
var agg = new AggregateEntity( );
sq.RootEntity = agg;
var related2 = new RelatedResource( );
agg.GroupedEntity = related2;
var related3 = new RelatedResource( );
related2.RelatedEntities.Add(related3);
AssertNodes(sq, agg, related2, related3);
}
public void Test_WalkExpressions_GroupBy(bool filteringOnly, int expected)
{
StructuredQuery sq = new StructuredQuery( );
AggregateEntity root = new AggregateEntity( );
sq.RootEntity = root;
root.GroupedEntity = new ResourceEntity( );
root.GroupBy.Add(new IdExpression( ));
root.GroupBy.Add(new MutateExpression {
Expression = new IdExpression( )
});
var res = StructuredQueryHelper.WalkExpressions(sq, filteringOnly);
Assert.That(res.Count( ), Is.EqualTo(expected));
}
public void BoundPronounsTest()
{
var target = new AggregateEntity(
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
);
IEnumerable <IReferencer> actual;
IEnumerable <IReferencer> expected = new[] { new PersonalPronoun("them") };
foreach (var r in expected)
{
target.BindReferencer(r);
}
actual = target.Referencers;
Check.That(actual).Contains(expected);
}
public void NotPruned_UnusedRootAggregate( )
{
StructuredQuery sq = new StructuredQuery( );
var agg = new AggregateEntity( );
sq.RootEntity = agg;
var related2 = new RelatedResource( );
agg.GroupedEntity = related2;
var related3 = new RelatedResource( );
related2.RelatedEntities.Add(related3);
var pruned = StructuredQueryHelper.PruneQueryTree(sq);
Assert.That(pruned, Is.SameAs(sq));
AssertNodes(pruned, agg, related2, related3);
}
public void DescriptorsTest()
{
var target = new AggregateEntity(
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
);
IEnumerable <IDescriptor> actual;
IDescriptor adj1 = new Adjective("western");
IDescriptor adj2 = new Adjective("proud");
target.BindDescriptor(adj1);
target.BindDescriptor(adj2);
actual = target.Descriptors;
Check.That(target.Descriptors).Contains(adj1);
Check.That(adj1.Describes).IsEqualTo(target);
Check.That(target.Descriptors).Contains(adj2);
Check.That(adj2.Describes).IsEqualTo(target);
}
public void BindPronounTest()
{
IEntity[] members =
{
new NounPhrase(new ProperPluralNoun("Americans")),
new NounPhrase(new ProperPluralNoun("Canadians"))
};
var target = new AggregateEntity(members);
var them = new PersonalPronoun("them");
target.BindReferencer(them);
Check.That(target.Referencers).Contains(them);
Check.That(them.RefersTo.Contains(target) || them.RefersTo == target || them.RefersTo.SetEqual(target)).IsTrue();
foreach (var member in members)
{
Assert.True(them.RefersTo.Contains(member) || them.RefersTo == member);
}
}
public void PossessedTest()
{
var target = new AggregateEntity(
new NounPhrase(new CommonPluralNoun("cats")),
new NounPhrase(new CommonPluralNoun("dogs"))
);
var possessions = new[] {
new NounPhrase(new CommonPluralNoun("claws")),
new NounPhrase(new CommonPluralNoun("teeth"))
};
foreach (var possession in possessions)
{
target.AddPossession(possession);
}
IEnumerable <IPossessable> actual;
actual = target.Possessions;
Check.That(actual).Contains(possessions);
}
void Apply(Created e) {
entity_ = new AggregateEntity();
AddEntity(entity_);
id_ = e.ID;
}
/// <summary>
/// Cleans the contact info entity.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="entity">The entity.</param>
public void CleanContactInfoEntity(AggregateEntity owner, ContactDomainEntity entity)
{
//entity.SetOwner(owner);
entity.CleanBeforeSave();
//entity.SetTableLevelAuditItems(owner);
}
/// <summary>
/// Sets the owner.
/// </summary>
/// <param name="entity">The entity.</param>
public void SetOwner(AggregateEntity entity)
{
if (entity != null && entity.Guid.EqualsIgnoreCase(Guid.Empty.ToString()))
return;
Owner = entity;
}
/// <summary>
/// Sets the table level audit items.
/// </summary>
/// <param name="owner">The owner.</param>
public void SetTableLevelAuditItems(AggregateEntity owner)
{
var auditDateTime = DateTime.UtcNow;
if (IsNew)
{
CreatedBy = owner.Guid;
CreatedByDate = auditDateTime;
}
LastModifiedBy = owner.Guid;
LastModifiedByDate = auditDateTime;
}
/// <summary>
/// Cleans the before save.
/// </summary>
public void CleanBeforeSave(AggregateEntity entity)
{
base.CleanBeforeSave();
if (Tenant == null && entity is ITenantAggregateEntity)
{
Tenant = ((ITenantAggregateEntity)entity).Tenant;
}
SetOwner(entity);
}
