public async Task GetDatabasesByCreatorAsync__RequiredParamsNotSupplied_ThrowsAppropriateError(string creatorString, string locationString)
{
// Arrange
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// Act + Assert
await Assert.ThrowsAsync <KeyNotFoundException>(async() => await dbSchemaScrapeAccess.GetDatabasesByCreatorAsync(
creatorString, locationString, new List <string>()));
}
public async Task GetTableRowCountAsync_ResultsFound_ReturnsCorrectNumberOfRows()
{
// Arrange
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// Act
var result = await dbSchemaScrapeAccess.GetTableRowCountAsync(nameof(TestSchemaTableModel));
// Assert - this is simply the number of objects loaded into the 'TestSchemaTableModel' table.
result.As <long?>().Should().Equals(_listSchemaTables.Count);
}
public async Task GetListOfDatabaseNamesInEnvironmentAsync_ResultsFound_ReturnsDistinctResultsForMatchingTypeAndCreator()
{
// Arrange
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// Act
var result = await dbSchemaScrapeAccess.GetListOfDatabaseNamesInEnvironmentAsync(MatchingCreatorString, MatchingLocationString);
// Assert - should only return Distinct Database names that match Tables or Aliases with the correct Creator value.
// There are 2 results loaded that match, but they have the same DBNAME, so should only be 1 distinct result returned.
result.As <List <string> >().Count.Should().Equals(_listSchemaTables.Where(x => x.CREATOR == MatchingCreatorString && RelevantTableTypes.Contains(x.TYPE)).Distinct());
}
public async Task GetDatabasesByCreatorAsync_CorrectMatchingDatabaseNameSupplied_ReturnsCorrectNumberOfRows()
{
// Arrange
var concreteWhitelistDatabaseNames = _db2QueryHelperConcrete.WhitelistDatabaseNamesToBeIngestedInSchemaAppendFilter(
new List <string> {
MatchingDatabase1String
},
SharedConstants.Db2SchemaScrape.Db2SystemDatabaseNameOfAliasTables);
_db2QueryHelper.Setup(x => x.WhitelistDatabaseNamesToBeIngestedInSchemaAppendFilter(
It.IsAny <List <string> >(),
SharedConstants.Db2SchemaScrape.Db2SystemDatabaseNameOfAliasTables))
.Returns(concreteWhitelistDatabaseNames);
_db2QueryHelper.Setup(x => x.GetAliasTableDetailsWithinWhitelistedDatabaseNamesToMatch(
It.IsAny <string>(),
It.IsAny <List <string> >(),
It.IsAny <List <string> >()))
// Return the actual value from this method - no need to mock it.
.Returns(_db2QueryHelperConcrete.GetAliasTableDetailsWithinWhitelistedDatabaseNamesToMatch(
"main.TestSchemaTableModel",
_listSchemaTables.Where(t => t.TYPE == RelevantTableTypes[0]).Select(t => t.NAME).ToList(),
new List <string> {
MatchingDatabase1String
}));
_db2QueryHelper.Setup(x => x.GetTableDetailsForEnvironmentQueryFormatted(
"main.TestSchemaTableModel",
concreteWhitelistDatabaseNames,
string.Empty))
// Return the actual value from this method - no need to mock it.
.Returns(_db2QueryHelperConcrete.GetTableDetailsForEnvironmentQueryFormatted(
"main.TestSchemaTableModel",
concreteWhitelistDatabaseNames,
string.Empty));
var schemaTablesThatMatchOurQuery = _listSchemaTables
.Where(x => x.CREATOR == MatchingCreatorString && RelevantTableTypes.Contains(x.TYPE));
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// Act
var result = await dbSchemaScrapeAccess.GetDatabasesByCreatorAsync(
MatchingCreatorString, MatchingLocationString, new List <string> {
MatchingDatabase1String
});
// Assert
// There are multiple results loaded that match, but they have the same DBNAME, so should only be 1 distinct Database result returned.
result.As <List <SchemaDatabaseModel> >().Should().Equals(schemaTablesThatMatchOurQuery.Select(x => x.DBNAME).Distinct());
}
public async Task BuildAliasTablesResultSetListForAllEnvironments_ResultsFound_ReturnsCorrectNumberOfRows()
{
// Arrange
_db2QueryHelper.Setup(x => x.GetAliasTableDetailsWithinWhitelistedDatabaseNamesToMatch(
It.IsAny <string>(),
It.IsAny <List <string> >(),
It.IsAny <List <string> >()))
// Return the actual value from this method - no need to mock it.
.Returns(_db2QueryHelperConcrete.GetAliasTableDetailsWithinWhitelistedDatabaseNamesToMatch(
"main.TestSchemaTableModel",
_listSchemaTables.Where(t => t.TYPE == RelevantTableTypes[0]).Select(t => t.NAME).ToList(),
new List <string> {
MatchingDatabase1String
}));
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// This is the return collection
var returnAliasTableCollection = _listSchemaTables
.Select(x => new SchemaTableModel
{
Type = x.TYPE,
AliasTableLocation = x.LOCATION,
Name = x.NAME,
AliasTableName = x.NAME,
AliasTableEnvironment = MatchingAliasCreatorString,
DatabaseName = x.DBNAME
})
.ToList();
try
{
// Act
await dbSchemaScrapeAccess.BuildAliasTablesResultSetListForAllEnvironments(
MatchingLocationString,
new List <string> {
MatchingDatabase1String
},
returnAliasTableCollection,
_testInMemoryDatabase.OpenConnection(),
string.Empty);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
// Assert
returnAliasTableCollection.First().SchemaColumns.Count.Should().Be(1);
}
public async Task GetDatabasesByCreatorAsync_InCorrectMatchingDatabaseNameSupplied_ReturnsZeroRows()
{
// Arrange
var concreteWhitelistDatabaseNames = _db2QueryHelperConcrete.WhitelistDatabaseNamesToBeIngestedInSchemaAppendFilter(
new List <string> {
DatabaseNameNotInOurInternalDataSet
},
SharedConstants.Db2SchemaScrape.Db2SystemDatabaseNameOfAliasTables);
_db2QueryHelper.Setup(x => x.WhitelistDatabaseNamesToBeIngestedInSchemaAppendFilter(
It.IsAny <List <string> >(),
SharedConstants.Db2SchemaScrape.Db2SystemDatabaseNameOfAliasTables))
.Returns(concreteWhitelistDatabaseNames);
_db2QueryHelper.Setup(x => x.GetTableDetailsForEnvironmentQueryFormatted(
"main.TestSchemaTableModel",
concreteWhitelistDatabaseNames,
string.Empty))
// Return the actual value from this method - no need to mock it.
.Returns(_db2QueryHelperConcrete.GetTableDetailsForEnvironmentQueryFormatted(
"main.TestSchemaTableModel",
concreteWhitelistDatabaseNames,
string.Empty));
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// Act
var result = await dbSchemaScrapeAccess.GetDatabasesByCreatorAsync(
MatchingCreatorString, MatchingLocationString, new List <string> {
DatabaseNameNotInOurInternalDataSet
});
// Assert
// AS we are using a Database name not in our test dataset, should be 0 results.
result.As <List <SchemaDatabaseModel> >().Count.Should().Be(0);
}
public async Task BuildAliasTablesResultSetListForAllEnvironments_PhysicalTableExistsInEnvironmentWithSameNameAsAliasTable_MessageLoggedAndPhysicalPreferred()
{
// Arrange
_db2QueryHelper.Setup(x => x.GetAliasTableDetailsWithinWhitelistedDatabaseNamesToMatch(
It.IsAny <string>(),
It.IsAny <List <string> >(),
It.IsAny <List <string> >()))
// Return the actual value from this method - no need to mock it.
.Returns(_db2QueryHelperConcrete.GetAliasTableDetailsWithinWhitelistedDatabaseNamesToMatch(
"main.TestSchemaTableModel",
_listSchemaTables.Where(t => t.TYPE == RelevantTableTypes[0]).Select(t => t.NAME).ToList(),
new List <string> {
MatchingDatabase1String
}));
// Insert another table with the same name into the in-memory database as the Alias table to act as the 'Physical' table.
var newTestInMemoryDatabase = new TestInMemoryDatabase();
_listSchemaTables.Add(new TestSchemaTableModel
{
Id = 0,
NAME = "ALIASTABLE1",
DBNAME = MatchingDatabase1String,
// This is type = 'T' for physical Table.
TYPE = RelevantTableTypes[1],
CREATOR = MatchingCreatorString
});
// Insert a column into this physical table.
_listSchemaColumns.Add(new TestSchemaColumnModel
{
Id = 100,
NAME = "COLUMN1",
TBNAME = "ALIASTABLE1",
COLNO = "1",
KEYSEQ = "1",
LENGTH = "1",
COLTYPE = "1",
NULLS = "0",
DEFAULT = "0",
SCALE = "0",
TBCREATOR = MatchingCreatorString
});
newTestInMemoryDatabase.Insert(_listSchemaTables);
newTestInMemoryDatabase.Insert(_listSchemaColumns);
var dbSchemaScrapeAccess = new Db2SchemaScrapeAccess(_logger.Object, _dbConnection.Object, _db2QueryHelper.Object);
// This is the return collection
var returnAliasTableCollection = _listSchemaTables
.Select(x => new SchemaTableModel
{
Type = x.TYPE,
AliasTableLocation = x.LOCATION,
Name = x.NAME,
AliasTableName = x.NAME,
AliasTableEnvironment = MatchingCreatorString,
DatabaseName = x.DBNAME,
SchemaColumns = new List <SchemaColumnModel>
{
new SchemaColumnModel
{
Name = ""
}
}
})
.ToList();
try
{
// Act
await dbSchemaScrapeAccess.BuildAliasTablesResultSetListForAllEnvironments(
MatchingLocationString,
new List <string> {
MatchingDatabase1String
},
returnAliasTableCollection,
newTestInMemoryDatabase.OpenConnection(),
string.Empty);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
// Assert
_logger.Verify(x => x.LogInformation(
It.Is <string>(s => s.Contains("A physical Table with existing Columns was found in the original TablesResultSetMasterList")),
It.IsAny <string>(),
It.IsAny <string>()), Times.Once);
}
