public void WhenSubmittingQuestionnaire_ThenPostsToCallingThreadsSyncContext()
        {
            var mockAsyncResult = new Mock<IAsyncResult>();
            var mockService = new Mock<IQuestionnaireService>();

            mockService
                .Setup(s => s.BeginSubmitQuestionnaire(It.IsAny<Questionnaire>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()))
                .Returns(mockAsyncResult.Object)
                .Callback<Questionnaire, AsyncCallback, object>((q, c, o) =>
                {
                    System.Threading.ThreadPool.QueueUserWorkItem(
                        (state) =>
                        {
                            c(mockAsyncResult.Object);
                        });
                });

            mockService
                .Setup(s => s.EndSubmitQuestionnaire(It.IsAny<IAsyncResult>()));

            var repository = new QuestionnaireRepository(mockService.Object);
            int callingThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
            int calledBackThreadId = 0;

            IOperationResult submitResult = null;
            repository.SubmitQuestionnaireAsync(
                new Questionnaire(),
                (r) =>
                {
                    submitResult = r;
                    calledBackThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
                }
            );

            EnqueueConditional(() => submitResult != null);
            EnqueueCallback(() => { Assert.AreEqual(callingThreadId, calledBackThreadId); });

            EnqueueTestComplete();
        }
        public void WhenExceptionOccursDuringSubmission_ThenExceptionCapturedAndReturned()
        {
            var mockAsyncResult = new Mock<IAsyncResult>();
            var mockService = new Mock<IQuestionnaireService>();

            mockService
                .Setup(s => s.BeginSubmitQuestionnaire(It.IsAny<Questionnaire>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()))
                .Returns(mockAsyncResult.Object)
                .Callback<Questionnaire, AsyncCallback, object>((q, c, o) =>
                {
                    c(mockAsyncResult.Object);
                });

            mockService
                .Setup(s => s.EndSubmitQuestionnaire(It.IsAny<IAsyncResult>()))
                .Throws(new NotImplementedException("TestException"));

            var repository = new QuestionnaireRepository(mockService.Object);

            IOperationResult submitResult = null;
            repository.SubmitQuestionnaireAsync(
                new Questionnaire(),
                (r) => { submitResult = r; }
            );

            EnqueueConditional(() => submitResult != null);
            EnqueueCallback(() => { Assert.IsInstanceOfType(submitResult.Error, typeof(NotImplementedException)); });

            EnqueueTestComplete();
        }
        public void WhenSubmittingQuestionnare_ThenInvokesCallback()
        {
            AsyncResult<object> ar = null;

            var serviceMock = new MockQuestionnaireService();
            serviceMock.HandleBeginSubmitResponses = (r) => ar = r;

            var repository = new QuestionnaireRepository(serviceMock);

            bool calledBack = false;

            repository.SubmitQuestionnaireAsync(new Questionnaire(), (result) => { calledBack = true; });

            serviceMock.ProceedSubmitResponses(ar);

            EnqueueConditional(() => calledBack);

            EnqueueCallback(() => { Assert.IsTrue(calledBack); });
            EnqueueTestComplete();
        }