private Transformation(IQuery query)
{
_query = query;
_repositoryFactory = new VerifiableRepositoryFactory();
_metadataSource = new AggregateConstructionMetadataSource();
_comparerFactory = new EqualityComparerFactory(new LinqToDbPropertyProvider(Schema.Erm, Schema.Facts, Schema.CustomerIntelligence));
}
public void ShouldProcessFirmCategoryForecastFromFirmForecastDto()
{
// Arrange
var repositoryFactory = new VerifiableRepositoryFactory();
var dto = new FirmForecastDto
{
ProjectId = 1,
Firms = new[]
{
new FirmForecastDto.FirmDto
{
Id = 1,
ForecastClick = 1,
ForecastAmount = 1,
Categories = new[]
{
new FirmForecastDto.CategoryDto
{
Id = 1,
ForecastAmount = 1,
ForecastClick = 1,
}
}
}
}
};
SourceDb.Has(new Bit::FirmCategoryForecast {
ProjectId = 1, FirmId = 1, CategoryId = 1
},
new Bit::FirmCategoryForecast {
ProjectId = 2, FirmId = 2, CategoryId = 1
});
var importer = CreateProcessor <FirmForecastDto, Bit::FirmCategoryForecast>(repositoryFactory);
// Act
var operations = importer.Import(dto).ToArray();
// Assert
Assert.That(operations.Count(), Is.EqualTo(1));
repositoryFactory.Verify <Bit::FirmCategoryForecast>(
m => m.Delete(It.Is(Predicate.Match(new Bit::FirmCategoryForecast {
ProjectId = 1, FirmId = 1, CategoryId = 1
}))), Times.AtLeastOnce);
repositoryFactory.Verify <Bit::FirmCategoryForecast>(
m => m.Delete(It.Is(Predicate.Match(new Bit::FirmCategoryForecast {
ProjectId = 2, FirmId = 2, CategoryId = 1
}))), Times.Never);
repositoryFactory.Verify <Bit::FirmCategoryForecast>(
m => m.Add(It.Is(Predicate.Match(new Bit::FirmCategoryForecast {
ProjectId = 1, FirmId = 1, CategoryId = 1, ForecastClick = 1, ForecastAmount = 1
}))), Times.AtLeastOnce);
}
public void ShouldProduceCalculateStatisticsOperationForCategoryStatisticsDto()
{
// Arrange
var repositoryFactory = new VerifiableRepositoryFactory();
var dto = new CategoryStatisticsDto
{
ProjectId = 1,
Categories = new[]
{
new CategoryStatisticsDto.CategoryDto
{
CategoryId = 2,
AdvertisersCount = 3,
}
}
};
SourceDb.Has(new Bit::ProjectCategoryStatistics {
ProjectId = 1, CategoryId = 7
},
new Bit::ProjectCategoryStatistics {
ProjectId = 2, CategoryId = 7
});
var metadataSource = new ImportStatisticsMetadataSource();
IMetadataElement importStatisticsMetadata;
if (!metadataSource.Metadata.Values.TryGetElementById(new Uri(typeof(CategoryStatisticsDto).Name, UriKind.Relative), out importStatisticsMetadata))
{
throw new NotSupportedException($"The aggregate of type '{typeof(CategoryStatisticsDto).Name}' is not supported.");
}
var importer = new StatisticsFactImporter <Bit::ProjectCategoryStatistics, CategoryStatisticsDto>(
(ImportStatisticsMetadata <Bit::ProjectCategoryStatistics, CategoryStatisticsDto>)importStatisticsMetadata,
Query,
repositoryFactory.Create <Bit::ProjectCategoryStatistics>());
// Act
var operations = importer.Import(dto).ToArray();
// Assert
Assert.That(operations.Count(), Is.EqualTo(1));
repositoryFactory.Verify <Bit::ProjectCategoryStatistics>(
m => m.Delete(It.Is(Predicate.Match(new Bit::ProjectCategoryStatistics {
ProjectId = 1, CategoryId = 7
}))),
Times.AtLeastOnce);
repositoryFactory.Verify <Bit::ProjectCategoryStatistics>(
m => m.Add(It.Is(Predicate.Match(new Bit::ProjectCategoryStatistics {
ProjectId = 1, CategoryId = 2, AdvertisersCount = 3
}))),
Times.AtLeastOnce);
}
public void ShouldProduceCalculateStatisticsOperationForFirmStatisticsDto()
{
// Arrange
var repositoryFactory = new VerifiableRepositoryFactory();
var dto = new FirmStatisticsDto
{
ProjectId = 1,
Firms = new[]
{
new FirmStatisticsDto.FirmDto
{
FirmId = 2,
Categories = new[]
{
new FirmStatisticsDto.FirmDto.CategoryDto
{
CategoryId = 3,
Hits = 4,
Shows = 5
}
}
}
}
};
SourceDb.Has(new Bit::FirmCategoryStatistics { ProjectId = 1, FirmId = 7 },
new Bit::FirmCategoryStatistics { ProjectId = 2, FirmId = 8 });
var metadataSource = new ImportStatisticsMetadataSource();
IMetadataElement importStatisticsMetadata;
if (!metadataSource.Metadata.Values.TryGetElementById(new Uri(typeof(FirmStatisticsDto).Name, UriKind.Relative), out importStatisticsMetadata))
{
throw new NotSupportedException($"The aggregate of type '{typeof(FirmStatisticsDto).Name}' is not supported.");
}
var importer = new StatisticsFactImporter<Bit::FirmCategoryStatistics, FirmStatisticsDto>(
(ImportStatisticsMetadata<Bit::FirmCategoryStatistics, FirmStatisticsDto>)importStatisticsMetadata,
Query,
repositoryFactory.Create<Bit::FirmCategoryStatistics>());
// Act
var operations = importer.Import(dto).ToArray();
// Assert
Assert.That(operations.Count(), Is.EqualTo(1));
repositoryFactory.Verify<Bit::FirmCategoryStatistics>(
m => m.Delete(It.Is(Predicate.Match(new Bit::FirmCategoryStatistics { ProjectId = 1, FirmId = 7 }))),
Times.AtLeastOnce);
repositoryFactory.Verify<Bit::FirmCategoryStatistics>(
m => m.Add(It.Is(Predicate.Match(new Bit::FirmCategoryStatistics { ProjectId = 1, FirmId = 2, CategoryId = 3, Hits = 4, Shows = 5 }))),
Times.AtLeastOnce);
}
public void ShouldProduceCalculateStatisticsOperationForFirmStatisticsDto()
{
// Arrange
var repositoryFactory = new VerifiableRepositoryFactory();
var dto = new FirmStatisticsDto
{
ProjectId = 1,
Firms = new[]
{
new FirmStatisticsDto.FirmDto
{
FirmId = 2,
Categories = new[]
{
new FirmStatisticsDto.FirmDto.CategoryDto
{
CategoryId = 3,
Hits = 4,
Shows = 5
}
}
}
}
};
SourceDb.Has(new Bit::FirmCategoryStatistics {
ProjectId = 1, FirmId = 7
},
new Bit::FirmCategoryStatistics {
ProjectId = 2, FirmId = 8
});
var importer = CreateProcessor <FirmStatisticsDto, Bit::FirmCategoryStatistics>(repositoryFactory);
// Act
var operations = importer.Import(dto).ToArray();
// Assert
Assert.That(operations.Count(), Is.EqualTo(1));
repositoryFactory.Verify <Bit::FirmCategoryStatistics>(
m => m.Delete(It.Is(Predicate.Match(new Bit::FirmCategoryStatistics {
ProjectId = 1, FirmId = 7
}))),
Times.AtLeastOnce);
repositoryFactory.Verify <Bit::FirmCategoryStatistics>(
m => m.Add(It.Is(Predicate.Match(new Bit::FirmCategoryStatistics {
ProjectId = 1, FirmId = 2, CategoryId = 3, Hits = 4, Shows = 5
}))),
Times.AtLeastOnce);
}
private static void VerifyElementDeletion <TTarget>(IQuery query, MockLinqToDbDataBuilder factsDb, TTarget targetObject)
where TTarget : class, IIdentifiable <long>, IFactObject, new()
{
factsDb.Has(targetObject);
var factory = new VerifiableRepositoryFactory();
Transformation.Create(query, factory)
.ApplyChanges <TTarget>(new DefaultIdentityProvider().GetId(targetObject));
factory.Verify <TTarget>(
x => x.Delete(It.Is(Predicate.ById <TTarget>(new DefaultIdentityProvider().GetId(targetObject)))),
Times.Once,
string.Format("The {0} element was not deleted.", typeof(TTarget).Name));
}
public void ShouldProduceCalculateStatisticsOperationForFirmStatisticsDto()
{
// Arrange
var firmPopularity = new DTO.FirmPopularity
{
ProjectId = 1,
Firms = new[]
{
new DTO.FirmPopularity.Firm
{
FirmId = 2,
Categories = new[]
{
new DTO.FirmPopularity.Firm.Category
{
CategoryId = 3,
Hits = 4,
Shows = 5
}
}
}
}
};
SourceDb.Has(new FirmCategoryStatistics { ProjectId = 1, FirmId = 7 },
new FirmCategoryStatistics { ProjectId = 2, FirmId = 8 });
var repositoryFactory = new VerifiableRepositoryFactory();
var accessor = new FirmCategoryStatisticsAccessor();
var actor = new ReplaceDataObjectsActor<FirmCategoryStatistics>(
Query,
repositoryFactory.Create<FirmCategoryStatistics>(),
accessor,
accessor);
// Act
var events = actor.ExecuteCommands(new[] { new ReplaceFirmPopularityCommand(firmPopularity) });
// Assert
Assert.That(events.Count, Is.EqualTo(1));
repositoryFactory.Verify<FirmCategoryStatistics>(
m => m.Delete(It.Is(Predicate.Match(new FirmCategoryStatistics { ProjectId = 1, FirmId = 7 }))),
Times.AtLeastOnce);
repositoryFactory.Verify<FirmCategoryStatistics>(
m => m.Add(It.Is(Predicate.Match(new FirmCategoryStatistics { ProjectId = 1, FirmId = 2, CategoryId = 3, Hits = 4, Shows = 5 }))),
Times.AtLeastOnce);
}
private static void VerifyElementUpdate <TSource, TTarget>(IQuery query, MockLinqToDbDataBuilder ermDb, MockLinqToDbDataBuilder factsDb, TSource sourceObject, TTarget targetObject)
where TSource : class, IIdentifiable, new()
where TTarget : class, IIdentifiable, IFactObject, new()
{
ermDb.Has(sourceObject);
factsDb.Has(targetObject);
var factory = new VerifiableRepositoryFactory();
Transformation.Create(query, factory)
.ApplyChanges <TTarget>(targetObject.Id);
factory.Verify <TTarget>(
x => x.Update(It.Is(Predicate.ById <TTarget>(targetObject.Id))),
Times.Once,
string.Format("The {0} element was not updated.", typeof(TTarget).Name));
}
private static void VerifyElementInsertion <TSource, TTarget>(IQuery query, MockLinqToDbDataBuilder ermDb, TSource sourceObject)
where TSource : class, IIdentifiable <long>, new()
where TTarget : class, IIdentifiable <long>, IFactObject, new()
{
var entityId = new DefaultIdentityProvider().GetId(sourceObject);
ermDb.Has(sourceObject);
var factory = new VerifiableRepositoryFactory();
Transformation.Create(query, factory)
.ApplyChanges <TTarget>(entityId);
factory.Verify <TTarget>(
x => x.Add(It.Is(Predicate.ById <TTarget>(entityId))),
Times.Once,
string.Format("The {0} element was not inserted.", typeof(TTarget).Name));
}
public void ShouldProduceCalculateStatisticsOperationForCategoryStatisticsDto()
{
// Arrange
var rubricPopularity = new DTO.RubricPopularity
{
ProjectId = 1,
Categories = new[]
{
new DTO.RubricPopularity.Category
{
CategoryId = 2,
AdvertisersCount = 3,
}
}
};
SourceDb.Has(new ProjectCategoryStatistics { ProjectId = 1, CategoryId = 7 },
new ProjectCategoryStatistics { ProjectId = 2, CategoryId = 7 });
var repositoryFactory = new VerifiableRepositoryFactory();
var accessor = new ProjectCategoryStatisticsAccessor();
var actor = new ReplaceDataObjectsActor<ProjectCategoryStatistics>(
Query,
repositoryFactory.Create<ProjectCategoryStatistics>(),
accessor,
accessor);
// Act
var events = actor.ExecuteCommands(new[] { new ReplaceRubricPopularityCommand(rubricPopularity) });
// Assert
Assert.That(events.Count, Is.EqualTo(1));
repositoryFactory.Verify<ProjectCategoryStatistics>(
m => m.Delete(It.Is(Predicate.Match(new ProjectCategoryStatistics { ProjectId = 1, CategoryId = 7 }))),
Times.AtLeastOnce);
repositoryFactory.Verify<ProjectCategoryStatistics>(
m => m.Add(It.Is(Predicate.Match(new ProjectCategoryStatistics { ProjectId = 1, CategoryId = 2, AdvertisersCount = 3 }))),
Times.AtLeastOnce);
}
public void ShouldProcessFirmCategoryForecastFromFirmForecastDto()
{
// Arrange
var firmForecast = new DTO.FirmForecast
{
ProjectId = 1,
Firms = new[]
{
new DTO.FirmForecast.Firm
{
Id = 1,
ForecastClick = 1,
ForecastAmount = 1,
Categories = new[]
{
new DTO.FirmForecast.Category
{
Id = 1,
ForecastAmount = 1,
ForecastClick = 1,
}
}
}
}
};
SourceDb.Has(new FirmCategoryForecast { ProjectId = 1, FirmId = 1, CategoryId = 1 },
new FirmCategoryForecast { ProjectId = 2, FirmId = 2, CategoryId = 1 });
var repositoryFactory = new VerifiableRepositoryFactory();
var accessor = new FirmCategoryForecastAccessor();
var actor = new ReplaceDataObjectsActor<FirmCategoryForecast>(
Query,
repositoryFactory.Create<FirmCategoryForecast>(),
accessor,
accessor);
// Act
var events = actor.ExecuteCommands(new[] { new ReplaceFirmCategoryForecastCommand(firmForecast) });
// Assert
Assert.That(events.Count, Is.EqualTo(1));
repositoryFactory.Verify<FirmCategoryForecast>(
m => m.Delete(It.Is(Predicate.Match(new FirmCategoryForecast { ProjectId = 1, FirmId = 1, CategoryId = 1 }))), Times.AtLeastOnce);
repositoryFactory.Verify<FirmCategoryForecast>(
m => m.Delete(It.Is(Predicate.Match(new FirmCategoryForecast { ProjectId = 2, FirmId = 2, CategoryId = 1 }))), Times.Never);
repositoryFactory.Verify<FirmCategoryForecast>(
m => m.Add(It.Is(Predicate.Match(new FirmCategoryForecast { ProjectId = 1, FirmId = 1, CategoryId = 1, ForecastClick = 1, ForecastAmount = 1 }))), Times.AtLeastOnce);
}
