public void changeTrackingService_hasTransientEntities_should_be_false_after_acceptChanges()
        {
            var svc = new ChangeTrackingService();
            var p = new Person( svc, true );
            svc.AcceptChanges();

            svc.HasTransientEntities.Should().Be.False();
        }
        public void changeTrackingService_hasTransientEntities_should_be_true_after_undo()
        {
            var svc = new ChangeTrackingService();
            var p = new Person( svc, true );
            svc.Undo();

            svc.HasTransientEntities.Should().Be.True();
        }
        public void afterPropertyChange_canUndo_is_true()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc, false );
            p.Name = "Mauro";

            Assert.IsTrue( svc.CanUndo );
        }
		public void changeTrackingService_using_beginAtomicOperation_should_set_is_changed_only_on_operation_completed()
		{
			var target = new ChangeTrackingService();

			var person = new Person( target );
			var list = new PersonCollection( target );

			using( var actual = target.BeginAtomicOperation() )
			{
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				target.IsChanged.Should().Be.False();

				actual.Complete();
			}

			target.IsChanged.Should().Be.True();
		}
		public void changeTrackingService_using_atomicOperation_after_operation_complete_entityState_should_be_changed()
		{
			var target = new ChangeTrackingService();

			var person = new Person( target );

			target.AcceptChanges();
			
			using( var op = target.BeginAtomicOperation() )
			{
				person.Name = "Mauro";

				op.Complete();
			}

			var state = target.GetEntityState( person );

			var actual = (state & EntityTrackingStates.HasBackwardChanges ) == EntityTrackingStates.HasBackwardChanges;
			actual.Should().Be.True();
		}
		public void changeTrackingService_using_beginAtomicOperation_should_fully_rollback_on_single_undo()
		{
			var target = new ChangeTrackingService();

			var person = new Person( target );
			var list = new PersonCollection( target );

			using( var actual = target.BeginAtomicOperation() )
			{
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				actual.Complete();
			}

			target.Undo();

			list.Count.Should().Be.EqualTo( 0 );
			person.Name.Should().Be.EqualTo( String.Empty );
		}
        public void after_resume_service_restart_tracking_changes()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc, false );

            svc.Suspend();
            svc.Resume();

            p.Name = "Mauro";

            Assert.IsTrue( svc.IsChanged );
        }
        public void entity_registeredAsTransient_with_autoRemove_on_Undo_is_transient()
        {
            ChangeTrackingService svc = new ChangeTrackingService();
            EntityTrackingStates expected = EntityTrackingStates.IsTransient | EntityTrackingStates.AutoRemove;

            Person p = new Person( svc );
            svc.Undo();

            EntityTrackingStates actual = svc.GetEntityState( p );

            Assert.AreEqual<EntityTrackingStates>( expected, actual );
        }
		public void changeTrackingService_using_beginAtomicOperation_getEntities_should_return_all_transient_entities()
		{
			var target = new ChangeTrackingService();

			var list = new PersonCollection( target );
			var person = new Person( target, false );

			using( var op = target.BeginAtomicOperation() )
			{
				target.RegisterTransient( person );
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				op.Complete();
			}

			var actual = target.GetEntities( EntityTrackingStates.IsTransient, false );

			actual.Contains( person ).Should().Be.True();
		}
		public void changeTrackingService_using_beginAtomicOperation_getEntityState_should_return_valid_entity_state()
		{
			var target = new ChangeTrackingService();

			var person = new Person( target );
			var list = new PersonCollection( target );

			using( var op = target.BeginAtomicOperation() )
			{
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				op.Complete();
			}

			var actual = target.GetEntityState( person );
			actual.Should().Be.EqualTo( EntityTrackingStates.HasBackwardChanges | EntityTrackingStates.IsTransient | EntityTrackingStates.AutoRemove );
		}
        public void afterPropertyChanges_getChangeSet_contains_change()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc, false );
            p.Name = "Mauro";
            p.Name = "Andrea";

            IChangeSet cSet = svc.GetChangeSet();

            Assert.AreEqual<Int32>( 2, cSet.Count );
        }
        public void after_rejectChanges_entity_is_no_more_changed()
        {
            EntityTrackingStates expected = EntityTrackingStates.None;

            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );
            p.Name = "Mauro";

            svc.RejectChanges();

            EntityTrackingStates actual = svc.GetEntityState( p );
            Assert.AreEqual<EntityTrackingStates>( expected, actual );
        }
        public void after_acceptChanges_service_isChanged_is_false()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );
            p.Name = "Mauro";
            svc.AcceptChanges();

            Assert.IsFalse( svc.IsChanged );
        }
        public void if_entity_is_iComponent_on_Disposed_entity_changes_are_removed_changes_stack()
        {
            ChangeTrackingService svc = new ChangeTrackingService();
            Boolean expected = false;

            Person p = null;
            using( p = new Person( svc, false ) )
            {
                p.Name = "Foo";
                p.Name = "Mauro";
            }

            Boolean actual = svc.IsChanged;

            Assert.AreEqual<Boolean>( expected, actual );
        }
        public void if_entity_is_iComponent_on_Disposed_entity_is_removed_from_transient()
        {
            ChangeTrackingService svc = new ChangeTrackingService();
            EntityTrackingStates expected = EntityTrackingStates.None;

            Person p = null;
            using( p = new Person( svc, false ) )
            {
                svc.RegisterTransient( p, false );
            }

            EntityTrackingStates actual = svc.GetEntityState( p );

            Assert.AreEqual<EntityTrackingStates>( expected, actual );
        }
        public void entity_registeredAsTransient_without_autoRemove_on_AcceptChanges_is_no_more_transient()
        {
            ChangeTrackingService svc = new ChangeTrackingService();
            EntityTrackingStates expected = EntityTrackingStates.None;

            Person p = new Person( svc, false );
            svc.RegisterTransient( p, false );
            svc.AcceptChanges();

            EntityTrackingStates actual = svc.GetEntityState( p );

            Assert.AreEqual<EntityTrackingStates>( expected, actual );
        }
        public void explicit_registerAsTransient_without_autoRemove_throws_exception_if_already_registered()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );
            svc.RegisterTransient( p, false );
        }
        public void afterUndo_propertyValue_is_rolledback()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc, false );
            String expected = p.Name;
            p.Name = "Mauro";

            svc.Undo();

            Assert.AreEqual<String>( expected, p.Name );
        }
        public void service_validate_a_bookmark_invalid_is_false()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );
            p.Name = "Mauro";

            var bmk = svc.CreateBookmark();
            svc.Undo();

            Assert.IsFalse( svc.Validate( bmk ) );
        }
        public void after_rejectChanges_service_canRedo_is_false()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );
            p.Name = "Mauro";
            svc.RejectChanges();

            Assert.IsFalse( svc.CanRedo );
        }
        public void service_successfully_revert_to_a_valid_bookmark_created_at_initial_state()
        {
            String expected = String.Empty;

            ChangeTrackingService svc = new ChangeTrackingService();
            IBookmark bmk = svc.CreateBookmark();

            Person p = new Person( svc );
            p.Name = "foo..";
            p.Name = "foo once again...";

            svc.Revert( bmk );

            Assert.AreEqual<String>( expected, p.Name );
        }
        public void afterUndo_service_Redo_restore_previous_value()
        {
            ChangeTrackingService svc = new ChangeTrackingService();
            String expected = "Mauro";

            Person p = new Person( svc, false );
            p.Name = expected;

            svc.Undo();
            svc.Redo();

            Assert.AreEqual<String>( expected, p.Name );
        }
		public void changeTrackingService_using_beginAtomicOperation_getEntities_should_return_all_changed_entities()
		{
			var target = new ChangeTrackingService();

			var person = new Person( target );
			var list = new PersonCollection( target );

			using( var op = target.BeginAtomicOperation() )
			{
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				op.Complete();
			}

			var actual = target.GetEntities( EntityTrackingStates.HasBackwardChanges, false );

			/*
			 * Non funziona perchè non funziona GetEntityState()
			 */

			actual.Contains( person ).Should().Be.True();
		}
        public void after_suspend_cannot_call_RegisterTransient_with_explicit_autoRemove_false()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc, false );
            svc.Suspend();
            svc.RegisterTransient( p, false );
        }
		public void changeTrackingService_using_beginAtomicOperation_hasTransientEntities_should_return_true_even_for_entities_created_in_the_atomic_operation()
		{
			var target = new ChangeTrackingService();

			var list = new PersonCollection( target );
			var person = new Person( target, false );

			using( var op = target.BeginAtomicOperation() )
			{
				target.RegisterTransient( person );
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				op.Complete();
			}

			var actual = target.HasTransientEntities;

			actual.Should().Be.True();
		}
        public void after_suspend_cannot_call_RejectChanges()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );
            p.Name = "Mauro";

            svc.Suspend();
            svc.RejectChanges();
        }
        public void after_multiple_change_canRedo_is_false()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc, false );
            p.Name = "Mauro";
            svc.Undo();
            p.Name = "Foo";

            Assert.IsFalse( svc.CanRedo );
        }
        public void after_suspend_cannot_call_UnregisterTransient()
        {
            ChangeTrackingService svc = new ChangeTrackingService();

            Person p = new Person( svc );

            svc.Suspend();
            svc.UnregisterTransient( p );
        }
		public void changeTrackingService_using_beginAtomicOperation_redo_should_reapply_all_changes_with_one_pass()
		{
			var target = new ChangeTrackingService();

			var person = new Person( target );
			var list = new PersonCollection( target );

			using( var actual = target.BeginAtomicOperation() )
			{
				person.Name = "Mauro";
				list.Add( person );
				person.Name = "Mauro Servienti";

				actual.Complete();
			}

			target.Undo();
			target.Redo();

			list.Count.Should().Be.EqualTo( 1 );
			person.Name.Should().Be.EqualTo( "Mauro Servienti" );
		}
        public void after_explicit_registerAsTransient_with_autoRemove_false_entityTrackingStates_is_transient()
        {
            ChangeTrackingService svc = new ChangeTrackingService();
            EntityTrackingStates expected = EntityTrackingStates.IsTransient;

            Person p = new Person( svc, false );
            svc.RegisterTransient( p, false );
            EntityTrackingStates actual = svc.GetEntityState( p );

            Assert.AreEqual<EntityTrackingStates>( expected, actual );
        }