public void MainTest() { Require.ProviderIs(StorageProvider.SqlServer); var initialConfig = DomainConfigurationFactory.Create(); initialConfig.Types.Register(typeof(model.MainTestModel.TestEntity)); initialConfig.Types.Register(typeof(model.MainTestModel.TestEntity2)); initialConfig.UpgradeMode = DomainUpgradeMode.Recreate; using (var domain = Domain.Build(initialConfig)) { } // useful work var configration = DomainConfigurationFactory.Create(); configration.Types.Register(typeof(model.MainTestModel.TestEntity)); configration.Types.Register(typeof(model.MainTestModel.TestEntity2)); configration.UpgradeMode = DomainUpgradeMode.PerformSafely; Exception exception = null; int step = 0; for (var i = 0; i < 30; i++, step++) { try { using (var domain = Domain.Build(configration)) { } } catch (Exception e) { exception = e; break; } } Assert.That(exception, Is.Null); Assert.That(step, Is.EqualTo(30)); }
public void Main() { Require.ProviderIs(StorageProvider.SqlServer); // Initialize domain Domain domain; try { var domainConfig = DomainConfigurationFactory.Create(); domainConfig.NamingConvention.NamespacePolicy = NamespacePolicy.AsIs; // Load assemblies with persistent classes from configuration : TestLog.Info("Loading plugins..."); domainConfig.Types.Register(typeof(QueueProcessor).Assembly, typeof(QueueProcessor).Namespace); domainConfig.UpgradeMode = DomainUpgradeMode.Recreate; domain = Domain.Build(domainConfig); } catch (DomainBuilderException e) { TestLog.Error("Domain build failed: " + e.ToString()); throw; } string key = CreateObjects.CreateTestEchoQueueProcessor(domain); IList <object> workList = QueueProcessor.GetWork(key, domain); foreach (object workUnit in workList) { QueueProcessor.Execute(key, workUnit, domain); } }
public void InternalTest(Func <DomainConfiguration, Domain> generator) { var config = DomainConfigurationFactory.Create(); config.Types.Register(typeof(IHasName).Assembly, typeof(IHasName).Namespace); var domain = generator(config); using (var session = domain.OpenSession()) using (var t = session.OpenTransaction()) { new A() { Name = "A" }; new B() { Name = "B" }; new C() { Name = "C" }; var hasNames = session.Query.All <IHasName>().ToList(); Assert.AreEqual(2, hasNames.Count); t.Complete(); } }
public void MainTest() { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(typeof(Test)); configuration.Types.Register(typeof(Test2)); configuration.UpgradeMode = DomainUpgradeMode.Recreate; using (var domain = Domain.Build(configuration)) { using (var session = domain.OpenSession()) using (session.Activate()) using (var t = session.OpenTransaction()) { var test2 = new Test2(); var test = new Test { Name = "", Struct = new StructType { Item = test2 } }; t.Complete(); } using (var session = domain.OpenSession()) using (session.Activate()) using (var t = session.OpenTransaction()) { var test2 = Session.Current.Query.All <Test2>().SingleOrDefault(); var result2 = test2.StructSet.OfType <Test>().ToList(); } } }
private void BuildDomain(DomainUpgradeMode upgradeMode) { CleanDomain(); var config = DomainConfigurationFactory.Create(); config.NamingConvention.NamespacePolicy = NamespacePolicy.Synonymize; config.NamingConvention.NamespaceSynonyms[typeof(NonClustered.Root).Namespace] = "NC"; config.NamingConvention.NamespaceSynonyms[typeof(Clustered.Root).Namespace] = "C"; config.NamingConvention.NamespaceSynonyms[typeof(CustomClustered.Root).Namespace] = "CC"; config.NamingConvention.NamespaceSynonyms[typeof(ErrorCases.DuplicateClusteredIndex).Namespace] = "E"; foreach (var type in domainTypes) { config.Types.Register(type); } config.Types.Register(typeof(SingleTableSchemaModifier).Assembly, typeof(SingleTableSchemaModifier).Namespace); config.UpgradeMode = upgradeMode; if (inheritanceSchema != null) { InheritanceSchemaModifier.ActivateModifier(inheritanceSchema.Value); } else { InheritanceSchemaModifier.DeactivateModifiers(); } domain = Domain.Build(config); }
public void MainTest() { var configuration1 = DomainConfigurationFactory.Create(); configuration1.Types.Register(typeof(InconsistentDefaultDateTimeValuesModel1.MyEntity)); configuration1.UpgradeMode = DomainUpgradeMode.Recreate; using (var domain1 = Domain.Build(configuration1)) using (var session = domain1.OpenSession()) using (var ts = session.OpenTransaction()) { new InconsistentDefaultDateTimeValuesModel1.MyEntity(); ts.Complete(); } var configuration2 = DomainConfigurationFactory.Create(); configuration2.Types.Register(typeof(InconsistentDefaultDateTimeValuesModel2.MyEntity)); configuration2.Types.Register(typeof(Upgrader)); configuration2.UpgradeMode = DomainUpgradeMode.Perform; using (var domain2 = Domain.Build(configuration2)) using (var session = domain2.OpenSession()) using (var ts = session.OpenTransaction()) { var count = session.Query.All <InconsistentDefaultDateTimeValuesModel2.MyEntity>().Count(); Assert.AreEqual(1, count); session.Query.All <InconsistentDefaultDateTimeValuesModel2.MyEntity>().First(entity => entity.Value == DateTime.MinValue); ts.Complete(); } }
public async Task ConnectionExtensionExistanceAsyncTest(int amoundOtAccessors) { var domainConfig = DomainConfigurationFactory.Create(); domainConfig.UpgradeMode = DomainUpgradeMode.Recreate; foreach (var accessor in GetAccessors(amoundOtAccessors)) { domainConfig.Types.Register(accessor); } await using (var domain = await Domain.BuildAsync(domainConfig)) await using (var session = await domain.OpenSessionAsync()) { var nativeHandler = (SqlSessionHandler)session.Handler; var extensions = nativeHandler.Connection.Extensions; if (amoundOtAccessors > 0) { Assert.That(extensions.Count, Is.EqualTo(1)); var extension = extensions.Get <DbConnectionAccessorExtension>(); Assert.That(extension, Is.Not.Null); Assert.That(extension.Accessors.Count, Is.EqualTo(amoundOtAccessors)); } else { Assert.That(extensions.Count, Is.EqualTo(0)); } } }
public void ConnectionExtensionExistanceTest(int includeHandlersCount) { var domainConfig = DomainConfigurationFactory.Create(); domainConfig.UpgradeMode = DomainUpgradeMode.Recreate; foreach (var accessor in GetAccessors(includeHandlersCount)) { domainConfig.Types.Register(accessor); } using (var domain = Domain.Build(domainConfig)) using (var session = domain.OpenSession()) { var nativeHandler = (SqlSessionHandler)session.Handler; var extensions = nativeHandler.Connection.Extensions; if (includeHandlersCount > 0) { Assert.That(extensions.Count, Is.EqualTo(1)); var extension = extensions.Get <DbConnectionAccessorExtension>(); Assert.That(extension, Is.Not.Null); Assert.That(extension.Accessors.Count, Is.EqualTo(includeHandlersCount)); } else { Assert.That(extensions.Count, Is.EqualTo(0)); } } }
public void MediaTest() { var config = DomainConfigurationFactory.Create(); config.Types.Register(typeof(Media)); config.Types.Register(typeof(Track <SimpleMedia>)); config.Types.Register(typeof(Track <ComplexMedia>)); config.Types.Register(typeof(SimpleTrack)); config.Types.Register(typeof(ComplexTrack)); var domain = Domain.Build(config); using (var session = domain.OpenSession()) using (var t = session.OpenTransaction()) { new SimpleTrack(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(10), new SimpleMedia() { Description = "Simple", Foo = 23 }); new ComplexTrack(TimeSpan.FromMinutes(6), TimeSpan.FromMinutes(15), new ComplexMedia() { Description = "Simple", Bar = DateTime.Now }); var listSimpleMedia = session.Query.All <Track <SimpleMedia> >().ToList(); var listComplexMedia = session.Query.All <Track <ComplexMedia> >().ToList(); Assert.AreEqual(1, listSimpleMedia.Count); Assert.AreEqual(1, listComplexMedia.Count); } }
private async Task BuildDomainAsync(string version, DomainUpgradeMode upgradeMode, int?keyCacheSize, params Type[] types) { if (domain != null) { domain.Dispose(); } var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = upgradeMode; foreach (var type in types) { configuration.Types.Register(type); } if (keyCacheSize.HasValue) { configuration.KeyGeneratorCacheSize = keyCacheSize.Value; } configuration.Types.Register(typeof(Upgrader)); using (Upgrader.Enable(version)) { domain = await Domain.BuildAsync(configuration); } }
private Xtensive.Orm.Configuration.DomainConfiguration BuildConfiguration0() { var config = DomainConfigurationFactory.Create(); config.Types.Register(CompileAssembly(0), "Modules.Model"); return(config); }
public void MainTest() { Require.ProviderIs(StorageProvider.SqlServer); var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = DomainUpgradeMode.Recreate; configuration.Types.Register(typeof(SomeEntity1)); configuration.Types.Register(typeof(SomeEntity2)); using (var domain = Domain.Build(configuration)) using (var session = domain.OpenSession()) using (var transaction = session.OpenTransaction()) { var accessor = session.Services.Get <DirectSqlAccessor>(); using (var command = accessor.CreateCommand()) { command.CommandText = CreateIndexQuery; _ = command.ExecuteNonQuery(); } transaction.Complete(); } configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = DomainUpgradeMode.Perform; configuration.Types.Register(typeof(SomeEntity1)); configuration.Types.Register(typeof(CustomUpgradeHandler)); Assert.DoesNotThrow(() => Domain.Build(configuration).Dispose()); }
public void MainTest() { var domainConfiguration = DomainConfigurationFactory.Create(); domainConfiguration.UpgradeMode = DomainUpgradeMode.Recreate; foreach (var type in typeof(FormElement).Assembly.GetTypes()) { if (typeof(IEntityBase).IsAssignableFrom(type)) { domainConfiguration.Types.Register(type); } } using (var domain = Domain.Build(domainConfiguration)) { using (var session = domain.OpenSession()) using (session.Activate()) using (var transaction = Session.Current.OpenTransaction()) { var externalDataField = new ExternalDataField(Guid.NewGuid()) { SysName = "ee" }; var eee = new FormElement.TpVisibleEnable(Guid.NewGuid(), externalDataField); transaction.Complete(); } using (var session = domain.OpenSession()) using (session.Activate()) using (var transaction = Session.Current.OpenTransaction()) { var e1 = Query.All <ExternalDataField>().Single(); e1.Remove(); transaction.Complete(); } } }
private Task <Domain> BuildDomainAsync(DomainUpgradeMode mode) { var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = mode; return(Domain.BuildAsync(configuration)); }
private void CreateAccessor() { var nodeConfiguration = new NodeConfiguration(); var configuration = DomainConfigurationFactory.Create(); var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider); var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory); var storageDriver = StorageDriver.Create(driverFactory, configuration); var nameBuilder = new NameBuilder(configuration, storageDriver.ProviderInfo); var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory); var accessor = new UpgradeServiceAccessor { Configuration = configuration, StorageDriver = storageDriver, NameBuilder = nameBuilder, HandlerFactory = handlerFactory }; configuration.Lock(); var connection = storageDriver.CreateConnection(null); connection.Open(); accessor.MappingResolver = MappingResolver.Create(configuration, nodeConfiguration, storageDriver.GetDefaultSchema(connection)); if (storageDriver.ProviderInfo.Supports(ProviderFeatures.SingleConnection)) { accessor.RegisterTemporaryResource(connection); } else { accessor.RegisterResource(connection); } accessor.Connection = connection; accessor.Connection.Extensions.AddOne(new TypeDelegator(typeof(IProviderExecutor))); this.accessor = accessor; }
private Domain BuildDomain(DomainUpgradeMode mode) { var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = mode; return(Domain.Build(configuration)); }
protected virtual DomainConfiguration BuildConfiguration() { var configuration = DomainConfigurationFactory.Create(); RegisterTypes(configuration); return(configuration); }
public void CombinedTest() { if (domain != null) { domain.DisposeSafely(); } var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = DomainUpgradeMode.Recreate; configuration.Types.Register(typeof(PropertyVersion <decimal?>)); domain = Domain.Build(configuration); using (var session = domain.OpenSession()) { using (var t = session.OpenTransaction()) { var v = new PropertyVersion <decimal?>() { PropertyValue = 123 }; t.Complete(); } using (var t = session.OpenTransaction()) { var count = session.Query.All <PropertyVersion <decimal?> >().Count(); Assert.AreEqual(1, count); var v = session.Query.All <PropertyVersion <decimal?> >().FirstOrDefault(); Assert.IsNotNull(v); Assert.AreEqual(123, v.PropertyValue); t.Complete(); } } }
public async Task SessionConnectionAccessorsAsyncTest() { var domainConfig = DomainConfigurationFactory.Create(); domainConfig.UpgradeMode = DomainUpgradeMode.Recreate; domainConfig.Types.Register(typeof(DummyEntity)); domainConfig.Types.Register(typeof(MyConnectionAccessor)); Guid?first = null; await using (var domain = await Domain.BuildAsync(domainConfig)) await using (var session = await domain.OpenSessionAsync()) { var nativeHandler = (SqlSessionHandler)session.Handler; var extension = nativeHandler.Connection.Extensions.Get <DbConnectionAccessorExtension>(); var accessorInstance = (MyConnectionAccessor)extension.Accessors.First(); Assert.That(accessorInstance.ConnectionOpeningCounter, Is.Not.EqualTo(0)); Assert.That(accessorInstance.ConnectionOpenedCounter, Is.Not.EqualTo(0)); first = accessorInstance.UniqueInstanceIdentifier; } Guid?second = null; await using (var domain = await Domain.BuildAsync(domainConfig)) await using (var session = await domain.OpenSessionAsync()) { var nativeHandler = (SqlSessionHandler)session.Handler; var extension = nativeHandler.Connection.Extensions.Get <DbConnectionAccessorExtension>(); var accessorInstance = (MyConnectionAccessor)extension.Accessors.First(); Assert.That(accessorInstance.ConnectionOpeningCounter, Is.Not.EqualTo(0)); Assert.That(accessorInstance.ConnectionOpenedCounter, Is.Not.EqualTo(0)); second = accessorInstance.UniqueInstanceIdentifier; } Assert.That(first != null && second != null && first != second, Is.True); }
private Domain BuildDomain(DomainUpgradeMode upgradeMode, Type sampleType) { var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = upgradeMode; configuration.Types.Register(sampleType.Assembly, sampleType.Namespace); return(Domain.Build(configuration)); }
private DomainConfiguration BuildDomainConfiguration() { var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = DomainUpgradeMode.Recreate; ApplyCustomConfigurationSettings(configuration); return(configuration); }
private DomainConfiguration BuildConfiguration(Type t) { var config = DomainConfigurationFactory.Create(); config.Types.Register(t.Assembly, t.Namespace); config.UpgradeMode = DomainUpgradeMode.Recreate; return(config); }
public void MainAsyncTest() { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(typeof(UpgradeHandler1)); configuration.Types.Register(typeof(UpgradeHandler2)); _ = Assert.ThrowsAsync <DomainBuilderException>(async() => await Domain.BuildAsync(configuration)); }
protected virtual DomainConfiguration BuildConfiguration() { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(typeof(ITrackingMonitor).Assembly); configuration.Types.Register(typeof(AutoBuildTest).Assembly); return(configuration); }
protected virtual DomainConfiguration BuildInitialConfiguration() { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(typeof(CleanupUpgradeHandler)); configuration.UpgradeMode = DomainUpgradeMode.Recreate; return(configuration); }
protected virtual DomainConfiguration BuildUpgradeConfiguration() { var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = DomainUpgradeMode.Recreate; configuration.Types.Register(typeof(TestEntity)); return(configuration); }
private void BuildDomain(Type type, DomainUpgradeMode upgradeMode) { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(type); configuration.UpgradeMode = upgradeMode; Domain.Build(configuration).Dispose(); }
protected override DomainConfiguration BuildConfiguration() { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(typeof(Book).Assembly, typeof(Book).Namespace); configuration.UpgradeMode = DomainUpgradeMode.Recreate; return(configuration); }
private Task <Domain> BuildDomainAsync(Type sampleType, DomainUpgradeMode mode) { var configuration = DomainConfigurationFactory.Create(); configuration.UpgradeMode = mode; configuration.Types.Register(sampleType.Assembly, sampleType.Namespace); return(Domain.BuildAsync(configuration)); }
public void MainTest() { var configuration = DomainConfigurationFactory.Create(); configuration.Types.Register(typeof(UpgradeHandler1)); configuration.Types.Register(typeof(UpgradeHandler2)); AssertEx.Throws <DomainBuilderException>(() => Domain.Build(configuration)); }