public void ShouldRejectChangesWithModifiedAndRemovedItem()
        {
            FriendEmailWrapper email = _emails.First();

            ChangeTrackingCollection <FriendEmailWrapper> c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);

            email.Email = "*****@*****.**";
            c.Remove(email);
            Assert.AreEqual("*****@*****.**", email.EmailOriginalValue);

            Assert.AreEqual(1, c.Count);
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.AreEqual(1, c.RemovedItems.Count);

            c.RejectChanges();

            Assert.AreEqual(2, c.Count);
            Assert.IsTrue(c.Contains(email));

            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.AreEqual(0, c.RemovedItems.Count);

            Assert.IsFalse(email.IsChanged);
            Assert.AreEqual("*****@*****.**", email.Email);
            Assert.AreEqual("*****@*****.**", email.EmailOriginalValue);

            Assert.IsFalse(c.IsChanged);
        }
        public void ShouldTrackAddedItems()
        {
            var emailToAdd = new FriendEmailWrapper(new FriendEmail());

            var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);

            Assert.Equal(2, c.Count);
            Assert.False(c.IsChanged);

            c.Add(emailToAdd);

            Assert.Equal(3, c.Count);
            Assert.Equal(1, c.AddedItems.Count);
            Assert.Equal(0, c.RemovedItems.Count);
            Assert.Equal(0, c.ModifiedItems.Count);
            Assert.Equal(emailToAdd, c.AddedItems.First());
            Assert.True(c.IsChanged);

            c.Remove(emailToAdd);

            Assert.Equal(2, c.Count);
            Assert.Equal(0, c.AddedItems.Count);
            Assert.Equal(0, c.RemovedItems.Count);
            Assert.Equal(0, c.ModifiedItems.Count);
            Assert.False(c.IsChanged);
        }
Example #3
0
        public void ShouldBeInSyncAfterRemovingEmail()
        {
            FriendWrapper      wrapper       = new FriendWrapper(_friend);
            FriendEmailWrapper emailToRemove = wrapper.Emails.Single(ew => ew.Model == _friendEmail);

            wrapper.Emails.Remove(emailToRemove);
            CheckIfModelEmailsCollectionIsInSync(wrapper);
        }
        public void ShouldSetIsValidOfRootWhenAddingInvalidItem()
        {
            var emailToAdd = new FriendEmailWrapper(new FriendEmail());
            var wrapper    = new FriendWrapper(_friend);

            Assert.IsTrue(wrapper.IsValid);
            wrapper.Emails.Add(emailToAdd);
            Assert.IsFalse(wrapper.IsValid);
            emailToAdd.Email = "*****@*****.**";
            Assert.IsTrue(wrapper.IsValid);
        }
        public void ShouldSetIsChangedOfFriendWrapper()
        {
            FriendWrapper      wrapper       = new FriendWrapper(_friend);
            FriendEmailWrapper emailToModify = wrapper.Emails.First();

            emailToModify.Email = "*****@*****.**";

            Assert.IsTrue(wrapper.IsChanged);

            emailToModify.Email = "*****@*****.**";
            Assert.IsFalse(wrapper.IsChanged);
        }
Example #6
0
        public void ShouldNotTrackAddedItemsAsModified()
        {
            var emailToAdd = new FriendEmailWrapper(new FriendEmail());

            var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);

            c.Add(emailToAdd);
            emailToAdd.Email = "*****@*****.**";
            Assert.IsTrue(emailToAdd.IsChanged);
            Assert.AreEqual(3, c.Count);
            Assert.AreEqual(1, c.AddedItems.Count);
            Assert.AreEqual(0, c.RemovedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.IsTrue(c.IsChanged);
        }
        public void ShouldRejectChanges()
        {
            FriendWrapper wrapper = new FriendWrapper(_friend);

            FriendEmailWrapper emailToModify = wrapper.Emails.First();

            emailToModify.Email = "*****@*****.**";

            Assert.IsTrue(wrapper.IsChanged);

            wrapper.RejectChanges();

            Assert.IsFalse(wrapper.IsChanged);
            Assert.AreEqual("*****@*****.**", emailToModify.Email);
            Assert.AreEqual("*****@*****.**", emailToModify.EmailOriginalValue);
        }
        public void ShouldRaisePropertyChangedEventForIsValidOfRootWhenAddingInvalidItem()
        {
            var fired = false;
            var wrapper = new FriendWrapper(_friend);
            wrapper.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == "IsValid") fired = true;
            };

            var emailToAdd = new FriendEmailWrapper(new FriendEmail());
            wrapper.Emails.Add(emailToAdd);
            Assert.True(fired);

            fired = false;
            emailToAdd.Email = "*****@*****.**";
            Assert.True(fired);
        }
Example #9
0
        public void ShouldReturnValidationErrorIfEmailAddressIsNotValid()
        {
            var email   = new FriendEmail();
            var wrapper = new FriendEmailWrapper(email);

            Assert.True(wrapper.HasErrors);

            wrapper.Email = "a";
            Assert.True(wrapper.HasErrors);

            var errors = wrapper.GetErrors(nameof(wrapper.Email)).Cast <string>().ToList();

            Assert.Equal(1, errors.Count);
            Assert.Equal("Email is not a valid email address", errors.First());

            wrapper.Email = "*****@*****.**";
            Assert.False(wrapper.HasErrors);
        }
        public void ShouldTrackModifiedItem()
        {
            FriendEmailWrapper emailToModify = _emails.First();
            ChangeTrackingCollection <FriendEmailWrapper> c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);

            Assert.AreEqual(2, c.Count);
            Assert.IsFalse(c.IsChanged);

            emailToModify.Email = "*****@*****.**";
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(1, c.ModifiedItems.Count);
            Assert.AreEqual(0, c.RemovedItems.Count);
            Assert.IsTrue(c.IsChanged);

            emailToModify.Email = "*****@*****.**";
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.AreEqual(0, c.RemovedItems.Count);
            Assert.IsFalse(c.IsChanged);
        }
        public void ShouldNotTrackRemovedItemAsModified()
        {
            FriendEmailWrapper emailToModifyAndRemove = _emails.First();

            ChangeTrackingCollection <FriendEmailWrapper> c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);

            emailToModifyAndRemove.Email = "*****@*****.**";
            Assert.AreEqual(2, c.Count);
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(0, c.RemovedItems.Count);
            Assert.AreEqual(1, c.ModifiedItems.Count);
            Assert.AreEqual(emailToModifyAndRemove, c.ModifiedItems.First());
            Assert.IsTrue(c.IsChanged);

            c.Remove(emailToModifyAndRemove);
            Assert.AreEqual(1, c.Count);
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(1, c.RemovedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.AreEqual(emailToModifyAndRemove, c.RemovedItems.First());
            Assert.IsTrue(c.IsChanged);
        }
        public void ShouldAcceptChanges()
        {
            var emailToModify = _emails.First();
            var emailToRemove = _emails.Skip(1).First();
            var emailToAdd    = new FriendEmailWrapper(new FriendEmail {
                Email = "*****@*****.**"
            });
            var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails)
            {
                emailToAdd
            };

            c.Remove(emailToRemove);
            emailToModify.Email = "*****@*****.**";

            Assert.Equal("*****@*****.**", emailToModify.EmailOriginalValue);

            Assert.Equal(2, c.Count);
            Assert.Equal(1, c.AddedItems.Count);
            Assert.Equal(1, c.ModifiedItems.Count);
            Assert.Equal(1, c.RemovedItems.Count);

            c.AcceptChanges();

            Assert.Equal(2, c.Count);
            Assert.True(c.Contains(emailToModify));
            Assert.True(c.Contains(emailToAdd));

            Assert.Equal(0, c.AddedItems.Count);
            Assert.Equal(0, c.ModifiedItems.Count);
            Assert.Equal(0, c.RemovedItems.Count);

            Assert.False(emailToModify.IsChanged);
            Assert.Equal("*****@*****.**", emailToModify.Email);
            Assert.Equal("*****@*****.**", emailToModify.EmailOriginalValue);

            Assert.False(c.IsChanged);
        }
        public void ShouldTrackRemovedItems()
        {
            FriendEmailWrapper emailToRemove = _emails.First();
            ChangeTrackingCollection <FriendEmailWrapper> c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);

            Assert.AreEqual(2, c.Count);
            Assert.IsFalse(c.IsChanged);

            c.Remove(emailToRemove);
            Assert.AreEqual(1, c.Count);
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(1, c.RemovedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.AreEqual(emailToRemove, c.RemovedItems.First());
            Assert.IsTrue(c.IsChanged);

            c.Add(emailToRemove);
            Assert.AreEqual(2, c.Count);
            Assert.AreEqual(0, c.AddedItems.Count);
            Assert.AreEqual(0, c.RemovedItems.Count);
            Assert.AreEqual(0, c.ModifiedItems.Count);
            Assert.IsFalse(c.IsChanged);
        }