ObjectLounge - An Object-Oriented Database Framework

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Technewlogic.Stasy.Framework;
using Technewlogic.Stasy.Test.Model;
using Technewlogic.Stasy.Framework.Proxy;
using Technewlogic.Stasy.Framework.UnitOfWork;

namespace Technewlogic.Stasy.Test.EntityCollectionTests
{
	[TestFixture]
	public class Remove
	{
		private Engine<CrmContext> _engine;
		private CrmContext _context;

		private Customer _sundk;
		private Order _cmms;
		private Material _hardware;

		[TestFixtureSetUp]
		public void TestFixtureSetUp()
		{
		}

		[SetUp]
		public void SetUp()
		{
			_context = new CrmContext();
			_engine = EngineFactory.CreateEngine(
				new DataContextMockSyncProvider(new DataContextMock()),
				_context);

			_sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
			_cmms = _sundk.Orders.Single(o => o.OrderID == "a-4711");
			_hardware = _cmms.Materials.Single(m => m.DefinitionID == "HW-01");
		}

		[Test]
		public void ChildNotInCompositionAnymore()
		{
			_sundk.Orders.Remove(_cmms);

			// Nicht mehr sichtbar in der Composition
			Assert.IsNull(_sundk.Orders.SingleOrDefault(o => o.OrderID == "a-4711"));
		}

		[Test]
		public void ForeignKeyDeleted()
		{
			_sundk.Orders.Remove(_cmms);

			Assert.AreEqual(new Guid(), _cmms._customerKey);
		}

		[Test]
		[ExpectedException(typeof(InvalidOperationException),
			ExpectedMessage = "The child is in another aggregation collection")]
		public void RemoveChildIncludedInAggregation()
		{
			OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == "StandardCompositor");
			OrderType lowPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == "LowPriority");

			standardCompositor.OrderTypes.Remove(lowPriority);
		}

		[Test]
		[ExpectedException(typeof(InvalidOperationException),
			ExpectedMessage = "The child is in another aggregation collection")]
		public void RelocateChildIncludedInAggregation()
		{
			OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == "StandardCompositor");

			OrderTypeCompositor newCompositor = _engine.CreateInstance<OrderTypeCompositor>();
			newCompositor._name = "NewCompositor";

			OrderType lowPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == "LowPriority");

			newCompositor.OrderTypes.Add(lowPriority);
		}

		[Test]
		public void RemoveChildNotIncludedInAggregation()
		{
			OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == "StandardCompositor");
			OrderType lowPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == "LowPriority");
			OrderType highPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == "HighPriority");
			var ordersWithLowPrio = _context.Orders.Where(o => o.OrderType == lowPriority);
			foreach (var order in ordersWithLowPrio)
				order.OrderType = highPriority;

			standardCompositor.OrderTypes.Remove(lowPriority);
		}

		[Test]
		public void BackpointerReset()
		{
			_sundk.Orders.Remove(_cmms);
			Assert.IsNull(_cmms.Customer);
		}

		[Test]
		[ExpectedException(typeof(InvalidOperationException))]
		public void RemoveUnknownSlave()
		{
			Order billingSystem = _sundk.Orders.Single(o => o.OrderID == "ind-123");
			_sundk.Orders.Remove(billingSystem);
		}	

		[Test]
		public void NewMaster_NewSlave_MasterState()
		{
			Customer newCustomer = _engine.CreateInstance<Customer>();
			newCustomer._name = "newCustomer";

			Order newOrder = _engine.CreateInstance<Order>();
			newOrder._orderID = "newOrder";

			newCustomer.Orders.Add(newOrder);

			// Parent korrekt markiert in der EntityCollection
			var ctc = (newCustomer as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Unknown, ctc.SynchronizationOperation);
			Assert.AreEqual(false, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void NewMaster_NewSlave_SlaveState()
		{
			Customer newCustomer = _engine.CreateInstance<Customer>();
			newCustomer._name = "newCustomer";

			Order newOrder = _engine.CreateInstance<Order>();
			newOrder._orderID = "newOrder";

			newCustomer.Orders.Add(newOrder);

			// Parent korrekt markiert in der EntityCollection
			var ctc = (newOrder as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Unknown, ctc.SynchronizationOperation);
			Assert.AreEqual(false, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void NewMaster_NewSlave_SlaveStateRecursion()
		{
			Customer newCustomer = _engine.CreateInstance<Customer>();
			newCustomer._name = "newCustomer";

			Order newOrder = _engine.CreateInstance<Order>();
			newOrder._orderID = "newOrder";

			newCustomer.Orders.Add(newOrder);

			Material newMaterial = _engine.CreateInstance<Material>();
			newMaterial._definitionID = "NewMaterial";

			newOrder.Materials.Add(newMaterial);

			// Children korrekt markiert in der EntityCollection
			var ctc = (newMaterial as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Unknown, ctc.SynchronizationOperation);
			Assert.AreEqual(false, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void NewMaster_OldSlave_MasterState()
		{
			Customer newCustomer = _engine.CreateInstance<Customer>();
			newCustomer._name = "newCustomer";

			Order newOrder = _engine.CreateInstance<Order>();
			newOrder._orderID = "newOrder";

			newCustomer.Orders.Add(newOrder);

			// Parent korrekt markiert in der EntityCollection
			var ctc = (newCustomer as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Unknown, ctc.SynchronizationOperation);
			Assert.AreEqual(false, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void NewMaster_OldSlave_SlaveState()
		{
			Customer newCustomer = _engine.CreateInstance<Customer>();
			newCustomer._name = "newCustomer";

			Order newOrder = _engine.CreateInstance<Order>();
			newOrder._orderID = "newOrder";

			newCustomer.Orders.Add(newOrder);

			// Parent korrekt markiert in der EntityCollection
			var ctc = (newOrder as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Unknown, ctc.SynchronizationOperation);
			Assert.AreEqual(false, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void NewMaster_OldSlave_SlaveStateRecursion()
		{
			Customer newCustomer = _engine.CreateInstance<Customer>();
			newCustomer._name = "newCustomer";

			Order newOrder = _engine.CreateInstance<Order>();
			newOrder._orderID = "newOrder";

			newCustomer.Orders.Add(newOrder);

			Material newMaterial = _engine.CreateInstance<Material>();
			newMaterial._definitionID = "NewMaterial";

			newOrder.Materials.Add(newMaterial);

			// Children korrekt markiert in der EntityCollection
			var ctc = (newMaterial as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Unknown, ctc.SynchronizationOperation);
			Assert.AreEqual(false, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void OldMaster_OldSlave_MasterState()
		{
			_sundk.Orders.Remove(_cmms);

			// Parent korrekt markiert in der EntityCollection
			var ctc = (_sundk as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Updated, ctc.SynchronizationOperation);
			Assert.AreEqual(true, ctc.IsCurrentlyInDB);
			Assert.AreEqual(true, ctc.WillBeInDB);
		}

		[Test]
		public void OldMaster_OldSlave_SlaveState()
		{
			_sundk.Orders.Remove(_cmms);

			// Parent korrekt markiert in der EntityCollection
			var ctc = (_cmms as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Deleted, ctc.SynchronizationOperation);
			Assert.AreEqual(true, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void OldMaster_OldSlave_SlaveStateRecursion()
		{
			_sundk.Orders.Remove(_cmms);

			// Children korrekt markiert in der EntityCollection
			var ctc = (_hardware as IProxy).ChangeTrackingConcern;
			Assert.AreEqual(SynchronizationOperation.Deleted, ctc.SynchronizationOperation);
			Assert.AreEqual(true, ctc.IsCurrentlyInDB);
			Assert.AreEqual(false, ctc.WillBeInDB);
		}

		[Test]
		public void BeforeRemove()
		{
			throw new NotImplementedException(
				"Da die CompCollection direkt im Proxy erzeugt wird, kann das hier nicht mehr gemacht werden. Evtl. IEntity implementieren und vom Proxy wird eine Initialize-Methode aufgerufen.");

			Order eventOrder = null;
			Customer oldCustomer = _context.Customers.Single(c => c.Name == Customer.SKName);
			oldCustomer.BeforeOrdersRemove += new EventHandler<EntityChangingEventArgs<Order>>((s, e) =>
			{
				eventOrder = e.Entity;
			});

			Order oldOrder = oldCustomer.Orders.Single(o => o.OrderID == "a-0815");
			oldCustomer.Orders.Remove(oldOrder);

			Assert.AreEqual(oldOrder, eventOrder);
			Assert.IsNull(oldCustomer.Orders.FirstOrDefault(o => o.OrderID == "a-0815"));
		}

		[Test]
		public void BeforeRemove_Cancelled()
		{
			throw new NotImplementedException(
				"Da die CompCollection direkt im Proxy erzeugt wird, kann das hier nicht mehr gemacht werden. Evtl. IEntity implementieren und vom Proxy wird eine Initialize-Methode aufgerufen.");

			Customer oldCustomer = _context.Customers.Single(c => c.Name == Customer.SKName);
			oldCustomer.BeforeOrdersRemove += new EventHandler<EntityChangingEventArgs<Order>>((s, e) =>
			{
				throw new ApplicationException();
			});

			Order oldOrder = oldCustomer.Orders.Single(o => o.OrderID == "a-0815");
			try
			{
				oldCustomer.Orders.Remove(oldOrder);
			}
			catch { }

			Assert.AreEqual(oldOrder, oldCustomer.Orders.FirstOrDefault(o => o.OrderID == "a-0815"));
		}
	}
}