public void should_handle_database_setup_and_teardown()
{
var configuration = new Configuration().Current.GetSection("ConnectionStrings");
var transientDatabaseName = RandomData.RandomWord();
var connectionStringManager = new ConnectionStringManager();
connectionStringManager.ConfigureTransientConnectionString(configuration["PgSQL"], transientDatabaseName);
var database = new Database();
database.ConfigureAndBuild(connectionStringManager, null, new Session());
Assert.True(database.Exists());
database.Drop();
Assert.False(database.Exists());
}
public void ShouldLoadNamedConnectionFromMachineConfigIfTargetAssemblyConfigHasNoMatch()
{
string configPath = GetPath("WithWrongConnectionString.config");
string machineConfigPath = GetPath("FromMachineConfig.config");
configManagerMock.Setup(x => x.LoadFromFile(TARGET))
.Returns(LoadFromFile(configPath));
configManagerMock.Setup(x => x.LoadFromMachineConfiguration())
.Returns(LoadFromFile(machineConfigPath));
var sut = new ConnectionStringManager(configManagerMock.Object, announcerMock.Object, CONNECTION_NAME, null, TARGET, DATABASE);
sut.LoadConnectionString();
configManagerMock.VerifyAll();
Assert.That(sut.ConnectionString, Is.EqualTo("From Machine Config"));
}
private static void Dump(string query, string file)
{
Console.WriteLine("doing " + file);
var df = new DataFactory(DatabaseProvider.SqlClient, ConnectionStringManager.MakeSQLClient("la1db2-dev-vm.mscorp.com", "testDb", true, null, null));
df.TestConnection();
var dt = df.FillTable(query);
using (var w = new StreamWriter(file, false, Encoding.ASCII))
{
foreach (DataRow dr in dt.Rows)
{
w.WriteLine(dr["foo"].ToString());
}
w.Flush();
w.Close();
}
}
System.Data.DataSet IFileConverter.Import(string filename)
{
string connectionString = null;
if (Options.Provider == "Microsoft.ACE.OLEDB.12.0")
{
connectionString = ConnectionStringManager.MakeExcel2007(filename, Options.Username, Options.Password, Options.UseHeader, true);
}
else
{
connectionString = ConnectionStringManager.MakeExcel(filename, Options.Username, Options.Password, Options.UseHeader, true);
}
//if (OpenTableBy == "POSITION")
//{
// OpenTableByPosition(connectionString);
//}
return(Common.OleDbTables(connectionString, Tablename, Options.TableFilter));
}
public DrugImageUrlFactory(string countryCode, IConfiguration config)
{
_country = ConnectionStringManager.GetCountryNames()[countryCode];
string connectionString = config.GetConnectionString(countryCode);
_connection = new SqliteConnection(connectionString);
string query = @"select distinct d.Id as DrugImageId, d.Strength as ProductStrength, p.ProductName
from DRUGIMAGE d
left outer join PRODUCT p on d.ProductId = p.Id
order by d.Id" ;
_connection.Open();
_drugImageDict = (IList <DrugImageUrl>)_connection.Query <DrugImageUrl>(query);
//Added this function to sync with the mims.com logic
GetMappingProductOriginalNameToAlias(countryCode);
GetMappingStrengthOriginalNameToAlias(countryCode);
}
public void ConnectionTypeLocatorFindsTypeFromServiceInfo()
{
var cosmosInfo = new CosmosDbServiceInfo("id");
var mongoInfo = new MongoDbServiceInfo("id", "mongodb://host");
var mysqlInfo = new MySqlServiceInfo("id", "mysql://host");
var oracleInfo = new OracleServiceInfo("id", "oracle://host");
var postgresInfo = new PostgresServiceInfo("id", "postgres://host");
var rabbitMqInfo = new RabbitMQServiceInfo("id", "rabbitmq://host");
var redisInfo = new RedisServiceInfo("id", "redis://host");
var sqlInfo = new SqlServerServiceInfo("id", "sqlserver://host");
var manager = new ConnectionStringManager(new ConfigurationBuilder().Build());
Assert.StartsWith("CosmosDb", manager.GetFromServiceInfo(cosmosInfo).Name);
Assert.StartsWith("MongoDb", manager.GetFromServiceInfo(mongoInfo).Name);
Assert.StartsWith("MySql", manager.GetFromServiceInfo(mysqlInfo).Name);
Assert.StartsWith("Oracle", manager.GetFromServiceInfo(oracleInfo).Name);
Assert.StartsWith("Postgres", manager.GetFromServiceInfo(postgresInfo).Name);
Assert.StartsWith("RabbitMQ", manager.GetFromServiceInfo(rabbitMqInfo).Name);
Assert.StartsWith("Redis", manager.GetFromServiceInfo(redisInfo).Name);
Assert.StartsWith("SqlServer", manager.GetFromServiceInfo(sqlInfo).Name);
}
public void AddRabbitMQConnection_AddsRabbitMQHealthContributor_WhenCommunityHealthCheckExistsAndForced()
{
// Arrange
IServiceCollection services = new ServiceCollection();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
var cm = new ConnectionStringManager(config);
var ci = cm.Get <RabbitMQConnectionInfo>();
services.AddHealthChecks().AddRabbitMQ(ci.ConnectionString, name: ci.Name);
// Act
RabbitMQProviderServiceCollectionExtensions.AddRabbitMQConnection(services, config, addSteeltoeHealthChecks: true);
var healthContributor = services.BuildServiceProvider().GetService <IHealthContributor>() as RabbitMQHealthContributor;
// Assert
Assert.NotNull(healthContributor);
}
/// <summary>
/// Creates a Cosmos DB database and a container with the specified partition key.
/// </summary>
/// <returns></returns>
/// <remarks><see cref="CosmosDbConnectorOptions"/></remarks>
private static async Task <CosmosDbService> InitializeCosmosClientInstanceAsync(IConfiguration configuration)
{
// read settings from "cosmosdb:client" and VCAP:services or services:
var configMgr = new ConnectionStringManager(configuration);
var cosmosInfo = configMgr.Get <CosmosDbConnectionInfo>();
// these are mapped into the properties dictionary
var databaseName = cosmosInfo.Properties["DatabaseId"];
var databaseLink = cosmosInfo.Properties["DatabaseLink"];
// container is not known to be provided by a service binding:
var containerName = configuration.GetValue <string>("CosmosDb:Container");
var cosmosClient = new CosmosClient(cosmosInfo.ConnectionString);
var cosmosDbService = new CosmosDbService(cosmosClient, databaseName, containerName);
var database = await cosmosClient.CreateDatabaseIfNotExistsAsync(databaseName);
await database.Database.CreateContainerIfNotExistsAsync(containerName, "/id");
return(cosmosDbService);
}
public void AddMySqlConnection_DoesntAddRelationalHealthContributor_WhenCommunityHealthExists()
{
// Arrange
IServiceCollection services = new ServiceCollection();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
var cm = new ConnectionStringManager(config);
var ci = cm.Get <MySqlConnectionInfo>();
services.AddHealthChecks().AddMySql(ci.ConnectionString, name: ci.Name);
// Act
MySqlProviderServiceCollectionExtensions.AddMySqlConnection(services, config);
var healthContributor = services.BuildServiceProvider().GetService <IHealthContributor>() as RelationalHealthContributor;
// Assert
Assert.Null(healthContributor);
}
private void UpdateTableList()
{
switch (InputDataSource)
{
case InputDataSourceType.File:
if (FileSupportsTables(Filename))
{
switch (GetFileExtension(Filename))
{
case "MDB":
Provider = DatabaseProvider.OleDb;
ConnectionString = ConnectionStringManager.MakeAccess(Filename, null, null, true);
break;
case "XLS":
Provider = DatabaseProvider.OleDb;
ConnectionString = ConnectionStringManager.MakeExcel(Filename, null, null, true, true);
break;
case "XLSX":
Provider = DatabaseProvider.OleDb;
ConnectionString = ConnectionStringManager.MakeExcel2007(Filename, null, null, true, true);
break;
default:
throw new ArgumentException("File extension not supported: " + Filename);
}
GetTableListing(Provider, ConnectionString);
}
break;
case InputDataSourceType.Database:
GetTableListing(Provider, ConnectionString);
break;
default:
throw new ArgumentOutOfRangeException("InputDataSource=" + InputDataSource);
}
}
public void AddMongoClientConnection_AddingCommunityContributor_AddsSteeltoeHealthCheckWhenForced()
{
IServiceCollection services = new ServiceCollection();
Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION);
Environment.SetEnvironmentVariable("VCAP_SERVICES", MongoDbTestHelpers.SingleBinding_Enterprise_VCAP);
var builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
var cm = new ConnectionStringManager(config);
var ci = cm.Get <MongoDbConnectionInfo>();
services.AddHealthChecks().AddMongoDb(ci.ConnectionString, name: ci.Name);
services.AddMongoClient(config, "steeltoe", addSteeltoeHealthChecks: true);
var healthContributor = services.BuildServiceProvider().GetService <IHealthContributor>() as MongoDbHealthContributor;
Assert.NotNull(healthContributor);
}
System.Data.DataSet IFileConverter.Import(string filename)
{
switch (Options.ImportEngine)
{
case DBFEngine.OLEDB:
{
string connectionString = ConnectionStringManager.MakeDBF(filename, true);
string tablename = Path.GetFileNameWithoutExtension(filename);
return(Common.OleDbTables(connectionString, tablename, QueryFilter.Exact));
}
case DBFEngine.DBF4:
{
var dbf = new dBase4(Options);
dbf.OpenFile(filename);
return(DataUtil.ToDataSet(dbf.DataTable));
}
default:
throw new ArgumentOutOfRangeException("ImportEngine=" + Options.ImportEngine);
}
}
public void GetLogsFromManager()
{
_stopwatch.Start();
SQLiteCRUD sql = new(ConnectionStringManager.GetConnectionString(ConnectionStringManager.DataBases.PCControllerDB));
ProcMonitorModel procData = new();
int numLogs = _parser.GetLogs(NumberOfNetMsgToFetch);
_log.Info("Getting Data Logs from {sql} number: {numOfMsgs}", sql, numLogs);
IList <NetworkMessageModel> rows = sql.GetSomeNetData(numLogs);
NetGridRows = rows;
_stopwatch.Stop();
string timeToFetchFromDb = $" DB query time: {_stopwatch.ElapsedMilliseconds} ms";
DataBaseQueryTime = timeToFetchFromDb;
RaisePropertyChanged(() => NetGridRows);
RaisePropertyChanged(() => DataBaseQueryTime);
}
public MonographUrlFactory(string countryCode, IConfiguration config)
{
_country = ConnectionStringManager.GetCountryNames()[countryCode];
string connectionString = config.GetConnectionString(countryCode);
_connection = new SqliteConnection(connectionString);
string selectOne = string.Empty;
if (AppSettings.ForCacheGeneration)
{
selectOne = "LIMIT 1";
}
string query = @"select * from (select distinct m.Id, m.MonographName, b.BrandName as Name, c.Value as UrlType
from MONOGRAPH m
join REL_PRODUCT_MONOGRAPH pm on m.Id = pm.MonographId
join PRODUCT p on pm.ProductId = p.Id
join BRAND b on p.BrandId = b.Id
join CODETABLE c on m.MonographType = c.Id {0})
union
select * from (select distinct m.Id, m.MonographName, g.GenericName as Name, c.Value as UrlType
from MONOGRAPH m
join rel_Generic_Monograph gm on m.Id = gm.MonographId
join Generic g on gm.GenericId = g.Id
join CODETABLE c on m.MonographType = c.Id {0})
Order by id";
query = string.Format(query, selectOne);
_connection.Open();
_brandMonographDict = (IList <Monograph>)_connection.Query <Monograph>(query);
//Added this function to sync with the mims.com logic
GetMappingMonographOriginalNameToAlias();
GetMappingBrandOriginalNameToAlias();
}
public static string ExecuteScalar(ConnectionConstant connectionConstant, string sql, params SqlParam[] sqlParameters)
{
try
{
var connectionString = ConnectionStringManager.GetConnectionString(connectionConstant);
object result = null;
using (var sqlConnection = new SqlConnection(connectionString))
{
using (var sqlCommand = new SqlCommand())
{
sqlCommand.Connection = sqlConnection;
sqlCommand.CommandText = sql;
foreach (var parameter in sqlParameters)
{
sqlCommand.Parameters.Add(parameter.ParameterName, parameter.SqlDbType).Value = (parameter.Value).ToString() == "" ? DBNull.Value : parameter.Value;
}
sqlConnection.Open();
result = sqlCommand.ExecuteScalar();
}
}
if (result != null)
{
return(result.ToString());
}
else
{
return(string.Empty);
}
}
catch (SqlException sqlException)
{
throw;
}
catch (Exception ex)
{
throw;
}
}
public void TestConnectionStringWithEqualAndSemicolonChar()
{
// Arrange
string connStr = ConnectionStringManager.MakeExcel(@"c:\f=oo;ba'r.xls", null, null, true, false);
Assert.AreEqual(connStr, "Provider=\"Microsoft.Jet.OLEDB.4.0\"; Data Source=\"c:\\f=oo;ba'r.xls\"; user id=\"admin\"; password=\"\"; Extended Properties=\"Excel 8.0; HDR=Yes; IMEX=1\";");
// Act
var result = ConnectionStringParser.Parse(connStr);
foreach (var item in result)
{
Console.WriteLine("[{0}] = [{1}]", item.Key, item.Value);
}
// Assert
Assert.AreEqual(result["Provider"], @"Microsoft.Jet.OLEDB.4.0");
Assert.AreEqual(result["Data Source"], @"c:\f=oo;ba'r.xls");
Assert.AreEqual(result["user id"], @"admin");
Assert.AreEqual(result["password"], @"");
Assert.AreEqual(result["Extended Properties"], @"Excel 8.0; HDR=Yes; IMEX=1");
Assert.AreEqual(result.Count, 5);
}
System.Data.DataSet IFileConverter.Import(string filename)
{
string connectionString = ConnectionStringManager.MakeAccess(filename, Options.Username, Options.Password, false);
return(Common.OleDbTables(connectionString, Options.Tablename, Options.TableFilter));
}
public void should_throw_when_transient_name_is_null_or_empty([Values(" ", "", null)] string transientName)
{
var connectionStringManager = new ConnectionStringManager();
Assert.Throws<ArgumentException>(() => connectionStringManager
.ConfigureTransientConnectionString(_connectionString, transientName));
}
private static IWebHost BuildWebHost(string[] args)
{
var defaultConfig = new ConfigurationBuilder()
.AddCommandLine(args)
.AddEnvironmentVariables(prefix: "ASPNETCORE_")
.Build();
var port = defaultConfig.GetValue("port", 5000);
var connectionString = defaultConfig.GetValue("ConnectionString", "");
return(WebHost.CreateDefaultBuilder(args)
.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.MaxRequestBodySize = 100 * 1024 * 1024; // 100Mb
})
.UseUrls($"http://0.0.0.0:{port}")
// .UseIISIntegration()
.ConfigureAppConfiguration((hostContext, config) =>
{
Log.LogEvent("Delete all default configuration providers");
// delete all default configuration providers
config.Sources.Clear();
config.SetBasePath(hostContext.HostingEnvironment.ContentRootPath);
var filePath = Path.Combine(hostContext.HostingEnvironment.ContentRootPath,
"connection.json");
if (!File.Exists(filePath))
{
ConnectionStringManager.CreateDefault(filePath);
}
if (!string.IsNullOrEmpty(connectionString))
{
ConnectionStringManager.CreateWithConnectionString(filePath, connectionString);
}
config.AddJsonFile("connection.json", optional: true, reloadOnChange: true);
var mainSettings = ConnectionStringManager.Read(filePath);
_defaultConnectionString = mainSettings?.ConnectionStrings?.DefaultConnection;
config.AddEfConfiguration(_defaultConnectionString);
EnabledPlugins = PluginHelper.GetPlugins(_defaultConnectionString);
DisabledPlugins = PluginHelper.GetDisablePlugins(_defaultConnectionString);
var contextFactory = new BaseDbContextFactory();
if (_defaultConnectionString != "...")
{
using var dbContext = contextFactory.CreateDbContext(new[] { _defaultConnectionString });
foreach (var plugin in EnabledPlugins)
{
var pluginEntity = dbContext.EformPlugins
.FirstOrDefault(x => x.PluginId == plugin.PluginId);
if (pluginEntity != null && !string.IsNullOrEmpty(pluginEntity.ConnectionString))
{
plugin.AddPluginConfig(config, pluginEntity.ConnectionString);
}
}
}
config.AddEnvironmentVariables();
})
.UseStartup <Startup>()
.Build());
}
public void Test()
{
var t = new ConnectionStringManager();
}
public void ReturnsNullByDefault()
{
var connectionStringManager = new ConnectionStringManager();
Assert.AreEqual(null, connectionStringManager.GetConnectionString(typeof(TestDbContextContainer), null, null));
}
public void IConnectionInfoTypeFoundByName(string value)
{
var manager = new ConnectionStringManager(new ConfigurationBuilder().Build());
Assert.StartsWith(value, manager.GetByTypeName(value).Name, StringComparison.InvariantCultureIgnoreCase);
}
static void TestQueryAnalyzer()
{
var connStr = ConnectionStringManager.MakeSQLite(@"%TMP%\foo.sqlitedb", null, false, false);
ControlManager.ShowQueryAnalyzer(connStr, DatabaseProvider.SQLite);
}
private static void ConnStrFileChanged_TimerChanged(object state)
{
ConnectionStringManager.ClearAllConnectionString();
}
public static IServiceCollection AddRepositoriesReadOnly(this IServiceCollection services, ConnectionStringManager connectionString)
{
var connectionStringElasticSearch = connectionString.ConnectionStrings[ConnectionStrings.WishListElasticSearch];
var elasticSearch = new QueryContext(connectionStringElasticSearch);
services.AddSingleton(elasticSearch);
services.AddScoped <IUserQueryRepository, UserQueryRepository>(factory => new UserQueryRepository(elasticSearch));
services.AddScoped <IProductQueryRepository, ProductQueryRepository>(factory => new ProductQueryRepository(elasticSearch));
services.AddScoped <IWishQueryRepository, WishQueryRepository>(factory => new WishQueryRepository(elasticSearch));
return(services);
}
public static IServiceCollection AddRepositories(this IServiceCollection services, ConnectionStringManager connectionStringManager)
{
#region Contexts
services.AddDbContext <WishListContext>(options =>
{
//options.UseSqlServer(connectionStringManager.ConnectionStrings[ConnectionStrings.WishList]);
options.UseSqlServer(Environment.GetEnvironmentVariable("DB_CONNECTION_STRING"));
}, ServiceLifetime.Scoped);
services.AddSingleton(new IndexContext(Environment.GetEnvironmentVariable("ELASTIC_SEARCH_CONNECTION_STRING")));
#endregion
services.AddTransient <IUserRepository, UserRepository>();
services.AddTransient <IProductRepository, ProductRepository>();
services.AddTransient <IWishRepository, WishRepository>();
services.AddScoped <IUnitOfWork, UnitOfWork>(factory =>
{
return(new UnitOfWork(factory.GetService <WishListContext>()));
});
services.AddTransient(typeof(IIndexRepository <>), typeof(IndexRepository <>));
services.AddTransient <IUserQueryRepository, UserQueryRepository>();
services.AddTransient <IProductQueryRepository, ProductQueryRepository>();
services.AddTransient <IWishQueryRepository, WishQueryRepository>();
return(services);
}
/// <summary>
///
/// </summary>
/// <param name="dbName"></param>
public DBConnectionContext(DatabaseName dbName) : base(ConnectionStringManager.GetConnectionString(dbName))
{
this.InitDLLs();
}
static DataCommandManager()
{
ConnectionStringManager.SetConnectionString(GetConnStrSetting);
}
