protected DatabaseBaseTest(DbAccessType type, bool asyncExecution, bool syncronised, params object[] additionalArguments) { //TestContext.CurrentContext.Test.Properties.Add("Type", type); AdditionalArguments = additionalArguments.Concat(new[] { asyncExecution ? "1" : "0", Synronised ? "1" : "0" }).ToArray(); Type = type; AsyncExecution = asyncExecution; Synronised = syncronised; }
public LocalRemotingStrategy(DbAccessType emulateDbType, DbConfig config, RemotingManager manager, string instanceName) : base(emulateDbType, config) { _manager = manager; var wrapper = _manager._subManager.GetWrapper(_manager._subManager.DbAccessType, instanceName); RemotingConsumerServer = new RemotingConsumerServer(() => { return(wrapper); }); }
/// <inheritdoc /> public RemotingStrategyExternal(DbAccessType emulateDbType, DbConfig config) : base(emulateDbType, config) { ConnectionIds = new ConcurrentDictionary <RemotingDbConnection, string>(); TransactionIds = new ConcurrentDictionary <RemoteDbTransaction, string>(); Events.ConnectionOpened += Events_ConnectionOpened; Events.ConnectionClosed += Events_ConnectionClosed; Events.TransactionCreated += Events_TransactionCreated; Events.TransactionCommit += Events_TransactionCommit; Events.TransactionRollback += Events_TransactionRollback; }
public DbAccessLayer GetWrapper(DbAccessType type) { DbAccessLayer expectWrapper = null; var elementType = GetElementType(); expectWrapper = _managers[type].GetWrapper(type); //if (elementType == DbAccessType.MsSql) //{ // expectWrapper = new MsSqlManager().GetWrapper(); //} //else if (elementType == DbAccessType.SqLite) //{ // expectWrapper = new SqLiteManager().GetWrapper(); //} _errorData = new StringBuilder(); expectWrapper.RaiseEvents = true; expectWrapper.OnSelect += (sender, eventArg) => { _errorData.AppendFormat(@"SELECT: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnDelete += (sender, eventArg) => { _errorData.AppendFormat(@"DELETE: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnInsert += (sender, eventArg) => { _errorData.AppendFormat(@"INSERT: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnUpdate += (sender, eventArg) => { _errorData.AppendFormat(@"Update: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; Assert.NotNull(expectWrapper, "This test cannot run as no Database Variable is defined"); bool checkDatabase = expectWrapper.CheckDatabase(); Assert.IsTrue(checkDatabase); expectWrapper.Config.ConstructorSettings.FileCollisonDetection = CollisonDetectionMode.Pessimistic; expectWrapper.Config.ConstructorSettings.CreateDebugCode = false; expectWrapper.Multipath = true; QueryDebugger.UseDefaultDatabase = expectWrapper.DatabaseStrategy; return expectWrapper; }
/// <summary> /// Create a DbAccessLayer that uses a Predefined type and Connection string /// </summary> public DbAccessLayer(DbAccessType dbAccessType, string connection, DbConfig config = null) : this(config) { if (dbAccessType == DbAccessType.Unknown) { throw new InvalidEnumArgumentException("dbAccessType", (int)DbAccessType.Unknown, typeof(DbAccessType)); } DbAccessType = dbAccessType; Database = new DefaultDatabaseAccess(new InstanceConnectionController()); var database = GenerateStrategyFromExternal(ProviderCollection.FirstOrDefault(s => s.Key == dbAccessType).Value, connection); Database.Attach(database); DatabaseStrategy = database; }
/// <inheritdoc /> public string CreationCommand(DbAccessType accessType) { switch (accessType) { case DbAccessType.MsSql: return(CreateMsSql); case DbAccessType.MySql: return(CreateMySql); case DbAccessType.SqLite: return(CreateSqLite); default: throw new ArgumentOutOfRangeException(nameof(accessType), accessType, null); } }
public DbAccessLayer GetWrapper(DbAccessType type, string testName) { if (ConfigurationManager.AppSettings["RDBMS.MySql.StartManagedServer"] == "True") { if (!MySqlConnectorInstance.Instance.HasStarted) { MySqlConnectorInstance.Instance.CreateDatabaseFiles().Wait(); MySqlConnectorInstance.Instance.RunMySql(); } } var dbname = string.Format("YAORM_TestDb_{0}", testName); if (_expectWrapper != null) { _expectWrapper.Database.CloseAllConnection(); } //Darn MySql with only 64 chars? if (dbname.Length > 64) { dbname = dbname.Substring(dbname.Length - 64); } var redesginDatabase = string.Format( "DROP DATABASE IF EXISTS {0};", dbname); _expectWrapper = new DbAccessLayer(DbAccessType, ConnectionString, new DbConfig(true)); _expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand(redesginDatabase)); _expectWrapper.ExecuteGenericCommand( _expectWrapper.Database.CreateCommand(string.Format("CREATE DATABASE {0};", dbname))); _expectWrapper = new DbAccessLayer(DbAccessType, string.Format(ConnectionString + "Database={0};", dbname)); foreach (var databaseMeta in MetaManager.DatabaseMetas) { _expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand(databaseMeta.Value.CreationCommand(DbAccessType))); } //_expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand("CREATE PROC TestProcA " + // "AS BEGIN " + // "SELECT * FROM Users " + // "END")); //_expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand("CREATE PROC TestProcB @bigThen INT " + // "AS BEGIN " + // "SELECT * FROM Users us WHERE @bigThen > us.User_ID " + // "END ")); return(_expectWrapper); }
public DbAccessLayer GetWrapper(DbAccessType type) { const string dbname = "testDB"; if (expectWrapper != null) { expectWrapper.Database.CloseAllConnection(); } var redesginDatabase = string.Format( "IF EXISTS (select * from sys.databases where name=\'{0}\') DROP DATABASE {0}", dbname); expectWrapper = new DbAccessLayer(DbAccessType, ConnectionString, null, new DbConfig(true)); try { expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(string.Format("ALTER DATABASE {0} SET SINGLE_USER WITH ROLLBACK IMMEDIATE ", dbname))); } catch (Exception) { Console.WriteLine("Db does not exist"); } expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(redesginDatabase)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(string.Format("CREATE DATABASE {0}", dbname))); expectWrapper = new DbAccessLayer(DbAccessType, string.Format(ConnectionString + "Initial Catalog={0};", dbname)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(UsersMeta.CreateMsSql)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(BookMeta.CreateMsSQl)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(ImageMeta.CreateMsSQl)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand("CREATE PROC TestProcA " + "AS BEGIN " + "SELECT * FROM Users " + "END")); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand("CREATE PROC TestProcB @bigThen INT " + "AS BEGIN " + "SELECT * FROM Users us WHERE @bigThen > us.User_ID " + "END ")); return expectWrapper; }
public DbAccessLayer GetWrapper(DbAccessType type) { if (expectWrapper != null) { expectWrapper.Database.CloseAllConnection(); } //string dbname = "testDB"; //var sqlLiteFileName = dbname + ".sqlite"; var tempPath = Path.GetTempFileName(); expectWrapper = new DbAccessLayer(DbAccessType, string.Format(ConnectionString, tempPath)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(UsersMeta.CreateSqLite)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(BookMeta.CreateSqLite)); expectWrapper.ExecuteGenericCommand(expectWrapper.Database.CreateCommand(ImageMeta.CreateSqLite)); return expectWrapper; }
public DbAccessLayer GetWrapper(DbAccessType type, string testName) { _dbname = string.Format("YAORM_2_TestDb_Test_MsSQL_{0}", testName); if (_expectWrapper != null) { _expectWrapper.Database.CloseAllConnection(); } var dbConfig = new DbConfig(true); dbConfig.EnableInstanceThreadSafety = true; _expectWrapper = new DbAccessLayer(DbAccessType, ConnectionString, dbConfig); var redesginDatabase = string.Format( "IF EXISTS (select * from sys.databases where name=\'{0}\') DROP DATABASE {0}", _dbname); _expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand(redesginDatabase)); _expectWrapper.ExecuteGenericCommand( _expectWrapper.Database.CreateCommand(string.Format("CREATE DATABASE {0}", _dbname))); _expectWrapper = new DbAccessLayer(DbAccessType, string.Format(ConnectionString + "Initial Catalog={0};", _dbname), dbConfig); foreach (var databaseMeta in MetaManager.DatabaseMetas) { _expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand(databaseMeta.Value.CreationCommand(DbAccessType))); } _expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand("CREATE PROC TestProcA " + "AS BEGIN " + "SELECT * FROM Users " + "END")); _expectWrapper.ExecuteGenericCommand( _expectWrapper.Database.CreateCommand("CREATE PROC TestProcB @bigThen INT " + "AS BEGIN " + "SELECT * FROM Users us WHERE @bigThen > us.User_ID " + "END ")); return(_expectWrapper); }
/// <summary> /// 获取数据连接对象 /// </summary> /// <param name="accessType">数据库类型:读/写,默认使用写库</param> /// <returns></returns> public IDbConnection GetDbConnection(DbAccessType accessType = DbAccessType.Write) { IDbConnection conn = null; if (OpenRwSeparate && accessType == DbAccessType.Read) { try { conn = GetReadSqlConn(); } catch { conn = GetSqlConnection(_dbWriteConnectInfo); } } else { conn = GetSqlConnection(_dbWriteConnectInfo); } return(conn); }
public DbAccessLayer GetWrapper(DbAccessType type, string testName) { if (_expectWrapper != null) { _expectWrapper.Database.CloseAllConnection(); } SqLiteInteroptWrapper.EnsureSqLiteInteropt(); //string dbname = "testDB"; //var sqlLiteFileName = dbname + ".sqlite"; var sqLiteConnection = Environment.ExpandEnvironmentVariables(ConfigurationManager .ConnectionStrings["RDBMS.SqLite.DefaultConnection"].ConnectionString); var connectionRegex = new Regex("Data Source=(.*);").Match(sqLiteConnection); _dbFilePath = Path.Combine(connectionRegex.Groups[1].Value, string.Format("YAORM_SqLite_{0}.db", testName)); var connection = sqLiteConnection.Replace(connectionRegex.Groups[1].Value, _dbFilePath); if (File.Exists(_dbFilePath)) { GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); File.Delete(_dbFilePath); } File.Create(_dbFilePath).Dispose(); //var file = MemoryMappedFile.CreateNew(dbname, 10000, MemoryMappedFileAccess.ReadWrite); //tempPath = Path.GetTempFileName() + dbname + "sqLite"; _expectWrapper = new DbAccessLayer(new DataAccess.SqLite.SqLiteStrategy(connection), new DbConfig(true)); foreach (var databaseMeta in MetaManager.DatabaseMetas) { _expectWrapper.ExecuteGenericCommand(_expectWrapper.Database.CreateCommand(databaseMeta.Value.CreationCommand(DbAccessType))); } return(_expectWrapper); }
/// <summary> /// /// </summary> /// <param name="emulateDbType"></param> /// <param name="config"></param> public RemotingStrategy(DbAccessType emulateDbType, DbConfig config) { Config = config; SourceDatabase = DbAccessType.Remoting | emulateDbType; Events = new RemotingStrategyEvents(); }
public QueryBuilderTests(DbAccessType type, bool asyncExecution, bool syncronised, bool asyncEnumeration) : base(type, asyncExecution, syncronised, asyncEnumeration) { _asyncEnumeration = asyncEnumeration; }
public SelectionTests(DbAccessType type, bool egarLoading, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised, egarLoading.ToString()) { _egarLoading = egarLoading; }
public CheckWrapperDatabaseBaseTests(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
public static void AddManager(DbAccessType type, IManager manager) { _managers.Add(type, manager); }
/// <inheritdoc /> public InsertTests(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
/// <inheritdoc /> public UpdateRefreshTests(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
/// <summary> /// Creates an instance based on a Ctor injection or Reflection loading /// or when using a MsCoreLib type direct enumeration /// </summary> /// <returns></returns> public static object CreateInstance(DbClassInfoCache classInfo, IDataRecord reader, out bool fullLoaded, DbAccessType? accessType = null) { if (classInfo.Type.Assembly == MsCoreLibAssembly && reader.FieldCount == 1) { fullLoaded = true; return reader.GetValue(0); } if (classInfo.Factory != null) { fullLoaded = classInfo.FullFactory; return classInfo.Factory(reader); } var objectFactorys = classInfo.Constructors.Where(s => s.Arguments.Count == 1 && s.Arguments.First().Type == typeof(IDataRecord)) .ToArray(); var constructor = objectFactorys.FirstOrDefault(s => s.Attributes.Any(f => f.Attribute is ObjectFactoryMethodAttribute && (!accessType.HasValue || ((ObjectFactoryMethodAttribute) f.Attribute).TargetDatabase == accessType.Value))); if (constructor == null) constructor = objectFactorys.FirstOrDefault(); //maybe single ctor with param if (constructor != null) { if (constructor.Arguments.Count == 1 && constructor.Arguments.First().Type == typeof(IDataRecord)) { classInfo.FullFactory = true; classInfo.Factory = s => constructor.Invoke(new object[] {s}); return CreateInstance(classInfo, reader, out fullLoaded, accessType); } } else { //check for a Factory mehtod var factory = classInfo.Mehtods .FirstOrDefault(s => s.Attributes.Any(f => f.Attribute is ObjectFactoryMethodAttribute)); if (factory != null) { if (factory.MethodInfo.IsStatic) { var methodInfo = factory.MethodInfo as MethodInfo; if (methodInfo != null) { var returnType = methodInfo.ReturnParameter; if (returnType != null && returnType.ParameterType == classInfo.Type) { if (factory.Arguments.Count == 1 && factory.Arguments.First().Type == typeof(IDataRecord)) { classInfo.FullFactory = true; classInfo.Factory = s => factory.Invoke(new object[] {reader}); return CreateInstance(classInfo, reader, out fullLoaded, accessType); } } } } } } var emptyCtor = classInfo.Constructors.FirstOrDefault(f => !f.Arguments.Any()); if (emptyCtor == null) { throw new NotSupportedException( "You have to define ether an ObjectFactoryMethod as static or constructor with and IDataReader or an constructor without any arguments"); } classInfo.FullFactory = false; classInfo.Factory = s => emptyCtor.Invoke(new object[0]); return CreateInstance(classInfo, reader, out fullLoaded, accessType); }
public QueryBuilderTests(DbAccessType type, bool asyncExecution, bool syncronised, bool asyncEnumeration, EnumerationMode enumerationMode) : base(type, asyncExecution, syncronised, enumerationMode, asyncEnumeration) { _enumerationMode = enumerationMode; _asyncEnumeration = asyncEnumeration; }
public PagerUnitTest(DbAccessType type) { _type = type; }
public EventTest(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
public static object ReflectionPropertySet( DbConfig config, object instance, DbClassInfoCache info, IDataRecord reader, Dictionary<int, DbPropertyInfoCache> cache, DbAccessType? dbAccessType) { if (instance == null) throw new ArgumentNullException("instance"); if (info == null) throw new ArgumentNullException("info"); if (reader == null) return instance; //Left c# property name and right the object to read from the reader //var listofpropertys = new Dictionary<string, object>(); var propertys = info.Propertys.ToArray(); var instanceOfFallbackList = new Dictionary<string, object>(); if (cache == null) { cache = new Dictionary<int, DbPropertyInfoCache>(); for (var i = 0; i < reader.FieldCount; i++) { DbPropertyInfoCache val = null; info.Propertys.TryGetValue(info.SchemaMappingDatabaseToLocal(reader.GetName(i)), out val); cache.Add(i, val); } } for (var i = 0; i < reader.FieldCount; i++) { var property = cache[i]; var value = reader.GetValue(i); if (property != null) { var attributes = property.Attributes; var valueConverterAttributeModel = attributes.FirstOrDefault(s => s.Attribute is ValueConverterAttribute); //Should the SQL value be converted if (valueConverterAttributeModel != null) { var converter = valueConverterAttributeModel.Attribute as ValueConverterAttribute; //Create the converter and then convert the value before everything else var valueConverter = converter.CreateConverter(); value = valueConverter.Convert(value, property.PropertyInfo.PropertyType, converter.Parameter, CultureInfo.CurrentCulture); } var xmlAttributeModel = attributes.FirstOrDefault(s => s.Attribute is FromXmlAttribute); //should the Content be considerd as XML text? if (xmlAttributeModel != null) { //Get the XML text and check if its null or empty var xmlStream = value.ToString(); if (string.IsNullOrEmpty(xmlStream)) { continue; } //Check for List //if this is a list we are expecting other entrys inside if (property.CheckForListInterface()) { //target Property is of type list //so expect a xml valid list Take the first element and expect the propertys inside this first element var record = XmlDataRecord.TryParse(xmlStream, property.PropertyInfo.PropertyType.GetGenericArguments().FirstOrDefault(), false, config); var xmlDataRecords = record.CreateListOfItems(); var genericArguments = config.GetOrCreateClassInfoCache(property.PropertyInfo.PropertyType.GetGenericArguments().FirstOrDefault()); var enumerableOfItems = xmlDataRecords.Select( s => DbAccessLayerHelper.SetPropertysViaReflection(genericArguments, s, dbAccessType, config)).ToList(); object castedList; if (genericArguments.Type.IsClass && genericArguments.Type.GetInterface("INotifyPropertyChanged") != null) { var caster = typeof(DbCollection<>).MakeGenericType(genericArguments.Type).GetConstructor(new[] {typeof(IEnumerable)}); Debug.Assert(caster != null, "caster != null"); castedList = caster.Invoke(new object[] {enumerableOfItems}); } else { var caster = typeof(NonObservableDbCollection<>).MakeGenericType(genericArguments.Type) .GetConstructor(new[] {typeof(IEnumerable)}); Debug.Assert(caster != null, "caster != null"); castedList = caster.Invoke(new object[] {enumerableOfItems}); } property.Setter.Invoke(instance, castedList); } else { var classInfo = config.GetOrCreateClassInfoCache(property .PropertyInfo .PropertyType); var xmlDataRecord = XmlDataRecord.TryParse(xmlStream, property.PropertyInfo.PropertyType, true, config); //the t var xmlSerilizedProperty = DbAccessLayerHelper.SetPropertysViaReflection(classInfo, xmlDataRecord, dbAccessType, config); property.Setter.Invoke(instance, xmlSerilizedProperty); } } else if (value is DBNull || value == null) { property.Setter.Invoke(instance, new object[] {null}); } else { object changedType; if (value.GetType() != property.PropertyInfo.PropertyType) { changedType = DataConverterExtensions.ChangeType(value, property.PropertyInfo.PropertyType); } else { changedType = value; } property.Setter.Invoke(instance, changedType); } } //This variable is null if we tried to find a property with the LoadNotImplimentedDynamicAttribute but did not found it else if (instanceOfFallbackList != null) { //no property found Look for LoadNotImplimentedDynamicAttribute property to include it if (instanceOfFallbackList.Any()) { instanceOfFallbackList.Add(reader.GetName(i), value); } else { var maybeFallbackProperty = propertys.FirstOrDefault( s => s.Value.Attributes.Any(e => e.Attribute is LoadNotImplimentedDynamicAttribute)); if (maybeFallbackProperty.Value != null) { instanceOfFallbackList = (Dictionary<string, object>) maybeFallbackProperty.Value.Getter.Invoke(instance); if (instanceOfFallbackList == null) { instanceOfFallbackList = new Dictionary<string, object>(); maybeFallbackProperty.Value.Setter.Invoke(instance, instanceOfFallbackList); } instanceOfFallbackList.Add(reader.GetName(i), value); } else { instanceOfFallbackList = null; } } } } //foreach (var item in listofpropertys) //{ // var property = propertys.FirstOrDefault(s => s.PropertyName == item.Key); //} if (reader is EgarDataRecord) { (reader as IDisposable).Dispose(); } return instance; }
public DbAccessor(DbAccessType accessType, string connectionString) : this() { this._AccessType = accessType; this._ConnectionString = connectionString; this.CreateAccessCommand(); }
public DbAccessor() { this._AccessType = DbAccessType.Sql; }
public static bool HasFlagFast(this DbAccessType value, DbAccessType flag) { return((value & flag) != 0); }
/// <summary> /// Create a DbAccessLayer that uses a Predefined type and Connection string /// </summary> public DbAccessLayer(DbAccessType dbAccessType, string connection, ILogger logger = null, DbConfig config = null) : this(logger, config) { if (dbAccessType == DbAccessType.Unknown) { throw new InvalidEnumArgumentException("dbAccessType", (int) DbAccessType.Unknown, typeof(DbAccessType)); } DbAccessType = dbAccessType; Database = new DefaultDatabaseAccess(); var database = GenerateStrategy(ProviderCollection.FirstOrDefault(s => s.Key == dbAccessType).Value, connection); Database.Attach(database); DatabaseStrategy = database; }
/// <inheritdoc /> public PagerConstraintTests(DbAccessType type) : base(type, false, false) { }
public PerformanceTests(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
public PagerConstraintTests(DbAccessType type) { _type = type; }
/// <summary> /// Creates a new Instance based on possible Ctor's and the given /// <paramref name="reader" /> /// </summary> /// <returns></returns> public object SetPropertysViaReflection(DbClassInfoCache type, IDataRecord reader, DbAccessType? accessType) { return type.SetPropertysViaReflection(reader, DbAccessType, Config); }
/// <inheritdoc /> public ProcedureTests(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
public ConfigurationTests(DbAccessType type, bool asyncExecution, bool syncronised) : base(type, asyncExecution, syncronised) { }
public DbAccessLayer GetWrapper(DbAccessType type, params object[] additionalArguments) { DbAccessLayer expectWrapper = null; _errorData.AppendLine("---------------------------------------------"); _errorData.AppendLine("Found " + type); Assert.That(new DbConfig().SClassInfoCaches, Is.Empty, () => "The Global Class cache is not empty"); var testClassName = TestContext.CurrentContext.Test.ClassName.Replace(typeof(Manager).Namespace, "").Where(e => char.IsUpper(e)).Select(e => e.ToString()) .Aggregate((e, f) => e + f) + "." + TestContext.CurrentContext.Test.MethodName; //var arguments = // additionalArguments.Select( // f => // { // if (f == null) // { // return TestContext.CurrentContext.Random.NextShort().ToString(); // } // if (typeof(string).Assembly.GetTypes().Contains(f.GetType())) // { // return f.ToString(); // } // return f.GetHashCode().ToString(); // }) // .ToArray(); //if (arguments.Any()) //{ // testClassName = //} testClassName = testClassName + "_" + Guid.NewGuid().ToString("N"); testClassName = new Regex("[^a-zA-Z0-9]").Replace(testClassName, "_"); _errorData.AppendLine($"Attach to Database: {testClassName}"); expectWrapper = (_selectedMgr = _managers[type]()).GetWrapper(type, testClassName); expectWrapper.Config.EnableInstanceThreadSafety = true; expectWrapper.RaiseEvents = true; expectWrapper.OnSelect += (sender, eventArg) => { _errorData.AppendFormat(@"SELECT: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnDelete += (sender, eventArg) => { _errorData.AppendFormat(@"DELETE: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnInsert += (sender, eventArg) => { _errorData.AppendFormat(@"INSERT: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnUpdate += (sender, eventArg) => { _errorData.AppendFormat(@"UPDATE: \r\n{0}", eventArg.QueryDebugger); _errorData.AppendLine(); }; expectWrapper.OnFailedQuery += (sender, eventArg, exception) => { _errorData.AppendFormat(@"Query Failed: \r\n{0}\r\n{1}", eventArg.QueryDebugger, exception); _errorData.AppendLine(); }; Assert.NotNull(expectWrapper, "This test cannot run as no Database Variable is defined"); var checkDatabase = expectWrapper.CheckDatabase(); Assert.IsTrue(checkDatabase); AllTestContextHelper.TestSetup(expectWrapper.Config.ConstructorSettings); expectWrapper.Multipath = true; return(expectWrapper); }
public DbAccessLayer GetWrapper(DbAccessType type, params object[] additionalArguments) { DbAccessLayer expectWrapper = null; _errorData.AppendLine("---------------------------------------------"); _errorData.AppendLine("Found " + type); Assert.That(new DbConfig().SClassInfoCaches, Is.Empty, () => "The Global Class cache is not empty"); var testClassName = TestContext.CurrentContext.Test.ClassName.Replace(typeof(Manager).Namespace, "") .Where(e => char.IsUpper(e)).Select(e => e.ToString()) .Aggregate((e, f) => e + f) + "." + TestContext.CurrentContext.Test.MethodName; testClassName = testClassName + "_" + Guid.NewGuid().ToString("N"); testClassName = new Regex("[^a-zA-Z0-9]").Replace(testClassName, "_"); _errorData.AppendLine($"Attach to Database: {testClassName}"); expectWrapper = (_selectedMgr = _managers[type]()).GetWrapper(type, testClassName); expectWrapper.Config.EnableInstanceThreadSafety = true; expectWrapper.RaiseEvents = true; expectWrapper.RaiseEventsAsync = false; expectWrapper.OnSelect += (sender, eventArg) => { _querys.Add(new KeyValuePair <string, string>("SELECT", eventArg.QueryDebugger.ToString())); }; expectWrapper.OnDelete += (sender, eventArg) => { _querys.Add(new KeyValuePair <string, string>("DELETE", eventArg.QueryDebugger.ToString())); }; expectWrapper.OnInsert += (sender, eventArg) => { _querys.Add(new KeyValuePair <string, string>("INSERT", eventArg.QueryDebugger.ToString())); }; expectWrapper.OnUpdate += (sender, eventArg) => { _querys.Add(new KeyValuePair <string, string>("UPDATE", eventArg.QueryDebugger.ToString())); }; expectWrapper.OnNonResultQuery += (sender, eventArg) => { _querys.Add(new KeyValuePair <string, string>("Query", eventArg.QueryDebugger.ToString())); }; expectWrapper.OnFailedQuery += (sender, eventArg, exception) => { _querys.Add(new KeyValuePair <string, string>("Query Failed", eventArg.QueryDebugger.ToString())); }; Assert.NotNull(expectWrapper, "This test cannot run as no Database Variable is defined"); var checkDatabase = expectWrapper.CheckDatabase(); Assert.IsTrue(checkDatabase); AllTestContextHelper.TestSetup(expectWrapper.Config.ConstructorSettings); expectWrapper.Multipath = true; return(expectWrapper); }
public CheckWrapperBaseTests(DbAccessType type) { _type = type; }
public DbAccessLayer GetWrapper(DbAccessType type, string instanceName) { return(new DbAccessLayer(_strategy = new LocalRemotingStrategy(type, new DbConfig(), this, instanceName + "RMT_"))); }
public QueryBuilderTests(DbAccessType type) { _type = type; Init(); }