ObjectLounge - An Object-Oriented Database Framework

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Technewlogic.ObjectLounge.Test.Model;
using NUnit.Framework;
using Technewlogic.ObjectLounge.Framework.BaseConcerns;
using Technewlogic.ObjectLounge.Framework.Proxy;

namespace Technewlogic.ObjectLounge.Test
{
	public class C_ChangeTracking_CompositeLinkTests : BaseTest
	{
		#region Add

		[Test]
		public void Add_NewParent_NewChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order newOrder = GetNewOrder();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(newOrder);
					newOrder.Materials.Add(newMaterial);
				});

			AssertAllEmpty();
		}

		[Test]
		public void Add_NewParent_NewChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order newOrder = GetNewOrder();
			Material oldMaterial = GetOldMaterial();
			Order oldParentOrder = oldMaterial.Order;

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(newOrder);
					newOrder.Materials.Add(oldMaterial);
				});

			AssertInserted();
			AssertUpdated(oldParentOrder);
			AssertDeleted(oldMaterial);
		}

		[Test]
		public void Add_NewParent_OldChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order oldOrder = GetOldOrder();
			Customer oldParentCustomer = oldOrder.Customer;
			Material oldMaterial = oldOrder.Materials.Single(); // wird auch mitgelöscht
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(oldOrder);
					oldOrder.Materials.Add(newMaterial);
				});

			AssertInserted();
			AssertUpdated(oldParentCustomer);
			AssertDeleted(oldOrder, oldMaterial);
		}

		[Test]
		public void Add_NewParent_OldChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order oldOrder = GetOldOrder();
			Customer oldParentCustomer = oldOrder.Customer;
			Material oldMaterial = GetOldMaterial();

			_engine.ExecuteTransaction(() =>
				newCustomer.Orders.Add(oldOrder));

			AssertInserted();
			AssertUpdated(oldParentCustomer);
			AssertDeleted(oldOrder, oldMaterial);
		}

		[Test]
		public void Add_OldParent_NewChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			Order newOrder = GetNewOrder();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					oldCustomer.Orders.Add(newOrder);
					newOrder.Materials.Add(newMaterial);
				});

			AssertInserted(newOrder, newMaterial);
			AssertUpdated(oldCustomer);
			AssertDeleted();
		}

		[Test]
		public void Add_OldParent_NewChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			Order newOrder = GetNewOrder();
			Material oldMaterial = GetOldMaterial();
			Order oldParentOrder = oldMaterial.Order;

			_engine.ExecuteTransaction(() =>
				{
					newOrder.Materials.Add(oldMaterial);
					oldCustomer.Orders.Add(newOrder);
				});

			AssertInserted(newOrder);
			AssertUpdated(oldParentOrder, oldCustomer, oldMaterial);
			AssertDeleted();
		}

		[Test]
		public void Add_OldParent_OldChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			// Man kann hier nicht die CMMS-Order nehmen, weil sie schon im oldCustomer ist
			Order oldOrder = _context.Orders.Single(it => it.OrderID == Order.BillingSystemID);
			Customer oldParentCustomer = oldOrder.Customer;
			var orderChild1 = oldOrder.Materials.First();
			var orderChild2 = oldOrder.Materials.Last();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					oldOrder.Materials.Add(newMaterial);
					oldCustomer.Orders.Add(oldOrder);
				});

			AssertInserted(newMaterial);
			AssertUpdated(oldCustomer, oldOrder, oldParentCustomer, orderChild1, orderChild2); // IMP: Wenn RemoveForRelocate richtig funktionieren würde, wäre die Children nicht drin.
			AssertDeleted();
		}

		[Test]
		public void Add_OldParent_OldChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			// Man kann hier nicht die CMMS-Order nehmen, weil sie schon im oldCustomer ist
			Order oldOrder = _context.Orders.Single(it => it.OrderID == Order.BillingSystemID);
			Customer oldParentCustomer = oldOrder.Customer;
			var orderChild1 = oldOrder.Materials.First();
			var orderChild2 = oldOrder.Materials.Last();
			Material oldMaterial = GetOldMaterial(); // Dieses Material war nicht in oldOrder drin.
			Order oldParentOrder = oldMaterial.Order;

			_engine.ExecuteTransaction(() =>
				{
					oldOrder.Materials.Add(oldMaterial);
					oldCustomer.Orders.Add(oldOrder);
				});

			AssertInserted();
			AssertUpdated(oldCustomer, oldOrder, oldParentCustomer, oldMaterial, oldParentOrder, orderChild1, orderChild2); // IMP: Wenn RemoveForRelocate richtig funktionieren würde, wäre die Children nicht drin.
			AssertDeleted();
		}

		#endregion

		#region Remove

		[Test]
		public void Remove_NewParent_NewChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order newOrder = GetNewOrder();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(newOrder);
					newOrder.Materials.Add(newMaterial);
					newCustomer.Orders.Remove(newOrder);
				});

			AssertAllEmpty();
		}

		[Test]
		public void Remove_NewParent_NewChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order newOrder = GetNewOrder();
			Material oldMaterial = GetOldMaterial();
			Order oldParentOrder = oldMaterial.Order;

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(newOrder);
					newOrder.Materials.Add(oldMaterial);
					newCustomer.Orders.Remove(newOrder);
				});

			AssertInserted();
			AssertUpdated(oldParentOrder);
			AssertDeleted(oldMaterial);
		}

		[Test]
		public void Remove_NewParent_OldChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order oldOrder = GetOldOrder();
			Customer oldParentCustomer = oldOrder.Customer;
			Material oldAncestor = oldOrder.Materials.Single();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(oldOrder);
					oldOrder.Materials.Add(newMaterial);
					newCustomer.Orders.Remove(oldOrder);
				});

			AssertInserted();
			AssertUpdated(oldParentCustomer);
			AssertDeleted(oldOrder, oldAncestor);
		}

		[Test]
		public void Remove_NewParent_OldChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer newCustomer = GetNewCustomer();
			Order oldOrder = GetOldOrder();
			Customer oldParentCustomer = oldOrder.Customer;
			Material oldMaterial = GetOldMaterial();

			_engine.ExecuteTransaction(() =>
				{
					newCustomer.Orders.Add(oldOrder);
					newCustomer.Orders.Remove(oldOrder);
				});

			AssertInserted();
			AssertUpdated(oldParentCustomer);
			AssertDeleted(oldOrder, oldMaterial);
		}

		[Test]
		public void Remove_OldParent_NewChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			Order newOrder = GetNewOrder();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					oldCustomer.Orders.Add(newOrder);
					newOrder.Materials.Add(newMaterial);
					oldCustomer.Orders.Remove(newOrder);
				});

			AssertInserted();
			AssertUpdated(oldCustomer);
			AssertDeleted();
		}

		[Test]
		public void Remove_OldParent_NewChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			Order newOrder = GetNewOrder();
			Material oldMaterial = GetOldMaterial();
			Order oldParentOrder = oldMaterial.Order;

			_engine.ExecuteTransaction(() =>
				{
					newOrder.Materials.Add(oldMaterial);
					oldCustomer.Orders.Add(newOrder);
					oldCustomer.Orders.Remove(newOrder);
				});

			AssertInserted();
			AssertUpdated(oldCustomer, oldParentOrder);
			AssertDeleted(oldMaterial);
		}

		[Test]
		public void Remove_OldParent_OldChild_NewAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			Order oldOrder = GetOldOrder();
			Material oldAncestor = oldOrder.Materials.Single();
			Material newMaterial = GetNewMaterial();

			_engine.ExecuteTransaction(() =>
				{
					oldOrder.Materials.Add(newMaterial);
					oldCustomer.Orders.Remove(oldOrder);
				});

			AssertInserted();
			AssertUpdated(oldCustomer);
			AssertDeleted(oldOrder, oldAncestor);
		}

		[Test]
		public void Remove_OldParent_OldChild_OldAncestor()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();
			Order oldOrder = GetOldOrder();
			Material oldMaterial = GetOldMaterial();

			_engine.ExecuteTransaction(() =>
				oldCustomer.Orders.Remove(oldOrder));

			AssertInserted();
			AssertUpdated(oldCustomer);
			AssertDeleted(oldOrder, oldMaterial);
		}

		#endregion

		/// <summary>
		/// Exemplarisch für die Rekursion.
		/// </summary>
		[Test]
		public void PropertyChange_OldParent_OldChildren()
		{
			throw new NotImplementedException();

			Customer oldCustomer = GetOldCustomer();

			_engine.ExecuteTransaction(() =>
				oldCustomer.Name += "4711");

			AssertInserted();
			AssertUpdated(oldCustomer);
			AssertDeleted();
		}
	}
}