Esempio n. 1
0
        public void SubscribeToStackNotNull()
        {
            IObserver <Message> observer = new ObserverMock();
            IDisposable         disposableMessageStack = membre.SubscribeToStack(observer, ami.id);

            Assert.IsNotNull(disposableMessageStack);
        }
        public void BindingTargetShouldUseDelegateIsEnabledProperty()
        {
            bool isEnabled = false;
            IAttachedBindingMemberInfo <object, bool> member =
                AttachedBindingMember.CreateMember <object, bool>(AttachedMemberConstants.Enabled,
                                                                  (info, o) => isEnabled,
                                                                  (info, o, v) => isEnabled = v);
            var memberProvider = new BindingMemberProvider();

            memberProvider.Register(typeof(object), member, false);
            BindingServiceProvider.MemberProvider = memberProvider;

            var mock = new ObserverMock {
                PathMembers = new BindingPathMembersMock(new object(), BindingPath.Empty)
            };
            var bindingTarget = (BindingTarget)CreateBindingSource(mock);

            bindingTarget.IsEnabled.ShouldBeFalse();
            bindingTarget.IsEnabled = true;
            isEnabled.ShouldBeTrue();
            bindingTarget.IsEnabled.ShouldBeTrue();

            bindingTarget.IsEnabled = false;
            isEnabled.ShouldBeFalse();
            bindingTarget.IsEnabled.ShouldBeFalse();
        }
Esempio n. 3
0
        public void SourceShouldReturnPathFromObserver()
        {
            var           mock   = new ObserverMock();
            BindingSource target = CreateBindingSource(mock);

            target.Path.ShouldBeNull();
            mock.Path = BindingPath.Create("test");
            target.Path.ShouldEqual(mock.Path);
        }
Esempio n. 4
0
        public void SourceShouldThrowExceptionWhenReturnSourceIfObserverHasException()
        {
            var mock = new ObserverMock
            {
                GetActualSource = b => { throw new TestException(); }
            };
            BindingSource target = CreateBindingSource(mock);

            ShouldThrow <TestException>(() => target.GetSource(true));
        }
Esempio n. 5
0
        public void SourceShouldThrowExceptionIfObserverHasException()
        {
            var mock = new ObserverMock
            {
                Validate = b => { throw new TestException(); }
            };
            var target = CreateBindingSource(mock);

            ShouldThrow <TestException>(() => target.Validate(true));
        }
Esempio n. 6
0
        public void SourceShouldReturnSourceFromObserver()
        {
            var src  = new object();
            var mock = new ObserverMock
            {
                GetActualSource = b => src
            };
            BindingSource target = CreateBindingSource(mock);

            target.GetSource(true).ShouldEqual(src);
        }
Esempio n. 7
0
        public void SourceShouldRaiseValueChangedWhenObserverRaisesValueChanged()
        {
            bool          isInvoked = false;
            var           mock      = new ObserverMock();
            BindingSource target    = CreateBindingSource(mock);

            target.ValueChanged += (sender, args) => isInvoked = true;
            isInvoked.ShouldBeFalse();
            mock.RaiseValueChanged();
            isInvoked.ShouldBeTrue();
        }
Esempio n. 8
0
        public void AddMessageInStackTest()
        {
            IObserver <Message> observer = new ObserverMock();
            Message             message  = new Message(ami.id, 1, "bob", "Hello world");

            membre.SubscribeToStack(observer, ami.id);
            membre.AddMessageInStack(message, ami.id);

            Assert.AreEqual(message.AuthorId, lastMessage.AuthorId);
            Assert.AreEqual(message.AuthorUsername, lastMessage.AuthorUsername);
            Assert.AreEqual(message.Content, lastMessage.Content);
        }
 protected override void OnInit()
 {
     base.OnInit();
     Behavior                   = CreateBehavior();
     BindingMock                = new DataBindingMock();
     TargetAccessorMock         = new BindingSourceAccessorMock();
     SourceAccessorMock         = new BindingSourceAccessorMock();
     TargetSourceMock           = new ObserverMock();
     SourceSourceMock           = new ObserverMock();
     SourceAccessorMock.Source  = SourceSourceMock;
     TargetAccessorMock.Source  = TargetSourceMock;
     BindingMock.TargetAccessor = TargetAccessorMock;
     BindingMock.SourceAccessor = SourceAccessorMock;
 }
Esempio n. 10
0
        public void SourceShouldReturnMembersFromObserver()
        {
            var mock = new ObserverMock {
                PathMembers = UnsetBindingPathMembers.Instance
            };
            BindingSource       target      = CreateBindingSource(mock);
            IBindingPathMembers pathMembers = target.GetPathMembers(true);

            pathMembers.ShouldEqual(UnsetBindingPathMembers.Instance);
            pathMembers.AllMembersAvailable.ShouldBeFalse();

            mock.PathMembers = new BindingPathMembersMock(this, BindingPath.Empty,
                                                          new BindingMemberInfo(PropertyInfo.Name, PropertyInfo, PropertyInfo.DeclaringType));
            pathMembers = target.GetPathMembers(true);
            pathMembers.ShouldEqual(mock.PathMembers);
            pathMembers.AllMembersAvailable.ShouldBeTrue();
        }
Esempio n. 11
0
        public void ManagerShouldRaiseEventWhenObserverValueChanged()
        {
            bool isInvoked = false;
            var  o         = new object();
            var  context   = new ExplicitDataContext {
                DataContext = o
            };
            var providerMock = new ObserverProviderMock();
            var observerMock = new ObserverMock();
            var manager      = CreateContextManager(observerProvider: providerMock);

            providerMock.Observe = (o1, path, arg3) => observerMock;
            var bindingContext = manager.GetBindingContext(context);

            bindingContext.ValueChanged += (sender, args) => isInvoked = true;
            isInvoked.ShouldBeFalse();
            observerMock.RaiseValueChanged();
            isInvoked.ShouldBeTrue();
        }
Esempio n. 12
0
        public void SourceShouldReturnValidateFromObserver()
        {
            bool param  = false;
            bool result = false;
            var  mock   = new ObserverMock
            {
                Validate = b =>
                {
                    b.ShouldEqual(param);
                    return(result);
                }
            };
            BindingSource target = CreateBindingSource(mock);

            target.Validate(param).ShouldBeFalse();

            param  = true;
            result = true;
            target.Validate(param).ShouldBeTrue();
        }
Esempio n. 13
0
        public void SubscribeUnsubscribeTest()
        {
            var l = new StringBuilder();

            var obs = new ObserverMock(l);

            var res = "";

            var del = new Action(() =>
            {
                res += "A";
            });

            obs.Event += del;
            var l1 = l.ToString();

            obs.Event += del;
            var l2 = l.ToString();

            obs.Handler.RaiseEvent();

            Action del1 = null;
            Action del2 = null;

            obs.Event -= del;
            var l3 = l.ToString();

            del1       = obs.Handler.Delegate;
            obs.Event -= del;
            var l4 = l.ToString();

            del2 = obs.Handler.Delegate;

            Assert.AreEqual("AA", res);
            Assert.AreEqual("s", l1);
            Assert.AreEqual("s", l2);
            Assert.AreEqual("s", l3);
            Assert.AreEqual("su", l4);
            Assert.IsNotNull(del1);
            Assert.IsNull(del2);
        }