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