ObjectLounge - An Object-Oriented Database Framework

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

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

		[TestFixtureSetUp]
		public void TestFixtureSetUp()
		{
		}

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

		[Test]
		public void RollbackSimple()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				string oldName = sundk.Name;
				sundk.Name = "New Name";

				ta.Rollback();

				Assert.AreEqual(oldName, sundk.Name);
			}
		}

		[Test]
		public void RollbackDeletedComposition_TreeRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				Order cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);

				sundk.Orders.Remove(cmms);
				cmms = sundk.Orders.SingleOrDefault(o => o.OrderID == Order.CmmsID);

				Assert.IsNull(cmms);

				ta.Rollback();

				cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);
			}
		}

		[Test]
		public void RollbackDeletedComposition_StateRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				Order cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);
				Material hardware = cmms.Materials.Single(m => m.DefinitionID == Material.HardwareServerDefinitionID);

				sundk.Orders.Remove(cmms);

				ta.Rollback();

				var ctcSundk = (sundk as IProxy).ChangeTrackingConcern;
				var ctcCmms = (cmms as IProxy).ChangeTrackingConcern;
				var ctcHardware = (hardware as IProxy).ChangeTrackingConcern;

				Assert.AreEqual(SynchronizationOperation.Nothing, ctcSundk.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcCmms.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcHardware.SynchronizationOperation);

				Assert.IsFalse(_engine.IsModified);
			}
		}

		[Test]
		public void RollbackAddedComposition_TreeRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);

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

				sundk.Orders.Add(newOrder);

				var checkNewOrder = sundk.Orders.SingleOrDefault(o => o.OrderID == newOrder.OrderID);

				ta.Rollback();

				Assert.IsFalse(sundk.Orders.Any(o => o.OrderID == newOrder.OrderID));
			}
		}

		[Test]
		public void RollbackAddedComposition_StateRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);

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

				sundk.Orders.Add(newOrder);

				ta.Rollback();

				var ctcSundk = (sundk as IProxy).ChangeTrackingConcern;
				var ctcNewOrder = (newOrder as IProxy).ChangeTrackingConcern;

				Assert.AreEqual(SynchronizationOperation.Nothing, ctcSundk.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Unknown, ctcNewOrder.SynchronizationOperation);

				Assert.IsFalse(_engine.IsModified);
			}
		}

		[Test]
		public void RollbackChangeAggregation_ReferenceRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				Order cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);
				OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == OrderTypeCompositor.StandardCompositorName);
				OrderType lowPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.LowPriorityName);
				OrderType highPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.HighPriorityName);

				Assert.AreEqual(highPriority, cmms.OrderType);

				cmms.OrderType = lowPriority;

				Assert.AreEqual(lowPriority, cmms.OrderType);

				ta.Rollback();

				Assert.AreEqual(highPriority, cmms.OrderType);
			}
		}

		[Test]
		public void RollbackChangeAggregation_StateRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				Order cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);
				OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == OrderTypeCompositor.StandardCompositorName);
				OrderType lowPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.LowPriorityName);
				OrderType highPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.HighPriorityName);

				Assert.AreEqual(highPriority, cmms.OrderType);

				cmms.OrderType = lowPriority;

				ta.Rollback();

				var ctcSundk = (sundk as IProxy).ChangeTrackingConcern;
				var ctcCmms = (cmms as IProxy).ChangeTrackingConcern;
				var ctcLowPriority = (lowPriority as IProxy).ChangeTrackingConcern;
				var ctcHighPriority = (highPriority as IProxy).ChangeTrackingConcern;

				Assert.AreEqual(SynchronizationOperation.Nothing, ctcSundk.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcCmms.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcLowPriority.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcHighPriority.SynchronizationOperation);

				Assert.IsFalse(_engine.IsModified);
			}
		}

		[Test]
		public void RollbackDeleteAggregation_ReferenceRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				Order cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);
				OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == OrderTypeCompositor.StandardCompositorName);
				OrderType highPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.HighPriorityName);

				Assert.AreEqual(highPriority, cmms.OrderType);

				cmms.OrderType = null;

				Assert.AreEqual(null, cmms.OrderType);

				ta.Rollback();

				Assert.AreEqual(highPriority, cmms.OrderType);
			}
		}
		
		[Test]
		public void RollbackDeleteAggregation_StateRestored()
		{
			using (var ta = _engine.TransactionManager.BeginTransaction())
			{
				Customer sundk = _context.Customers.Single(c => c.Name == Customer.SKName);
				Order cmms = sundk.Orders.Single(o => o.OrderID == Order.CmmsID);
				OrderTypeCompositor standardCompositor = _context.OrderTypeCompositors.Single(otc => otc.Name == OrderTypeCompositor.StandardCompositorName);
				OrderType lowPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.LowPriorityName);
				OrderType highPriority = standardCompositor.OrderTypes.Single(ot => ot.Name == OrderType.HighPriorityName);

				Assert.AreEqual(highPriority, cmms.OrderType);

				cmms.OrderType = null;

				ta.Rollback();

				var ctcSundk = (sundk as IProxy).ChangeTrackingConcern;
				var ctcCmms = (cmms as IProxy).ChangeTrackingConcern;
				var ctcLowPriority = (lowPriority as IProxy).ChangeTrackingConcern;
				var ctcHighPriority = (highPriority as IProxy).ChangeTrackingConcern;

				Assert.AreEqual(SynchronizationOperation.Nothing, ctcSundk.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcCmms.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcLowPriority.SynchronizationOperation);
				Assert.AreEqual(SynchronizationOperation.Nothing, ctcHighPriority.SynchronizationOperation);

				Assert.IsFalse(_engine.IsModified);
			}
		}
	}
}