protected void OnSchemaInitialized(string appName, SchemaInitializer initializer)
{
if (SchemaInitialized != null)
{
SchemaInitialized(appName, initializer);
}
}
protected void OnSchemaInitialized(SchemaInitializer initializer)
{
if (SchemaInitialized != null)
{
SchemaInitialized(this, initializer);
}
}
private async Task CreateDatabaseIfNotExists(string databaseName, CancellationToken cancellationToken)
{
using (var connection = await _sqlConnectionFactory.GetSqlConnectionAsync(cancellationToken: cancellationToken))
{
await connection.TryOpenAsync(cancellationToken);
bool doesDatabaseExist = await SchemaInitializer.DoesDatabaseExistAsync(connection, databaseName, cancellationToken);
if (!doesDatabaseExist)
{
_logger.LogInformation("The database does not exists.");
bool created = await SchemaInitializer.CreateDatabaseAsync(connection, databaseName, cancellationToken);
if (created)
{
_logger.LogInformation("The database is created.");
}
else
{
throw new SchemaManagerException(Resources.InsufficientDatabasePermissionsMessage);
}
}
}
}
///<inheritdoc/>
public virtual void LoadDbAdapter()
{
Config.FilterSchema = SchemaName;
Config.IncludedTable = DbObjectName;
Config.LoadUserDefinedTables(Connector, AppDbContext);
Config.DatabaseConnectorName = Connector.Name;
SchemaInitializer.Initilize();
}
public SqlServerFhirStorageTestsFixture()
{
var initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;
_databaseName = $"FHIRINTEGRATIONTEST_{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}_{BigInteger.Abs(new BigInteger(Guid.NewGuid().ToByteArray()))}";
_masterConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = "master"
}.ToString();
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = _databaseName
}.ToString();
var config = new SqlServerDataStoreConfiguration {
ConnectionString = TestConnectionString, Initialize = true
};
var schemaUpgradeRunner = new SchemaUpgradeRunner(config, NullLogger <SchemaUpgradeRunner> .Instance);
var schemaInformation = new SchemaInformation();
_schemaInitializer = new SchemaInitializer(config, schemaUpgradeRunner, schemaInformation, NullLogger <SchemaInitializer> .Instance);
var searchParameterDefinitionManager = Substitute.For <ISearchParameterDefinitionManager>();
searchParameterDefinitionManager.AllSearchParameters.Returns(new[]
{
new SearchParameter {
Name = SearchParameterNames.Id, Type = SearchParamType.Token, Url = SearchParameterNames.IdUri.ToString()
}.ToInfo(),
new SearchParameter {
Name = SearchParameterNames.LastUpdated, Type = SearchParamType.Date, Url = SearchParameterNames.LastUpdatedUri.ToString()
}.ToInfo(),
});
var securityConfiguration = new SecurityConfiguration {
PrincipalClaims = { "oid" }
};
var sqlServerFhirModel = new SqlServerFhirModel(config, schemaInformation, searchParameterDefinitionManager, Options.Create(securityConfiguration), NullLogger <SqlServerFhirModel> .Instance);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSqlServerTableRowParameterGenerators();
serviceCollection.AddSingleton(sqlServerFhirModel);
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
var upsertResourceTvpGenerator = serviceProvider.GetRequiredService <V1.UpsertResourceTvpGenerator <ResourceMetadata> >();
var searchParameterToSearchValueTypeMap = new SearchParameterToSearchValueTypeMap(searchParameterDefinitionManager);
SqlTransactionHandler = new SqlTransactionHandler();
SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(config, SqlTransactionHandler);
_fhirDataStore = new SqlServerFhirDataStore(config, sqlServerFhirModel, searchParameterToSearchValueTypeMap, upsertResourceTvpGenerator, Options.Create(new CoreFeatureConfiguration()), SqlConnectionWrapperFactory, NullLogger <SqlServerFhirDataStore> .Instance);
_testHelper = new SqlServerFhirStorageTestHelper(TestConnectionString);
}
// Only 1 public constructor is allowed for test fixture.
internal SqlDataStoreTestsFixture(string databaseName)
{
EnsureArg.IsNotNullOrEmpty(databaseName, nameof(databaseName));
_databaseName = databaseName;
string initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;
_masterConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = "master"
}.ToString();
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = _databaseName
}.ToString();
var config = new SqlServerDataStoreConfiguration
{
ConnectionString = TestConnectionString,
Initialize = true,
SchemaOptions = new SqlServerSchemaOptions
{
AutomaticUpdatesEnabled = true,
},
};
var scriptProvider = new ScriptProvider <SchemaVersion>();
var baseScriptProvider = new BaseScriptProvider();
var mediator = Substitute.For <IMediator>();
var sqlConnectionStringProvider = new DefaultSqlConnectionStringProvider(config);
var sqlConnectionFactory = new DefaultSqlConnectionFactory(sqlConnectionStringProvider);
var schemaManagerDataStore = new SchemaManagerDataStore(sqlConnectionFactory);
var schemaUpgradeRunner = new SchemaUpgradeRunner(scriptProvider, baseScriptProvider, mediator, NullLogger <SchemaUpgradeRunner> .Instance, sqlConnectionFactory, schemaManagerDataStore);
var schemaInformation = new SchemaInformation(SchemaVersionConstants.Min, SchemaVersionConstants.Max);
_schemaInitializer = new SchemaInitializer(config, schemaUpgradeRunner, schemaInformation, sqlConnectionFactory, sqlConnectionStringProvider, NullLogger <SchemaInitializer> .Instance);
SqlTransactionHandler = new SqlTransactionHandler();
SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(SqlTransactionHandler, new SqlCommandWrapperFactory(), sqlConnectionFactory);
SqlIndexDataStoreFactory = new SqlIndexDataStoreFactory(
schemaInformation,
new[] { new SqlIndexDataStoreV1(SqlConnectionWrapperFactory), new SqlIndexDataStoreV2(SqlConnectionWrapperFactory) });
InstanceStore = new SqlInstanceStore(SqlConnectionWrapperFactory);
ExtendedQueryTagStore = new SqlExtendedQueryTagStore(SqlConnectionWrapperFactory, schemaInformation, NullLogger <SqlExtendedQueryTagStore> .Instance);
TestHelper = new SqlIndexDataStoreTestHelper(TestConnectionString);
}
public SqlDataStoreTestsFixture()
{
string initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;
_databaseName = $"DICOMINTEGRATIONTEST_{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}_{BigInteger.Abs(new BigInteger(Guid.NewGuid().ToByteArray()))}";
_masterConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = "master"
}.ToString();
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = _databaseName
}.ToString();
var config = new SqlServerDataStoreConfiguration
{
ConnectionString = TestConnectionString,
Initialize = true,
SchemaOptions = new SqlServerSchemaOptions
{
AutomaticUpdatesEnabled = true,
},
};
var scriptProvider = new ScriptProvider <SchemaVersion>();
var baseScriptProvider = new BaseScriptProvider();
var mediator = Substitute.For <IMediator>();
var sqlConnectionStringProvider = new DefaultSqlConnectionStringProvider(config);
var sqlConnectionFactory = new DefaultSqlConnectionFactory(sqlConnectionStringProvider);
var schemaManagerDataStore = new SchemaManagerDataStore(sqlConnectionFactory);
var schemaUpgradeRunner = new SchemaUpgradeRunner(scriptProvider, baseScriptProvider, mediator, NullLogger <SchemaUpgradeRunner> .Instance, sqlConnectionFactory, schemaManagerDataStore);
var schemaInformation = new SchemaInformation((int)SchemaVersion.V1, (int)SchemaVersion.V1);
_schemaInitializer = new SchemaInitializer(config, schemaUpgradeRunner, schemaInformation, sqlConnectionFactory, sqlConnectionStringProvider, NullLogger <SchemaInitializer> .Instance);
var dicomSqlIndexSchema = new SqlIndexSchema(schemaInformation, NullLogger <SqlIndexSchema> .Instance);
SqlTransactionHandler = new SqlTransactionHandler();
SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(SqlTransactionHandler, new SqlCommandWrapperFactory(), sqlConnectionFactory);
IndexDataStore = new SqlIndexDataStore(
dicomSqlIndexSchema,
SqlConnectionWrapperFactory);
InstanceStore = new SqlInstanceStore(SqlConnectionWrapperFactory);
TestHelper = new SqlIndexDataStoreTestHelper(TestConnectionString);
}
///<inheritdoc/>
public void ConfigureAction(Connector connector, OperationType dbAction, string dbObjectName)
{
Check.NotNull(connector, nameof(connector));
Connector = connector;
DbObjectName = dbObjectName;
var connectionInfo = _connctionStringFactory.GetConnectionInformation(Connector.ResourceType, Connector.ConnectionStringDecrypted);
Connector.SetConnectionInfo(connectionInfo);
SchemaInitializer.ConfigureAction(connector, dbAction);
}
public virtual async Task InitializeAsync()
{
SqlConnectionStringBuilder connectionBuilder = new SqlConnectionStringBuilder(Config.ConnectionString);
connectionBuilder.InitialCatalog = "master";
Connection = new SqlConnection(connectionBuilder.ToString());
await Connection.OpenAsync();
await SchemaInitializer.CreateDatabaseAsync(Connection, DatabaseName, CancellationToken.None);
await Connection.ChangeDatabaseAsync(DatabaseName);
Output.WriteLine($"Using database '{DatabaseName}'.");
}
public void InitializeSchema()
{
var config = new Config();
var schemaBuilder = new Mock <IDbSchemaBuilder>();
var schmea = new SchemaInitializer(config,
schemaBuilder.Object, Mock.Of <IDbSchema>());
schmea.Initilize();
schemaBuilder.Verify(c => c.GetTableViews(), Times.Once);
schemaBuilder.Verify(c => c.GetStoredProcedures(), Times.Once);
}
public void ConfgiureAction()
{
var config = new Config();
var schemaBuilder = new Mock <IDbSchemaBuilder>();
var schmea = new SchemaInitializer(config,
schemaBuilder.Object, Mock.Of <IDbSchema>());
schmea.ConfigureAction(new Connector {
ConnectionStringDecrypted = "conn1"
}, OperationType.read);
Assert.AreEqual("conn1", config.ConnectionString);
}
private async Task InitializeAsync(CancellationToken cancellationToken)
{
var configuredConnectionBuilder = new SqlConnectionStringBuilder(_sqlServerDataStoreConfiguration.ConnectionString);
string databaseName = configuredConnectionBuilder.InitialCatalog;
SchemaInitializer.ValidateDatabaseName(databaseName);
SqlConnectionStringBuilder connectionBuilder = new SqlConnectionStringBuilder(_sqlServerDataStoreConfiguration.ConnectionString)
{
InitialCatalog = string.Empty
};
using (var connection = new SqlConnection(connectionBuilder.ToString()))
{
bool doesDatabaseExist = await SchemaInitializer.DoesDatabaseExistAsync(connection, databaseName, cancellationToken);
// database creation is allowed
if (!doesDatabaseExist)
{
Console.WriteLine("The database does not exists.");
bool created = await SchemaInitializer.CreateDatabaseAsync(connection, databaseName, cancellationToken);
if (created)
{
Console.WriteLine("The database is created.");
}
else
{
throw new SchemaManagerException(Resources.InsufficientDatabasePermissionsMessage);
}
connection.Close();
}
}
bool canInitialize = false;
// now switch to the target database
using (var connection = await _sqlConnectionFactory.GetSqlConnectionAsync(cancellationToken: cancellationToken))
{
canInitialize = await SchemaInitializer.CheckDatabasePermissionsAsync(connection, cancellationToken);
}
if (!canInitialize)
{
throw new SchemaManagerException(Resources.InsufficientTablesPermissionsMessage);
}
}
public async Task DatabaseExists_DoesDatabaseExistAsync_ReturnsTrue()
{
const string dbName = "willexist";
try
{
Assert.False(await SchemaInitializer.DoesDatabaseExistAsync(Connection, dbName, CancellationToken.None));
Assert.True(await SchemaInitializer.CreateDatabaseAsync(Connection, dbName, CancellationToken.None));
Assert.True(await SchemaInitializer.DoesDatabaseExistAsync(Connection, dbName, CancellationToken.None));
}
finally
{
await DeleteDatabaseAsync(dbName);
}
}
public void InitializeTable()
{
var config = new Config
{
IncludedTable = "tbl"
};
var schemaBuilder = new Mock <IDbSchemaBuilder>();
var schmea = new SchemaInitializer(config,
schemaBuilder.Object, Mock.Of <IDbSchema>()
);
schmea.Initilize();
schemaBuilder.Verify(c => c.GetColumns(), Times.Once);
}
public SqlServerFhirModel(
SqlServerDataStoreConfiguration configuration,
SchemaInitializer schemaInitializer,
ISearchParameterDefinitionManager searchParameterDefinitionManager,
IOptions <SecurityConfiguration> securityConfiguration,
ILogger <SqlServerFhirModel> logger)
{
EnsureArg.IsNotNull(configuration, nameof(configuration));
EnsureArg.IsNotNull(schemaInitializer, nameof(schemaInitializer));
EnsureArg.IsNotNull(searchParameterDefinitionManager, nameof(searchParameterDefinitionManager));
EnsureArg.IsNotNull(securityConfiguration?.Value, nameof(securityConfiguration));
EnsureArg.IsNotNull(logger, nameof(logger));
_configuration = configuration;
_schemaInitializer = schemaInitializer;
_searchParameterDefinitionManager = searchParameterDefinitionManager;
_securityConfiguration = securityConfiguration.Value;
_logger = logger;
}
private async Task InitializeAsync(CancellationToken cancellationToken)
{
string sqlConnectionString = await _sqlConnectionStringProvider.GetSqlConnectionString(cancellationToken);
var configuredConnectionBuilder = new SqlConnectionStringBuilder(sqlConnectionString);
string databaseName = configuredConnectionBuilder.InitialCatalog;
SchemaInitializer.ValidateDatabaseName(databaseName);
await CreateDatabaseIfNotExists(databaseName, cancellationToken);
bool canInitialize = false;
// now switch to the target database
using (var connection = await _sqlConnectionFactory.GetSqlConnectionAsync(cancellationToken: cancellationToken))
{
canInitialize = await SchemaInitializer.CheckDatabasePermissionsAsync(connection, cancellationToken);
}
if (!canInitialize)
{
throw new SchemaManagerException(Resources.InsufficientTablesPermissionsMessage);
}
}
public void CorrectlyInitializesSchema()
{
string assembly = Tarantino.Core.DatabaseManager.Services.Impl.SqlDatabaseManager.SQL_FILE_ASSEMBLY;
string sqlFile = string.Format(Tarantino.Core.DatabaseManager.Services.Impl.SqlDatabaseManager.SQL_FILE_TEMPLATE, "CreateSchema");
ConnectionSettings settings =
new ConnectionSettings(String.Empty, String.Empty, false, String.Empty, String.Empty);
string sqlScript = "SQL script...";
MockRepository mocks = new MockRepository();
IResourceFileLocator fileLocator = mocks.CreateMock <IResourceFileLocator>();
IQueryExecutor queryExecutor = mocks.CreateMock <IQueryExecutor>();
Expect.Call(fileLocator.ReadTextFile(assembly, sqlFile)).Return(sqlScript);
queryExecutor.ExecuteNonQuery(settings, sqlScript, true);
mocks.ReplayAll();
ISchemaInitializer versioner = new SchemaInitializer(fileLocator, queryExecutor);
versioner.EnsureSchemaCreated(settings);
mocks.VerifyAll();
}
internal SqlDataStoreTestsFixture(string databaseName, SchemaInformation schemaInformation)
{
DatabaseName = EnsureArg.IsNotNullOrEmpty(databaseName, nameof(databaseName));
SchemaInformation = EnsureArg.IsNotNull(schemaInformation, nameof(schemaInformation));
IConfiguration environment = new ConfigurationBuilder()
.AddEnvironmentVariables()
.Build();
string initialConnectionString = environment["SqlServer:ConnectionString"] ?? LocalConnectionString;
_masterConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = "master"
}.ToString();
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = DatabaseName
}.ToString();
var config = new SqlServerDataStoreConfiguration
{
ConnectionString = TestConnectionString,
Initialize = true,
SchemaOptions = new SqlServerSchemaOptions
{
AutomaticUpdatesEnabled = true,
},
};
IOptions <SqlServerDataStoreConfiguration> configOptions = Options.Create(config);
var scriptProvider = new ScriptProvider <SchemaVersion>();
var baseScriptProvider = new BaseScriptProvider();
var mediator = Substitute.For <IMediator>();
var sqlConnectionStringProvider = new DefaultSqlConnectionStringProvider(configOptions);
var sqlConnectionFactory = new DefaultSqlConnectionFactory(sqlConnectionStringProvider);
var schemaManagerDataStore = new SchemaManagerDataStore(sqlConnectionFactory, configOptions, NullLogger <SchemaManagerDataStore> .Instance);
SchemaUpgradeRunner = new SchemaUpgradeRunner(scriptProvider, baseScriptProvider, NullLogger <SchemaUpgradeRunner> .Instance, sqlConnectionFactory, schemaManagerDataStore);
_schemaInitializer = new SchemaInitializer(configOptions, schemaManagerDataStore, SchemaUpgradeRunner, SchemaInformation, sqlConnectionFactory, sqlConnectionStringProvider, mediator, NullLogger <SchemaInitializer> .Instance);
SqlTransactionHandler = new SqlTransactionHandler();
SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(SqlTransactionHandler, new SqlCommandWrapperFactory(), sqlConnectionFactory);
var schemaResolver = new PassthroughSchemaVersionResolver(SchemaInformation);
IndexDataStore = new SqlIndexDataStore(new VersionedCache <ISqlIndexDataStore>(
schemaResolver,
new[]
{
new SqlIndexDataStoreV1(SqlConnectionWrapperFactory),
new SqlIndexDataStoreV2(SqlConnectionWrapperFactory),
new SqlIndexDataStoreV3(SqlConnectionWrapperFactory),
new SqlIndexDataStoreV4(SqlConnectionWrapperFactory),
new SqlIndexDataStoreV5(SqlConnectionWrapperFactory),
new SqlIndexDataStoreV6(SqlConnectionWrapperFactory),
}));
InstanceStore = new SqlInstanceStore(new VersionedCache <ISqlInstanceStore>(
schemaResolver,
new[]
{
new SqlInstanceStoreV1(SqlConnectionWrapperFactory),
new SqlInstanceStoreV4(SqlConnectionWrapperFactory),
new SqlInstanceStoreV6(SqlConnectionWrapperFactory),
}));
PartitionStore = new SqlPartitionStore(new VersionedCache <ISqlPartitionStore>(
schemaResolver,
new[]
{
new SqlPartitionStoreV6(SqlConnectionWrapperFactory),
}));
ExtendedQueryTagStore = new SqlExtendedQueryTagStore(new VersionedCache <ISqlExtendedQueryTagStore>(
schemaResolver,
new[]
{
new SqlExtendedQueryTagStoreV1(),
new SqlExtendedQueryTagStoreV2(SqlConnectionWrapperFactory, NullLogger <SqlExtendedQueryTagStoreV2> .Instance),
new SqlExtendedQueryTagStoreV4(SqlConnectionWrapperFactory, NullLogger <SqlExtendedQueryTagStoreV4> .Instance),
new SqlExtendedQueryTagStoreV8(SqlConnectionWrapperFactory, NullLogger <SqlExtendedQueryTagStoreV8> .Instance),
}));
ExtendedQueryTagErrorStore = new SqlExtendedQueryTagErrorStore(new VersionedCache <ISqlExtendedQueryTagErrorStore>(
schemaResolver,
new[]
{
new SqlExtendedQueryTagErrorStoreV1(),
new SqlExtendedQueryTagErrorStoreV4(SqlConnectionWrapperFactory, NullLogger <SqlExtendedQueryTagErrorStoreV4> .Instance),
new SqlExtendedQueryTagErrorStoreV6(SqlConnectionWrapperFactory, NullLogger <SqlExtendedQueryTagErrorStoreV6> .Instance),
}));
IndexDataStoreTestHelper = new SqlIndexDataStoreTestHelper(TestConnectionString);
ExtendedQueryTagStoreTestHelper = new ExtendedQueryTagStoreTestHelper(TestConnectionString);
ExtendedQueryTagErrorStoreTestHelper = new ExtendedQueryTagErrorStoreTestHelper(TestConnectionString);
}
private async Task <(SqlServerFhirStorageTestHelper testHelper, SchemaUpgradeRunner upgradeRunner)> SetupTestHelperAndCreateDatabase(string databaseName, int maxSchemaVersion, bool forceIncrementalSchemaUpgrade)
{
var initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;
var searchService = Substitute.For <ISearchService>();
ISearchParameterDefinitionManager defManager = new SearchParameterDefinitionManager(ModelInfoProvider.Instance, Substitute.For <IMediator>(), () => searchService.CreateMockScope(), NullLogger <SearchParameterDefinitionManager> .Instance);
FilebasedSearchParameterStatusDataStore statusStore = new FilebasedSearchParameterStatusDataStore(defManager, ModelInfoProvider.Instance);
var schemaInformation = new SchemaInformation(SchemaVersionConstants.Min, maxSchemaVersion);
var connectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = databaseName
}.ToString();
var schemaOptions = new SqlServerSchemaOptions {
AutomaticUpdatesEnabled = true
};
var config = new SqlServerDataStoreConfiguration {
ConnectionString = connectionString, Initialize = true, SchemaOptions = schemaOptions
};
var sqlConnectionStringProvider = new DefaultSqlConnectionStringProvider(config);
var securityConfiguration = new SecurityConfiguration {
PrincipalClaims = { "oid" }
};
SqlServerFhirModel sqlServerFhirModel = new SqlServerFhirModel(
schemaInformation,
defManager,
() => statusStore,
Options.Create(securityConfiguration),
sqlConnectionStringProvider,
Substitute.For <IMediator>(),
NullLogger <SqlServerFhirModel> .Instance);
var sqlConnectionFactory = new DefaultSqlConnectionFactory(sqlConnectionStringProvider);
var testHelper = new SqlServerFhirStorageTestHelper(
initialConnectionString,
MasterDatabaseName,
sqlServerFhirModel,
sqlConnectionFactory);
var scriptProvider = new ScriptProvider <SchemaVersion>();
var baseScriptProvider = new BaseScriptProvider();
var mediator = Substitute.For <IMediator>();
var schemaManagerDataStore = new SchemaManagerDataStore(sqlConnectionFactory);
var schemaUpgradeRunner = new SchemaUpgradeRunner(
scriptProvider,
baseScriptProvider,
NullLogger <SchemaUpgradeRunner> .Instance,
sqlConnectionFactory,
schemaManagerDataStore);
var schemaInitializer = new SchemaInitializer(
config,
schemaUpgradeRunner,
schemaInformation,
sqlConnectionFactory,
sqlConnectionStringProvider,
mediator,
NullLogger <SchemaInitializer> .Instance);
await testHelper.CreateAndInitializeDatabase(
databaseName,
maxSchemaVersion,
forceIncrementalSchemaUpgrade,
schemaInitializer);
return(testHelper, schemaUpgradeRunner);
}
internal SqlServerFhirStorageTestsFixture(int maximumSupportedSchemaVersion, string databaseName, IOptions <CoreFeatureConfiguration> coreFeatures = null)
{
var initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;
_maximumSupportedSchemaVersion = maximumSupportedSchemaVersion;
_databaseName = databaseName;
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = _databaseName
}.ToString();
var schemaOptions = new SqlServerSchemaOptions {
AutomaticUpdatesEnabled = true
};
var config = Options.Create(new SqlServerDataStoreConfiguration {
ConnectionString = TestConnectionString, Initialize = true, SchemaOptions = schemaOptions, StatementTimeout = TimeSpan.FromMinutes(10)
});
SchemaInformation = new SchemaInformation(SchemaVersionConstants.Min, maximumSupportedSchemaVersion);
var scriptProvider = new ScriptProvider <SchemaVersion>();
var baseScriptProvider = new BaseScriptProvider();
var mediator = Substitute.For <IMediator>();
var sqlSortingValidator = new SqlServerSortingValidator(SchemaInformation);
var sqlConnectionStringProvider = new DefaultSqlConnectionStringProvider(config);
SqlConnectionFactory = new DefaultSqlConnectionFactory(sqlConnectionStringProvider);
var schemaManagerDataStore = new SchemaManagerDataStore(SqlConnectionFactory, config, NullLogger <SchemaManagerDataStore> .Instance);
_schemaUpgradeRunner = new SchemaUpgradeRunner(scriptProvider, baseScriptProvider, NullLogger <SchemaUpgradeRunner> .Instance, SqlConnectionFactory, schemaManagerDataStore);
_schemaInitializer = new SchemaInitializer(config, schemaManagerDataStore, _schemaUpgradeRunner, SchemaInformation, SqlConnectionFactory, sqlConnectionStringProvider, mediator, NullLogger <SchemaInitializer> .Instance);
_searchParameterDefinitionManager = new SearchParameterDefinitionManager(ModelInfoProvider.Instance, _mediator, () => _searchService.CreateMockScope(), NullLogger <SearchParameterDefinitionManager> .Instance);
_searchParameterDefinitionManager.StartAsync(CancellationToken.None);
_filebasedSearchParameterStatusDataStore = new FilebasedSearchParameterStatusDataStore(_searchParameterDefinitionManager, ModelInfoProvider.Instance);
var securityConfiguration = new SecurityConfiguration {
PrincipalClaims = { "oid" }
};
var sqlServerFhirModel = new SqlServerFhirModel(
SchemaInformation,
_searchParameterDefinitionManager,
() => _filebasedSearchParameterStatusDataStore,
Options.Create(securityConfiguration),
SqlConnectionFactory,
Substitute.For <IMediator>(),
NullLogger <SqlServerFhirModel> .Instance);
SqlServerFhirModel = sqlServerFhirModel;
var searchParameterToSearchValueTypeMap = new SearchParameterToSearchValueTypeMap();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSqlServerTableRowParameterGenerators();
serviceCollection.AddSingleton(sqlServerFhirModel);
serviceCollection.AddSingleton <ISqlServerFhirModel>(sqlServerFhirModel);
serviceCollection.AddSingleton(searchParameterToSearchValueTypeMap);
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
var upsertResourceTvpGeneratorV6 = serviceProvider.GetRequiredService <V6.UpsertResourceTvpGenerator <ResourceMetadata> >();
var upsertResourceTvpGeneratorV7 = serviceProvider.GetRequiredService <V7.UpsertResourceTvpGenerator <ResourceMetadata> >();
var upsertResourceTvpGeneratorV13 = serviceProvider.GetRequiredService <V13.UpsertResourceTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var upsertResourceTvpGeneratorV17 = serviceProvider.GetRequiredService <V17.UpsertResourceTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var upsertResourceTvpGeneratorVLatest = serviceProvider.GetRequiredService <VLatest.UpsertResourceTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var reindexResourceTvpGeneratorV17 = serviceProvider.GetRequiredService <V17.ReindexResourceTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var bulkReindexResourceTvpGeneratorV17 = serviceProvider.GetRequiredService <V17.BulkReindexResourcesTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var reindexResourceTvpGeneratorVLatest = serviceProvider.GetRequiredService <VLatest.ReindexResourceTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var bulkReindexResourceTvpGeneratorVLatest = serviceProvider.GetRequiredService <VLatest.BulkReindexResourcesTvpGenerator <IReadOnlyList <ResourceWrapper> > >();
var upsertSearchParamsTvpGenerator = serviceProvider.GetRequiredService <VLatest.UpsertSearchParamsTvpGenerator <List <ResourceSearchParameterStatus> > >();
_supportedSearchParameterDefinitionManager = new SupportedSearchParameterDefinitionManager(_searchParameterDefinitionManager);
SqlTransactionHandler = new SqlTransactionHandler();
SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(SqlTransactionHandler, new SqlCommandWrapperFactory(), SqlConnectionFactory);
SqlServerSearchParameterStatusDataStore = new SqlServerSearchParameterStatusDataStore(
() => SqlConnectionWrapperFactory.CreateMockScope(),
upsertSearchParamsTvpGenerator,
() => _filebasedSearchParameterStatusDataStore,
SchemaInformation,
sqlSortingValidator,
sqlServerFhirModel,
_searchParameterDefinitionManager);
IOptions <CoreFeatureConfiguration> options = coreFeatures ?? Options.Create(new CoreFeatureConfiguration());
_fhirDataStore = new SqlServerFhirDataStore(
sqlServerFhirModel,
searchParameterToSearchValueTypeMap,
upsertResourceTvpGeneratorV6,
upsertResourceTvpGeneratorV7,
upsertResourceTvpGeneratorV13,
upsertResourceTvpGeneratorV17,
upsertResourceTvpGeneratorVLatest,
reindexResourceTvpGeneratorV17,
reindexResourceTvpGeneratorVLatest,
bulkReindexResourceTvpGeneratorV17,
bulkReindexResourceTvpGeneratorVLatest,
options,
SqlConnectionWrapperFactory,
new CompressedRawResourceConverter(),
NullLogger <SqlServerFhirDataStore> .Instance,
SchemaInformation);
_fhirOperationDataStore = new SqlServerFhirOperationDataStore(SqlConnectionWrapperFactory, NullLogger <SqlServerFhirOperationDataStore> .Instance);
_fhirRequestContextAccessor.RequestContext.CorrelationId.Returns(Guid.NewGuid().ToString());
_fhirRequestContextAccessor.RequestContext.RouteName.Returns("routeName");
var searchableSearchParameterDefinitionManager = new SearchableSearchParameterDefinitionManager(_searchParameterDefinitionManager, _fhirRequestContextAccessor);
var searchParameterExpressionParser = new SearchParameterExpressionParser(new ReferenceSearchValueParser(_fhirRequestContextAccessor));
var expressionParser = new ExpressionParser(() => searchableSearchParameterDefinitionManager, searchParameterExpressionParser);
var searchOptionsFactory = new SearchOptionsFactory(
expressionParser,
() => searchableSearchParameterDefinitionManager,
options,
_fhirRequestContextAccessor,
sqlSortingValidator,
NullLogger <SearchOptionsFactory> .Instance);
var searchParamTableExpressionQueryGeneratorFactory = new SearchParamTableExpressionQueryGeneratorFactory(searchParameterToSearchValueTypeMap);
var sqlRootExpressionRewriter = new SqlRootExpressionRewriter(searchParamTableExpressionQueryGeneratorFactory);
var chainFlatteningRewriter = new ChainFlatteningRewriter(searchParamTableExpressionQueryGeneratorFactory);
var sortRewriter = new SortRewriter(searchParamTableExpressionQueryGeneratorFactory);
var partitionEliminationRewriter = new PartitionEliminationRewriter(sqlServerFhirModel, SchemaInformation, () => searchableSearchParameterDefinitionManager);
_searchService = new SqlServerSearchService(
searchOptionsFactory,
_fhirDataStore,
sqlServerFhirModel,
sqlRootExpressionRewriter,
chainFlatteningRewriter,
sortRewriter,
partitionEliminationRewriter,
SqlConnectionWrapperFactory,
SchemaInformation,
_fhirRequestContextAccessor,
new CompressedRawResourceConverter(),
NullLogger <SqlServerSearchService> .Instance);
ISearchParameterSupportResolver searchParameterSupportResolver = Substitute.For <ISearchParameterSupportResolver>();
searchParameterSupportResolver.IsSearchParameterSupported(Arg.Any <SearchParameterInfo>()).Returns((true, false));
_searchParameterStatusManager = new SearchParameterStatusManager(
SqlServerSearchParameterStatusDataStore,
_searchParameterDefinitionManager,
searchParameterSupportResolver,
mediator,
NullLogger <SearchParameterStatusManager> .Instance);
_testHelper = new SqlServerFhirStorageTestHelper(initialConnectionString, MasterDatabaseName, sqlServerFhirModel, SqlConnectionFactory);
}
protected void OnSchemaInitialized(string appName, SchemaInitializer initializer)
{
SchemaInitialized?.Invoke(appName, initializer);
}
public async Task CreateAndInitializeDatabase(string databaseName, int maximumSupportedSchemaVersion, bool forceIncrementalSchemaUpgrade, SchemaInitializer schemaInitializer = null, CancellationToken cancellationToken = default)
{
var testConnectionString = new SqlConnectionStringBuilder(_initialConnectionString)
{
InitialCatalog = databaseName
}.ToString();
schemaInitializer ??= CreateSchemaInitializer(testConnectionString, maximumSupportedSchemaVersion);
await _dbSetupRetryPolicy.ExecuteAsync(async() =>
{
// Create the database.
await using SqlConnection connection = await _sqlConnectionFactory.GetSqlConnectionAsync(_masterDatabaseName, cancellationToken);
await connection.OpenAsync(cancellationToken);
await using SqlCommand command = connection.CreateCommand();
command.CommandTimeout = 600;
command.CommandText = @$ "
IF NOT EXISTS (SELECT * FROM sys.databases WHERE name = '{databaseName}')
BEGIN
CREATE DATABASE {databaseName};
END";
await command.ExecuteNonQueryAsync(cancellationToken);
});
///<inheritdoc/>
public virtual IEnumerable <string> ListSchemas()
{
SchemaInitializer.FindSchemas();
return(DbSchema.SchemaNames);
}
///<inheritdoc/>
public virtual void LoadProc()
{
Config.FilterSchema = SchemaName;
Config.IncludedStoredProcedure = DbObjectName;
SchemaInitializer.Initilize();
}
///<inheritdoc/>
public virtual void LoadSchema()
{
Config.FilterSchema = SchemaName;
Config.DatabaseConnectorName = Connector.Name;
SchemaInitializer.Initilize();
}
public async Task DatabaseDoesNotExist_DoesDatabaseExistAsync_ReturnsFalse()
{
Assert.False(await SchemaInitializer.DoesDatabaseExistAsync(Connection, "doesnotexist", CancellationToken.None));
}
public SqlServerFhirStorageTestsFixture()
{
var initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalDatabase.DefaultConnectionString;
_databaseName = $"FHIRINTEGRATIONTEST_{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}_{BigInteger.Abs(new BigInteger(Guid.NewGuid().ToByteArray()))}";
_masterConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = "master"
}.ToString();
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = _databaseName
}.ToString();
using (var connection = new SqlConnection(_masterConnectionString))
{
connection.Open();
using (SqlCommand command = connection.CreateCommand())
{
command.CommandTimeout = 600;
command.CommandText = $"CREATE DATABASE {_databaseName}";
command.ExecuteNonQuery();
}
}
var config = new SqlServerDataStoreConfiguration {
ConnectionString = TestConnectionString, Initialize = true
};
var schemaUpgradeRunner = new SchemaUpgradeRunner(config);
var schemaInformation = new SchemaInformation();
var schemaInitializer = new SchemaInitializer(config, schemaUpgradeRunner, schemaInformation, NullLogger <SchemaInitializer> .Instance);
schemaInitializer.Start();
var searchParameterDefinitionManager = Substitute.For <ISearchParameterDefinitionManager>();
searchParameterDefinitionManager.AllSearchParameters.Returns(new[]
{
new SearchParameter {
Id = SearchParameterNames.Id, Url = SearchParameterNames.IdUri.ToString()
},
new SearchParameter {
Id = SearchParameterNames.LastUpdated, Url = SearchParameterNames.LastUpdatedUri.ToString()
},
});
var securityConfiguration = new SecurityConfiguration {
PrincipalClaims = { "oid" }
};
var sqlServerFhirModel = new SqlServerFhirModel(config, schemaInformation, searchParameterDefinitionManager, Options.Create(securityConfiguration), NullLogger <SqlServerFhirModel> .Instance);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSqlServerTableRowParameterGenerators();
serviceCollection.AddSingleton(sqlServerFhirModel);
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
var upsertResourceTvpGenerator = serviceProvider.GetRequiredService <V1.UpsertResourceTvpGenerator <ResourceMetadata> >();
var searchParameterToSearchValueTypeMap = new SearchParameterToSearchValueTypeMap(searchParameterDefinitionManager);
_fhirDataStore = new SqlServerFhirDataStore(config, sqlServerFhirModel, searchParameterToSearchValueTypeMap, upsertResourceTvpGenerator, NullLogger <SqlServerFhirDataStore> .Instance);
_testHelper = new SqlServerFhirStorageTestHelper(TestConnectionString);
}
public async Task CreateAndInitializeDatabase(string databaseName, bool forceIncrementalSchemaUpgrade, SchemaInitializer schemaInitializer = null, CancellationToken cancellationToken = default)
{
var testConnectionString = new SqlConnectionStringBuilder(_initialConnectionString)
{
InitialCatalog = databaseName
}.ToString();
schemaInitializer = schemaInitializer ?? CreateSchemaInitializer(testConnectionString);
// Create the database.
using (var connection = new SqlConnection(_masterConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (SqlCommand command = connection.CreateCommand())
{
command.CommandTimeout = 600;
command.CommandText = $"CREATE DATABASE {databaseName}";
await command.ExecuteNonQueryAsync(cancellationToken);
}
}
// Verify that we can connect to the new database. This sometimes does not work right away with Azure SQL.
await Policy
.Handle <SqlException>()
.WaitAndRetryAsync(
retryCount: 7,
sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)))
.ExecuteAsync(async() =>
{
using (var connection = new SqlConnection(testConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (SqlCommand sqlCommand = connection.CreateCommand())
{
sqlCommand.CommandText = "SELECT 1";
await sqlCommand.ExecuteScalarAsync(cancellationToken);
}
}
});
schemaInitializer.Initialize(forceIncrementalSchemaUpgrade);
}
public SqlServerFhirStorageTestsFixture()
{
var initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;
_databaseName = $"FHIRINTEGRATIONTEST_{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}_{BigInteger.Abs(new BigInteger(Guid.NewGuid().ToByteArray()))}";
TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
{
InitialCatalog = _databaseName
}.ToString();
var schemaOptions = new SqlServerSchemaOptions {
AutomaticUpdatesEnabled = true
};
var config = new SqlServerDataStoreConfiguration {
ConnectionString = TestConnectionString, Initialize = true, SchemaOptions = schemaOptions
};
var schemaInformation = new SchemaInformation(SchemaVersionConstants.Min, SchemaVersionConstants.Max);
var scriptProvider = new ScriptProvider <SchemaVersion>();
var baseScriptProvider = new BaseScriptProvider();
var mediator = Substitute.For <IMediator>();
var sqlConnectionFactory = new DefaultSqlConnectionFactory(config);
var schemaUpgradeRunner = new SchemaUpgradeRunner(scriptProvider, baseScriptProvider, mediator, NullLogger <SchemaUpgradeRunner> .Instance, sqlConnectionFactory);
_schemaInitializer = new SchemaInitializer(config, schemaUpgradeRunner, schemaInformation, sqlConnectionFactory, NullLogger <SchemaInitializer> .Instance);
var searchParameterDefinitionManager = new SearchParameterDefinitionManager(ModelInfoProvider.Instance);
_filebasedSearchParameterStatusDataStore = new FilebasedSearchParameterStatusDataStore(searchParameterDefinitionManager, ModelInfoProvider.Instance);
var securityConfiguration = new SecurityConfiguration {
PrincipalClaims = { "oid" }
};
var sqlServerFhirModel = new SqlServerFhirModel(
config,
schemaInformation,
searchParameterDefinitionManager,
() => _filebasedSearchParameterStatusDataStore,
Options.Create(securityConfiguration),
NullLogger <SqlServerFhirModel> .Instance);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSqlServerTableRowParameterGenerators();
serviceCollection.AddSingleton(sqlServerFhirModel);
ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
var upsertResourceTvpGenerator = serviceProvider.GetRequiredService <VLatest.UpsertResourceTvpGenerator <ResourceMetadata> >();
var upsertSearchParamsTvpGenerator = serviceProvider.GetRequiredService <VLatest.UpsertSearchParamsTvpGenerator <List <ResourceSearchParameterStatus> > >();
var searchParameterToSearchValueTypeMap = new SearchParameterToSearchValueTypeMap(new SupportedSearchParameterDefinitionManager(searchParameterDefinitionManager));
SqlTransactionHandler = new SqlTransactionHandler();
SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(SqlTransactionHandler, new SqlCommandWrapperFactory(), sqlConnectionFactory);
SqlServerSearchParameterStatusDataStore = new SqlServerSearchParameterStatusDataStore(
() => SqlConnectionWrapperFactory.CreateMockScope(),
upsertSearchParamsTvpGenerator,
() => _filebasedSearchParameterStatusDataStore,
schemaInformation);
_fhirDataStore = new SqlServerFhirDataStore(config, sqlServerFhirModel, searchParameterToSearchValueTypeMap, upsertResourceTvpGenerator, Options.Create(new CoreFeatureConfiguration()), SqlConnectionWrapperFactory, NullLogger <SqlServerFhirDataStore> .Instance, schemaInformation);
_fhirOperationDataStore = new SqlServerFhirOperationDataStore(SqlConnectionWrapperFactory, NullLogger <SqlServerFhirOperationDataStore> .Instance);
_testHelper = new SqlServerFhirStorageTestHelper(initialConnectionString, MasterDatabaseName, searchParameterDefinitionManager, sqlServerFhirModel, sqlConnectionFactory);
}
protected void OnSchemaInitialized(SchemaInitializer initializer)
{
SchemaInitialized?.Invoke(this, initializer);
}
