public void ShouldRecalculateFirmHavingCategory()
{
SourceDb.Has(new Facts::Category { Id = 1, Level = 3 },
new Facts::Category { Id = 2, Level = 3 });
SourceDb.Has(new Facts::CategoryOrganizationUnit { Id = 1, CategoryId = 1, OrganizationUnitId = 1 },
new Facts::CategoryOrganizationUnit { Id = 2, CategoryId = 2, OrganizationUnitId = 1 });
SourceDb.Has(new Facts::Project { OrganizationUnitId = 1 });
SourceDb.Has(new Facts::FirmAddress { Id = 1, FirmId = 1 },
new Facts::FirmAddress { Id = 2, FirmId = 2 });
SourceDb.Has(new Facts::CategoryFirmAddress { Id = 1, FirmAddressId = 1, CategoryId = 1 },
new Facts::CategoryFirmAddress { Id = 2, FirmAddressId = 2, CategoryId = 2 });
SourceDb.Has(new Facts::Firm { Id = 1, OrganizationUnitId = 1 },
new Facts::Firm { Id = 2, OrganizationUnitId = 1 },
new Facts::Firm { Id = 3, OrganizationUnitId = 1 });
TargetDb.Has(new CI::Firm { Id = 1 },
new CI::Firm { Id = 2 },
new CI::Firm { Id = 3 })
.Has(new CI::FirmCategory { FirmId = 2, CategoryId = 1 },
new CI::FirmCategory { FirmId = 3, CategoryId = 1 });
Transformation.Create(Query)
.Recalculate<CI::Firm>(1)
.Recalculate<CI::Firm>(2)
.Recalculate<CI::Firm>(3)
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 1, AddressCount = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 2, AddressCount = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 3 }))))
.Verify<CI::FirmCategory>(m => m.Add(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 1, CategoryId = 1 }))))
.Verify<CI::FirmCategory>(m => m.Add(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 2, CategoryId = 2 }))))
.Verify<CI::FirmCategory>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 2, CategoryId = 1 }))))
.Verify<CI::FirmCategory>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory { FirmId = 3, CategoryId = 1 }))));
}
public void ShouldRecalculateFirmIfBranchOfficeOrganizationUnitUpdated()
{
SourceDb.Has(new Erm::BranchOfficeOrganizationUnit {
Id = 1, OrganizationUnitId = 2
});
TargetDb.Has(new Facts::Firm {
Id = 1, ClientId = 1, OrganizationUnitId = 1
})
.Has(new Facts::Firm {
Id = 2, ClientId = 1, OrganizationUnitId = 2
})
.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::BranchOfficeOrganizationUnit {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::LegalPerson {
Id = 1, ClientId = 1
})
.Has(new Facts::Account {
Id = 1, LegalPersonId = 1, BranchOfficeOrganizationUnitId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::BranchOfficeOrganizationUnit>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1), Aggregate.Recalculate <CI.Firm>(2));
}
public void ShouldRecalculateFirmIfCategoryOfLevel1Deleted()
{
TargetDb.Has(new Facts::Firm {
Id = 1
})
.Has(new Facts::FirmAddress {
Id = 1, FirmId = 1
})
.Has(new Facts::CategoryFirmAddress {
Id = 1, FirmAddressId = 1, CategoryId = 3
})
.Has(new Facts::Category {
Id = 1, Level = 1
})
.Has(new Facts::Category {
Id = 2, Level = 2, ParentId = 1
})
.Has(new Facts::Category {
Id = 3, Level = 3, ParentId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Category>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateFirmHavingBalance()
{
SourceDb.Has(new Facts::Project { Id = 1, OrganizationUnitId = 1 })
.Has(new Facts::Client { Id = 1 },
new Facts::Client { Id = 2 })
.Has(new Facts::BranchOfficeOrganizationUnit { Id = 1, OrganizationUnitId = 1 })
.Has(new Facts::LegalPerson { Id = 1, ClientId = 1 },
new Facts::LegalPerson { Id = 2, ClientId = 2 })
.Has(new Facts::Account { Id = 1, LegalPersonId = 1, BranchOfficeOrganizationUnitId = 1, Balance = 123 },
new Facts::Account { Id = 2, LegalPersonId = 2, BranchOfficeOrganizationUnitId = 1, Balance = 456 })
.Has(new Facts::Firm { Id = 1, ClientId = 1, OrganizationUnitId = 1 },
new Facts::Firm { Id = 2, ClientId = 2, OrganizationUnitId = 1 },
new Facts::Firm { Id = 3, OrganizationUnitId = 1 });
TargetDb.Has(new CI::Firm { Id = 1 },
new CI::Firm { Id = 2 },
new CI::Firm { Id = 3 })
.Has(new CI::FirmBalance { FirmId = 2, AccountId = 2, ProjectId = 1, Balance = 123 },
new CI::FirmBalance { FirmId = 3, ProjectId = 1, Balance = 123 });
Transformation.Create(Query)
.Recalculate<CI::Firm>(1, 2, 3)
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 1, ClientId = 1, ProjectId = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 2, ClientId = 2, ProjectId = 1 }))))
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 3, ProjectId = 1 }))))
.Verify<CI::FirmBalance>(m => m.Add(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 1, AccountId = 1, ProjectId = 1, Balance = 123 }))))
.Verify<CI::FirmBalance>(m => m.Update(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 2, AccountId = 2, ProjectId = 1, Balance = 456 }))))
.Verify<CI::FirmBalance>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 3, ProjectId = 1, Balance = 123 }))));
}
public void ShouldDestroyFirmHavingCategory()
{
TargetDb.Has(new CI::Firm {
Id = 1
})
.Has(new CI::FirmCategory1 {
FirmId = 1, CategoryId = 1
})
.Has(new CI::FirmCategory2 {
FirmId = 1, CategoryId = 2
})
;
Transformation.Create(Query)
.Destroy <CI::Firm>(1)
.Verify <CI::Firm>(m => m.Delete(It.Is(Predicate.Match(new CI::Firm {
Id = 1
}))))
.Verify <CI::FirmCategory1>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory1 {
FirmId = 1, CategoryId = 1
}))))
.Verify <CI::FirmCategory2>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmCategory2 {
FirmId = 1, CategoryId = 2
}))))
;
}
public void ShouldRecalculateFirmIfContactUpdated()
{
SourceDb.Has(new Erm::Contact {
Id = 1, ClientId = 2
});
TargetDb.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::Client {
Id = 2
})
.Has(new Facts::Firm {
Id = 1, ClientId = 1
})
.Has(new Facts::Firm {
Id = 2, ClientId = 2
})
.Has(new Facts::Contact {
Id = 1, ClientId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Contact>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Client>(1), Aggregate.Recalculate <CI.Firm>(1), Aggregate.Recalculate <CI.Client>(2), Aggregate.Recalculate <CI.Firm>(2));
}
public void ShouldRecalculateFirmHavingTerritory()
{
SourceDb.Has(new Facts::Firm {
Id = 1
})
.Has(new Facts::FirmAddress {
FirmId = 1, TerritoryId = 2
});
TargetDb.Has(new CI::Firm {
Id = 1
})
.Has(new CI::FirmTerritory {
FirmId = 1, TerritoryId = 3
});
Transformation.Create(Query)
.Recalculate <CI::Firm>(1)
.Verify <CI::FirmTerritory>(m => m.Add(It.Is(Predicate.Match(new CI::FirmTerritory {
FirmId = 1, TerritoryId = 2
}))))
.Verify <CI::FirmTerritory>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmTerritory {
FirmId = 1, TerritoryId = 3
}))));
}
public void ShouldRecalculateFirmHavingClient()
{
SourceDb.Has(new Facts::Category {
Id = 1, Level = 3
})
.Has(new Facts::Project {
OrganizationUnitId = 1
})
.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::Firm {
Id = 1, ClientId = 1, OrganizationUnitId = 1
});
TargetDb.Has(new CI::Firm {
Id = 1
})
.Has(new CI::Client {
Id = 1
});
Transformation.Create(Query)
.Recalculate <CI::Firm>(1)
.Verify <CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm {
Id = 1, ClientId = 1
}))))
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 1
}))), Times.Never);
}
public void ShouldRecalculateDependentAggregatesIfProjectUpdated()
{
SourceDb.Has(new Erm::Project {
Id = 1, OrganizationUnitId = 2
});
TargetDb.Has(new Facts::Project {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::Territory {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::Territory {
Id = 2, OrganizationUnitId = 2
})
.Has(new Facts::Firm {
Id = 1, OrganizationUnitId = 1
})
.Has(new Facts::Firm {
Id = 2, OrganizationUnitId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Project>(1)
.VerifyDistinct(Statistics.Operation(1),
Aggregate.Recalculate <CI::Territory>(1),
Aggregate.Recalculate <CI::Firm>(1),
Aggregate.Recalculate <CI::Project>(1),
Aggregate.Recalculate <CI::Territory>(2),
Aggregate.Recalculate <CI::Firm>(2));
}
public void ShouldRecalculateFirmsIfActivityCreated()
{
SourceDb.Has(new Appointment {
Id = 1, ModifiedOn = DateTimeOffset.Now, IsActive = true, Status = ActivityStatusCompleted
})
.Has(new AppointmentReference {
ActivityId = 1, Reference = RegardingObjectReference, ReferencedObjectId = 2, ReferencedType = EntityTypeIds.Client
},
new AppointmentReference {
ActivityId = 1, Reference = RegardingObjectReference, ReferencedObjectId = 3, ReferencedType = EntityTypeIds.Firm
});
TargetDb.Has(new Facts::Client {
Id = 2
});
TargetDb.Has(new Facts::Firm {
Id = 3
});
TargetDb.Has(new Facts::Firm {
Id = 4, ClientId = 2
});
TargetDb.Has(new Facts::Firm {
Id = 5
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Activity>(1)
.VerifyDistinct(Aggregate.Recalculate <CI::Firm>(3),
Aggregate.Recalculate <CI::Firm>(4));
}
public void ShouldRecalculateClientAndFirmIfCategoryFirmAddressUpdated()
{
SourceDb.Has(new Erm::CategoryFirmAddress {
Id = 1, FirmAddressId = 1, CategoryId = 1
})
.Has(new Erm::FirmAddress {
Id = 1, FirmId = 1
})
.Has(new Erm::Firm {
Id = 1, OrganizationUnitId = 1, ClientId = 1
})
.Has(new Erm::Client {
Id = 1
});
TargetDb.Has(new Facts::CategoryFirmAddress {
Id = 1, FirmAddressId = 1, CategoryId = 1
});
TargetDb.Has(new Facts::FirmAddress {
Id = 1, FirmId = 1
});
TargetDb.Has(new Facts::Firm {
Id = 1, OrganizationUnitId = 1, ClientId = 1
});
TargetDb.Has(new Facts::Client {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::CategoryFirmAddress>(1)
.VerifyDistinct(Aggregate.Recalculate <CI::Firm>(1),
Aggregate.Recalculate <CI::Client>(1));
}
public void ShouldDestroyClient()
{
TargetDb.Has(new CI::Client { Id = 1 });
Transformation.Create(Query)
.Destroy<CI::Client>(1)
.Verify<CI::Client>(m => m.Delete(It.Is(Predicate.Match(new CI::Client { Id = 1 }))));
}
public void ShouldDestroyCategoryGroup()
{
TargetDb.Has(new CI::CategoryGroup { Id = 1 });
Transformation.Create(Query)
.Destroy<CI::CategoryGroup>(1)
.Verify<CI::CategoryGroup>(x => x.Delete(It.Is(Predicate.Match(new CI::CategoryGroup { Id = 1 }))));
}
public void ShouldRecalculateClient()
{
SourceDb.Has(new Facts::Client { Id = 1, Name = "new name" });
TargetDb.Has(new CI::Client { Id = 1, Name = "old name" });
Transformation.Create(Query)
.Recalculate<CI::Client>(1)
.Verify<CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client { Id = 1, Name = "new name" }))));
}
public void ShouldDestroyTerritoryIfTerritoryDeleted()
{
TargetDb.Has(new Facts::Territory {
Id = 1, OrganizationUnitId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Territory>(1)
.VerifyDistinct(Aggregate.Destroy <CI::Territory>(1));
}
public void ShouldDestroyFirmHavingBalance()
{
TargetDb.Has(new CI::Firm { Id = 1 })
.Has(new CI::FirmBalance { FirmId = 1, Balance = 123 });
Transformation.Create(Query)
.Destroy<CI::Firm>(1)
.Verify<CI::Firm>(m => m.Delete(It.Is(Predicate.Match(new CI::Firm { Id = 1 }))))
.Verify<CI::FirmBalance>(m => m.Delete(It.Is(Predicate.Match(new CI::FirmBalance { FirmId = 1, Balance = 123 }))));
}
public void ShouldDestroyFirmHavingClient()
{
TargetDb.Has(new CI::Firm { Id = 1, ClientId = 1 })
.Has(new CI::Client { Id = 1 });
Transformation.Create(Query)
.Destroy<CI::Firm>(1)
.Verify<CI::Firm>(m => m.Delete(It.Is(Predicate.Match(new CI::Firm { Id = 1, ClientId = 1 }))))
.Verify<CI::Client>(m => m.Delete(It.Is(Predicate.Match(new CI::Client { Id = 1 }))), Times.Never);
}
public void ShouldDestroyClientIfClientDeleted()
{
TargetDb.Has(new Facts::Client {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Client>(1)
.VerifyDistinct(Aggregate.Destroy <CI.Client>(1));
}
public void ShouldProcessFactAccordingToPriority()
{
//arrange
var factProcessor = new Mock <IFactProcessor>();
factProcessor.Setup(x => x.ApplyChanges(It.IsAny <IReadOnlyCollection <long> >()))
.Returns(new IOperation[0]);
var provider = new MetadataProvider(new[] { new FactsReplicationMetadataSource() }, new IMetadataProcessor[0]);
var factoryInvocationOrder = new List <Type>();
var factProcessorFactory = new Mock <IFactProcessorFactory>();
factProcessorFactory.Setup(x => x.Create(It.IsAny <IMetadataElement>()))
.Callback <IMetadataElement>(element =>
{
var type = element.GetType().GenericTypeArguments[0];
factoryInvocationOrder.Add(type);
})
.Returns(factProcessor.Object);
var transformation = new FactsReplicator(Mock.Of <ITracer>(),
Mock.Of <IReplicationSettings>(),
provider,
factProcessorFactory.Object,
new CustomerIntelligenceFactTypePriorityComparer());
SourceDb.Has(new Erm::Firm {
Id = 2
})
.Has(new Erm::FirmAddress {
Id = 1, FirmId = 1
}, new Erm::FirmAddress {
Id = 2, FirmId = 2
});
TargetDb.Has(new Facts::Firm {
Id = 1
});
var inputOperations = new[]
{
new FactOperation(typeof(Facts::FirmAddress), 1),
new FactOperation(typeof(Facts::Firm), 2),
new FactOperation(typeof(Facts::FirmAddress), 2),
};
//act
transformation.Replicate(inputOperations);
//assert
Assert.That(factoryInvocationOrder.Count, Is.EqualTo(2));
Assert.That(factoryInvocationOrder[0], Is.EqualTo(typeof(Facts::Firm)));
Assert.That(factoryInvocationOrder[1], Is.EqualTo(typeof(Facts::FirmAddress)));
}
public void ShouldDestroyProjectIfProjectDeleted()
{
TargetDb.Has(new Facts::Project {
Id = 1, OrganizationUnitId = 2
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Project>(1)
.VerifyDistinct(Statistics.Operation(1),
Aggregate.Destroy <CI::Project>(1));
}
public void ShouldDestroyCategoryGroupIfCategoryGroupDeleted()
{
TargetDb.Has(
new Facts::CategoryGroup {
Id = 1, Name = "Name", Rate = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::CategoryGroup>(1)
.VerifyDistinct(Aggregate.Destroy <CI::CategoryGroup>(1));
}
public void ShouldRecalculateFirm()
{
SourceDb.Has(new Facts::Project { OrganizationUnitId = 1 })
.Has(new Facts::Firm { Id = 1, OrganizationUnitId = 1 });
TargetDb.Has(new CI::Firm { Id = 1 });
Transformation.Create(Query)
.Recalculate<CI::Firm>(1)
.Verify<CI::Firm>(m => m.Update(It.Is(Predicate.Match(new CI::Firm { Id = 1 }))));
}
public void ShouldRecalculateTerritory()
{
SourceDb.Has(new Facts::Project { Id = 1, OrganizationUnitId = 1 })
.Has(new Facts::Territory { Id = 1, OrganizationUnitId = 1, Name = "new name" });
TargetDb.Has(new CI::Territory { Id = 1, Name = "old name" });
Transformation.Create(Query)
.Recalculate<CI::Territory>(1)
.Verify<CI::Territory>(m => m.Update(It.Is(Predicate.Match(new CI::Territory { Id = 1, ProjectId = 1, Name = "new name" }))));
}
public void ShouldRecalculateClientHavingContact()
{
SourceDb.Has(new Facts::Client {
Id = 1
},
new Facts::Client {
Id = 2
},
new Facts::Client {
Id = 3
})
.Has(new Facts::Contact {
Id = 1, ClientId = 1
},
new Facts::Contact {
Id = 2, ClientId = 2
});
TargetDb.Has(new CI::Client {
Id = 1
},
new CI::Client {
Id = 2
},
new CI::Client {
Id = 3
})
.Has(new CI::ClientContact {
ClientId = 2, ContactId = 2
},
new CI::ClientContact {
ClientId = 3, ContactId = 3
});
Transformation.Create(Query)
.Recalculate <CI::Client>(1)
.Recalculate <CI::Client>(2)
.Recalculate <CI::Client>(3)
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 1
}))))
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 2
}))))
.Verify <CI::Client>(m => m.Update(It.Is(Predicate.Match(new CI::Client {
Id = 3
}))))
.Verify <CI::ClientContact>(m => m.Add(It.Is(Predicate.Match(new CI::ClientContact {
ClientId = 1, ContactId = 1
}))))
.Verify <CI::ClientContact>(m => m.Delete(It.Is(Predicate.Match(new CI::ClientContact {
ClientId = 3, ContactId = 3
}))));
}
public void ShouldRecalculateFirmIfOrderCreated()
{
SourceDb.Has(new Erm::Order {
Id = 2, FirmId = 1, WorkflowStepId = 4
});
TargetDb.Has(new Facts::Firm {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Order>(2)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateTerritoryIfTerritoryUpdated()
{
SourceDb.Has(new Erm::Territory {
Id = 1, OrganizationUnitId = 2
});
TargetDb.Has(new Facts::Territory {
Id = 1, OrganizationUnitId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Territory>(1)
.VerifyDistinct(Aggregate.Recalculate <CI::Territory>(1));
}
public void ShouldRecalculateDetachedFirmIfBranchOfficeOrganizationUnitDeleted()
{
TargetDb.Has(new Facts::Firm {
Id = 1, ClientId = 2, OrganizationUnitId = 1
})
.Has(new Facts::BranchOfficeOrganizationUnit {
Id = 3, OrganizationUnitId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::BranchOfficeOrganizationUnit>(3)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateFirmIfFirmAddressDeleted()
{
TargetDb.Has(new Facts::Firm {
Id = 1
})
.Has(new Facts::FirmAddress {
Id = 2, FirmId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::FirmAddress>(2)
.VerifyDistinct(Aggregate.Recalculate <CI.Firm>(1));
}
public void ShouldRecalculateFirmIfClientDeleted()
{
TargetDb.Has(new Facts::Client {
Id = 1
})
.Has(new Facts::Firm {
Id = 2, ClientId = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Client>(1)
.VerifyDistinct(op => op is RecalculateAggregate, Aggregate.Recalculate <CI.Firm>(2));
}
public void ShouldRecalculateClientIfClientUpdated()
{
SourceDb.Has(new Erm::Client {
Id = 1
});
TargetDb.Has(new Facts::Client {
Id = 1
});
Transformation.Create(Query, RepositoryFactory)
.ApplyChanges <Facts::Client>(1)
.VerifyDistinct(Aggregate.Recalculate <CI.Client>(1));
}
