public DatabaseTests()
{
using (var context = new SimpleModelContext())
{
context.Database.Initialize(force: false);
}
using (var context = new SimpleModelContextWithNoData())
{
context.Database.Initialize(force: false);
}
using (var connection = new SqlConnection(SimpleConnectionString("master")))
{
connection.Open();
if (DatabaseTestHelpers.IsSqlAzure(connection.ConnectionString))
{
CreateLoginForSqlAzure(connection);
}
else
{
CreateLoginForSqlServer(connection);
}
}
}
public void If_connection_is_changed_to_point_to_different_server_then_operations_that_use_OriginalConnectionString_pick_up_this_change()
{
var changedServer = DatabaseTestHelpers.IsLocalDb(SimpleConnectionString("")) ? @".\SQLEXPRESS" : @"(localdb)\mssqllocaldb";
var changedConnectionString = string.Format(
CultureInfo.InvariantCulture,
@"Data Source={0};Initial Catalog=MutatingConnectionContext4;Integrated Security=True", changedServer);
If_connection_is_changed_then_operations_that_use_OriginalConnectionString_pick_up_this_change(
c => new MutatingConnectionContext4b(c),
changedConnectionString);
}
public GuidIdentityColumnUpdateTests()
{
using (var context = new GuidIdentityColumnContext())
{
_isSqlAzure = DatabaseTestHelpers.IsSqlAzure(context.Database.Connection.ConnectionString);
if (!_isSqlAzure)
{
context.Customers.ToList();
}
}
}
public OrderByLiftingFixture()
{
var sqlVersion = DatabaseTestHelpers.GetSqlDatabaseVersion <ArubaContext>(() => new ArubaContext());
if (sqlVersion >= 11)
{
SetExpectedSqlForSql2012();
}
else
{
SetExpectedSqlForLegacySql();
}
}
public void Nongeneric_SQL_query_is_streaming_by_default()
{
using (var context = new SimpleModelContext())
{
var expectedState = DatabaseTestHelpers.IsSqlAzure(context.Database.Connection.ConnectionString)
? ConnectionState.Closed
: ConnectionState.Open;
var products = context.Database.SqlQuery(typeof(int), "select Id from Products");
var enumerator = products.GetEnumerator();
enumerator.MoveNext();
Assert.Equal(expectedState, context.Database.Connection.State);
}
}
public void GetServerType_returns_correct_ServerType_for_real_test_database()
{
using (var context = new RealDatabase())
{
context.Database.CreateIfNotExists();
var connection = context.Database.Connection;
connection.Open();
var expectedServerType = DatabaseTestHelpers.IsSqlAzure(connection.ConnectionString) ? ServerType.Cloud : ServerType.OnPremises;
Assert.Equal(expectedServerType, SqlVersionUtils.GetServerType(connection));
connection.Close();
}
}
public static DbModel CreateDynamicUpdateModel()
{
using (var context = new TestContext())
{
var providerInfo = DatabaseTestHelpers.IsSqlAzure(context.Database.Connection.ConnectionString)
? ProviderRegistry.SqlAzure2012_ProviderInfo
: ProviderRegistry.Sql2008_ProviderInfo;
return(context
.InternalContext
.CodeFirstModel
.CachedModelBuilder
.BuildDynamicUpdateModel(providerInfo));
}
}
public ChangeTrackingProxyTests()
{
using (var context = new GranniesContext())
{
context.Database.Initialize(force: false);
}
using (var context = new HaveToDoContext())
{
_isSqlAzure = DatabaseTestHelpers.IsSqlAzure(context.Database.Connection.ConnectionString);
if (!_isSqlAzure)
{
context.Database.Initialize(force: false);
}
}
}
public override void DropDatabase()
{
SqlConnection.ClearAllPools();
if (DatabaseTestHelpers.IsSqlAzure(ConnectionString))
{
string azureConnectionString = ConnectionString + ";Database=Master;";
ExecuteNonQuery(
@"DROP DATABASE [" + _name + "]", azureConnectionString);
}
else
{
ExecuteNonQuery(
@"ALTER DATABASE [" + _name
+ "] SET OFFLINE WITH ROLLBACK IMMEDIATE;ALTER DATABASE [" + _name
+ "] SET ONLINE;DROP DATABASE [" + _name + "]");
}
}
public void GetStorageMappingItemCollection_should_return_collection()
{
DbProviderInfo providerInfo;
using (var context = new ShopContext_v1())
{
var storageMappingItemCollection = context.GetModel().GetStorageMappingItemCollection(out providerInfo);
Assert.NotNull(storageMappingItemCollection);
Assert.NotNull(providerInfo);
Assert.Equal("System.Data.SqlClient", providerInfo.ProviderInvariantName);
if (DatabaseTestHelpers.IsSqlAzure(context.Database.Connection.ConnectionString))
{
Assert.True(providerInfo.ProviderManifestToken == "2012.Azure");
}
}
}
public void DatabaseExists_returns_true_for_existing_database_when_no_master_nor_database_permissions()
{
using (var context = new NoMasterPermissionContext(SimpleConnectionString <NoMasterPermissionContext>()))
{
context.Database.Delete();
context.Database.Initialize(force: false);
}
using (var connection = new SqlConnection(SimpleConnectionString <NoMasterPermissionContext>()))
{
connection.Open();
using (var command = connection.CreateCommand())
{
// Double-check there's no user for this login
command.CommandText
= string.Format(
@"IF EXISTS (SELECT * FROM sys.sysusers WHERE name= N'EFTestSimpleModelUser')
BEGIN
DROP USER [EFTestSimpleModelUser]
END");
command.ExecuteNonQuery();
}
}
var connectionString
= SimpleConnectionStringWithCredentials <NoMasterPermissionContext>(
"EFTestSimpleModelUser",
"Password1");
using (var context = new NoMasterPermissionContext(connectionString))
{
if (DatabaseTestHelpers.IsSqlAzure(connectionString))
{
Assert.False(context.Database.Exists());
}
else
{
Assert.True(context.Database.Exists());
}
}
}
public void DatabaseExists_returns_true_for_existing_database_when_no_master_permissions()
{
using (var context = new NoMasterPermissionContext(SimpleConnectionString <NoMasterPermissionContext>()))
{
context.Database.Delete();
context.Database.Initialize(force: false);
}
using (var connection = new SqlConnection(SimpleConnectionString <NoMasterPermissionContext>()))
{
connection.Open();
if (DatabaseTestHelpers.IsSqlAzure(connection.ConnectionString))
{
// Scenario not supported on SqlAzure, need to be connected to master
// in order to view existing users
return;
}
using (var command = connection.CreateCommand())
{
command.CommandText = string.Format(
@"IF NOT EXISTS (SELECT * FROM sys.sysusers WHERE name= N'EFTestSimpleModelUser')
BEGIN
CREATE USER [EFTestSimpleModelUser] FOR LOGIN [EFTestSimpleModelUser]
END");
command.ExecuteNonQuery();
}
}
var connectionString
= SimpleConnectionStringWithCredentials <NoMasterPermissionContext>(
"EFTestSimpleModelUser",
"Password1");
using (var context = new NoMasterPermissionContext(connectionString))
{
// Note: Database gets created as part of TestInit
Assert.True(context.Database.Exists());
}
}
private void EnsureEfTestUserExists()
{
using (var connection = new SqlConnection(SimpleConnectionString("master")))
{
connection.Open();
if (DatabaseTestHelpers.IsSqlAzure(connection.ConnectionString))
{
var loginExists = ExecuteScalarReturnsOne(
connection,
"SELECT COUNT(*) FROM sys.sql_logins WHERE name = N'EFTestUser'");
if (!loginExists)
{
ExecuteNonQuery(connection, "CREATE LOGIN [EFTestUser] WITH PASSWORD=N'Password1'");
}
var userExists = ExecuteScalarReturnsOne(
connection,
"SELECT COUNT(*) FROM sys.sysusers WHERE name = N'EFTestUser'");
if (!userExists)
{
ExecuteNonQuery(connection, "CREATE USER [EFTestUser] FROM LOGIN [EFTestUser]");
ExecuteNonQuery(connection, "EXEC sp_addrolemember 'loginmanager', 'EFTestUser'");
ExecuteNonQuery(connection, "EXEC sp_addrolemember 'dbmanager', 'EFTestUser'");
}
}
else
{
ExecuteNonQuery(
connection,
@"IF NOT EXISTS (SELECT * FROM sys.server_principals WHERE name = N'EFTestUser')
BEGIN
CREATE LOGIN [EFTestUser] WITH PASSWORD=N'Password1', DEFAULT_DATABASE=[master], DEFAULT_LANGUAGE=[us_english], CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF
EXEC sys.sp_addsrvrolemember @loginame = N'EFTestUser', @rolename = N'sysadmin'
END");
}
}
}
private void DatabaseExists_returns_true_for_existing_attached_database_when_no_master_nor_database_permission(bool useInitialcatalog)
{
using (var context = new AttachedContext(SimpleAttachConnectionString <AttachedContext>()))
{
if (DatabaseTestHelpers.IsSqlAzure(context.Database.Connection.ConnectionString))
{
// SQL Azure does not suppot attaching databases
return;
}
// Ensure database is initialized
context.Database.Initialize(force: true);
}
// See CodePlex 1554 - Handle User Instance flakiness
MutableResolver.AddResolver <Func <IDbExecutionStrategy> >(new ExecutionStrategyResolver <IDbExecutionStrategy>(
SqlProviderServices.ProviderInvariantName, null, () => new SqlAzureExecutionStrategy()));
try
{
using (var context = new AttachedContext(
SimpleAttachConnectionStringWithCredentials <AttachedContext>(
"EFTestSimpleModelUser",
"Password1",
useInitialcatalog)))
{
Assert.True(context.Database.Exists(), "context.Database does not exist, actual connection string: " + context.Database.Connection.ConnectionString);
}
}
finally
{
MutableResolver.ClearResolvers();
using (var context = new AttachedContext(SimpleAttachConnectionString <AttachedContext>()))
{
context.Database.Delete();
}
}
}
private void AttachableDatabaseTest(Action <AttachedContext> testMethod, bool useInitialCatalog = true)
{
using (var context = new AttachedContext(SimpleAttachConnectionString <AttachedContext>(useInitialCatalog)))
{
// SQL Azure and LocalDB do not support attaching databases
var connectionString = context.Database.Connection.ConnectionString;
if (DatabaseTestHelpers.IsSqlAzure(connectionString) || DatabaseTestHelpers.IsLocalDb(connectionString))
{
return;
}
try
{
// Execute actual test
testMethod(context);
}
finally
{
// Ensure database is deleted/detached
context.Database.Delete();
}
}
}
protected bool ShouldRun(IAttributeInfo factAttribute, TestGroup testGroup)
{
#if SkipMigrationsTests
if (testGroup == TestGroup.MigrationsTests)
{
return(false);
}
#endif
#if SkipSlowTests
if (testGroup != TestGroup.Default)
{
return(false);
}
#endif
if (factAttribute.GetNamedArgument <bool>(nameof(ExtendedFactAttribute.SkipForSqlAzure)))
{
var connectionString = ConfigurationManager.AppSettings["BaseConnectionString"];
if (DatabaseTestHelpers.IsSqlAzure(connectionString))
{
return(false);
}
}
if (factAttribute.GetNamedArgument <bool>(nameof(ExtendedFactAttribute.SkipForLocalDb)))
{
var connectionString = ConfigurationManager.AppSettings["BaseConnectionString"];
if (DatabaseTestHelpers.IsLocalDb(connectionString))
{
return(false);
}
}
return(true);
}
protected bool ShouldRun(TestGroup testGroup)
{
#if SkipMigrationsTests
if (testGroup == TestGroup.MigrationsTests)
{
return(false);
}
#endif
#if SkipSlowTests
if (testGroup != TestGroup.Default)
{
return(false);
}
#endif
if (SkipForSqlAzure)
{
var connectionString = ConfigurationManager.AppSettings["BaseConnectionString"];
if (DatabaseTestHelpers.IsSqlAzure(connectionString))
{
return(false);
}
}
if (SkipForLocalDb)
{
var connectionString = ConfigurationManager.AppSettings["BaseConnectionString"];
if (DatabaseTestHelpers.IsLocalDb(connectionString))
{
return(false);
}
}
return(true);
}
private void TransactionHandler_and_ExecutionStrategy_does_not_retry_on_false_commit_fail_implementation(
Action <BlogContextCommit> runAndVerify, int queryFailures = 0)
{
var failingTransactionInterceptorMock = new Mock <FailingTransactionInterceptor> {
CallBase = true
};
var failingTransactionInterceptor = failingTransactionInterceptorMock.Object;
DbInterception.Add(failingTransactionInterceptor);
var failingCommandInterceptor = new FailingCommandInterceptor();
DbInterception.Add(failingCommandInterceptor);
var isSqlAzure = DatabaseTestHelpers.IsSqlAzure(ModelHelpers.BaseConnectionString);
MutableResolver.AddResolver <Func <IDbExecutionStrategy> >(
key =>
(Func <IDbExecutionStrategy>)
(() => isSqlAzure
? new SuspendableSqlAzureExecutionStrategy()
: (IDbExecutionStrategy) new SqlAzureExecutionStrategy(maxRetryCount: 2, maxDelay: TimeSpan.FromMilliseconds(1))));
try
{
using (var context = new BlogContextCommit())
{
failingTransactionInterceptor.ShouldFailTimes = 0;
context.Database.Delete();
Assert.Equal(1, context.Blogs.Count());
failingTransactionInterceptor.ShouldFailTimes = 2;
failingTransactionInterceptor.ShouldRollBack = false;
failingCommandInterceptor.FailAfter = 1;
failingCommandInterceptor.ShouldFailTimes = queryFailures;
context.Blogs.Add(new BlogContext.Blog());
runAndVerify(context);
failingTransactionInterceptorMock.Verify(
m => m.Committing(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext>()),
isSqlAzure
? Times.AtLeast(3)
: Times.Exactly(3));
}
using (var context = new BlogContextCommit())
{
Assert.Equal(2, context.Blogs.Count());
using (var transactionContext = new TransactionContext(context.Database.Connection))
{
using (var infoContext = GetInfoContext(transactionContext))
{
Assert.True(
!infoContext.TableExists("__Transactions") ||
!transactionContext.Transactions.Any());
}
}
}
}
finally
{
DbInterception.Remove(failingTransactionInterceptorMock.Object);
DbInterception.Remove(failingCommandInterceptor);
MutableResolver.ClearResolvers();
}
DbDispatchersHelpers.AssertNoInterceptors();
}
private void Execute_commit_failure_test(
Action <Action> verifyInitialization, Action <Action> verifySaveChanges, int expectedBlogs, bool useTransactionHandler,
bool useExecutionStrategy, bool rollbackOnFail)
{
using (var context = new BlogContextCommit())
{
ExtendedSqlAzureExecutionStrategy.ExecuteNew(
() =>
{
context.Database.Delete();
});
}
var failingTransactionInterceptorMock = new Mock <FailingTransactionInterceptor> {
CallBase = true
};
var failingTransactionInterceptor = failingTransactionInterceptorMock.Object;
DbInterception.Add(failingTransactionInterceptor);
if (useTransactionHandler)
{
MutableResolver.AddResolver <Func <TransactionHandler> >(
new TransactionHandlerResolver(() => new CommitFailureHandler(), null, null));
}
var isSqlAzure = DatabaseTestHelpers.IsSqlAzure(ModelHelpers.BaseConnectionString);
if (useExecutionStrategy)
{
MutableResolver.AddResolver <Func <IDbExecutionStrategy> >(
key =>
(Func <IDbExecutionStrategy>)
(() => isSqlAzure
? new SuspendableSqlAzureExecutionStrategy()
: (IDbExecutionStrategy)
new SqlAzureExecutionStrategy(maxRetryCount: 2, maxDelay: TimeSpan.FromMilliseconds(1))));
}
else
{
FunctionalTestsConfiguration.SuspendExecutionStrategy = true;
}
try
{
using (var context = new BlogContextCommit())
{
failingTransactionInterceptor.ShouldFailTimes = 1;
failingTransactionInterceptor.ShouldRollBack = rollbackOnFail;
verifyInitialization(() => context.Blogs.Count());
failingTransactionInterceptor.ShouldFailTimes = 0;
ExtendedSqlAzureExecutionStrategy.ExecuteNew(
() =>
{
Assert.Equal(1, context.Blogs.Count());
});
failingTransactionInterceptor.ShouldFailTimes = 1;
context.Blogs.Add(new BlogContext.Blog());
verifySaveChanges(() => context.SaveChanges());
var expectedCommitCount = useTransactionHandler
? useExecutionStrategy
? 6
: rollbackOnFail && !isSqlAzure
? 4
: 3
: 4;
failingTransactionInterceptorMock.Verify(
m => m.Committing(It.IsAny <DbTransaction>(), It.IsAny <DbTransactionInterceptionContext>()),
isSqlAzure
? Times.AtLeast(expectedCommitCount)
: Times.Exactly(expectedCommitCount));
}
using (var context = new BlogContextCommit())
{
ExtendedSqlAzureExecutionStrategy.ExecuteNew(
() =>
{
Assert.Equal(expectedBlogs, context.Blogs.Count());
});
using (var transactionContext = new TransactionContext(context.Database.Connection))
{
using (var infoContext = GetInfoContext(transactionContext))
{
ExtendedSqlAzureExecutionStrategy.ExecuteNew(
() =>
{
Assert.True(
!infoContext.TableExists("__Transactions") ||
!transactionContext.Transactions.Any());
});
}
}
}
}
finally
{
FunctionalTestsConfiguration.SuspendExecutionStrategy = false;
DbInterception.Remove(failingTransactionInterceptor);
MutableResolver.ClearResolvers();
}
DbDispatchersHelpers.AssertNoInterceptors();
}
