ln.types/test/ODBTests.cs

using System;
using System.IO;
using System.Linq;
using ln.types.odb.ng;
using ln.types.odb.ng.storage;
using ln.types.odb.ng.storage.fs;
using ln.types.odb.ng.storage.session;
using ln.types.odb.values;
using NUnit.Framework;
namespace ln.types.test
{
	[TestFixture()]
    public class ODBTests
    {
        [SetUp()]
        public void Prepare()
        {
            if (Directory.Exists("odb.test"))
                Directory.Delete("odb.test", true);
        }


        [TestCase(ExpectedException = typeof(IOException))]
        public void DoubleOpen()
        {
            using (IStorageContainer storageContainer = new FSStorageContainer("odb.test").Open())
            {
                IStorageContainer container2 = new FSStorageContainer("odb.test").Open();
            }
        }

        [Test()]
        public void StorageTest()
        {
            Guid documentID;

            using (IStorageContainer storageContainer = new FSStorageContainer("odb.test").Open())
            {
                using (IStorage storage = storageContainer.GetStorage("test1"))
                {
                    storage.Open();

                    Document document = new Document();

                    storage.Save(document);

                    Assert.AreNotEqual(Guid.Empty, document.ID);

                    document[new ODBStringValue("FeldA")] = new ODBStringValue("FeldA");
                    document[new ODBStringValue("FeldB")] = new ODBStringValue("FeldB");
					Document nestedDocument = new Document();
					nestedDocument["EineZeichenkette"] = new ODBStringValue("Ich bin eine Zeichenkette");
					document[new ODBStringValue("FeldDokument")] = nestedDocument;

                    storage.Save(document);

                    Assert.AreEqual(1, storage.GetDocumentIDs().Count());

                    documentID = document.ID;
                }
            }
            using (IStorageContainer storageContainer = new FSStorageContainer("odb.test").Open())
            {
                using (IStorage storage = storageContainer.GetStorage("test1"))
                {
                    storage.Open();

                    Assert.AreEqual(1, storage.GetDocumentIDs().Count());

                    Document document = storage.Load(storage.GetDocumentIDs().First());

                    Assert.AreEqual(documentID, document.ID);

                    Assert.AreEqual(new ODBStringValue("FeldA"), document[new ODBStringValue("FeldA")]);
                    Assert.AreEqual(new ODBStringValue("FeldB"), document[new ODBStringValue("FeldB")]);

                    storage.Delete(document.ID);

                    Assert.AreEqual(0, storage.GetDocumentIDs().Count());
                }
            }
        }

        [TestCase()]
        public void TestMapper()
        {
            using (IStorageContainer storageContainer = new FSStorageContainer("odb.test").Open())
            {
                Mapper mapper = new Mapper(storageContainer);

                Person[] persons = new Person[]
                {
                    new Person()
                    {
                        FirstName="Harald",
                        MiddleNames = new string[]{ "Christian", "Joachim" },
                        LastName = "Wolff-Thobaben",
                        Age=39
                    },
                    new Person()
                    {
                        FirstName="Liesschen",
                        LastName = "Müller",
                        Age=39
                    },
                };

                mapper.Save<Person>(persons[0]);
                mapper.Save<Person>(persons[1]);

                Assert.AreEqual(2, mapper.Load<Person>().Count());
                Assert.AreEqual(0, mapper.Load<Person>(Query.Equals<Person>("FirstName", "Wolfgang")).Count());
                Assert.AreEqual(1, mapper.Load<Person>(Query.Equals<Person>("FirstName", "Harald")).Count());
                Assert.AreEqual(1, mapper.Load<Person>(Query.Equals<Person>("FirstName", "Liesschen")).Count());

				Person harald = mapper.Load<Person>(Query.Equals<Person>("FirstName", "Harald")).FirstOrDefault();

				Assert.AreEqual(persons[0], harald);
            }

        }

		[TestCase()]
		public void TestConcurrentAccess()
		{
			using (IStorageContainer storageContainer = new FSStorageContainer("odb.test").Open())
			{
				using (
					SessionStorageContainer
					ssc1 = new SessionStorageContainer(storageContainer),
					ssc2 = new SessionStorageContainer(storageContainer)
					)
				{
					using (IStorage
						storage1 = ssc1.GetStorage("test2"),
						storage2 = ssc2.GetStorage("test2")
						)
					{
						Document origin = new Document();

						origin["FeldA"] = new ODBStringValue("OriginalA");
						origin["FeldB"] = new ODBStringValue("OriginalB");
						origin["FeldC"] = new ODBStringValue("OriginalC");

						storage1.Save(origin);

						Document secondary = storage2.Load(origin.ID);

						Assert.IsTrue(origin.CompareTo(secondary) == 0);

						secondary["FeldB"] = new ODBStringValue("ZweiB");
						storage2.Save(secondary);

						Assert.IsFalse(origin.CompareTo(secondary) == 0);

						Document reloaded1 = storage1.Load(origin.ID);
						Assert.AreSame(reloaded1, origin);

						Assert.IsTrue(secondary.CompareTo(reloaded1) == 0);
					}

				}

			}
		}


		public class Person
        {
			public readonly Guid ID;

            public String FirstName = "";
            public String[] MiddleNames = new string[0];
            public String LastName = "";

            public int Age = 18;

			public Person()
			{
				ID = Guid.NewGuid();
			}

			public override int GetHashCode() => ID.GetHashCode();
			public override bool Equals(object obj) => (obj is Person) && ID.Equals((obj as Person).ID);


		}

    }
}