Esempio n. 1
0
 /// <summary>
 /// Called in order to commit this change.
 /// </summary>
 protected virtual void OnCommit(CommitReason reason)
 {
     if (this.CommitCallback != null)
     {
         ChangeCommittedEventArgs <T> args = new ChangeCommittedEventArgs <T>(this.Owner, this.CachedValue, this, reason);
         this.CommitCallback(args);
     }
 }
        public void changeCommittedArgs_generic_ctor_normal_should_correctly_set_values()
        {
            var entity      = new Object();
            var cachedValue = new GenericParameterHelper();
            var iChange     = A.Dummy <IChange>();
            var reason      = CommitReason.AcceptChanges;

            var target = new ChangeCommittedEventArgs <GenericParameterHelper>(entity, cachedValue, iChange, reason);

            target.Entity.Should().Be.EqualTo(entity);
            target.CachedValue.Should().Be.EqualTo(cachedValue);
            target.Source.Should().Be.EqualTo(iChange);
            target.Reason.Should().Be.EqualTo(reason);
        }
Esempio n. 3
0
        public void generic_iChange_commitCallback_is_invoked_with_expected_values()
        {
            ChangeCommittedEventArgs <string> expected = null;

            var owner = new Object();
            var value = "Foo";
            RejectCallback <string> rc = e => { };
            CommitCallback <string> cc = e => { expected = e; };
            var description            = string.Empty;
            var reason = CommitReason.AcceptChanges;

            var target = new ChangeMock <string>(owner, value, rc, cc, description);

            target.Commit(reason);

            expected.Should().Not.Be.Null();
            expected.Source.Should().Be.EqualTo(target);
            expected.Reason.Should().Be.EqualTo(reason);
            expected.Entity.Should().Be.EqualTo(owner);
            expected.CachedValue.Should().Be.EqualTo(value);
        }