public async Task AcquireExclusive2Test() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var factory = new TaskFactory(); var tasks = new Task[2]; for (int i = 0; i < tasks.Length; i++) { tasks[i] = factory.StartNew(() => { using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { s.AcquireLock(LockType.ExclusiveWait, "a"); Sleep(100); s.AcceptChanges(); } }); } Task.WaitAll(tasks); #if TEST Assert.True(((LockManager)((IStore)store).LockManager).IsEmpty()); #endif }
public async Task RollbackUpdateTest() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var provider = new TransactionalMemoryStore(domain); using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { provider.AddNode(new Data("1", 10)); s.AcceptChanges(); } using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { provider.UpdateNode(new Data("1", 20)); } using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { Assert.Equal(((Data)provider.GetNode(new Identity("test", "1"))).Value, 10); s.AcceptChanges(); } }
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 EmbeddedRelationship() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <LibraryDefinition>().CreateAsync(); var dm = await store.DomainModels.New().CreateAsync("Test"); Library lib; Book b; using (var s = store.BeginSession()) { lib = new Library(dm); lib.Name = "Library"; b = new Book(dm); b.Title = "book"; b.Copies = 1; lib.Books.Add(b); s.AcceptChanges(); } using (var s = store.BeginSession()) { lib.Books.Remove(b); s.AcceptChanges(); } Assert.Null(dm.GetElement <Book>(((IModelElement)b).Id)); Assert.Equal(0, lib.Books.Count()); }
// [Fact] public async Task BenchWithConstraints() { long nb = 0; store = await StoreBuilder.New().CreateAsync(); schema = await store.Schemas.New<TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var sw = new Stopwatch(); // Ajout de 100 contraintes var nbc = 100; for (int i = 0; i < nbc; i++) schema.Definition.XExtendsBaseClass.AddImplicitConstraint( self => System.Threading.Interlocked.Increment(ref nb) > 0, "OK"); sw.Start(); var mx = 10000; AddElement(domain, mx); UpdateElement(mx); ReadElement(mx); RemoveElement(mx); sw.Stop(); Assert.Equal(mx * nbc * 2, nb); // Nbre de fois la contrainte est appelée (sur le add et le update) Assert.True(sw.ElapsedMilliseconds < 4000, String.Format("ElapsedTime = {0}", sw.ElapsedMilliseconds)); }
public async Task UndoWithEnum() { 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); YClass y; using (var s = store.BeginSession()) { y = new YClass(domain); s.AcceptChanges(); } using (var s = store.BeginSession()) { y.Direction = Model.Direction.West; s.AcceptChanges(); } undoManager.Undo(); Assert.Equal(Model.Direction.South, y.Direction); undoManager.Redo(); Assert.Equal(Model.Direction.West, y.Direction); }
public async Task RegisterMany() { var store = await StoreBuilder.New().CreateAsync(); var r1 = store.Services; r1.Register <IService>(new Service()); r1.Register <IService>(new Service()); Assert.Equal(2, r1.ResolveAll <IService>().Count()); Assert.Equal(2, r1.Resolve <IService>().Id); Assert.Equal(2, r1.ResolveAll <IService>().First().Id); Assert.Equal(1, r1.ResolveAll <IService>().Last().Id); var r2 = r1.NewScope(); r2.Register <IService>(new Service()); Assert.Equal(3, r2.ResolveAll <IService>().Count()); Assert.Equal(3, r2.Resolve <IService>().Id); Assert.Equal(3, r2.ResolveAll <IService>().First().Id); // D'abord ceux de r2 Assert.Equal(1, r2.ResolveAll <IService>().Last().Id); // puis ceux de r1 r2.Dispose(); r1.Dispose(); }
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 Extension_constraint_in_readonly_mode() { var store = await StoreBuilder.New().EnableScoping().CreateAsync(); var schema = await store.Schemas.New <InitialDomainDefinition>().CreateAsync(); var initial = await store.DomainModels.New().CreateAsync("D1"); store.GetSchemaEntity <Category>().AddImplicitConstraint <Category>(c => c.Value < 10, "Invalid value"); Category cat; using (var s = store.BeginSession()) { cat = new Category(initial); cat.Value = 1; s.AcceptChanges(); } await schema.LoadSchemaExtension(new ExtensionsDomainDefinition(), SchemaConstraintExtensionMode.Replace); var extended = await initial.CreateScopeAsync("Ex1"); CategoryEx catx; using (var s = store.BeginSession()) { catx = store.GetElement <CategoryEx>(((IModelElement)cat).Id); catx.Value = 10; // Pas d'erreur car la contrainte ne s'applique pas s.AcceptChanges(); } }
public async Task RegisterByDomain() { var store = await StoreBuilder.New().CreateAsync(); var r1 = store.Services; r1.Register <IService>(services => new Service()); Assert.Equal(1, r1.Resolve <IService>().Id); Assert.Equal(1, r1.Resolve <IService>().Id); Assert.Equal(1, r1.Resolve <IService>().Id); Assert.Equal(1, r1.Resolve <IService>().Id); var r2 = r1.NewScope(); Assert.Equal(2, r2.Resolve <IService>().Id); Assert.Equal(2, r2.Resolve <IService>().Id); Assert.Equal(2, r2.Resolve <IService>().Id); Assert.Equal(2, r2.Resolve <IService>().Id); var r3 = r1.NewScope(); Assert.Equal(3, r3.Resolve <IService>().Id); Assert.Equal(3, r3.Resolve <IService>().Id); Assert.Equal(3, r3.Resolve <IService>().Id); Assert.Equal(3, r3.Resolve <IService>().Id); r3.Dispose(); r2.Dispose(); r1.Dispose(); }
public async Task Serialization() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <LibraryDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); Library lib; using (var session = store.BeginSession()) { lib = new Library(domain); lib.Name = "Lib1"; for (int i = 0; i < 5; i++) { var b = new Book(domain); b.Title = "Book \"book\" " + i.ToString(); b.Copies = i + 1; lib.Books.Add(b); var m = new Member(domain); m.Name = "Book " + i.ToString(); lib.Members.Add(m); } session.AcceptChanges(); } var text = Hyperstore.Modeling.Serialization.HyperstoreSerializer.Serialize(domain); Assert.Equal(11, domain.GetEntities().Count()); Assert.Equal(10, domain.GetRelationships().Count()); var store2 = await StoreBuilder.New().CreateAsync(); await store2.Schemas.New <LibraryDefinition>().CreateAsync(); var domain2 = await store2.DomainModels.New().CreateAsync("Test"); using (var reader = new MemoryStream(Encoding.UTF8.GetBytes(text))) { Hyperstore.Modeling.Serialization.XmlDeserializer.Deserialize(reader, domain2); } Assert.Equal(11, domain2.GetEntities().Count()); Assert.Equal(10, domain2.GetRelationships().Count()); foreach (var book2 in domain2.GetEntities <Book>()) { var book = domain.GetEntity <Book>(((IModelElement)book2).Id); Assert.NotNull(book); Assert.Equal(book.Title, book2.Title); Assert.Equal(book.Copies, book2.Copies); } lib = domain2.GetEntities <Library>().FirstOrDefault(); Assert.NotNull(lib); Assert.Equal(5, lib.Books.Count()); }
public async Task JsonSerialization() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <LibraryDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); Library lib; using (var session = store.BeginSession()) { lib = new Library(domain); lib.Name = "Lib1"; for (int i = 0; i < 1; i++) { var b = new Book(domain); b.Title = "Book \"book\" " + i.ToString(); b.Copies = i + 1; lib.Books.Add(b); var m = new Member(domain); m.Name = "Book " + i.ToString(); lib.Members.Add(m); } session.AcceptChanges(); } var text = Hyperstore.Modeling.Serialization.HyperstoreSerializer.Serialize(domain, new SerializationSettings { Options = SerializationOptions.Json | SerializationOptions.CompressSchema }); Assert.NotNull(text); Newtonsoft.Json.JsonConvert.DeserializeObject(text); }
public async Task AddInterceptorTest() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); int cx = 0; domain.Commands.RegisterInterceptor(new SharedInterceptor(() => { cx = 1; }), 1); using (var s = store.BeginSession()) { s.Execute(new MyCommand(domain)); s.AcceptChanges(); } Assert.Equal(1, cx); domain.Commands.RegisterInterceptor(new MyInterceptor(() => { cx = 2; })); using (var s = store.BeginSession()) { s.Execute(new MyCommand(domain)); s.AcceptChanges(); } Assert.Equal(2, cx); }
public async Task RemoveFromIndex() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var graph = domain.Resolve <IHyperGraph>() as Hyperstore.Modeling.HyperGraph.HyperGraph; MemoryIndexManager manager = graph.IndexManager as MemoryIndexManager; manager.CreateIndex(schema.Definition.XExtendsBaseClass, "index1", true, "Name"); var index = manager.GetIndex("index1"); var id = new Identity("Test", "1"); using (var session = store.BeginSession(new SessionConfiguration { Readonly = true })) { manager.AddToIndex(schema.Definition.XExtendsBaseClass, "index1", id, "momo"); Assert.Equal(id, index.Get("momo")); manager.RemoveFromIndex(schema.Definition.XExtendsBaseClass, "index1", id, "momo"); Assert.Null(index.Get("momo")); } }
public async Task CreateDefault() { var store = await StoreBuilder.New().CreateAsync(); Assert.NotNull(store.Services.Resolve <IHyperstore>()); store.Dispose(); }
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 AddInTransaction() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); domain.Indexes.CreateIndex(schema.Definition.XExtendsBaseClass, "index1", true, "Name"); var index = domain.Indexes.GetIndex("index1"); using (var s = domain.Store.BeginSession()) { dynamic a = new DynamicModelEntity(domain, schema.Definition.XExtendsBaseClass); a.Name = "momo"; s.AcceptChanges(); // Est visible dans la transaction Assert.NotNull(domain.GetElement(index.Get("momo"))); } using (var session = domain.Store.BeginSession(new SessionConfiguration { Readonly = true })) { Assert.NotNull(domain.GetElement(index.Get("momo"))); } }
public async Task CompareModels() { var store = await StoreBuilder.New().EnableScoping().Using <IIdGenerator>(r => new Hyperstore.Modeling.Domain.LongIdGenerator()).CreateAsync(); await store.Schemas.New <LibraryDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); using (var session = store.BeginSession()) { var lib = new Library(domain); lib.Name = "Lib1"; for (int i = 0; i < 3; i++) { var b = new Book(domain); b.Title = "Book \"book\" " + i.ToString(); b.Copies = i + 1; lib.Books.Add(b); var m = new Member(domain); m.Name = "Book " + i.ToString(); lib.Members.Add(m); } session.AcceptChanges(); } var domain2 = await domain.CreateScopeAsync("domain2"); Library lib2 = null; using (var session = store.BeginSession()) { lib2 = domain2.GetEntities <Library>().First(); // Remove 1 book var book = lib2.Books.First(); lib2.Books.Remove(book); // Add 2 books var b = new Book(domain2); b.Title = "New book 1"; b.Copies = 1; lib2.Books.Add(b); b = new Book(domain2); b.Title = "New book 2"; b.Copies = 2; lib2.Books.Add(b); // Change one book property lib2.Books.Last().Title = "Updated book"; session.AcceptChanges(); } Assert.Equal(2, domain2.GetDeletedElements().Count()); Assert.Equal(4, lib2.Books.Count()); Assert.Equal(6, domain2.GetScopeElements().Count()); // Books : 2 created, 1 updated, Library : 1 updated (Books property), LibraryHasBooks : 2 created Assert.Equal(5, domain2.GetUpdatedProperties().Count()); // New Books * 2 + 1 in the extendee domain }
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 AddElementTest() { var store = await StoreBuilder.New().CreateAsync(); await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var Graph = domain.Resolve <IHyperGraph>(); var aid = Id(1); using (var session = domain.Store.BeginSession()) { Graph.CreateEntity(aid, store.PrimitivesSchema.SchemaEntitySchema); Assert.NotNull(Graph.GetElement(aid)); session.AcceptChanges(); } using (var session = domain.Store.BeginSession(new SessionConfiguration { Readonly = true })) { Assert.NotNull(Graph.GetElement(aid)); } }
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 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 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 SerializableTransactionTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); Identity aid; dynamic a; using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { a = new DynamicModelEntity(domain, schema.Definition.XExtendsBaseClass); aid = a.Id; a.Value = 10; s.AcceptChanges(); } var factory = new TaskFactory(); var signal = new System.Threading.ManualResetEventSlim(); var signal2 = new System.Threading.ManualResetEventSlim(); var t1 = factory.StartNew(() => { using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.Serializable })) { // Accès sur A pour ouvrir une transaction Serializable (la session ne fait rien). Ce n'est que qu'en on // accède à la donnée que la transaction est crèèe var x = a.Value; // Ou n'importe quoi signal2.Set(); signal.Wait(); Assert.Equal(a.Value, 10); // On ne "voit" pas les modifications des autres transactions } }); Sleep(50); var t2 = factory.StartNew(() => { signal2.Wait(); using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { a.Value = 11; s.AcceptChanges(); } signal.Set(); }); Task.WaitAll(t1, t2); }
public async Task SchemaEvents() { var store = await StoreBuilder.New().CreateAsync(); var def = new MySchemaDefinition(); var schema = await store.Schemas.New(def).CreateAsync(); Assert.True(def.IsSchemaLoaded); }
public async Task ReadPhantomTest() { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); Identity aid; dynamic a; // Création d'une valeur using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { a = new DynamicModelEntity(domain, schema.Definition.XExtendsBaseClass); aid = a.Id; a.Value = 10; s.AcceptChanges(); } var factory = new TaskFactory(); var signal = new System.Threading.ManualResetEventSlim(); var signal2 = new System.Threading.ManualResetEventSlim(); var t1 = factory.StartNew(() => { // Cette transaction démarre avant l'autre mais elle va pouvoir 'voir' ses modifs commités using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { signal2.Set(); signal.Wait(); // On attend le commit de l'autre Assert.Equal(11, a.Value); // On "voit" dèja que la valeur a été modifiée } }); Sleep(50); var t2 = factory.StartNew(() => { signal2.Wait(); // On s'assure de démarrer aprés l'autre transaction using (var s = store.BeginSession(new SessionConfiguration { IsolationLevel = SessionIsolationLevel.ReadCommitted })) { a.Value = 11; s.AcceptChanges(); } signal.Set(); }); Task.WaitAll(t1, t2); }
public async Task DoubleTest() { var store = await StoreBuilder.New().CreateAsync(); var dt = 10.2; IDomainModel dm = await store.DomainModels.New().CreateAsync("Test"); Assert.Equal(dt, (Double)store.PrimitivesSchema.DoubleSchema.Deserialize(new SerializationContext(store.PrimitivesSchema.DoubleSchema, store.PrimitivesSchema.DoubleSchema.Serialize(dt)))); Assert.Null(store.PrimitivesSchema.DoubleSchema.Serialize(null)); }
public async Task TimeSpanTest() { var store = await StoreBuilder.New().CreateAsync(); var dt = DateTime.Now.TimeOfDay; IDomainModel dm = await store.DomainModels.New().CreateAsync("Test"); Assert.Equal((TimeSpan)store.PrimitivesSchema.TimeSpanSchema.Deserialize(new SerializationContext(store.PrimitivesSchema.TimeSpanSchema, store.PrimitivesSchema.TimeSpanSchema.Serialize(dt))), dt); Assert.Null(store.PrimitivesSchema.TimeSpanSchema.Serialize(null)); }
public async Task FloatTest() { var store = await StoreBuilder.New().CreateAsync(); var dt = 10.2; IDomainModel dm = await store.DomainModels.New().CreateAsync("Test"); Assert.True((Single)store.PrimitivesSchema.SingleSchema.Deserialize(new SerializationContext(store.PrimitivesSchema.SingleSchema, store.PrimitivesSchema.SingleSchema.Serialize(dt))) - dt < 0.01); Assert.Null(store.PrimitivesSchema.SingleSchema.Serialize(null)); }
public async Task UnknowMetadata_raises_exception() { await Assert.ThrowsAsync <MetadataNotFoundException>(async() => { var store = await StoreBuilder.New().CreateAsync(); var schema = await store.Schemas.New <TestDomainDefinition>().CreateAsync(); var domain = await store.DomainModels.New().CreateAsync("Test"); var metadata = schema.GetSchemaInfo("Z"); }); }