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); } } }