public PreparingRedirectToSubFunctionState(IExecutionStateContext executionStateContext, PreparingRedirectToSubFunctionStateParameters parameters, WxeReturnOptions returnOptions)
: base(executionStateContext, parameters)
{
ArgumentUtility.CheckNotNull("returnOptions", returnOptions);
_returnOptions = returnOptions;
}
public void ExecuteSubFunction()
{
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
WxeReturnOptions returnOptions = new WxeReturnOptions();
IExecutionState executionState = CreateExecutionState(permaUrlOptions, returnOptions);
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.Null);
Assert.That(nextState.Parameters.PermaUrlOptions, Is.SameAs(permaUrlOptions));
Assert.That(nextState.ReturnOptions, Is.SameAs(returnOptions));
});
}
MockRepository.ReplayAll();
executionState.ExecuteSubFunction(WxeContext);
MockRepository.VerifyAll();
}
public void ExecuteFunctionExternalByRedirect()
{
WxeContextMock.SetCurrent(_wxeContext);
WxePermaUrlOptions permaUrlOptions = new WxePermaUrlOptions();
WxeReturnOptions returnOptions = new WxeReturnOptions();
using (_mockRepository.Ordered())
{
_pageMock.Expect(mock => mock.WxeHandler).Return(_wxeHandler);
_pageStep.Expect(mock => mock.Execute(_wxeContext)).WhenCalled(
invocation =>
{
var executionState = (PreProcessingSubFunctionState_WithRedirect)((IExecutionStateContext)_pageStep).ExecutionState;
Assert.That(executionState.Parameters.SubFunction, Is.SameAs(_subFunction));
Assert.That(executionState.Parameters.PermaUrlOptions, Is.SameAs(permaUrlOptions));
Assert.That(executionState.ReturnOptions, Is.SameAs(returnOptions));
Assert.That(PrivateInvoke.GetNonPublicField(_pageStep, "_wxeHandler"), Is.SameAs(_wxeHandler));
});
}
_mockRepository.ReplayAll();
_pageStep.ExecuteFunctionExternalByRedirect(
new PreProcessingSubFunctionStateParameters(_pageMock, _subFunction, permaUrlOptions), returnOptions);
_mockRepository.VerifyAll();
}
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);
}
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));
}
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();
}
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();
}
