//[Ignore("TODO: deal with cm calling OnProtocol +=.")]
        public void RoomFinishLeaveTest()
        {
            using (mocks.Record())
            {
                Expect.Call(stream.Document).Return(doc);

                stream.OnProtocol += null;
                IEventRaiser onProtocol = LastCall.IgnoreArguments().GetEventRaiser();

                stream.Write((XmlElement)null);
                LastCall.Callback((Func <XmlElement, bool>)
                                  delegate(XmlElement elem)
                {
                    onProtocol.Raise(new object[] { null, CreateUnavailPacket(elem) });
                    return(true);
                });
            }

            using (mocks.Playback())
            {
                Room testRoom = CreateRoomPlayback(false, delegate { return(null); });
                testRoom.Leave(REASON);
            }

            Assert.IsFalse(cm.HasRoom(jid));
        }
Example #2
0
        public void IqRequestTest()
        {
            string nodever = "";

            IEventRaiser iqEvent;

            using (mocks.Record())
            {
                stream.OnIQ += null;
                iqEvent      = LastCall.IgnoreArguments().GetEventRaiser();

                Expect.Call(stream.Document).Return(doc);
                stream.Write((XmlElement)null);
                LastCall.Callback((Func <XmlElement, bool>)
                                  delegate(XmlElement arg0)
                {
                    string original   = arg0.OuterXml.Replace(" ", "");
                    string comparison = GetIQResponse(nodever).Replace(" ", "");
                    return(original == comparison);
                });
            }

            using (mocks.Playback())
            {
                CapsManager cm = new CapsManager();
                cm.Stream = stream;
                cm.Node   = NODE;

                nodever = cm.NodeVer;

                iqEvent.Raise(new object[] { null, CreateIqRequest() });
            }
        }
Example #3
0
        public void TestOverrideReturnValue()
        {
            //Create and mock the interceptor.
            MockRepository mock  = new MockRepository();
            IAspect        hmock = mock.StrictMock <IAspect>();

            Expect.Call(hmock.PreCall(null))
            .Return(MethodVoteOptions.Continue)
            .IgnoreArguments();
            hmock.PostCall(null, null);
            LastCall.Callback(delegate(CastleIInvocation ii, AspectReturnValue retval)
            {
                retval.WrappedReturnValue = "1234567890";
                return(retval.Original.Equals("12"));
            });

            mock.ReplayAll();
            using (TestContainer container = new TestContainer(@"Concrete\Castle\AOP\TestSuite1\Configs\ConfigSample2.config"))
            {
                //Set the mock into the kernel.
                container.Kernel.RemoveComponent("interceptor");
                container.Kernel.AddComponentInstance("interceptor", hmock);
                ISomething something = container.Resolve <ISomething>();
                String     retvalue  = something.OtherMethod("1", "2");
                Assert.That(retvalue, Is.EqualTo("1234567890"));
            }

            mock.VerifyAll();
        }
Example #4
0
 public void CallbackThatThrows()
 {
     demo = (IDemo)mocks.StrictMock(typeof(IDemo));
     demo.VoidNoArgs();
     LastCall.Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback));
     mocks.ReplayAll();
     Assert.Throws <AddressAlreadyInUseException>(demo.VoidNoArgs);
 }
Example #5
0
        public void LastCallCallback()
        {
            demo.VoidNoArgs();
            delegateWasCalled = false;
            LastCall.Callback(delegateCalled);
            mocks.ReplayAll();

            demo.VoidNoArgs();
            Assert.True(delegateWasCalled);
        }
        private void CreateJoinExpected(Func <XmlElement, XmlElement> sendPresence)
        {
            Expect.Call(stream.Document).Return(doc);

            stream.OnProtocol += null;
            IEventRaiser onProtocol = LastCall.IgnoreArguments().GetEventRaiser();

            stream.Write((XmlElement)null);
            LastCall.Callback((Func <XmlElement, bool>)
                              delegate(XmlElement elem)
            {
                onProtocol.Raise(new object[] { null, sendPresence(elem) });

                string original = elem.OuterXml;
                return(original.Replace(" ", "") ==
                       GetJoinPresence().Replace(" ", ""));
            });
        }
        //[Ignore("TODO: deal with cm calling OnProtocol +=.")]
        public void RoomLeaveTest()
        {
            using (mocks.Record())
            {
                Expect.Call(stream.Document).Return(doc);
                stream.Write((XmlElement)null);
                LastCall.Callback((Func <XmlElement, bool>)
                                  delegate(XmlElement elem)
                {
                    string original = elem.OuterXml;
                    return(original.Replace(" ", "") ==
                           GetLeavePresence().Replace(" ", ""));
                });
                stream.OnProtocol += null;
                LastCall.IgnoreArguments();
            }

            using (mocks.Playback())
            {
                Room testRoom = CreateRoomPlayback(false, delegate { return(null); });
                testRoom.Leave(REASON);
            }
        }
        private void SendMessage(bool shouldJoinRoom)
        {
            using (mocks.Record())
            {
                CreateJoinExpected(CreateJoinResponsePacket);

                Expect.Call(stream.Document).Return(doc);
                stream.Write((XmlElement)null);
                LastCall.Callback((Func <XmlElement, bool>)
                                  delegate(XmlElement elem)
                {
                    string id       = elem.GetAttribute("id");
                    string original = elem.OuterXml;
                    return(original.Replace(" ", "") == GetRoomMessage(id).Replace(" ", ""));
                });
            }

            using (mocks.Playback())
            {
                Room testRoom = CreateRoomPlayback(shouldJoinRoom, delegate { return(null); });
                testRoom.PublicMessage(MESSAGE);
            }
        }
Example #9
0
 private void SetupTrackerBeginIq(Func <IQ, IqCB, object, bool> func)
 {
     Expect.Call(stream.Tracker).Return(tracker);
     tracker.BeginIQ(null, null, null);
     LastCall.Callback(func);
 }