public void ExecuteFunction()
{
WxeContextMock.SetCurrent(_wxeContext);
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
WxeRepostOptions repostOptions = WxeRepostOptions.SuppressRepost(MockRepository.GenerateStub <Control>(), true);
using (_mockRepository.Ordered())
{
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
_pageStep.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(
invocation =>
{
var executionState = (PreProcessingSubFunctionState)((IExecutionStateContext)_pageStep).ExecutionState;
Assert.That(executionState.Parameters.SubFunction, Is.SameAs(_subFunction));
Assert.That(executionState.Parameters.PermaUrlOptions, Is.SameAs(permaUrlOptions));
Assert.That(executionState.RepostOptions, Is.SameAs(repostOptions));
Assert.That(PrivateInvoke.GetNonPublicField(_pageStep, "_wxeHandler"), Is.SameAs(_wxeHandler));
});
}
_mockRepository.ReplayAll();
_pageStep.ExecuteFunction(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), repostOptions);
_mockRepository.VerifyAll();
}
public void ExecuteSubFunction_WithPermaUrl_WithParentPermaUrl_DoNotReturnToCaller_GoesToRedirectingToSubFunction ()
{
WxeContext.QueryString.Add ("Key", "NewValue");
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions (true);
IExecutionState executionState = CreateExecutionState (permaUrlOptions, WxeReturnOptions.Null);
ExecutionStateContextMock.Expect (mock => mock.SetExecutionState (Arg<RedirectingToSubFunctionState>.Is.NotNull))
.WhenCalled (
invocation =>
{
var nextState = CheckExecutionState ((RedirectingToSubFunctionState) invocation.Arguments[0]);
Assert.That (nextState.Parameters.SubFunction.ReturnUrl, Is.EqualTo ("DefaultReturn.html"));
string destinationUrl = UrlUtility.AddParameters (
"/session/sub.wxe",
new NameValueCollection
{
{ "Parameter1", "OtherValue" },
{ WxeHandler.Parameters.WxeFunctionToken, SubFunction.FunctionToken },
{ WxeHandler.Parameters.ReturnUrl, "/root.wxe?Key=NewValue" }
},
Encoding.Default);
Assert.That (nextState.Parameters.DestinationUrl, Is.EqualTo (destinationUrl));
});
MockRepository.ReplayAll();
executionState.ExecuteSubFunction (WxeContext);
MockRepository.VerifyAll();
}
public void ExecuteSubFunction_WithPermaUrl_ReturnToCaller_WithCallerUrlParameters_GoesToRedirectingToSubFunction ()
{
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
IExecutionState executionState = CreateExecutionState (permaUrlOptions, new WxeReturnOptions (new NameValueCollection { { "Key", "Value" } }));
ExecutionStateContextMock.Stub (stub => stub.CurrentFunction).Return (RootFunction).Repeat.Any();
ExecutionStateContextMock.Expect (mock => mock.SetExecutionState (Arg<RedirectingToSubFunctionState>.Is.NotNull))
.WhenCalled (
invocation =>
{
var nextState = CheckExecutionState ((RedirectingToSubFunctionState) invocation.Arguments[0]);
Assert.That (
nextState.Parameters.SubFunction.ReturnUrl,
Is.EqualTo ("/session/root.wxe?Key=Value&WxeFunctionToken=" + WxeContext.FunctionToken));
Assert.That (
nextState.Parameters.DestinationUrl,
Is.EqualTo ("/session/sub.wxe?Parameter1=OtherValue&WxeFunctionToken=" + SubFunction.FunctionToken));
});
MockRepository.ReplayAll();
executionState.ExecuteSubFunction (WxeContext);
MockRepository.VerifyAll();
}
public void Test_SubFunctionCompleted_ReEntrancy()
{
WxeContextMock.SetCurrent(_wxeContext);
using (_mockRepository.Ordered())
{
using (_mockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(_postBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
}
_subFunction.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(invocation => Thread.CurrentThread.Abort());
_pageExecutorMock.Expect(mock => mock.ExecutePage(_wxeContext, "~/ThePage", true));
}
_mockRepository.ReplayAll();
try
{
WxePermaUrlOptions permaUrlOptions = WxePermaUrlOptions.Null;
WxeRepostOptions repostOptions = WxeRepostOptions.DoRepost(null);
_pageStep.ExecuteFunction(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), repostOptions);
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
_pageStep.Execute();
_mockRepository.VerifyAll();
}
public PreparingRedirectToSubFunctionStateParameters(
WxeFunction subFunction, NameValueCollection postBackCollection, WxePermaUrlOptions permaUrlOptions)
: base(subFunction, postBackCollection)
{
ArgumentUtility.CheckNotNull("permaUrlOptions", permaUrlOptions);
_permaUrlOptions = permaUrlOptions;
}
public void ExecuteSubFunction_WithPermaUrl()
{
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
IExecutionState executionState = CreateExecutionStateForDoRepost(null, permaUrlOptions);
using (MockRepository.Ordered())
{
using (MockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(PostBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
}
ExecutionStateContextMock.Expect(mock => mock.SetExecutionState(Arg <PreparingRedirectToSubFunctionState> .Is.NotNull))
.WhenCalled(
invocation =>
{
var nextState = CheckExecutionState((PreparingRedirectToSubFunctionState)invocation.Arguments[0]);
Assert.That(nextState.Parameters.PostBackCollection, Is.Not.SameAs(PostBackCollection));
Assert.That(
nextState.Parameters.PostBackCollection.AllKeys,
Is.EquivalentTo(new[] { "Key", c_senderUniqueID, ControlHelper.PostEventSourceID, ControlHelper.PostEventArgumentID }));
Assert.That(nextState.Parameters.SubFunction.ParentStep, Is.SameAs(_parentStep));
Assert.That(nextState.Parameters.PermaUrlOptions, Is.SameAs(permaUrlOptions));
});
}
MockRepository.ReplayAll();
executionState.ExecuteSubFunction(WxeContext);
MockRepository.VerifyAll();
}
public PreProcessingSubFunctionStateParameters(IWxePage page, WxeFunction subFunction, WxePermaUrlOptions permaUrlOptions)
{
ArgumentUtility.CheckNotNull("page", page);
ArgumentUtility.CheckNotNull("subFunction", subFunction);
ArgumentUtility.CheckNotNull("permaUrlOptions", permaUrlOptions);
_page = page;
_subFunction = subFunction;
_permaUrlOptions = permaUrlOptions;
}
public void ExecuteFunction(WxeFunction function, Control sender, WxeCallOptions options)
{
ArgumentUtility.CheckNotNull("function", function);
// sender can be null
ArgumentUtility.CheckNotNull("options", options);
WxePermaUrlOptions permaUrlOptions = options.PermaUrlOptions;
WxeRepostOptions repostOptions = WxeRepostOptions.DoRepost(sender);
_wxePageInfo.CurrentPageStep.ExecuteFunction(new PreProcessingSubFunctionStateParameters(_page, function, permaUrlOptions), repostOptions);
}
public void ExecuteFunctionNoRepost(WxeFunction function, Control sender, WxeCallOptionsNoRepost options)
{
ArgumentUtility.CheckNotNull("function", function);
ArgumentUtility.CheckNotNull("sender", sender);
ArgumentUtility.CheckNotNull("options", options);
bool usesEventTarget = options.UsesEventTarget ?? UsesEventTarget;
WxePermaUrlOptions permaUrlOptions = options.PermaUrlOptions;
WxeRepostOptions repostOptions = WxeRepostOptions.SuppressRepost(sender, usesEventTarget);
_wxePageInfo.CurrentPageStep.ExecuteFunction(new PreProcessingSubFunctionStateParameters(_page, function, permaUrlOptions), repostOptions);
}
public void ExecuteFunctionExternalByRedirect(WxeFunction function, Control sender, WxeCallOptionsExternalByRedirect options)
{
ArgumentUtility.CheckNotNull("function", function);
ArgumentUtility.CheckNotNull("sender", sender);
ArgumentUtility.CheckNotNull("options", options);
WxeReturnOptions returnOptions;
if (options.ReturnToCaller)
{
returnOptions = new WxeReturnOptions(options.CallerUrlParameters ?? _page.GetPermanentUrlParameters());
}
else
{
returnOptions = WxeReturnOptions.Null;
}
WxePermaUrlOptions permaUrlOptions = options.PermaUrlOptions;
_wxePageInfo.CurrentPageStep.ExecuteFunctionExternalByRedirect(new PreProcessingSubFunctionStateParameters(_page, function, permaUrlOptions), returnOptions);
}
public void Test_SubFunction()
{
WxeContextMock.SetCurrent(_wxeContext);
using (_mockRepository.Ordered())
{
using (_mockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(_postBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
}
_subFunction.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(
invocation =>
{
PrivateInvoke.SetNonPublicField(_functionState, "_postBackID", 100);
_pageStep.SetPostBackCollection(new NameValueCollection());
});
_pageExecutorMock.Expect(mock => mock.ExecutePage(_wxeContext, "~/ThePage", false)).WhenCalled(
invocation =>
{
Assert.That(((IExecutionStateContext)_pageStep).ExecutionState, Is.SameAs(NullExecutionState.Null));
Assert.That(_pageStep.PostBackCollection[WxePageInfo.PostBackSequenceNumberID], Is.EqualTo("100"));
Assert.That(_pageStep.PostBackCollection.AllKeys, Has.Member("Key"));
Assert.That(_pageStep.ReturningFunction, Is.SameAs(_subFunction));
Assert.That(_pageStep.IsReturningPostBack, Is.True);
});
}
_mockRepository.ReplayAll();
WxePermaUrlOptions permaUrlOptions = WxePermaUrlOptions.Null;
WxeRepostOptions repostOptions = WxeRepostOptions.DoRepost(null);
_pageStep.ExecuteFunction(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), repostOptions);
_mockRepository.VerifyAll();
}
public void ExecuteSubFunction_WithPermaUrl_GoesToExecutingSubFunction()
{
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
IExecutionState executionState = CreateExecutionState(permaUrlOptions);
ExecutionStateContextMock.Expect(mock => mock.SetExecutionState(Arg <RedirectingToSubFunctionState> .Is.NotNull))
.WhenCalled(
invocation =>
{
var nextState = CheckExecutionState((RedirectingToSubFunctionState)invocation.Arguments[0]);
Assert.That(
nextState.Parameters.DestinationUrl,
Is.EqualTo("/session/sub.wxe?Parameter1=OtherValue&WxeFunctionToken=" + WxeContext.FunctionToken));
Assert.That(nextState.Parameters.ResumeUrl, Is.EqualTo("/session/root.wxe?WxeFunctionToken=" + WxeContext.FunctionToken));
});
MockRepository.ReplayAll();
executionState.ExecuteSubFunction(WxeContext);
MockRepository.VerifyAll();
}
public void ExecuteSubFunction_WithPermaUrl_WithCustumUrlParamters_DoNotReturnToCaller_GoesToRedirectingToSubFunction ()
{
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions (false, new NameValueCollection { { "Key", "NewValue" } });
IExecutionState executionState = CreateExecutionState (permaUrlOptions, WxeReturnOptions.Null);
ExecutionStateContextMock.Expect (mock => mock.SetExecutionState (Arg<RedirectingToSubFunctionState>.Is.NotNull))
.WhenCalled (
invocation =>
{
var nextState = CheckExecutionState ((RedirectingToSubFunctionState) invocation.Arguments[0]);
Assert.That (nextState.Parameters.SubFunction.ReturnUrl, Is.EqualTo ("DefaultReturn.html"));
Assert.That (
nextState.Parameters.DestinationUrl,
Is.EqualTo ("/session/sub.wxe?Key=NewValue&WxeFunctionToken=" + SubFunction.FunctionToken));
});
MockRepository.ReplayAll();
executionState.ExecuteSubFunction (WxeContext);
MockRepository.VerifyAll();
}
public void Test_SubFunction_RedirectToPermaUrl()
{
WxeContextMock.SetCurrent(_wxeContext);
Uri uri = new Uri("http://localhost/root.wxe");
HttpResponseBase responseMock = _mockRepository.StrictMock <HttpResponseBase>();
responseMock.Stub(stub => stub.ApplyAppPathModifier("~/sub.wxe")).Return("/session/sub.wxe").Repeat.Any();
responseMock.Stub(stub => stub.ApplyAppPathModifier("/session/sub.wxe")).Return("/session/sub.wxe").Repeat.Any();
responseMock.Stub(stub => stub.ApplyAppPathModifier("/root.wxe")).Return("/session/root.wxe").Repeat.Any();
responseMock.Stub(stub => stub.ApplyAppPathModifier("/session/root.wxe")).Return("/session/root.wxe").Repeat.Any();
responseMock.Stub(stub => stub.ContentEncoding).Return(Encoding.Default).Repeat.Any();
_httpContextMock.Stub(stub => stub.Response).Return(responseMock).Repeat.Any();
HttpRequestBase requestMock = _mockRepository.StrictMock <HttpRequestBase>();
requestMock.Stub(stub => stub.Url).Return(uri).Repeat.Any();
_httpContextMock.Stub(stub => stub.Request).Return(requestMock).Repeat.Any();
using (_mockRepository.Ordered())
{
using (_mockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(_postBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
}
//Redirect to subfunction
responseMock.Expect(mock => mock.Redirect("/session/sub.wxe?WxeFunctionToken=" + _wxeContext.FunctionToken))
.WhenCalled(invocation => Thread.CurrentThread.Abort());
//Show sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(invocation => Thread.CurrentThread.Abort());
//Return from sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).Throw(new WxeExecuteNextStepException());
//Return from sub function
responseMock.Expect(mock => mock.Redirect("/session/root.wxe?WxeFunctionToken=" + _wxeContext.FunctionToken))
.WhenCalled(
invocation =>
{
PrivateInvoke.SetNonPublicField(_functionState, "_postBackID", 100);
_pageStep.SetPostBackCollection(new NameValueCollection());
Thread.CurrentThread.Abort();
});
_pageExecutorMock.Expect(mock => mock.ExecutePage(_wxeContext, "~/ThePage", true)).WhenCalled(
invocation =>
{
Assert.That(((IExecutionStateContext)_pageStep).ExecutionState, Is.SameAs(NullExecutionState.Null));
Assert.That(_pageStep.PostBackCollection[WxePageInfo.PostBackSequenceNumberID], Is.EqualTo("100"));
Assert.That(_pageStep.PostBackCollection.AllKeys, Has.Member("Key"));
Assert.That(_pageStep.ReturningFunction, Is.SameAs(_subFunction));
Assert.That(_pageStep.IsReturningPostBack, Is.True);
});
}
_mockRepository.ReplayAll();
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
try
{
//Redirect to subfunction
WxeRepostOptions repostOptions = WxeRepostOptions.DoRepost(null);
_pageStep.ExecuteFunction(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), repostOptions);
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Show sub function
_pageStep.Execute();
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Return from sub function
_pageStep.Execute();
Assert.Fail();
}
catch (WxeExecuteNextStepException)
{
}
try
{
//Return from sub function
_pageStep.Execute();
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
//Show current page
_pageStep.Execute();
_mockRepository.VerifyAll();
}
public void Test_DoNotReturnToCaller()
{
using (_mockRepository.Ordered())
{
using (_mockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(_postBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
}
//Redirect to external subfunction
_responseMock
.Expect(mock => mock.Redirect(Arg <string> .Matches(arg => arg == "/session/sub.wxe?WxeFunctionToken=" + _subFunction.FunctionToken)))
.WhenCalled(invocation => Thread.CurrentThread.Abort());
//Show external sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(invocation => Thread.CurrentThread.Abort());
//Return from external sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).Throw(new WxeExecuteNextStepException());
}
_mockRepository.ReplayAll();
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
try
{
//Redirect to external subfunction
WxeReturnOptions returnOptions = WxeReturnOptions.Null;
_pageStep.ExecuteFunctionExternalByRedirect(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), returnOptions);
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Show external sub function
_subFunction.Execute();
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Return from external sub function
_subFunction.Execute();
Assert.Fail();
}
catch (WxeExecuteNextStepException)
{
}
Assert.That(_subFunction.ReturnUrl, Is.EqualTo("DefaultReturn.html"));
_mockRepository.VerifyAll();
}
public void Test_ReturnToCaller()
{
NameValueCollection callerUrlParameters = new NameValueCollection {
{ "CallerKey", "CallerValue" }
};
using (_mockRepository.Ordered())
{
using (_mockRepository.Unordered())
{
_pageMock.Expect(mock => mock.GetPostBackCollection()).Return(_postBackCollection);
_pageMock.Expect(mock => mock.SaveAllState());
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
}
//Redirect to external subfunction
_responseMock
.Expect(mock => mock.Redirect(Arg <string> .Matches(arg => arg == "/session/sub.wxe?WxeFunctionToken=" + _subFunction.FunctionToken)))
.WhenCalled(invocation => Thread.CurrentThread.Abort());
//Show external sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(
invocation =>
{
PrivateInvoke.SetNonPublicField(_functionState, "_postBackID", 100);
_pageStep.SetPostBackCollection(new NameValueCollection());
Thread.CurrentThread.Abort();
});
//Return from external sub function
_subFunction.Expect(mock => mock.Execute(_wxeContext)).Throw(new WxeExecuteNextStepException());
_requestMock.Expect(mock => mock.HttpMethod).Return("GET");
_pageExecutorMock.Expect(mock => mock.ExecutePage(_wxeContext, "~/ThePage", true)).WhenCalled(
invocation =>
{
Assert.That(((IExecutionStateContext)_pageStep).ExecutionState, Is.SameAs(NullExecutionState.Null));
Assert.That(_pageStep.PostBackCollection[WxePageInfo.PostBackSequenceNumberID], Is.EqualTo("100"));
Assert.That(_pageStep.PostBackCollection.AllKeys, Has.Member("Key"));
Assert.That(_pageStep.ReturningFunction, Is.SameAs(_subFunction));
Assert.That(_pageStep.IsReturningPostBack, Is.True);
});
}
_mockRepository.ReplayAll();
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
try
{
//Redirect to external subfunction
WxeReturnOptions returnOptions = new WxeReturnOptions(callerUrlParameters);
_pageStep.ExecuteFunctionExternalByRedirect(new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), returnOptions);
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Show external sub function
_subFunction.Execute();
Assert.Fail();
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
try
{
//Return from external sub function
_subFunction.Execute();
Assert.Fail();
}
catch (WxeExecuteNextStepException)
{
}
Assert.That(_subFunction.ReturnUrl, Is.EqualTo("/session/root.wxe?CallerKey=CallerValue&WxeFunctionToken=" + _rootFunction.FunctionToken));
//Show current page
_pageStep.Execute();
_mockRepository.VerifyAll();
}
private PreparingRedirectToSubFunctionState CreateExecutionState (WxePermaUrlOptions permaUrlOptions, WxeReturnOptions returnOptions)
{
return new PreparingRedirectToSubFunctionState (
ExecutionStateContextMock, new PreparingRedirectToSubFunctionStateParameters (SubFunction, PostBackCollection, permaUrlOptions), returnOptions);
}
private PreProcessingSubFunctionState CreateExecutionState(WxePermaUrlOptions permaUrlOptions, WxeReturnOptions returnOptions)
{
return(new PreProcessingSubFunctionState(
ExecutionStateContextMock, new PreProcessingSubFunctionStateParameters(_pageMock, SubFunction, permaUrlOptions), returnOptions));
}
private PreProcessingSubFunctionState CreateExecutionStateForDoRepost(Control sender, WxePermaUrlOptions permaUrlOptions)
{
return(new PreProcessingSubFunctionState(
ExecutionStateContextMock,
new PreProcessingSubFunctionStateParameters(_pageMock, SubFunction, permaUrlOptions),
WxeRepostOptions.DoRepost(sender)));
}
