public IAsyncResult DefaultBeginDisplayInitializationUI(IClientChannel channel, AsyncCallback callback, object state)
    {
        MockAsyncResult result = new MockAsyncResult(TimeSpan.FromSeconds(30), callback, state);

        result.Complete();
        return(result);
    }
Пример #2
0
    public MockCommunicationObject()
    {
        OpenAsyncResult = new MockAsyncResult();
        CloseAsyncResult = new MockAsyncResult();

        // Each overrideable method has a delegate property that
        // can be set to override it, please a default handler.

        // All the abstracts
        DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout;
        DefaultOpenTimeoutOverride = DefaultDefaultOpenTimeout;

        OnAbortOverride = DefaultOnAbort;
        OnOpenOverride = DefaultOnOpen;
        OnCloseOverride = DefaultOnClose;

        OnBeginOpenOverride = DefaultOnBeginOpen;
        OnEndOpenOverride = DefaultOnEndOpen;

        OnBeginCloseOverride = DefaultOnBeginClose;
        OnEndCloseOverride = DefaultOnEndClose;

        // All the virtuals
        OnOpeningOverride = DefaultOnOpening;
        OnOpenedOverride = DefaultOnOpened;
        OnClosingOverride = DefaultOnClosing;
        OnClosedOverride = DefaultOnClosed;
        OnFaultedOverride = DefaultOnFaulted;
    }
Пример #3
0
    public MockChannelFactory(BindingContext context, MessageEncoderFactory encoderFactory)
        : base(context.Binding)
    {
        MessageEncoderFactory = encoderFactory;

        OnCreateChannelOverride = DefaultOnCreateChannel;

        OpenAsyncResult  = new MockAsyncResult();
        CloseAsyncResult = new MockAsyncResult();

        // Each overrideable method has a delegate property that
        // can be set to override it, please a default handler.

        // CommunicationObject overrides
        DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout;
        DefaultOpenTimeoutOverride  = DefaultDefaultOpenTimeout;

        OnAbortOverride = DefaultOnAbort;
        OnOpenOverride  = DefaultOnOpen;
        OnCloseOverride = DefaultOnClose;

        OnBeginOpenOverride = DefaultOnBeginOpen;
        OnEndOpenOverride   = DefaultOnEndOpen;

        OnBeginCloseOverride = DefaultOnBeginClose;
        OnEndCloseOverride   = DefaultOnEndClose;

        // All the virtuals
        OnOpeningOverride = DefaultOnOpening;
        OnOpenedOverride  = DefaultOnOpened;
        OnClosingOverride = DefaultOnClosing;
        OnClosedOverride  = DefaultOnClosed;
        OnFaultedOverride = DefaultOnFaulted;
    }
Пример #4
0
        public MockHttpListener() : base()
        {
            DefaultValue = DefaultValue.Mock;
            SetupAllProperties();

            Setup(r => r.Prefixes).Returns(Prefixes);
            Setup(r => r.Start()).Callback(() => SetupGet(r => r.IsListening).Returns(true));
            Setup(r => r.Stop()).Callback(() => SetupGet(r => r.IsListening).Returns(false));

            Setup(r => r.BeginGetContext(It.IsAny <AsyncCallback>(), It.IsAny <object>()))
            .Callback((AsyncCallback callback, object state) => {
                ++BeginContextCallCount;
                BeginContextAction?.Invoke();
                if (BeginContextTriggersCallback)
                {
                    BeginContextTriggersCallback = false;
                    MockAsyncResult.SetupGet(r => r.AsyncState).Returns(() => state);
                    callback(MockAsyncResult.Object);
                }
            });

            Setup(r => r.EndGetContext(MockAsyncResult.Object))
            .Callback((IAsyncResult unused) => EndGetContextAction?.Invoke())
            .Returns((IAsyncResult unused) => MockContext.Object);
        }
Пример #5
0
    public MockChannelBase(ChannelManagerBase manager, MessageEncoderFactory encoderFactory, EndpointAddress address)
        : base(manager)
    {
        _address = address;
        _manager = manager;
        _encoder = encoderFactory.CreateSessionEncoder();

        OpenAsyncResult  = new MockAsyncResult();
        CloseAsyncResult = new MockAsyncResult();

        GetEndpointPropertyOverride = DefaultGetEndpointProperty;

        // CommunicationObject overrides
        DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout;
        DefaultOpenTimeoutOverride  = DefaultDefaultOpenTimeout;

        OnAbortOverride = DefaultOnAbort;
        OnOpenOverride  = DefaultOnOpen;
        OnCloseOverride = DefaultOnClose;

        OnBeginOpenOverride = DefaultOnBeginOpen;
        OnEndOpenOverride   = DefaultOnEndOpen;

        OnBeginCloseOverride = DefaultOnBeginClose;
        OnEndCloseOverride   = DefaultOnEndClose;

        // All the virtuals
        OnOpeningOverride = DefaultOnOpening;
        OnOpenedOverride  = DefaultOnOpened;
        OnClosingOverride = DefaultOnClosing;
        OnClosedOverride  = DefaultOnClosed;
        OnFaultedOverride = DefaultOnFaulted;
    }
    public MockCommunicationObject()
    {
        OpenAsyncResult  = new MockAsyncResult();
        CloseAsyncResult = new MockAsyncResult();

        // Each overrideable method has a delegate property that
        // can be set to override it, please a default handler.

        // All the abstracts
        DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout;
        DefaultOpenTimeoutOverride  = DefaultDefaultOpenTimeout;

        OnAbortOverride = DefaultOnAbort;
        OnOpenOverride  = DefaultOnOpen;
        OnCloseOverride = DefaultOnClose;

        OnBeginOpenOverride = DefaultOnBeginOpen;
        OnEndOpenOverride   = DefaultOnEndOpen;

        OnBeginCloseOverride = DefaultOnBeginClose;
        OnEndCloseOverride   = DefaultOnEndClose;

        // All the virtuals
        OnOpeningOverride = DefaultOnOpening;
        OnOpenedOverride  = DefaultOnOpened;
        OnClosingOverride = DefaultOnClosing;
        OnClosedOverride  = DefaultOnClosed;
        OnFaultedOverride = DefaultOnFaulted;
    }
Пример #7
0
    public MockChannelBase(ChannelManagerBase manager, MessageEncoderFactory encoderFactory, EndpointAddress address)
    : base(manager)
    {
        _address = address;
        _manager = manager;
        _encoder = encoderFactory.CreateSessionEncoder();

        OpenAsyncResult = new MockAsyncResult();
        CloseAsyncResult = new MockAsyncResult();

        GetEndpointPropertyOverride = DefaultGetEndpointProperty;

        // CommunicationObject overrides
        DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout;
        DefaultOpenTimeoutOverride = DefaultDefaultOpenTimeout;

        OnAbortOverride = DefaultOnAbort;
        OnOpenOverride = DefaultOnOpen;
        OnCloseOverride = DefaultOnClose;

        OnBeginOpenOverride = DefaultOnBeginOpen;
        OnEndOpenOverride = DefaultOnEndOpen;

        OnBeginCloseOverride = DefaultOnBeginClose;
        OnEndCloseOverride = DefaultOnEndClose;

        // All the virtuals
        OnOpeningOverride = DefaultOnOpening;
        OnOpenedOverride = DefaultOnOpened;
        OnClosingOverride = DefaultOnClosing;
        OnClosedOverride = DefaultOnClosed;
        OnFaultedOverride = DefaultOnFaulted;
    }
Пример #8
0
        public void ExecuteCore_Asynchronous_ActionNotFound()
        {
            // Arrange
            MockAsyncResult innerAsyncResult = new MockAsyncResult();

            Mock <IAsyncActionInvoker> mockActionInvoker = new Mock <IAsyncActionInvoker>();

            mockActionInvoker.Setup(o => o.BeginInvokeAction(It.IsAny <ControllerContext>(), "SomeAction", It.IsAny <AsyncCallback>(), It.IsAny <object>())).Returns(innerAsyncResult);
            mockActionInvoker.Setup(o => o.EndInvokeAction(innerAsyncResult)).Returns(false);

            RequestContext  requestContext = GetRequestContext("SomeAction");
            EmptyController controller     = new EmptyController()
            {
                ActionInvoker = mockActionInvoker.Object
            };

            // Act & assert
            IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null);

            Assert.False(controller.TempDataSaved);

            ((IAsyncController)controller).EndExecute(outerAsyncResult);
            Assert.True(controller.TempDataSaved);
            Assert.True(controller.HandleUnknownActionCalled);
        }
Пример #9
0
 public IAsyncResult DefaultBeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state)
 {
     // Default is to create an already completed IAsyncResult containing
     // the input message.
     MockAsyncResult result = new MockAsyncResult(timeout, callback, state);
     result.Complete(message);
     return result;
 }
Пример #10
0
        public void Complete_ThrowsIfCallbackThrows()
        {
            // Arrange
            MockAsyncCallback mockCallback    = new MockAsyncCallback(true);
            MockAsyncResult   mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);

            // Act/Assert
            Assert.Throws <InvalidOperationException>(() => mockAsyncResult.Complete(false));
        }
Пример #11
0
    public IAsyncResult DefaultBeginRequest(Message message, TimeSpan timeout, AsyncCallback callback, object state)
    {
        // Default is to create an already completed IAsyncResult containing
        // the input message.
        MockAsyncResult result = new MockAsyncResult(timeout, callback, state);

        result.Complete(message);
        return(result);
    }
Пример #12
0
        public void End_ThrowsOnInvalidAsyncResult()
        {
            Mock <IAsyncResult> mockIAsyncResult = new Mock <IAsyncResult>();

            Assert.ThrowsArgument(
                () => MockAsyncResult.End <MockAsyncResult>(mockIAsyncResult.Object),
                "result"
                );
        }
Пример #13
0
        public void Complete_SetsCompletedSynchronously(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.Equal(completedSynchronously, mockAsyncResult.CompletedSynchronously);
        }
Пример #14
0
        public void Complete_SetsIsCompleted(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.True(mockAsyncResult.IsCompleted);
        }
Пример #15
0
        public void Complete_ThrowsOnMultipleCompletes(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.Throws <InvalidOperationException>(() => mockAsyncResult.Complete(completedSynchronously));
        }
Пример #16
0
        public void AsyncWaitHandle_ThrowsIfAcessedAfterEndIsCalled(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            mockAsyncResult.Complete(completedSynchronously);
            MockAsyncResult.End <MockAsyncResult>(mockAsyncResult);

            // Act/Assert
            Assert.Throws <InvalidOperationException>(() => mockAsyncResult.AsyncWaitHandle);
        }
Пример #17
0
        public void AsyncWaitHandle_ReturnsIncompleteHandle()
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            WaitHandle handle = mockAsyncResult.AsyncWaitHandle;
            bool       signal = handle.WaitOne(_timeout);

            // Assert
            Assert.False(signal);
        }
Пример #18
0
        public void AsyncWaitHandle_ReturnsSameHandle()
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            WaitHandle handle1 = mockAsyncResult.AsyncWaitHandle;
            WaitHandle handle2 = mockAsyncResult.AsyncWaitHandle;

            // Assert
            Assert.Same(handle1, handle2);
        }
Пример #19
0
        public void End_ThrowsIfCompletedWithException(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback    mockCallback         = new MockAsyncCallback(false);
            MockAsyncResult      mockAsyncResult      = new MockAsyncResult(mockCallback.Callback, null);
            ApplicationException applicationException = new ApplicationException("Complete failed!");

            mockAsyncResult.Complete(completedSynchronously, applicationException);

            // Act/Assert
            Assert.Throws <ApplicationException>(() => MockAsyncResult.End <MockAsyncResult>(mockAsyncResult));
        }
Пример #20
0
        public void Complete_CallsCallback(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback mockCallback    = new MockAsyncCallback(false);
            MockAsyncResult   mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.True(mockCallback.WasInvoked);
            Assert.Same(mockAsyncResult, mockCallback.AsyncResult);
        }
Пример #21
0
        public void Complete_SetsHandleWhenNotCompletingSynchronously()
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(false);
            WaitHandle handle = mockAsyncResult.AsyncWaitHandle;
            bool       signal = handle.WaitOne(_timeout);

            // Assert
            Assert.True(signal);
        }
Пример #22
0
        public void End_ThrowsIfCalledTwiceOnSameAsyncResult(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback mockCallback    = new MockAsyncCallback(false);
            MockAsyncResult   mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);

            mockAsyncResult.Complete(completedSynchronously);

            // Act
            MockAsyncResult.End <MockAsyncResult>(mockAsyncResult);

            // Act
            Assert.Throws <InvalidOperationException>(() => MockAsyncResult.End <MockAsyncResult>(mockAsyncResult));
        }
Пример #23
0
        public void Constructor_Initializes()
        {
            // Arrange
            AsyncCallback callback = new AsyncCallback(_ => { });
            object        state    = new object();

            // Act
            MockAsyncResult mockAsyncResult = new MockAsyncResult(callback, state);

            // Assert
            Assert.True(mockAsyncResult.HasCallback);
            Assert.False(mockAsyncResult.IsCompleted);
            Assert.False(mockAsyncResult.CompletedSynchronously);
            Assert.Same(state, mockAsyncResult.AsyncState);
        }
Пример #24
0
        public void End_ClosesHandle(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback    mockCallback         = new MockAsyncCallback(false);
            MockAsyncResult      mockAsyncResult      = new MockAsyncResult(mockCallback.Callback, null);
            ApplicationException applicationException = new ApplicationException("Complete failed!");

            mockAsyncResult.Complete(completedSynchronously);
            WaitHandle handle = mockAsyncResult.AsyncWaitHandle;

            // Act
            MockAsyncResult.End <MockAsyncResult>(mockAsyncResult);

            // Assert
            Assert.ThrowsObjectDisposed(() => handle.WaitOne(), "");
        }
Пример #25
0
        public void ProcessRequestAsync_AsyncController_NormalExecution()
        {
            // Arrange
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                bool disposeWasCalled = false;

                Mock <IAsyncController> mockController = new Mock <IAsyncController>();
                mockController
                .Setup(
                    o =>
                    o.BeginExecute(
                        It.IsAny <RequestContext>(),
                        It.IsAny <AsyncCallback>(),
                        It.IsAny <object>()
                        )
                    )
                .Returns(innerAsyncResult);
                mockController
                .As <IDisposable>()
                .Setup(o => o.Dispose())
                .Callback(
                    delegate
                {
                    disposeWasCalled = true;
                }
                    );

                MvcHandler handler = GetMvcHandler(mockController.Object);

                // Act & assert
                IAsyncResult outerAsyncResult = handler.BeginProcessRequest(
                    handler.RequestContext.HttpContext,
                    null,
                    null
                    );
                Assert.False(disposeWasCalled);

                handler.EndProcessRequest(outerAsyncResult);
                Assert.True(disposeWasCalled);
                mockController.Verify(o => o.EndExecute(innerAsyncResult), Times.AtMostOnce());
            }
        }
Пример #26
0
        public void ProcessRequestAsync_AsyncController_NormalExecution()
        {
            // Arrange
            MockAsyncResult innerAsyncResult = new MockAsyncResult();
            bool            disposeWasCalled = false;

            Mock <IAsyncController> mockController = new Mock <IAsyncController>();

            mockController.Expect(o => o.BeginExecute(It.IsAny <RequestContext>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())).Returns(innerAsyncResult);
            mockController.Expect(o => o.EndExecute(innerAsyncResult)).AtMostOnce();
            mockController.As <IDisposable>().Expect(o => o.Dispose()).Callback(delegate { disposeWasCalled = true; });

            MvcHandler handler = GetMvcHandler(mockController.Object);

            // Act & assert
            IAsyncResult outerAsyncResult = handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null);

            Assert.IsFalse(disposeWasCalled, "Dispose shouldn't have been called yet.");

            handler.EndProcessRequest(outerAsyncResult);
            Assert.IsTrue(disposeWasCalled);
        }
Пример #27
0
        public void ExecuteCore_Synchronous_ActionNotFound()
        {
            // Arrange
            MockAsyncResult innerAsyncResult = new MockAsyncResult();

            Mock <IActionInvoker> mockActionInvoker = new Mock <IActionInvoker>();

            mockActionInvoker.Expect(o => o.InvokeAction(It.IsAny <ControllerContext>(), "SomeAction")).Returns(false);

            RequestContext  requestContext = GetRequestContext("SomeAction");
            EmptyController controller     = new EmptyController()
            {
                ActionInvoker = mockActionInvoker.Object
            };

            // Act & assert
            IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null);

            Assert.IsFalse(controller.TempDataSaved, "TempData shouldn't have been saved yet.");

            ((IAsyncController)controller).EndExecute(outerAsyncResult);
            Assert.IsTrue(controller.TempDataSaved);
            Assert.IsTrue(controller.HandleUnknownActionCalled);
        }
 public IAsyncResult DefaultBeginDisplayInitializationUI(IClientChannel channel, AsyncCallback callback, object state)
 {
     MockAsyncResult result = new MockAsyncResult(TimeSpan.FromSeconds(30), callback, state);
     result.Complete();
     return result;
 }
Пример #29
0
 public void End_ThrowsOnNullAsyncResult()
 {
     Assert.ThrowsArgumentNull(() => MockAsyncResult.End <MockAsyncResult>(null), "result");
 }