public void CreateConnection_WhenConnectionContextReturnsNull_ThrowException()
{
_connectionContextFactoryMock.Setup(x => x.GetCurrentConnectionContext())
.Returns(null as ConnectionContext);
Func <IDbConnection> func = () => _sqlConnectionFactory.CreateConnection();
func.Should().Throw <InvalidOperationException>().Which.Message.Should()
.Be("Could not get context from connection context factory.");
}
public static SqlServerValidationToolkitContext Create(string connectionString)
{
SqlConnectionFactory f = new SqlConnectionFactory();
var connection = f.CreateConnection(connectionString);
return(new SqlServerValidationToolkitContext(connection, true));
}
public static DbConnection CreateConnection(string connectionString)
{
SqlConnectionFactory f = new SqlConnectionFactory();
var connection = f.CreateConnection(connectionString);
return(connection);
}
public static DbConnection GetConnection()
{
var sqlConnFactory = new SqlConnectionFactory();
var sqlConn = sqlConnFactory.CreateConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString);
return(sqlConn);
}
public PinnaSoftsDbContext Create()
{
string SQlServConString = "data source=.;initial catalog=PinnaSoftsDb;user id=sa;password=amihan";
SqlConnectionFactory sql = new SqlConnectionFactory(SQlServConString);
return(new PinnaSoftsDbContext(sql.CreateConnection(SQlServConString), true));
}
public void AddPersonToCollection(Model.Person person)
{
var address = person.Address;
if (address.Id == 0)
{
using (var connection = SqlConnectionFactory.CreateConnection())
{
var sql = $"INSERT INTO ADDRESS(STREET, HOUSENUMBER, ZIP, CITY) VALUES('{address.Street}', '{address.HouseNumber}', '{address.Zip}', '{address.City}'); SELECT SCOPE_IDENTITY();";
var insertCommand = new SqlCommand(sql, connection);
connection.Open();
address.Id = Convert.ToInt32(insertCommand.ExecuteScalar());
}
}
if (person.Id == 0)
{
using var connection = SqlConnectionFactory.CreateConnection();
var sql = $"INSERT INTO PERSON(FIRSTNAME, LASTNAME, ID_ADDRESS) VALUES ('{person.FirstName}', '{person.LastName}', '{address.Id}'); SELECT SCOPE_IDENTITY();";
var insertCommand = new SqlCommand(sql, connection);
connection.Open();
person.Id = Convert.ToInt32(insertCommand.ExecuteScalar());
}
}
private void CheckDisposedAndKillOnDispose()
{
try
{
ctx.Database.Exists();
}
catch (InvalidOperationException)
{
if (!KillConnectionOnDispose)
{
var connfactory = new SqlConnectionFactory();
ConnectionToUse = connfactory.CreateConnection(ConnectionString);
ctx = new DbContext(new EntityConnection(Workspace, ConnectionToUse, KillConnectionOnDispose), KillConnectionOnDispose);
ctx.Database.Connection.Open();
ctx.Database.Initialize(true);
logger.LoadContext(ctx.Database.Connection, KillConnectionOnDispose);
}
else
{
throw new Exceptions.Repository_ContextDisposeException("Context was disposed, and KillConnectionOnDispose was set to " + KillConnectionOnDispose);
}
}
}
public static TestDatabaseContext Create(string connectionString)
{
SqlConnectionFactory f = new SqlConnectionFactory();
var connection = f.CreateConnection(connectionString);
return(new TestDatabaseContext(connection, true));
}
public PDEXDbContext Create()
{
//switch (Singleton.Edition)
//{
// case PDEXEdition.CompactEdition:
//var sqlCeConString = "Data Source=" + Singleton.SqlceFileName + ";" +
// "Max Database Size=4091;Password=amSt0ckP@ssw0rd";
//Singleton.ConnectionStringName = sqlCeConString;
//Singleton.ProviderName = "System.Data.SqlServerCe.4.0";
//var sqlce = new SqlCeConnectionFactory(Singleton.ProviderName);
//return new PDEXDbContext(sqlce.CreateConnection(sqlCeConString), true);
// case PDEXEdition.ServerEdition:
const string serverName = "."; //pdexserver "server-01";
var sQlServConString = "data source=" + serverName + ";initial catalog=" + Singleton.SqlceFileName +
";user id=sa;password=amihan";
Singleton.ConnectionStringName = sQlServConString;
Singleton.ProviderName = "System.Data.SqlClient";
var sql = new SqlConnectionFactory(sQlServConString);
return(new PDEXDbContext(sql.CreateConnection(sQlServConString), true));
//}
//return null;
}
public void SqlConnectionFactory_throws_when_a_bad_base_connection_string_is_used()
{
var factory = new SqlConnectionFactory("You Wouldnt Let It Lie=True");
Assert.Throws <ArgumentException>(() => factory.CreateConnection("FakeDatabaseName")).ValidateMessage(
typeof(SqlConnection).Assembly, "ADP_KeywordNotSupported", null, "you wouldnt let it lie");
}
public AMStockServerDBContext Create()
{
#region For Debug
const string serverName = ".";
const string initialCatalog = "AMStockDbWeb1";
const string sQlServConString = "data source=" + serverName + ";initial catalog=" + initialCatalog + ";" +
"user id=sa;password=amihan";
Singleton.ConnectionStringName = sQlServConString;
Singleton.ProviderName = "System.Data.SqlClient";
var sql = new SqlConnectionFactory(sQlServConString);
return(new AMStockServerDBContext(sql.CreateConnection(sQlServConString), true));
#endregion
#region For Release
//const string serverIp = "198.38.83.33";
//const string serverInitialCatalog = "ibrahim11_amstock1";
//var sQlServerConString = "Data Source=" + serverIp + ";Initial Catalog=" + serverInitialCatalog + ";"+
// "User ID=ibrahim11_armsdev;Password=@rmsd3v;"+
// "encrypt=true;trustServerCertificate=true";
//var sql = new SqlConnectionFactory(sQlServerConString);
//return new AMStockServerDBContext(sql.CreateConnection(sQlServerConString), true);
#endregion
}
public void ValidarCriacaoDeConexaoSqlConnection(string server, string database, string user, string password)
{
var connectionFactory = new SqlConnectionFactory(server, database, user, password);
var sqlConnection = connectionFactory.CreateConnection();
Assert.True(sqlConnection.GetType() == typeof(System.Data.SqlClient.SqlConnection));
}
public void SqlConnectionFactory_throws_if_given_MDF_filename()
{
var factory = new SqlConnectionFactory();
Assert.Equal(
Strings.SqlConnectionFactory_MdfNotSupported("FakeDatabaseName.mdf"),
Assert.Throws <NotSupportedException>(() => factory.CreateConnection("FakeDatabaseName.mdf")).Message);
}
public static DbConnection GetSqlConn4DBName(string dbName)
{
var sqlConnFact = new SqlConnectionFactory(
"Data Source=localhost; Integrated Security=True; MultipleActiveResultSets=True");
var sqlConn = sqlConnFact.CreateConnection(dbName);
return(sqlConn);
}
public override void Load()
{
Bind <IBlogPostRepository>().To <BlogPostRepository>();
Bind <IBlogUserRepository>().To <BlogUserRepository>();
Bind <IAuthRepository>().To <AuthRepository>();
Bind <ITransactionManager>().To <SqlTransactionManager>().InRequestScope();
Bind <SqlConnection>().ToMethod(ctx => SqlConnectionFactory.CreateConnection()).InRequestScope();
}
public void SqlConnectionFactory_creates_SqlConnection()
{
var factory = new SqlConnectionFactory();
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.IsType <SqlConnection>(connection);
}
public void SqlConnectionFactory_uses_database_name_as_initial_catalog()
{
var factory = new SqlConnectionFactory();
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
AssertConnectionStringHasDefaultParts(connection.ConnectionString);
}
public void TestSendMessage()
{
var connStr = @"Data Source=.\SQLEXPRESS;Database=appointments;User Id=chinook;Password=pr0t3ct3d";
var sender = new SqlMessageSender(connStr, "dbo.messages");
var msg1 = new Message("message body1", DateTime.Today, "12345678");
var msg2 = new Message("message body2", DateTime.Today, "12345678");
var msg3 = new Message("message body3", DateTime.Today, "12345678");
// var task = sender.Send(msg1);
var task = sender.Send(new List <Message> {
msg1, msg2, msg3
});
task.Wait();
var connectionFactory = new SqlConnectionFactory(connStr);
var readQuery = string.Format(
CultureInfo.InvariantCulture,
@"SELECT TOP(1)
{0}.[Id] AS [Id],
{0}.[Body] AS [Body],
{0}.[DeliveryDate] AS [DeliveryDate],
{0}.[CorrelationId] AS [CorrelationId]
FROM {0} WITH (UPDLOCK, READPAST)
WHERE ({0}.[DeliveryDate] IS NULL) OR ({0}.[DeliveryDate] <= @CurrentDate)
ORDER BY {0}.[Id] ASC",
"messages");
using (var connection = connectionFactory.CreateConnection(connStr))
{
connection.Open();
using (var command = connection.CreateCommand())
{
command.CommandType = CommandType.Text;
command.CommandText = readQuery;
((SqlCommand)command).Parameters.Add("@CurrentDate", SqlDbType.DateTime).Value = DateTime.Now;
using (var reader = command.ExecuteReader())
{
if (!reader.Read())
{
return;
}
var body = (string)reader["Body"];
var deliveryDateValue = reader["DeliveryDate"];
var deliveryDate = deliveryDateValue == DBNull.Value
? (DateTime?)null
: new DateTime?((DateTime)deliveryDateValue);
var correlationId = (string)reader["CorrelationId"];
Assert.IsTrue(body.Contains("message body"));
Assert.AreEqual(correlationId, "12345678");
Assert.AreEqual(deliveryDate.Value.Date, DateTime.Today.Date);
}
}
}
}
public void SqlConnectionFactory_replaces_any_initial_catalog_set_in_the_base_connection()
{
var factory = new SqlConnectionFactory(
@"Data Source=.\SQLEXPRESS; Integrated Security=True; Initial Catalog=TheManWithTheStick");
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.False(connection.ConnectionString.Contains("Initial Catalog=TheManWithTheStick"));
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void SqlConnectionFactory_CreateConnection()
{
// Arrange
var sqlConnectionFactory = new SqlConnectionFactory(appSettingsMock.Object);
// Act
IDbConnection actual = sqlConnectionFactory.CreateConnection();
// Assert
Assert.IsNotNull(actual);
}
public void SqlConnectionFactory_uses_changed_base_connection_string_when_creating_connection_string()
{
var factory = new SqlConnectionFactory("Data Source=190.190.200.100,1433");
Assert.Equal("Data Source=190.190.200.100,1433", factory.BaseConnectionString);
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.True(connection.ConnectionString.Contains("Data Source=190.190.200.100,1433"));
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void ValidarValicaoConexao()
{
var dbConnectionFactory = new SqlConnectionFactory("localhost", "master", string.Empty, string.Empty);
var conexao = new Conexao(dbConnectionFactory);
conexao.validaConexao(null);
var connection = dbConnectionFactory.CreateConnection();
conexao.validaConexao(connection);
}
public void SqlConnectionFactory_handles_no_provider_factory_found()
{
var factory = new SqlConnectionFactory
{
ProviderFactory = name => null
};
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal(typeof(SqlConnection), connection.GetType());
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public MATSDbContext Create()
{
if (Singleton.Edition == MATSEdition.CompactEdition)
{
var sqlCeConString = "Data Source=" + Singleton.SqlceFileName + ";Max Database Size=4091;Password=mat3P@ssw0rd"; // "Data Source=E:\\DB_Test\\oneface\\MATSDb.sdf;Password=1fac3P@ssw0rd";
var sqlce = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0"); //, path, pathfile);
return(new MATSDbContext(sqlce.CreateConnection(sqlCeConString), true));
}
//data source should be contant value="MATSSERVER" "matsserver"
string sQlServConString = "data source=.;initial catalog=" + Singleton.SqlceFileName + ";user id=sa;password=amihan";
var sql = new SqlConnectionFactory(sQlServConString);
return(new MATSDbContext(sql.CreateConnection(sQlServConString), true));
}
public void SqlConnectionFactory_handles_provider_factory_returning_null_connection()
{
var mockProviderFactory = new Mock <DbProviderFactory>();
mockProviderFactory.Setup(m => m.CreateConnection()).Returns <DbConnection>(null);
var factory = new SqlConnectionFactory
{
ProviderFactory = name => mockProviderFactory.Object
};
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal(typeof(SqlConnection), connection.GetType());
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void TestFileOutput()
{
var facade = Helper.CreateFacade(ConnectionString);
IDataManagerFactory dataManagerFactory = new FakeDataManagerFactory();
var connectionFactory = new SqlConnectionFactory(ConnectionString);
var dataManager = dataManagerFactory.CreateDataManager(connectionFactory.CreateConnection(), null);
var securityRepository = facade.RepositoryManager.ClaimSecurityRepository(dataManager);
var fileManager = new TradingTargetsFileManager();
var targetings = fileManager.GetFileContent(securityRepository, dataManager);
using (StreamWriter sw = new StreamWriter(String.Format(@"C:\temp\AshmoreEMM_Models - as of {0:yyyyMMdd}-{0:HHmmss}.CSV", DateTime.Now)))
{
sw.Write(targetings);
}
}
private static DbConnection BuildConnection(IConnectionSettings connectionSettings)
{
if (null == connectionSettings)
{
connectionSettings = ConnectionSettings;
}
switch (connectionSettings.ProviderInvariantName)
{
case DataConfiguration.SqlServerCompactProviderInvariantName:
{
var connectionFactory =
new SqlCeConnectionFactory(DataConfiguration.SqlServerCompactProviderInvariantName);
return(connectionFactory.CreateConnection(connectionSettings.ConnectionString));
}
case DataConfiguration.SqlServerProviderInvariantName:
{
var connectionFactory = new SqlConnectionFactory();
return(connectionFactory.CreateConnection(connectionSettings.ConnectionString));
}
case DataConfiguration.MySqlProviderInvariantName:
{
var connectionFactory = new MySqlConnectionFactory();
return(connectionFactory.CreateConnection(connectionSettings.ConnectionString));
}
case DataConfiguration.PostgreSqlProviderInvariantName:
{
var connectionFactory = new NpgsqlConnectionFactory();
return(connectionFactory.CreateConnection(connectionSettings.ConnectionString));
}
case DataConfiguration.OracleDBProviderInvariantName:
{
var connectionFactory = new OracleConnectionFactory();
return(connectionFactory.CreateConnection(connectionSettings.ConnectionString));
}
default:
throw new InvalidOperationException("connectionSettings.ProviderInvariantName == " +
connectionSettings.ProviderInvariantName);
}
}
//private List<Model.Person> _persons = new List<Model.Person>();
public IEnumerable <Model.Person> LoadAllPersons()
{
var query = @"SELECT p.ID, p.FIRSTNAME, p.LASTNAME, a.ID, a.STREET as STREET, a.HOUSENUMBER, a.ZIP, a.CITY
FROM PERSON p
JOIN ADDRESS a ON p.ID_ADDRESS = a.ID";
using (var connection = SqlConnectionFactory.CreateConnection())
{
var personList = new List <Model.Person>();
var command = new SqlCommand(query, connection);
connection.Open();
var reader = command.ExecuteReader();
while (reader.Read())
{
var idx = 0;
var personId = (int)reader[idx++];
var firstName = (string)reader[idx++];
var lastName = (string)reader[idx++];
var addressId = (int)reader[idx++];
var street = (string)reader["STREET"];
idx++;
var houseNumber = (string)reader[idx++];
var zip = (string)reader[idx++];
var city = (string)reader[idx++];
var person = new Model.Person
{
Id = personId,
FirstName = firstName,
LastName = lastName,
Address = new Address
{
Id = addressId,
City = city,
HouseNumber = houseNumber,
Street = street,
Zip = zip
}
};
personList.Add(person);
}
return(personList);
}
}
public void SqlConnectionFactory_uses_db_provider_factory()
{
var mockProviderFactory = new Mock <DbProviderFactory>();
var mockConnection = new Mock <DbConnection>();
mockConnection.SetupProperty(c => c.ConnectionString);
mockProviderFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object);
var factory = new SqlConnectionFactory
{
ProviderFactory = name => mockProviderFactory.Object
};
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Same(mockConnection.Object, connection);
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
private void CleanUpDatabase()
{
var sqlConnectionFactory = new SqlConnectionFactory(new SqlConnectionStringBuilder(Configuration["Database:ConnectionString"]));
using (var connection = sqlConnectionFactory.CreateConnection())
{
var sqlQuery = @"DELETE FROM Attachments
DELETE FROM ChannelMembers
DELETE FROM Clients
DELETE FROM Notifications
DELETE FROM NotificationSettings
DELETE FROM Settings
DELETE FROM ForwardMessages
DELETE FROM Messages
DELETE FROM Channels
DELETE FROM Members";
connection.ExecuteScalar(sqlQuery);
}
}
public static void AppInitialize()
{
ConnectionStringSettings connectionString = ConfigurationManager.ConnectionStrings["SqlServerVirtualPathProvider"];
ISqlConnectionFactory factory = new SqlConnectionFactory(connectionString);
if (HostingEnvironment.IsHosted)
{
HostingEnvironment.RegisterVirtualPathProvider(new SqlServerVirtualPathProvider(factory));
}
//test for proper connection
try
{
using (IDbConnection conn = factory.CreateConnection())
{
conn.Close();
}
}
catch (SqlException)
{
throw new ArgumentException("connection string missing or invalid");
}
EnsureDatabaseSchemaIsValid();
}
public void SqlConnectionFactory_throws_when_a_bad_base_connection_string_is_used()
{
var factory = new SqlConnectionFactory("You Wouldnt Let It Lie=True");
Assert.Throws<ArgumentException>(() => factory.CreateConnection("FakeDatabaseName")).ValidateMessage(
typeof(SqlConnection).Assembly(), "ADP_KeywordNotSupported", null, "you wouldnt let it lie");
}
public void SqlConnectionFactory_handles_provider_factory_returning_null_connection()
{
var mockProviderFactory = new Mock<DbProviderFactory>();
mockProviderFactory.Setup(m => m.CreateConnection()).Returns<DbConnection>(null);
var factory = new SqlConnectionFactory
{
ProviderFactory = name => mockProviderFactory.Object
};
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal(typeof(SqlConnection), connection.GetType());
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void SqlConnectionFactory_uses_db_provider_factory()
{
var mockProviderFactory = new Mock<DbProviderFactory>();
var mockConnection = new Mock<DbConnection>();
mockConnection.SetupProperty(c => c.ConnectionString);
mockProviderFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object);
var factory = new SqlConnectionFactory
{
ProviderFactory = name => mockProviderFactory.Object
};
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Same(mockConnection.Object, connection);
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void SqlConnectionFactory_handles_no_provider_factory_found()
{
var factory = new SqlConnectionFactory
{
ProviderFactory = name => null
};
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal(typeof(SqlConnection), connection.GetType());
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void SqlConnectionFactory_replaces_any_initial_catalog_set_in_the_base_connection()
{
var factory = new SqlConnectionFactory(
@"Data Source=.\SQLEXPRESS; Integrated Security=True; Initial Catalog=TheManWithTheStick");
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.False(connection.ConnectionString.Contains("Initial Catalog=TheManWithTheStick"));
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void SqlConnectionFactory_uses_changed_base_connection_string_when_creating_connection_string()
{
var factory = new SqlConnectionFactory("Data Source=190.190.200.100,1433");
Assert.Equal("Data Source=190.190.200.100,1433", factory.BaseConnectionString);
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.True(connection.ConnectionString.Contains("Data Source=190.190.200.100,1433"));
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
}
public void SqlConnectionFactory_throws_if_given_MDF_filename()
{
var factory = new SqlConnectionFactory();
Assert.Equal(
Strings.SqlConnectionFactory_MdfNotSupported("FakeDatabaseName.mdf"),
Assert.Throws<NotSupportedException>(() => factory.CreateConnection("FakeDatabaseName.mdf")).Message);
}
public void SqlConnectionFactory_uses_database_name_as_initial_catalog()
{
var factory = new SqlConnectionFactory();
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.True(connection.ConnectionString.Contains("Initial Catalog=FakeDatabaseName"));
AssertConnectionStringHasDefaultParts(connection.ConnectionString);
}
public void SqlConnectionFactory_creates_SqlConnection()
{
var factory = new SqlConnectionFactory();
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.IsType<SqlConnection>(connection);
}
