public static async Task GetRoutine_WhenGivenNonMatchingRoutineName_ReturnsNone()
{
var identifierDefaults = new IdentifierDefaults("test_server", "test_database", "test_schema");
var identifierResolver = new VerbatimIdentifierResolutionStrategy();
var tables = Array.Empty<IRelationalDatabaseTable>();
var views = Array.Empty<IDatabaseView>();
var sequences = Array.Empty<IDatabaseSequence>();
var synonyms = Array.Empty<IDatabaseSynonym>();
var testRoutineName = Identifier.CreateQualifiedIdentifier("test_routine_name");
var routine = new Mock<IDatabaseRoutine>();
routine.Setup(t => t.Name).Returns(testRoutineName);
var routines = new[] { routine.Object };
var database = new RelationalDatabase(
identifierDefaults,
identifierResolver,
tables,
views,
sequences,
synonyms,
routines
);
var dbRoutine = await database.GetRoutine("missing_routine_name").ToOption().ConfigureAwait(false);
Assert.That(dbRoutine, OptionIs.None);
}
public static async Task GetAllRoutines_WhenInvoked_ReturnsRoutinesFromCtor()
{
var identifierDefaults = new IdentifierDefaults("test_server", "test_database", "test_schema");
var identifierResolver = new VerbatimIdentifierResolutionStrategy();
var tables = Array.Empty<IRelationalDatabaseTable>();
var views = Array.Empty<IDatabaseView>();
var sequences = Array.Empty<IDatabaseSequence>();
var synonyms = Array.Empty<IDatabaseSynonym>();
var testRoutineName = Identifier.CreateQualifiedIdentifier("test_routine_name");
var routine = new Mock<IDatabaseRoutine>();
routine.Setup(t => t.Name).Returns(testRoutineName);
var routines = new[] { routine.Object };
var database = new RelationalDatabase(
identifierDefaults,
identifierResolver,
tables,
views,
sequences,
synonyms,
routines
);
var dbRoutines = await database.GetAllRoutines().ToListAsync().ConfigureAwait(false);
var routineName = dbRoutines.Select(r => r.Name).Single();
Assert.That(routineName, Is.EqualTo(testRoutineName));
}
public static async Task GetSynonym_WhenGivenMatchingSynonymName_ReturnsSynonymFromCtor()
{
var identifierDefaults = new IdentifierDefaults("test_server", "test_database", "test_schema");
var identifierResolver = new VerbatimIdentifierResolutionStrategy();
var tables = Array.Empty<IRelationalDatabaseTable>();
var views = Array.Empty<IDatabaseView>();
var sequences = Array.Empty<IDatabaseSequence>();
var testSynonymName = Identifier.CreateQualifiedIdentifier("test_synonym_name");
var synonym = new Mock<IDatabaseSynonym>();
synonym.Setup(t => t.Name).Returns(testSynonymName);
var synonyms = new[] { synonym.Object };
var routines = Array.Empty<IDatabaseRoutine>();
var database = new RelationalDatabase(
identifierDefaults,
identifierResolver,
tables,
views,
sequences,
synonyms,
routines
);
var dbSynonym = await database.GetSynonym(testSynonymName).ToOption().ConfigureAwait(false);
var synonymName = dbSynonym.Match(s => s.Name.LocalName, string.Empty);
Assert.Multiple(() =>
{
Assert.That(dbSynonym, OptionIs.Some);
Assert.That(synonymName, Is.EqualTo(testSynonymName.LocalName));
});
}
public static async Task SnapshotAsync_WhenGivenRelationalDatabaseWithObjects_ReturnsDatabaseWithMatchingObjectsInGetAllObjects()
{
var identifierDefaults = new IdentifierDefaults("test_server", "test_database", "test_schema");
var identifierResolver = new VerbatimIdentifierResolutionStrategy();
var testTableName = Identifier.CreateQualifiedIdentifier("test_table_name");
var table = new Mock<IRelationalDatabaseTable>();
table.Setup(t => t.Name).Returns(testTableName);
var tables = new[] { table.Object };
var testViewName = Identifier.CreateQualifiedIdentifier("test_view_name");
var view = new Mock<IDatabaseView>();
view.Setup(t => t.Name).Returns(testViewName);
var views = new[] { view.Object };
var testSequenceName = Identifier.CreateQualifiedIdentifier("test_sequence_name");
var sequence = new Mock<IDatabaseSequence>();
sequence.Setup(t => t.Name).Returns(testSequenceName);
var sequences = new[] { sequence.Object };
var testSynonymName = Identifier.CreateQualifiedIdentifier("test_synonym_name");
var synonym = new Mock<IDatabaseSynonym>();
synonym.Setup(t => t.Name).Returns(testSynonymName);
var synonyms = new[] { synonym.Object };
var testRoutineName = Identifier.CreateQualifiedIdentifier("test_routine_name");
var routine = new Mock<IDatabaseRoutine>();
routine.Setup(t => t.Name).Returns(testRoutineName);
var routines = new[] { routine.Object };
var database = new RelationalDatabase(
identifierDefaults,
identifierResolver,
tables,
views,
sequences,
synonyms,
routines
);
var snapshot = await RelationalDatabase.SnapshotAsync(database, identifierResolver).ConfigureAwait(false);
var snapshotTables = await snapshot.GetAllTables().ToListAsync().ConfigureAwait(false);
var snapshotViews = await snapshot.GetAllViews().ToListAsync().ConfigureAwait(false);
var snapshotSequences = await snapshot.GetAllSequences().ToListAsync().ConfigureAwait(false);
var snapshotSynonyms = await snapshot.GetAllSynonyms().ToListAsync().ConfigureAwait(false);
var snapshotRoutines = await snapshot.GetAllRoutines().ToListAsync().ConfigureAwait(false);
Assert.Multiple(() =>
{
Assert.That(snapshotTables, Is.EqualTo(tables));
Assert.That(snapshotViews, Is.EqualTo(views));
Assert.That(snapshotSequences, Is.EqualTo(sequences));
Assert.That(snapshotSynonyms, Is.EqualTo(synonyms));
Assert.That(snapshotRoutines, Is.EqualTo(routines));
});
}
public static void GetResolutionOrder_GivenIdentifier_ReturnsIdenticalIdentifier()
{
var resolver = new VerbatimIdentifierResolutionStrategy();
var input = new Identifier("A", "B", "C", "D");
var results = resolver.GetResolutionOrder(input).ToList();
Assert.Multiple(() =>
{
Assert.That(results, Has.Exactly(1).Items);
Assert.That(results[0], Is.EqualTo(input));
});
}
public static void Ctor_GivenNullViews_ThrowsArgumentNullException()
{
var identifierDefaults = new IdentifierDefaults("test_server", "test_database", "test_schema");
var identifierResolver = new VerbatimIdentifierResolutionStrategy();
var tables = Array.Empty<IRelationalDatabaseTable>();
var sequences = Array.Empty<IDatabaseSequence>();
var synonyms = Array.Empty<IDatabaseSynonym>();
var routines = Array.Empty<IDatabaseRoutine>();
Assert.That(
() => new RelationalDatabase(
identifierDefaults,
identifierResolver,
tables,
null,
sequences,
synonyms,
routines
),
Throws.ArgumentNullException
);
}
public static async Task SnapshotAsync_WhenGivenEmptyRelationalDatabase_ReturnsDatabaseWithMatchingIdentifierDefaults()
{
var identifierDefaults = new IdentifierDefaults("test_server", "test_database", "test_schema");
var identifierResolver = new VerbatimIdentifierResolutionStrategy();
var database = new RelationalDatabase(
identifierDefaults,
identifierResolver,
Array.Empty<IRelationalDatabaseTable>(),
Array.Empty<IDatabaseView>(),
Array.Empty<IDatabaseSequence>(),
Array.Empty<IDatabaseSynonym>(),
Array.Empty<IDatabaseRoutine>()
);
var snapshot = await RelationalDatabase.SnapshotAsync(database, identifierResolver).ConfigureAwait(false);
Assert.Multiple(() =>
{
Assert.That(snapshot.IdentifierDefaults.Server, Is.EqualTo(identifierDefaults.Server));
Assert.That(snapshot.IdentifierDefaults.Database, Is.EqualTo(identifierDefaults.Database));
Assert.That(snapshot.IdentifierDefaults.Schema, Is.EqualTo(identifierDefaults.Schema));
});
}
public static void GetColumnLookup_ForIdentifierResolvingOverloadGivenNullView_ThrowsArgumentNullException()
{
var resolver = new VerbatimIdentifierResolutionStrategy();
Assert.That(() => DatabaseViewExtensions.GetColumnLookup(null, resolver), Throws.ArgumentNullException);
}
public static void GetCheckLookup_ForIdentifierResolvingOverloadGivenNullTable_ThrowsArgumentNullException()
{
var resolver = new VerbatimIdentifierResolutionStrategy();
Assert.That(() => RelationalDatabaseTableExtensions.GetCheckLookup(null, resolver), Throws.ArgumentNullException);
}
public static void GetResolutionOrder_GivenNullIdentifier_ThrowsArgumentNullException()
{
var resolver = new VerbatimIdentifierResolutionStrategy();
Assert.That(() => resolver.GetResolutionOrder(null), Throws.ArgumentNullException);
}
