public async Task DisposedTest() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().UsingIdGenerator(r => new Hyperstore.Modeling.Domain.LongIdGenerator()).CreateAsync("Test"); XReferencesY rel = null; using (var session = store.BeginSession()) { var lockX = session.AcquireLock(LockType.Shared, "X"); // Upgrade lock type to Exclusive lockX = session.AcquireLock(LockType.Exclusive, "X"); var lockY = session.AcquireLock(LockType.Exclusive, "Y"); lockX.Dispose(); // Release lockX } // Release lockY using (var s = store.BeginSession()) { var start = new XExtendsBaseClass(domain); var start2 = new XExtendsBaseClass(domain); start.OthersX.Add(start2); var end = new YClass(domain); rel = new XReferencesY(start, end); s.AcceptChanges(); } Assert.NotNull(rel); }
public async Task PropertyChangedOnSetReferenceTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().UsingIdGenerator(r => new LongIdGenerator()).CreateAsync("Test"); XExtendsBaseClass x = null; YClass y = null; var yrelationChanges = 0; var allPropertychanges = 0; using (var s = store.BeginSession()) { x = new XExtendsBaseClass(dm); s.AcceptChanges(); } x.PropertyChanged += (sender, e) => { allPropertychanges++; if (e.PropertyName == "YRelation") { yrelationChanges++; } }; using (var s = store.BeginSession()) { y = new YClass(dm) { Name = "1" }; x.YRelation = y; s.AcceptChanges(); } using (var s = store.BeginSession()) { y = new YClass(dm) { Name = "2" }; x.YRelation = y; s.AcceptChanges(); } var rel = x.GetRelationships <XReferencesY>().FirstOrDefault(); using (var s = store.BeginSession()) { x.YRelation = null; s.AcceptChanges(); } Assert.Equal(3, yrelationChanges); Assert.Equal(3, allPropertychanges); }
public async Task CalculatedPropertyTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); XExtendsBaseClass start = null; using (var s = store.BeginSession()) { start = new XExtendsBaseClass(dm); Assert.Equal(0, start.CalculatedValue); s.AcceptChanges(); } bool flag = false; start.PropertyChanged += (sender, e) => { if (e.PropertyName == "CalculatedValue") { flag = true; } }; using (var s = store.BeginSession()) { start.Value = 10; s.AcceptChanges(); } Assert.True(flag); Assert.Equal(50, start.CalculatedValue); }
public async Task DefineEnumPropertyTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test") as IUpdatableDomainModel; using (var s = store.BeginSession()) { ISchemaElement metadata = schema.Definition.XExtendsBaseClass; var e = new Hyperstore.Modeling.Metadata.Primitives.EnumPrimitive(schema, typeof(ETest)); var prop = metadata.DefineProperty <ETest>("enum"); IModelElement a = new XExtendsBaseClass(domain); var pv = domain.GetPropertyValue(a.Id, prop); Assert.Equal(0, pv.CurrentVersion); Assert.Equal(ETest.A, pv.Value); domain.SetPropertyValue(a, prop, ETest.B); pv = domain.GetPropertyValue(a.Id, prop); Assert.NotEqual(0, pv.CurrentVersion); Assert.Equal(ETest.B, pv.Value); s.AcceptChanges(); } }
public async Task SetReferenceToNullFromOppositeTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); XExtendsBaseClass x = null; YClass y = null; using (var s = store.BeginSession()) { x = new XExtendsBaseClass(dm); y = new YClass(dm) { Name = "1" }; x.YRelation = y; s.AcceptChanges(); } var rel = x.GetRelationships <XReferencesY>().FirstOrDefault(); using (var s = store.BeginSession()) { y.X = null; s.AcceptChanges(); } Assert.Equal(x.YRelation, null); Assert.Equal(((IModelElement)y).Status, ModelElementStatus.Disposed); Assert.Equal(x.GetRelationships <XReferencesY>().Count(), 0); }
public Modeling.Events.IEvent Handle(ExecutionCommandContext <MyCommand> context) { var a = new XExtendsBaseClass(DomainModel); a.Name = "Test"; return(new MyEvent(DomainModel, context.CurrentSession.SessionId)); }
public async Task ImplicitConstraint() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XExtendsBaseClass.AddImplicitConstraint(self => self.Name == "momo" , "Not null").Register(); try { using (var s = domain.Store.BeginSession()) { var a = new XExtendsBaseClass(domain); a.Name = "mama"; s.AcceptChanges(); } throw new Exception("Inconclusive"); } catch (SessionException ex) { Assert.True(ex.Messages.Count() == 1); } }
public async Task Contraint_Error_Notification() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XExtendsBaseClass.AddImplicitConstraint(self => self.Name != null, "Not null").Register(); bool sawError = false; domain.Events.OnErrors.Subscribe(m => { sawError = true; }); try { using (var s = domain.Store.BeginSession()) { var a = new XExtendsBaseClass(domain); s.AcceptChanges(); } throw new Exception("Inconclusive"); } catch (SessionException ex) { Assert.True(ex.Messages.Count() == 1); } Assert.Equal(true, sawError); }
public async Task SetReferenceToNullFromOpposite2Test() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); XExtendsBaseClass x = null; YClass y = null; using (var s = store.BeginSession()) { x = new XExtendsBaseClass(dm); y = new YClass(dm) { Name = "1" }; new XReferencesY(x, y); s.AcceptChanges(); } var rel = x.GetRelationships <XReferencesY>().FirstOrDefault(); using (var s = store.BeginSession()) { y.X = null; // TODO Since it's an embedded relationship and y is the opposite, y is deleted. Is it the wright behavior ??? s.AcceptChanges(); } Assert.Equal(x.YRelation, null); Assert.Equal(x.GetRelationships <XReferencesY>().Count(), 0); using (var s = store.BeginSession()) { y = new YClass(dm) { Name = "1" }; new XReferencesY(x, y); s.AcceptChanges(); } rel = x.GetRelationships <XReferencesY>().FirstOrDefault(); using (var s = store.BeginSession()) { x.YRelation = null; s.AcceptChanges(); } Assert.Equal(x.YRelation, null); Assert.Equal(((IModelElement)y).Status, ModelElementStatus.Disposed); Assert.Equal(x.GetRelationships <XReferencesY>().Count(), 0); }
private void UpdateElement(int max) { Parallel.For(0, max, i => { using (var tx = store.BeginSession()) { XExtendsBaseClass a = store.GetElement<XExtendsBaseClass>(ids[i]); a.Name = "Toto" + i; tx.AcceptChanges(); } }); }
private void ReadElement(int max) { //Parallel.For(0, max, i => for (int i = 0; i < max; i++) { using (var tx = store.BeginSession()) { XExtendsBaseClass a = store.GetElement<XExtendsBaseClass>(ids[i]); var x = a.Name; tx.AcceptChanges(); } } //); }
private void AddElement(IDomainModel domain, int max) { ids = new ConcurrentDictionary<int, Identity>(); Parallel.For(0, max, i => { using (var tx = store.BeginSession()) { var a = new XExtendsBaseClass(domain); if (ids.TryAdd(i, ((IModelElement)a).Id)) tx.AcceptChanges(); } }); }
public async Task SetReferenceTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); XExtendsBaseClass x = null; YClass y = null; using (var s = store.BeginSession()) { x = new XExtendsBaseClass(dm); y = new YClass(dm) { Name = "1" }; x.YRelation = y; s.AcceptChanges(); } Assert.Equal(x.YRelation, y); Assert.Equal(x.YRelation.X, x); Assert.Equal(y.X, x); var rel = x.GetRelationships <XReferencesY>().FirstOrDefault(); Assert.Equal(rel.Start, x); Assert.Equal(rel.End, y); using (var s = store.BeginSession()) { y = new YClass(dm) { Name = "2" }; x.YRelation = y; s.AcceptChanges(); } Assert.Equal(x.YRelation, y); Assert.Equal(x.YRelation.X, x); Assert.Equal(x.GetRelationships <XReferencesY>().Count(), 1); rel = x.GetRelationships <XReferencesY>().FirstOrDefault(); Assert.Equal(rel.Start, x); Assert.Equal(rel.End, y); }
public async Task EatConstraintException() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XExtendsBaseClass.AddImplicitConstraint(self => self.Name != null, "Not null").Register(); domain.Events.OnErrors.Subscribe(m => { m.SetSilentMode(); }); using (var s = domain.Store.BeginSession()) { var a = new XExtendsBaseClass(domain); s.AcceptChanges(); } }
// [Fact] public async Task MultiConstraints() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); // Loading domain using (var session = store.BeginSession(new SessionConfiguration { Mode = SessionMode.Loading | SessionMode.SkipConstraints })) { /// loading data session.AcceptChanges(); } var max = 200; var nbElem = 1000; int cx = max * nbElem; for (int i = 0; i < max; i++) { var x = i; schema.Definition.XExtendsBaseClass.AddImplicitConstraint(self => { System.Threading.Interlocked.Decrement(ref cx); return(self.Value > x); }, "error").Register(); } using (var s = domain.Store.BeginSession()) { for (int j = 0; j < nbElem; j++) { var a = new XExtendsBaseClass(domain); a.Value = max + 1; } s.AcceptChanges(); } Assert.Equal(0, cx); }
public async Task UndoInEmbeddedSessions() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var undoManager = new UndoManager(store); undoManager.RegisterDomain(domain); XExtendsBaseClass a; using (var s = store.BeginSession()) { a = new XExtendsBaseClass(domain); a.Name = "mama"; s.AcceptChanges(); } Assert.True(undoManager.CanUndo); Assert.False(undoManager.CanRedo); using (var s = store.BeginSession()) { using (var s2 = store.BeginSession()) { a.Name = "momo"; s2.AcceptChanges(); } s.AcceptChanges(); } Assert.True(undoManager.CanUndo); Assert.False(undoManager.CanRedo); undoManager.Undo(); Assert.True(undoManager.CanRedo); Assert.True(undoManager.CanUndo); Assert.Equal("mama", a.Name); }
public async Task ConstraintByComposition() { var store = await StoreBuilder.New().ComposeWith(typeof(ConstraintsTest).Assembly).CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); using (var s = store.BeginSession()) { var a = new XExtendsBaseClass(domain); a.Name = "mama"; s.AcceptChanges(); } // Pas d'erreur var result = schema.Constraints.Validate(domain.GetElements()); Assert.True(result.Messages.Count() == 1); }
public async Task IsAInheritTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); IModelElement a; using (var s = store.BeginSession()) { a = new XExtendsBaseClass(dm); s.AcceptChanges(); } Assert.True(a.SchemaInfo.IsA(schema.Definition.AbstractClass)); Assert.True(a.SchemaInfo.IsA(store.PrimitivesSchema.ModelEntitySchema)); Assert.False(((ISchemaElement)schema.Definition.AbstractClass).IsA(a.SchemaInfo)); }
public async Task Inherited_constraint() { await Assert.ThrowsAsync <SessionException>(async() => { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XExtendsBaseClass.AddImplicitConstraint(self => { return(self.Name != "xxx"); } , "Not null").Register(); using (var s = domain.Store.BeginSession()) { var a = new XExtendsBaseClass(domain); a.Name = "xxx"; s.AcceptChanges(); } }); }
public async Task ReferenceInRelationshipTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); XReferencesY rel = null; using (var s = store.BeginSession()) { var start = new XExtendsBaseClass(dm); var end = new YClass(dm); rel = new XReferencesY(start, end); rel.YRelation = end; s.AcceptChanges(); } Assert.NotNull(rel); Assert.NotNull(rel.YRelation); }
public async Task ExplicitConstraint() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XExtendsBaseClass.AddConstraint(self => self.Name == "momo" , "Not null").Register(); using (var s = store.BeginSession()) { var a = new XExtendsBaseClass(domain); a.Name = "mama"; s.AcceptChanges(); } // Pas d'erreur var result = schema.Constraints.Validate(domain.GetElements()); Assert.True(result.Messages.Count() == 1); }
public async Task RelationshipConstraintTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XReferencesY.AddImplicitConstraint(r => r.Weight > 0, "error").Register(); Assert.Throws <SessionException>( () => { XReferencesY rel = null; using (var s = store.BeginSession()) { var start = new XExtendsBaseClass(domain); var end = new YClass(domain); rel = new XReferencesY(start, end); rel.YRelation = end; s.AcceptChanges(); } }); }
public async Task Constraint_Cannot_modify_the_model() { await Assert.ThrowsAsync <SessionException>(async() => { Identity aid = null; var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); schema.Definition.XExtendsBaseClass.AddImplicitConstraint(self => { self.Name = "xxx"; // Forbidden return(true); } , "Not null").Register(); using (var s = domain.Store.BeginSession()) { var a = new XExtendsBaseClass(domain); aid = ((IModelElement)a).Id; s.AcceptChanges(); } }); }