public void CloneWithExtractionProgress()
{
var sds = _configuration.SelectedDataSets[0];
var ci = sds.GetCatalogue().CatalogueItems.First();
var origProgress = new ExtractionProgress(DataExportRepository, sds, null, DateTime.Now, 10, "fff drrr", ci.ID);
origProgress.ProgressDate = new DateTime(2001, 01, 01);
origProgress.SaveToDatabase();
ExtractionConfiguration deepClone = _configuration.DeepCloneWithNewIDs();
Assert.AreEqual(deepClone.Cohort_ID, _configuration.Cohort_ID);
Assert.AreNotEqual(deepClone.ID, _configuration.ID);
var clonedSds = deepClone.SelectedDataSets.Single(s => s.ExtractableDataSet_ID == sds.ExtractableDataSet_ID);
var clonedProgress = clonedSds.ExtractionProgressIfAny;
Assert.IsNotNull(clonedProgress);
Assert.IsNull(clonedProgress.StartDate);
Assert.IsNull(clonedProgress.ProgressDate, "Cloning a ExtractionProgress should reset its ProgressDate back to null in anticipation of it being extracted again");
Assert.AreEqual(clonedProgress.EndDate, origProgress.EndDate);
Assert.AreEqual(clonedProgress.NumberOfDaysPerBatch, origProgress.NumberOfDaysPerBatch);
Assert.AreEqual(clonedProgress.Name, origProgress.Name);
Assert.AreEqual(clonedProgress.ExtractionInformation_ID, origProgress.ExtractionInformation_ID);
deepClone.DeleteInDatabase();
// remove the progress so that it doesn't trip other tests
origProgress.DeleteInDatabase();
}
private void RunTestWithCleanup(Project p, ExtractionConfiguration config, ICheckNotifier notifier = null)
{
try
{
new ProjectChecker(new ThrowImmediatelyActivator(RepositoryLocator), p).Check(notifier ?? new ThrowImmediatelyCheckNotifier()
{
ThrowOnWarning = true
});
}
finally
{
config.DeleteInDatabase();
p.DeleteInDatabase();
}
}
private void TestDataExportOfTvf()
{
var config = new ExtractionConfiguration(DataExportRepository, _project);
config.Cohort_ID = DataExportRepository.GetAllObjects <ExtractableCohort>().Single().ID;
config.SaveToDatabase();
var tvfExtractable = new ExtractableDataSet(DataExportRepository, _tvfCatalogue);
var selected = new SelectedDataSets(DataExportRepository, config, tvfExtractable, null);
//make all columns part of the extraction
foreach (ExtractionInformation e in _tvfCatalogue.GetAllExtractionInformation(ExtractionCategory.Any))
{
config.AddColumnToExtraction(tvfExtractable, e);
}
//the default value should be 10
Assert.AreEqual("10", _tvfTableInfo.GetAllParameters().Single().Value);
//configure an extraction specific global of 1 so that only 1 chi number is fetched (which will be in the cohort)
var globalP = new GlobalExtractionFilterParameter(DataExportRepository, config, "DECLARE @numberOfRecords AS int;");
globalP.Value = "1";
globalP.SaveToDatabase();
var extractionCommand = new ExtractDatasetCommand(config, new ExtractableDatasetBundle(tvfExtractable));
var source = new ExecuteDatasetExtractionSource();
source.PreInitialize(extractionCommand, new ThrowImmediatelyDataLoadEventListener());
var dt = source.GetChunk(new ThrowImmediatelyDataLoadEventListener(), new GracefulCancellationToken());
Assert.AreEqual(1, dt.Rows.Count);
Assert.AreEqual("ReleaseId", dt.Columns[0].ColumnName);
//should be a guid
Assert.IsTrue(dt.Rows[0][0].ToString().Length > 10);
Assert.IsTrue(dt.Rows[0][0].ToString().Contains("-"));
selected.DeleteInDatabase();
globalP.DeleteInDatabase();
config.DeleteInDatabase();
tvfExtractable.DeleteInDatabase();
}
public void CreateExtractionConfiguration()
{
Project parent = new Project(DataExportRepository, "unit_test_CreateExtractionConfiguration");
ExtractionConfiguration table = new ExtractionConfiguration(DataExportRepository, parent);
try
{
Assert.AreEqual(table.Username, Environment.UserName);
}
finally
{
table.DeleteInDatabase();//must delete child before parent to preserve referential integrity
parent.DeleteInDatabase();
}
}
public void CreateAndAssociateColumns()
{
var cata = new Catalogue(CatalogueRepository, "MyCat");
var cataItem = new CatalogueItem(CatalogueRepository, cata, "MyCataItem");
var TableInfo = new TableInfo(CatalogueRepository, "Cata");
var ColumnInfo = new ColumnInfo(CatalogueRepository, "Col", "varchar(10)", TableInfo);
var ExtractionInfo = new ExtractionInformation(CatalogueRepository, cataItem, ColumnInfo, "fish");
var ds = new ExtractableDataSet(DataExportRepository, cata);
var proj = new Project(DataExportRepository, "MyProj");
var config = new ExtractionConfiguration(DataExportRepository, proj);
SelectedDataSets selectedDataSets;
var extractableColumn = new ExtractableColumn(DataExportRepository, ds, config, ExtractionInfo, 1, "fish");
try
{
selectedDataSets = new SelectedDataSets(DataExportRepository, config, ds, null);
var cols = config.GetAllExtractableColumnsFor(ds);
Assert.AreEqual(1, cols.Count());
Assert.AreEqual(extractableColumn, cols.Single());
cols = config.GetAllExtractableColumnsFor(ds);
Assert.AreEqual(1, cols.Count());
Assert.AreEqual(extractableColumn, cols.Single());
}
finally
{
extractableColumn.DeleteInDatabase();
config.DeleteInDatabase();
proj.DeleteInDatabase();
ds.DeleteInDatabase();
TableInfo.DeleteInDatabase();
cata.DeleteInDatabase();
}
}
public void CloneWithFilters(bool introduceOrphanExtractionInformation)
{
if (introduceOrphanExtractionInformation)
{
IntroduceOrphan();
}
Assert.IsEmpty(_configuration.ReleaseLog);
var filter = new ExtractionFilter(CatalogueRepository, "FilterByFish", _extractionInformations[0]);
try
{
//setup a filter with a parameter
filter.WhereSQL = "Fish = @fish";
new ParameterCreator(new ExtractionFilterFactory(_extractionInformations[0]), null, null).CreateAll(filter, null);
filter.SaveToDatabase();
Assert.IsTrue(filter.ExtractionFilterParameters.Count() == 1);
//create a root container
var container = new FilterContainer(DataExportRepository);
_selectedDataSet.RootFilterContainer_ID = container.ID;
_selectedDataSet.SaveToDatabase();
//create a deployed filter
var importer = new FilterImporter(new DeployedExtractionFilterFactory(DataExportRepository), null);
var deployedFilter = (DeployedExtractionFilter)importer.ImportFilter(filter, null);
deployedFilter.FilterContainer_ID = container.ID;
deployedFilter.Name = "FilterByFishDeployed";
deployedFilter.SaveToDatabase();
var param = deployedFilter.ExtractionFilterParameters[0];
param.Value = "'jormungander'";
param.SaveToDatabase();
ExtractDatasetCommand request = new ExtractDatasetCommand(_configuration, new ExtractableDatasetBundle(_extractableDataSet));
request.GenerateQueryBuilder();
Assert.AreEqual(
CollapseWhitespace(
string.Format(
@"DECLARE @fish AS varchar(50);
SET @fish='jormungander';
/*The ID of the cohort in [{0}CohortDatabase]..[Cohort]*/
DECLARE @CohortDefinitionID AS int;
SET @CohortDefinitionID=-599;
/*The project number of project {0}ExtractionConfiguration*/
DECLARE @ProjectNumber AS int;
SET @ProjectNumber=1;
SELECT DISTINCT
[{0}CohortDatabase]..[Cohort].[ReleaseID] AS ReleaseID,
[{0}ScratchArea].[dbo].[TestTable].[Name],
[{0}ScratchArea].[dbo].[TestTable].[DateOfBirth]
FROM
[{0}ScratchArea].[dbo].[TestTable] INNER JOIN [{0}CohortDatabase]..[Cohort] ON [{0}ScratchArea].[dbo].[TestTable].[PrivateID]=[{0}CohortDatabase]..[Cohort].[PrivateID]
WHERE
(
/*FilterByFishDeployed*/
Fish = @fish
)
AND
[{0}CohortDatabase]..[Cohort].[cohortDefinition_id]=-599
"
, TestDatabaseNames.Prefix))
, CollapseWhitespace(request.QueryBuilder.SQL));
ExtractionConfiguration deepClone = _configuration.DeepCloneWithNewIDs();
Assert.AreEqual(deepClone.Cohort_ID, _configuration.Cohort_ID);
Assert.AreNotEqual(deepClone.ID, _configuration.ID);
try
{
ExtractDatasetCommand request2 = new ExtractDatasetCommand(deepClone, new ExtractableDatasetBundle(_extractableDataSet));
request2.GenerateQueryBuilder();
Assert.AreEqual(request.QueryBuilder.SQL, request2.QueryBuilder.SQL);
}
finally
{
deepClone.DeleteInDatabase();
}
}
finally
{
filter.DeleteInDatabase();
}
}
public void ExtractableColumnTest()
{
ExtractableDataSet dataSet = null;
ExtractionConfiguration configuration = null;
Project project = null;
Catalogue cata = null;
CatalogueItem cataItem = null;
ColumnInfo column = null;
TableInfo table = null;
ExtractionInformation extractionInformation = null;
ExtractableColumn extractableColumn = null;
try
{
//setup catalogue side of things
cata = new Catalogue(CatalogueRepository, "unit_test_ExtractableColumnTest_Cata");
cataItem = new CatalogueItem(CatalogueRepository, cata, "unit_test_ExtractableColumnTest_CataItem");
table = new TableInfo(CatalogueRepository, "DaveTable");
column = new ColumnInfo(CatalogueRepository, "Name", "string", table);
cataItem.SetColumnInfo(column);
extractionInformation = new ExtractionInformation(CatalogueRepository, cataItem, column, "Hashme(Name)");
//setup extractor side of things
dataSet = new ExtractableDataSet(DataExportRepository, cata);
project = new Project(DataExportRepository, "unit_test_ExtractableColumnTest_Proj");
configuration = new ExtractionConfiguration(DataExportRepository, project);
extractableColumn = new ExtractableColumn(DataExportRepository, dataSet, configuration, extractionInformation, 0, "Hashme2(Name)");
Assert.AreEqual(configuration.GetAllExtractableColumnsFor(dataSet).Length, 1);
}
finally
{
if (extractionInformation != null)
{
extractionInformation.DeleteInDatabase();
}
if (column != null)
{
column.DeleteInDatabase();
}
if (table != null)
{
table.DeleteInDatabase();
}
if (cataItem != null)
{
cataItem.DeleteInDatabase();
}
if (configuration != null)
{
configuration.DeleteInDatabase();
}
if (project != null)
{
project.DeleteInDatabase();
}
if (dataSet != null)
{
dataSet.DeleteInDatabase();
}
if (cata != null)
{
cata.DeleteInDatabase();
}
}
}
