public async Task CreateAsync_ReturnSuccess_And_CreateNotBlockedUserInDb_When_PassingClientWithUri()
{
await this.InsertDefaultClient(1);
await this.InsertDefaultClient(2);
await this.InsertDefaultClient(3);
var repository = new SqlCeClientRepository(this.ConnectionFactory);
RepositoryResponse response = await repository.CreateAsync(new NewIdSrvClientDto { Name = "n", Secret = "s", Uri = "u" });
Assert.AreEqual(RepositoryResponse.Success, response);
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
IEnumerable <IdSrvClientDto> clients = await db.Query("Clients").GetAsync <IdSrvClientDto>();
Assert.AreEqual(4, clients.Count());
IdSrvClientDto createdClient = clients.Where(c => c.Name == "n").FirstOrDefault();
Assert.IsNotNull(createdClient);
Assert.AreEqual("n", createdClient.Name);
Assert.AreEqual("s", createdClient.Secret);
Assert.AreEqual("u", createdClient.Uri);
Assert.IsFalse(createdClient.IsBlocked);
}
}
public async Task DeleteAsync_ReturnSuccess_And_DeleteClientsFromDb_When_DoubleInvokedWithExistingIds()
{
Guid[] ids = new Guid[3];
ids[0] = await this.InsertDefaultClient(1);
ids[1] = await this.InsertDefaultClient(2);
ids[2] = await this.InsertDefaultClient(3);
var notExistingId = Guid.NewGuid();
while (ids.Contains(notExistingId))
{
notExistingId = Guid.NewGuid();
}
var repository = new SqlCeClientRepository(this.ConnectionFactory);
RepositoryResponse response = await repository.DeleteAsync(ids[0]);
Assert.AreEqual(RepositoryResponse.Success, response);
response = await repository.DeleteAsync(ids[2]);
Assert.AreEqual(RepositoryResponse.Success, response);
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
IEnumerable <Guid> clientsIds = await db.Query("Clients").Select("Id").GetAsync <Guid>();
Assert.AreEqual(ids.Except(new Guid[] { ids[0], ids[2] }).ToList().OrderBy(x => x), clientsIds.ToList().OrderBy(x => x));
}
}
public TestConfiguration()
{
var connectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0", string.Empty,
$"Data Source=\"{DbFile}\";Password={Password}");
SetDefaultConnectionFactory(connectionFactory);
}
public async Task CreateAsync_ReturnConflict_And_DoNotChangeDb_When_PassingClientNameAlreadyExists()
{
Guid[] ids = new Guid[3];
ids[0] = await this.InsertDefaultClient(1);
ids[1] = await this.InsertDefaultClient(2);
ids[2] = await this.InsertDefaultClient(3);
var repository = new SqlCeClientRepository(this.ConnectionFactory);
RepositoryResponse response = await repository.CreateAsync(new NewIdSrvClientDto { Name = "n1", Secret = "s", Uri = "u" });
Assert.AreEqual(RepositoryResponse.Conflict, response);
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
IEnumerable <IdSrvClientDto> clients = await db.Query("Clients").GetAsync <IdSrvClientDto>();
Assert.AreEqual(3, clients.Count());
for (int i = 1; i <= 3; ++i)
{
Assert.AreEqual(ids[i - 1], clients.ElementAt(i - 1).Id);
Assert.AreEqual($"n{i}", clients.ElementAt(i - 1).Name);
Assert.AreEqual($"u{i}", clients.ElementAt(i - 1).Uri);
Assert.AreEqual($"p{i}", clients.ElementAt(i - 1).Secret);
Assert.AreEqual(false, clients.ElementAt(i - 1).IsBlocked);
}
}
}
public async Task ChangeBlockingAsync_ReturnSuccess_And_DoNotChangeClientInDb_When_BlockingExistingBlockedClient()
{
Guid[] ids = new Guid[3];
ids[0] = await this.InsertDefaultClient(1);
ids[1] = await this.InsertDefaultClient(2, isBlocked : true);
ids[2] = await this.InsertDefaultClient(3);
var repository = new SqlCeClientRepository(this.ConnectionFactory);
RepositoryResponse response = await repository.ChangeBlockingAsync(new IdSrvClientBlockDto
{
Id = ids[1],
IsBlocked = true
});
Assert.AreEqual(RepositoryResponse.Success, response);
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
IEnumerable <IdSrvClientDto> clients = await db.Query("Clients").GetAsync <IdSrvClientDto>();
Assert.AreEqual(3, clients.Count());
for (int i = 1; i <= 3; ++i)
{
Assert.AreEqual(ids[i - 1], clients.ElementAt(i - 1).Id);
Assert.AreEqual($"n{i}", clients.ElementAt(i - 1).Name);
Assert.AreEqual($"u{i}", clients.ElementAt(i - 1).Uri);
Assert.AreEqual($"p{i}", clients.ElementAt(i - 1).Secret);
Assert.AreEqual(i == 2, clients.ElementAt(i - 1).IsBlocked);
}
}
}
/// <summary>
/// 初始化连接工厂
/// </summary>
public virtual void InitConnectionFactory()
{
var connectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
//TODO fix compilation warning (below)
#pragma warning disable 0618
Database.DefaultConnectionFactory = connectionFactory;
}
public static IDbConnection Create(Connection cn)
{
IDbConnection output;
switch (cn.Provider)
{
case "sqlserver":
output = new SqlServerConnectionFactory(cn).GetConnection();
break;
case "mysql":
output = new MySqlConnectionFactory(cn).GetConnection();
break;
case "postgresql":
output = new PostgreSqlConnectionFactory(cn).GetConnection();
break;
case "sqlite":
output = new SqLiteConnectionFactory(cn).GetConnection();
break;
case "sqlce":
output = new SqlCeConnectionFactory(cn).GetConnection();
break;
default:
throw new DataException($"Provider {cn.Provider} is not supported!");
}
output.Open();
return(output);
}
/// <summary>
/// Initialize connection factory
/// </summary>
public virtual void InitConnectionFactory()
{
var connectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
//TODO fix compilation warning (below)
#pragma warning disable 0618
Database.DefaultConnectionFactory = connectionFactory;
}
public void SqlCeConnectionFactory_treats_improperly_start_formed_environment_style_as_path_which_then_throws()
{
var factory = new SqlCeConnectionFactory("System.Data.FakeSqlClient", @"AnyaLovesXander|", "");
Assert.Equal(
GenerateException(() => Path.Combine("|", "Willow")).Message,
Assert.Throws <ArgumentException>(() => factory.CreateConnection("FakeDatabaseName")).Message);
}
public void SqlCeConnectionFactory_uses_database_name_as_sdf_filename_even_when_database_name_already_ends_in_sdf()
{
var factory = new SqlCeConnectionFactory("System.Data.FakeSqlClient");
var connection = factory.CreateConnection("FakeDatabaseName.sdf");
Assert.Equal("Data Source=|DataDirectory|FakeDatabaseName.sdf; ", connection.ConnectionString);
}
/// <summary>
/// 初始化SqlCe数据库连接工厂
/// </summary>
public virtual void InitConnectionFactory()
{
var connectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
#pragma warning disable 618
Database.DefaultConnectionFactory = connectionFactory;
#pragma warning restore 618
}
public void SqlCeConnectionFactory_with_properly_formed_environment_style_is_concatenated_correctly()
{
var factory = new SqlCeConnectionFactory("System.Data.FakeSqlClient", @"|BuffyLovesAngel|", "");
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal(@"Data Source=|BuffyLovesAngel|FakeDatabaseName.sdf; ", connection.ConnectionString);
}
public async Task GetConnectionAsync_ReturnOpenedConnection_When_PassingRealConnectionStringToCtor()
{
var factory = new SqlCeConnectionFactory(this.TestConnectionString);
using (IDbConnection connection = await factory.GetConnectionAsync())
{
Assert.AreEqual(ConnectionState.Open, connection.State);
}
}
public void SqlCeConnectionFactory_throws_when_a_bad_base_connection_string_is_used()
{
var factory = new SqlCeConnectionFactory(
"System.Data.SqlServerCe.4.0", "",
"Whats On The End Of The Stick Vic=Admiral Nelsons Final Flannel");
Assert.Throws <ArgumentException>(() => factory.CreateConnection("Something")).ValidateMessage(
_sqlCeAssembly.Value, "ADP_KeywordNotSupported", null, "whats on the end of the stick vic");
}
public DbContextTestsForSqlCe()
{
_previousConnectionFactory = DefaultConnectionFactoryResolver.Instance.ConnectionFactory;
var sqlCeConnectionFactory = new SqlCeConnectionFactory(
"System.Data.SqlServerCe.4.0",
AppDomain.CurrentDomain.BaseDirectory, "");
DefaultConnectionFactoryResolver.Instance.ConnectionFactory = sqlCeConnectionFactory;
}
public async Task SetUp()
{
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
await db.Query("Clients").DeleteAsync();
}
}
public void SqlCeConnectionFactory_uses_changed_database_path_when_creating_connection_string()
{
var factory = new SqlCeConnectionFactory("System.Data.FakeSqlClient", @"C:\VicAndBobs\Novelty Island", "");
Assert.Equal(@"C:\VicAndBobs\Novelty Island", factory.DatabaseDirectory);
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal(@"Data Source=C:\VicAndBobs\Novelty Island\FakeDatabaseName.sdf; ", connection.ConnectionString);
}
public void SqlCeConnectionFactory_uses_changed_base_connection_string_when_creating_connection_string()
{
var factory = new SqlCeConnectionFactory("System.Data.FakeSqlClient", "", "Persist Security Info=False");
Assert.Equal("Persist Security Info=False", factory.BaseConnectionString);
var connection = factory.CreateConnection("FakeDatabaseName");
Assert.Equal("Data Source=FakeDatabaseName.sdf; Persist Security Info=False", connection.ConnectionString);
}
public void SqlCeConnectionFactory_creates_a_SQL_CE_connection_from_a_database_name()
{
using (
var connection =
new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0").CreateConnection("FakeDatabaseName"))
{
var sqlCeExceptionType = _sqlCeAssembly.Value.GetType("System.Data.SqlServerCe.SqlCeConnection");
Assert.IsType(sqlCeExceptionType, connection);
Assert.Equal("Data Source=|DataDirectory|FakeDatabaseName.sdf; ", connection.ConnectionString);
}
}
public void GetConnectionAsync_DoesNoThrow_When_PassingRealConnectionStringToCtor()
{
var factory = new SqlCeConnectionFactory(this.TestConnectionString);
Assert.DoesNotThrowAsync(async() =>
{
using (await factory.GetConnectionAsync())
{
}
});
}
public void Ce_Insert_LowLevel()
{
long ms = 0;
using (new MetricTracker("Starting complex object", t => ms = t))
{
Level1 level1 = new Level1();
level1.Value = "test";
level1.levels = new List <Level2>();
for (int i = 0; i < 5; i++)
{
Level2 curLevel2 = new Level2();
level1.levels.Add(curLevel2);
curLevel2.Value = "test" + i.ToString();
curLevel2.levels = new List <Level3>();
for (int j = 0; j < 5; j++)
{
Level3 curLevel3 = new Level3();
curLevel2.levels.Add(curLevel3);
curLevel3.Value = "test" + j.ToString();
curLevel3.levels = new List <Level4>();
for (int k = 0; k < 10; k++)
{
Level4 curLevel4 = new Level4();
curLevel3.levels.Add(curLevel4);
curLevel4.Value = "test" + k.ToString();
curLevel4.levels = new List <Level5>();
for (int l = 0; l < 10; l++)
{
Level5 curLevel5 = new Level5();
curLevel4.levels.Add(curLevel5);
curLevel5.Value = "test" + l.ToString();
}
}
}
}
SqlCeConnectionFactory cf = new SqlCeConnectionFactory("System.Data.SqlServerCE.4.0");
using (SqlCeConnection conn = (SqlCeConnection)cf.CreateConnection(@"c:\temp\myDataPoor.sdf"))
{
conn.Open();
// Level1
int parentId = SqlCeInsertAdapterLevels.Write_Level1(level1, conn);
}
}
ms.Should().BeLessThan(775);
}
public void DbContext_construction_does_not_throw_but_subsequent_calls_using_connection_throw_for_invalid_SqlCE_connection_string()
{
var sqlCeAssembly =
new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0").CreateConnection("Dummy").GetType().Assembly;
var context = new SimpleModelContextWithNoData("Data Sourc=Scenario_Use_AppConfig.sdf");
Assert.Throws <ArgumentException>(() => GetObjectContext(context)).ValidateMessage(
sqlCeAssembly,
"ADP_KeywordNotSupported",
"System.Data.SqlServerCe",
"data sourc");
}
public void SqlCeConnectionFactory_throws_when_a_connection_with_bad_database_path_is_used()
{
var factory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0", @"//C:::\\\D:\\D::::D\\\", "");
using (var connection = factory.CreateConnection("FakeDatabaseName"))
{
Assert.Throws <NotSupportedException>(() => connection.Open()).ValidateMessage(
typeof(File).Assembly,
"Argument_PathFormatNotSupported",
null);
}
}
public void GetConnectionAsync_Throws_When_PassingRealConnectionStringToCtor()
{
var factory = new SqlCeConnectionFactory(@"Data Source=C:\Users\test_compact_db.sdf");
Assert.ThrowsAsync <SqlCeException>(async() =>
{
using (IDbConnection connection = await factory.GetConnectionAsync())
{
Assert.AreEqual(ConnectionState.Open, connection.State);
}
});
}
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 SetUp()
{
var filePath = @"bank_test.sdf";
if (File.Exists(filePath))
{
File.Delete(filePath);
}
string connectionString = "Data Source = " + filePath;
var connFac = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
Database.DefaultConnectionFactory = connFac;
repo = new EFRepository(connectionString);
}
SqlCeConnectionFactory_creates_a_SQL_CE_connection_using_changed_database_path_and_base_connection_string()
{
var factory = new SqlCeConnectionFactory(
"System.Data.SqlServerCe.4.0", @"C:\VicAndBob\",
"Persist Security Info=False");
using (var connection = factory.CreateConnection("FakeDatabaseName"))
{
var sqlCeExceptionType = _sqlCeAssembly.Value.GetType("System.Data.SqlServerCe.SqlCeConnection");
Assert.IsType(sqlCeExceptionType, connection);
Assert.Equal(
@"Data Source=C:\VicAndBob\FakeDatabaseName.sdf; Persist Security Info=False",
connection.ConnectionString);
}
}
public void SqlCeConnectionFactory_throws_when_provider_returns_null_connection()
{
try
{
FakeSqlProviderFactory.Instance.ForceNullConnection = true;
var factory = new SqlCeConnectionFactory("System.Data.FakeSqlClient");
Assert.Equal(
Strings.DbContext_ProviderReturnedNullConnection,
Assert.Throws <InvalidOperationException>(() => factory.CreateConnection("FakeDatabaseName")).Message);
}
finally
{
FakeSqlProviderFactory.Instance.ForceNullConnection = false;
}
}
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);
}
}
public async Task InsertInDb_InsertNullAsUri_When_UriNotSpecified()
{
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
await db.Query("Clients").InsertAsync(new
{
Name = "n",
Secret = "s"
});
IdSrvClientDto client = await db.Query("Clients").Where(new { Name = "n" }).FirstOrDefaultAsync <IdSrvClientDto>();
Assert.IsNull(client.Uri);
}
}
public async Task UpdateAsync_ReturnNotFound_And_DoNotChangeClientsInDb_When_PassingNotExisintClientId()
{
Guid[] ids = new Guid[3];
ids[0] = await this.InsertDefaultClient(1);
ids[1] = await this.InsertDefaultClient(2);
ids[2] = await this.InsertDefaultClient(3);
var repository = new SqlCeClientRepository(this.ConnectionFactory);
var notExisintGuid = Guid.NewGuid();
while (ids.Contains(notExisintGuid))
{
notExisintGuid = Guid.NewGuid();
}
RepositoryResponse response = await repository.UpdateAsync(new UpdateIdSrvClientDto
{
Id = notExisintGuid,
Name = "n",
Secret = "p",
Uri = "u"
});
Assert.AreEqual(RepositoryResponse.NotFound, response);
using (IDbConnection connection = await this.ConnectionFactory.GetConnectionAsync())
{
var compiler = new SqlServerCompiler();
var db = new QueryFactory(connection, compiler);
this.ConnectionFactory = new SqlCeConnectionFactory(this.TestConnectionString);
IEnumerable <IdSrvClientDto> clients = await db.Query("Clients").GetAsync <IdSrvClientDto>();
Assert.AreEqual(3, clients.Count());
for (int i = 1; i <= 3; ++i)
{
Assert.AreEqual(ids[i - 1], clients.ElementAt(i - 1).Id);
Assert.AreEqual($"n{i}", clients.ElementAt(i - 1).Name);
Assert.AreEqual($"u{i}", clients.ElementAt(i - 1).Uri);
Assert.AreEqual($"p{i}", clients.ElementAt(i - 1).Secret);
Assert.AreEqual(false, clients.ElementAt(i - 1).IsBlocked);
}
}
}
