You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by mg...@apache.org on 2013/06/13 11:48:13 UTC
[01/11] git commit: ignore idea project files
Updated Branches:
refs/heads/master b5d53c526 -> 22f1e0489
ignore idea project files
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/f5af56b0
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/f5af56b0
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/f5af56b0
Branch: refs/heads/master
Commit: f5af56b012d972dd6d8f7ff62d5070578c24a3ea
Parents: e86fea3
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Wed Sep 26 22:06:09 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Wed Sep 26 22:06:09 2012 +0200
----------------------------------------------------------------------
.gitignore | 4 ++++
1 file changed, 4 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/f5af56b0/.gitignore
----------------------------------------------------------------------
diff --git a/.gitignore b/.gitignore
index 797d696..bbefc81 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,7 @@ velocity.log
.project
.classpath
*velocity.log*
+.idea/
+*.iml
+*~
+
[04/11] git commit: unit tests to preserve state
Posted by mg...@apache.org.
unit tests to preserve state
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/74ba7773
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/74ba7773
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/74ba7773
Branch: refs/heads/master
Commit: 74ba7773d0b635dfc986c7b9b9802b512271eb05
Parents: 0a192b5
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Wed Sep 26 22:52:13 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Wed Sep 26 22:52:13 2012 +0200
----------------------------------------------------------------------
.../handler/render/WebPageRendererTest.java | 103 ++++++++++++++++++-
1 file changed, 98 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/74ba7773/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 9935f6d..709d070 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@ -625,11 +625,6 @@ public class WebPageRendererTest
Assert.assertTrue(stored.get());
}
- // or one pass render mode is on
- // or the targetUrl matches current url and the page is not stateless
- // or the targetUrl matches current url, page is stateless but it's redirect-to-render
- // or the request determines that the current url should be preserved
- // just render the page
@Test
public void testShouldRenderPageAndWriteResponseCondition() {
@@ -664,6 +659,104 @@ public class WebPageRendererTest
Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+ // or one pass render mode is on
+ // -> or one pass render mode is on and its NOT ajax and its NOT always redirect
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ onePassRender=true;
+ ajax=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ redirectToRender=true;
+ shouldPreserveClientUrl=true;
+ targetEqualsCurrentUrl=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or the targetUrl matches current url and the page is not stateless
+ // or the targetUrl matches current url, page is stateless but it's redirect-to-render
+ // --> its NOT ajax and
+ // the targetUrl matches current url and the page is NOT stateless and its NOT a new instance
+ // or the targetUrl matches current url and it's redirect-to-render
+
+ ajax=false;
+ targetEqualsCurrentUrl=true;
+ pageStateless=false;
+ newPageInstance=false;
+
+ onePassRender=false;
+ redirectToRender=false;
+ shouldPreserveClientUrl=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ targetEqualsCurrentUrl=true;
+ pageStateless=true;
+ newPageInstance=true;
+ redirectToRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or the request determines that the current url should be preserved
+ // just render the page
+ shouldPreserveClientUrl=true;
+
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ ajax=true;
+ onePassRender=false;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ }
+
+ @Test
+ public void testShouldNOTRenderPageAndWriteResponseCondition() {
+
+ RedirectPolicy redirectPolicy;
+ boolean ajax;
+ boolean onePassRender;
+ boolean redirectToRender;
+ boolean shouldPreserveClientUrl;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+
+ // NOT if the policy is never to redirect
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+
+ // NOT or one pass render mode is on
+ // -> or one pass render mode is on and its NOT ajax and its NOT always redirect
+ ajax=true;
+ onePassRender=false;
+
+ // NOT or the targetUrl matches current url and the page is not stateless
+ // or the targetUrl matches current url, page is stateless but it's redirect-to-render
+ // --> its NOT ajax and
+ // the targetUrl matches current url and the page is NOT stateless and its NOT a new instance
+ // or the targetUrl matches current url and it's redirect-to-render
+ targetEqualsCurrentUrl=false;
+
+ // or the request determines that the current url should be preserved
+ // just render the page
+ shouldPreserveClientUrl=false;
+
+ redirectToRender=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ redirectToRender=false;
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
}
/**
[08/11] git commit: full test webpagerender method for current
implementation state
Posted by mg...@apache.org.
full test webpagerender method for current implementation state
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/4950a773
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/4950a773
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/4950a773
Branch: refs/heads/master
Commit: 4950a773dc7e3d286c67cdc4611f3b9bd2b060af
Parents: b891bb8
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Thu Sep 27 00:57:12 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Thu Sep 27 00:57:12 2012 +0200
----------------------------------------------------------------------
.../request/handler/render/WebPageRenderer.java | 128 ++++++++++---------
.../handler/render/AbstractVariations.java | 37 ++++++
.../render/ShouldRedirectToTargetUrl.java | 55 ++++++++
...uldRenderPageAndWriteResponseVariations.java | 19 +--
.../handler/render/WebPageRendererTest.java | 68 ++++++++--
5 files changed, 222 insertions(+), 85 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/4950a773/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
index b74df37..6bb7b90 100644
--- a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
+++ b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
@@ -182,6 +182,7 @@ public class WebPageRenderer extends PageRenderer
boolean onePassRender = isOnePassRender();
boolean isRedirectToRender = isRedirectToRender();
+ boolean redirectToBuffer = isRedirectToBuffer();
boolean targetEqualsCurrentUrl = targetUrl.equals(currentUrl);
boolean isNewPageInstance = getPageProvider().isNewPageInstance();
@@ -195,76 +196,79 @@ public class WebPageRenderer extends PageRenderer
response.writeTo((WebResponse)requestCycle.getResponse());
}
}
- else if (shouldRedirectToTargetUrl(isAjax, redirectPolicy, isRedirectToRender, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless))
- {
- redirectTo(targetUrl, requestCycle);
- }
- else
- {
- if (isRedirectToBuffer() == false && logger.isDebugEnabled())
- {
- String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
- "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
- Application.get().getRequestCycleSettings().getRenderStrategy(),
- isAjax, redirectPolicy, currentUrl, targetUrl, isNewPageInstance,
- isPageStateless, isSessionTemporary());
- logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
- "matched. Details: " + details);
- }
-
- // redirect to buffer
- BufferedWebResponse response = renderPage(targetUrl, requestCycle);
-
- if (response == null)
- {
- return;
- }
-
- // check if the url hasn't changed after page has been rendered
- // (i.e. the stateless flag might have changed which could result in different page url)
- Url targetUrl2 = requestCycle.mapUrlFor(getRenderPageRequestHandler());
-
- if (targetUrl.getSegments().equals(targetUrl2.getSegments()) == false)
- {
- // the amount of segments is different - generated relative URLs will not work, we
- // need to rerender the page. This shouldn't happen, but in theory it can - with
- // RequestHandlerEncoders that produce different URLs with different amount of
- // segments for stateless and stateful pages
- response = renderPage(targetUrl2, requestCycle);
- }
-
- if (currentUrl.equals(targetUrl2))
+ else {
+ boolean sessionTemporary = isSessionTemporary();
+ if (shouldRedirectToTargetUrl(isAjax, redirectPolicy, isRedirectToRender, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless, sessionTemporary))
{
- // no need to redirect when both urls are exactly the same
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- // if page is still stateless after render
- else if (isPageStateless && !enableRedirectForStatelessPage())
- {
- // we don't want the redirect to happen for stateless page
- // example:
- // when a normal mounted stateful page is hit at /mount/point
- // wicket renders the page to buffer and redirects to /mount/point?12
- // but for stateless page the redirect is not necessary
- // also for listener interface on stateful page we want to redirect
- // after the listener is invoked, but on stateless page the user
- // must ask for redirect explicitly
- response.writeTo((WebResponse)requestCycle.getResponse());
+ redirectTo(targetUrl, requestCycle);
}
else
{
- storeBufferedResponse(targetUrl2, response);
-
- redirectTo(targetUrl2, requestCycle);
+ if (redirectToBuffer == false && logger.isDebugEnabled())
+ {
+ String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
+ "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
+ Application.get().getRequestCycleSettings().getRenderStrategy(),
+ isAjax, redirectPolicy, currentUrl, targetUrl, isNewPageInstance,
+ isPageStateless, sessionTemporary);
+ logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
+ "matched. Details: " + details);
+ }
+
+ // redirect to buffer
+ BufferedWebResponse response = renderPage(targetUrl, requestCycle);
+
+ if (response == null)
+ {
+ return;
+ }
+
+ // check if the url hasn't changed after page has been rendered
+ // (i.e. the stateless flag might have changed which could result in different page url)
+ Url targetUrl2 = requestCycle.mapUrlFor(getRenderPageRequestHandler());
+
+ if (targetUrl.getSegments().equals(targetUrl2.getSegments()) == false)
+ {
+ // the amount of segments is different - generated relative URLs will not work, we
+ // need to rerender the page. This shouldn't happen, but in theory it can - with
+ // RequestHandlerEncoders that produce different URLs with different amount of
+ // segments for stateless and stateful pages
+ response = renderPage(targetUrl2, requestCycle);
+ }
+
+ if (currentUrl.equals(targetUrl2))
+ {
+ // no need to redirect when both urls are exactly the same
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ // if page is still stateless after render
+ else if (isPageStateless && !enableRedirectForStatelessPage())
+ {
+ // we don't want the redirect to happen for stateless page
+ // example:
+ // when a normal mounted stateful page is hit at /mount/point
+ // wicket renders the page to buffer and redirects to /mount/point?12
+ // but for stateless page the redirect is not necessary
+ // also for listener interface on stateful page we want to redirect
+ // after the listener is invoked, but on stateless page the user
+ // must ask for redirect explicitly
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ else
+ {
+ storeBufferedResponse(targetUrl2, response);
+
+ redirectTo(targetUrl2, requestCycle);
+ }
}
}
}
}
- protected boolean shouldRedirectToTargetUrl(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless) {
+ protected static boolean shouldRedirectToTargetUrl(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless,boolean sessionTemporary) {
return shouldRedirectToTargetUrlConditionA(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl)
||
- shouldAlsoRedirectToTargetUrlConditionB(targetEqualsCurrentUrl, newPageInstance, pageStateless);
+ shouldAlsoRedirectToTargetUrlConditionB(targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary);
}
// if
@@ -274,7 +278,7 @@ public class WebPageRenderer extends PageRenderer
// or
// its ajax and the targetUrl matches current url
// just redirect
- protected static boolean shouldRedirectToTargetUrlConditionA(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl) {
+ private static boolean shouldRedirectToTargetUrlConditionA(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl) {
return alwaysRedirect(redirectPolicy) //
||
redirectToRender //
@@ -295,10 +299,10 @@ public class WebPageRenderer extends PageRenderer
// *before* page is rendered, render the page, get URL after render and if the URL is
// different (meaning page is not stateless), save the buffer and redirect again (which
// is pretty much what the next step does)
- private boolean shouldAlsoRedirectToTargetUrlConditionB(boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless) {
+ private static boolean shouldAlsoRedirectToTargetUrlConditionB(boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless, boolean sessionTemporary) {
return !targetEqualsCurrentUrl //
&&
- (newPageInstance || (isSessionTemporary() && pageStateless));
+ (newPageInstance || (sessionTemporary && pageStateless));
}
http://git-wip-us.apache.org/repos/asf/wicket/blob/4950a773/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
new file mode 100644
index 0000000..ddec3ca
--- /dev/null
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.wicket.request.handler.render;
+
+public abstract class AbstractVariations {
+
+ protected abstract VariationIterator<?> last();
+
+ public abstract boolean getResult();
+
+ public boolean hasNextVariation() {
+ return last().hasNextVariation();
+ }
+
+ public void nextVariation() {
+ last().nextVariation();
+ }
+
+ protected static void toString(StringBuilder sb,String label, VariationIterator<?> iterator) {
+ sb.append(label).append("=").append(iterator.value()).append(",");
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/wicket/blob/4950a773/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
new file mode 100644
index 0000000..e54768c
--- /dev/null
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.wicket.request.handler.render;
+
+import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
+
+public class ShouldRedirectToTargetUrl extends AbstractVariations {
+
+ VariationIterator<Boolean> ajax=VariationIterator.of(Variation.ofBoolean());
+ VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(ajax,Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
+ VariationIterator<Boolean> redirectToRender=VariationIterator.of(redirectPolicy,Variation.ofBoolean());
+ VariationIterator<Boolean> targetEqualsCurrentUrl=VariationIterator.of(redirectToRender,Variation.ofBoolean());
+ VariationIterator<Boolean> newPageInstance=VariationIterator.of(targetEqualsCurrentUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> pageStateless=VariationIterator.of(newPageInstance,Variation.ofBoolean());
+ VariationIterator<Boolean> sessionTemporary=VariationIterator.of(pageStateless,Variation.ofBoolean());
+
+ VariationIterator<Boolean> last=sessionTemporary;
+
+
+ public String toString() {
+ StringBuilder sb=new StringBuilder();
+ toString(sb,"ajax",ajax);
+ toString(sb,"redirectPolicy",redirectPolicy);
+ toString(sb,"redirectToRender",redirectToRender);
+ toString(sb,"targetEqualsCurrentUrl",targetEqualsCurrentUrl);
+ toString(sb,"newPageInstance",newPageInstance);
+ toString(sb,"pageStateless",pageStateless);
+ toString(sb,"sessionTemporary",sessionTemporary);
+ return sb.toString();
+ }
+
+ @Override
+ protected VariationIterator<?> last() {
+ return last;
+ }
+
+ @Override
+ public boolean getResult() {
+ return WebPageRenderer.shouldRedirectToTargetUrl(ajax.value(), redirectPolicy.value(), redirectToRender.value(), targetEqualsCurrentUrl.value(), newPageInstance.value(), pageStateless.value(),sessionTemporary.value());
+ }
+}
http://git-wip-us.apache.org/repos/asf/wicket/blob/4950a773/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
index f1bad05..213c395 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
@@ -18,7 +18,7 @@ package org.apache.wicket.request.handler.render;
import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
-public class ShouldRenderPageAndWriteResponseVariations {
+public class ShouldRenderPageAndWriteResponseVariations extends AbstractVariations {
VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
VariationIterator<Boolean> ajax=VariationIterator.of(redirectPolicy, Variation.ofBoolean());
@@ -31,16 +31,13 @@ public class ShouldRenderPageAndWriteResponseVariations {
VariationIterator<Boolean> last=pageStateless;
- public boolean getResult() {
- return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.value(),onePassRender.value(),redirectToRender.value(),redirectPolicy.value(),shouldPreserveClientUrl.value(),targetEqualsCurrentUrl.value(),newPageInstance.value(),pageStateless.value());
- }
-
- public boolean hasNextVariation() {
- return last.hasNextVariation();
+ @Override
+ protected VariationIterator<?> last() {
+ return last;
}
- public void nextVariation() {
- last.nextVariation();
+ public boolean getResult() {
+ return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.value(),onePassRender.value(),redirectToRender.value(),redirectPolicy.value(),shouldPreserveClientUrl.value(),targetEqualsCurrentUrl.value(),newPageInstance.value(),pageStateless.value());
}
public String toString() {
@@ -56,7 +53,5 @@ public class ShouldRenderPageAndWriteResponseVariations {
return sb.toString();
}
- static void toString(StringBuilder sb,String label, VariationIterator<?> iterator) {
- sb.append(label).append("=").append(iterator.value()).append(",");
- }
+
}
http://git-wip-us.apache.org/repos/asf/wicket/blob/4950a773/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 47022a3..a537360 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@ -761,20 +761,13 @@ public class WebPageRendererTest
@Test
public void testShouldRenderPageAndWriteResponseVariationIntegrity() {
- int count=1;
- ShouldRenderPageAndWriteResponseVariations variations=new ShouldRenderPageAndWriteResponseVariations();
- while (variations.hasNextVariation()) {
- count++;
- variations.nextVariation();
- }
+ int count = countVariations(new ShouldRenderPageAndWriteResponseVariations());
Assert.assertEquals(2*2*2*2*2*2*2*3,count);
}
@Test
public void testShouldRenderPageAndWriteResponseVariation() {
- int idx=0;
-
String match =
" X XXXXXXXX" +
" XXXXXXXXXXXX" +
@@ -801,14 +794,67 @@ public class WebPageRendererTest
" XXXXXXXX" +
" XXXXXXXXXXX";
- ShouldRenderPageAndWriteResponseVariations variations=new ShouldRenderPageAndWriteResponseVariations();
+ checkVariations(match,new ShouldRenderPageAndWriteResponseVariations());
+ }
+
+ @Test
+ public void testShouldRedirectToTargetUrlIntegrity() {
+ int count = countVariations(new ShouldRedirectToTargetUrl());
+ Assert.assertEquals(2*3*2*2*2*2*2,count);
+ }
+
+ @Test
+ public void testShouldRedirectToTargetUrl() {
+
+ String match =
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXX " +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXX " +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXX";
+
+ checkVariations(match,new ShouldRedirectToTargetUrl());
+ }
+
+
+ private int countVariations(AbstractVariations variations) {
+ int count=1;
while (variations.hasNextVariation()) {
- Assert.assertEquals(variations.toString(), match.charAt(idx) == 'X',variations.getResult());
+ count++;
variations.nextVariation();
- idx++;
}
+ return count;
+ }
+ private void checkVariations(String match,AbstractVariations variations) {
+ int idx=0;
+ while (variations.hasNextVariation()) {
+ Assert.assertEquals(variations.toString(), match.charAt(idx) == 'X', variations.getResult());
+ variations.nextVariation();
+ idx++;
+ }
+ }
+ private void printVariations(AbstractVariations variations) {
+ int idx=0;
+ System.out.print("\"");
+ while (variations.hasNextVariation()) {
+ System.out.print(variations.getResult() ? 'X': ' ');
+ variations.nextVariation();
+ idx++;
+ if (idx>=16) {
+ System.out.print("\"+\n\"");
+ idx=0;
+ }
+ }
+ System.out.println("\";");
}
/**
[07/11] git commit: next condition refactoring
Posted by mg...@apache.org.
next condition refactoring
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/b891bb8d
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/b891bb8d
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/b891bb8d
Branch: refs/heads/master
Commit: b891bb8ddff1fcd16b3deb1044f9753bd878ce36
Parents: 0d284b5
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Thu Sep 27 00:32:03 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Thu Sep 27 00:32:03 2012 +0200
----------------------------------------------------------------------
.../request/handler/render/WebPageRenderer.java | 121 +++++++++++++------
1 file changed, 82 insertions(+), 39 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/b891bb8d/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
index 66b1224..b74df37 100644
--- a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
+++ b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
@@ -195,32 +195,8 @@ public class WebPageRenderer extends PageRenderer
response.writeTo((WebResponse)requestCycle.getResponse());
}
}
- else if (redirectPolicy == RedirectPolicy.ALWAYS_REDIRECT //
- ||
- isRedirectToRender //
- || (isAjax && targetEqualsCurrentUrl))
+ else if (shouldRedirectToTargetUrl(isAjax, redirectPolicy, isRedirectToRender, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless))
{
- // if target URL is different
- // and render policy is always-redirect or it's redirect-to-render
- redirectTo(targetUrl, requestCycle);
- }
- else if (!targetEqualsCurrentUrl //
- &&
- (isNewPageInstance || (isSessionTemporary() && isPageStateless)))
- {
- // if target URL is different and session is temporary and page is stateless
- // this is special case when page is stateless but there is no session so we can't
- // render it to buffer
-
- // alternatively if URLs are different and we have a page class and not an instance we
- // can redirect to the url which will instantiate the instance of us
-
- // note: if we had session here we would render the page to buffer and then redirect to
- // URL generated *after* page has been rendered (the statelessness may change during
- // render). this would save one redirect because now we have to render to URL generated
- // *before* page is rendered, render the page, get URL after render and if the URL is
- // different (meaning page is not stateless), save the buffer and redirect again (which
- // is pretty much what the next step does)
redirectTo(targetUrl, requestCycle);
}
else
@@ -285,21 +261,88 @@ public class WebPageRenderer extends PageRenderer
}
}
- // if the policy is never to redirect
- // or one pass render mode is on
- // or the targetUrl matches current url and the page is not stateless
- // or the targetUrl matches current url, page is stateless but it's redirect-to-render
- // or the request determines that the current url should be preserved
- // just render the page
+ protected boolean shouldRedirectToTargetUrl(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless) {
+ return shouldRedirectToTargetUrlConditionA(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl)
+ ||
+ shouldAlsoRedirectToTargetUrlConditionB(targetEqualsCurrentUrl, newPageInstance, pageStateless);
+ }
+
+ // if
+ // render policy is always-redirect
+ // or
+ // it's redirect-to-render
+ // or
+ // its ajax and the targetUrl matches current url
+ // just redirect
+ protected static boolean shouldRedirectToTargetUrlConditionA(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl) {
+ return alwaysRedirect(redirectPolicy) //
+ ||
+ redirectToRender //
+ ||
+ (ajax && targetEqualsCurrentUrl);
+ }
+
+ // if target URL is different and session is temporary and page is stateless
+ // this is special case when page is stateless but there is no session so we can't
+ // render it to buffer
+
+ // alternatively if URLs are different and we have a page class and not an instance we
+ // can redirect to the url which will instantiate the instance of us
+
+ // note: if we had session here we would render the page to buffer and then redirect to
+ // URL generated *after* page has been rendered (the statelessness may change during
+ // render). this would save one redirect because now we have to render to URL generated
+ // *before* page is rendered, render the page, get URL after render and if the URL is
+ // different (meaning page is not stateless), save the buffer and redirect again (which
+ // is pretty much what the next step does)
+ private boolean shouldAlsoRedirectToTargetUrlConditionB(boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless) {
+ return !targetEqualsCurrentUrl //
+ &&
+ (newPageInstance || (isSessionTemporary() && pageStateless));
+ }
+
+
+ // if
+ // the policy is never to redirect
+ // or
+ // its NOT ajax and
+ // one pass render mode is on and NOT forced to redirect
+ // or
+ // the targetUrl matches current url and page is NOT stateless and NOT a new instance
+ // or
+ // the targetUrl matches current url and it's redirect-to-render
+ // or
+ // the request determines that the current url should be preserved
+ // just render the page
protected static boolean shouldRenderPageAndWriteResponse(boolean ajax, boolean onePassRender, boolean redirectToRender, RedirectPolicy redirectPolicy, boolean shouldPreserveClientUrl, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless) {
- return redirectPolicy == RedirectPolicy.NEVER_REDIRECT ||
- (onePassRender && ajax == false && redirectPolicy != RedirectPolicy.ALWAYS_REDIRECT) //
+ return neverRedirect(redirectPolicy)
||
- (!ajax //
- &&
- (targetEqualsCurrentUrl && !newPageInstance && !pageStateless) //
- || (targetEqualsCurrentUrl && redirectToRender) //
- ) //
- || shouldPreserveClientUrl;
+ (!ajax &&
+ (
+ (onePassRender && notForcedRedirect(redirectPolicy))
+ ||
+ (targetEqualsCurrentUrl && notNewAndNotStatelessPage(newPageInstance, pageStateless)))
+ )
+ ||
+ (targetEqualsCurrentUrl && redirectToRender)
+ ||
+ shouldPreserveClientUrl;
+ }
+
+ private static boolean notNewAndNotStatelessPage(boolean newPageInstance, boolean pageStateless) {
+ return !newPageInstance && !pageStateless;
+ }
+
+ private static boolean neverRedirect(RedirectPolicy redirectPolicy) {
+ return redirectPolicy == RedirectPolicy.NEVER_REDIRECT;
}
+
+ private static boolean alwaysRedirect(RedirectPolicy redirectPolicy) {
+ return redirectPolicy == RedirectPolicy.ALWAYS_REDIRECT;
+ }
+
+ private static boolean notForcedRedirect(RedirectPolicy redirectPolicy) {
+ return !alwaysRedirect(redirectPolicy);
+ }
+
}
[10/11] git commit: tests done
Posted by mg...@apache.org.
tests done
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/d3055f73
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/d3055f73
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/d3055f73
Branch: refs/heads/master
Commit: d3055f73934936dbc2d3d4d7bebac86c3618ca4c
Parents: 58daafa
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Thu Sep 27 01:28:20 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Thu Sep 27 01:28:20 2012 +0200
----------------------------------------------------------------------
.../handler/render/WebPageRendererTest.java | 132 +++++++++++++++----
1 file changed, 109 insertions(+), 23 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/d3055f73/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index a537360..bce93cb 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@ -637,7 +637,9 @@ public class WebPageRendererTest
boolean newPageInstance;
boolean pageStateless;
- // if the policy is never to redirect
+
+ // if
+ // the policy is never to redirect
redirectPolicy=RedirectPolicy.NEVER_REDIRECT;
ajax=true;
onePassRender=true;
@@ -659,36 +661,30 @@ public class WebPageRendererTest
Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
- // or one pass render mode is on
- // -> or one pass render mode is on and its NOT ajax and its NOT always redirect
+ // or
+ // its NOT ajax and
+ // one pass render mode is on and NOT forced to redirect
+ // or
+ // the targetUrl matches current url and page is NOT stateless and NOT a new instance
redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
- onePassRender=true;
ajax=false;
+ onePassRender=true;
Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
- redirectToRender=true;
- shouldPreserveClientUrl=true;
targetEqualsCurrentUrl=true;
- newPageInstance=true;
- pageStateless=true;
+ redirectPolicy=RedirectPolicy.ALWAYS_REDIRECT;
+ onePassRender=false;
- Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+ newPageInstance=false;
+ pageStateless=false;
- // or the targetUrl matches current url and the page is not stateless
- // or the targetUrl matches current url, page is stateless but it's redirect-to-render
- // --> its NOT ajax and
- // the targetUrl matches current url and the page is NOT stateless and its NOT a new instance
- // or the targetUrl matches current url and it's redirect-to-render
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
- ajax=false;
+ // or
+ // the targetUrl matches current url and it's redirect-to-render
+ redirectToRender=true;
targetEqualsCurrentUrl=true;
- pageStateless=false;
- newPageInstance=false;
-
- onePassRender=false;
- redirectToRender=false;
- shouldPreserveClientUrl=false;
Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
@@ -699,8 +695,9 @@ public class WebPageRendererTest
Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
- // or the request determines that the current url should be preserved
- // just render the page
+ // or
+ // the request determines that the current url should be preserved
+ // just render the page
shouldPreserveClientUrl=true;
redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
@@ -823,6 +820,95 @@ public class WebPageRendererTest
checkVariations(match,new ShouldRedirectToTargetUrl());
}
+ public void testShouldRedirectToTargetUrlCondition() {
+
+ boolean ajax;
+ RedirectPolicy redirectPolicy;
+ boolean redirectToRender;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+ boolean sessionTemporary;
+
+ // if
+ // render policy is always-redirect
+
+ ajax=false;
+ redirectPolicy=RedirectPolicy.ALWAYS_REDIRECT;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+ sessionTemporary=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // it's redirect-to-render
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ redirectToRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // its ajax and the targetUrl matches current url
+ redirectToRender=false;
+ ajax=true;
+ targetEqualsCurrentUrl=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
+ ajax=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ newPageInstance=false;
+ sessionTemporary=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+ // just redirect
+ }
+
+ public void testShouldNOTRedirectToTargetUrlCondition() {
+
+ boolean ajax;
+ RedirectPolicy redirectPolicy;
+ boolean redirectToRender;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+ boolean sessionTemporary;
+
+ // NOT if
+ // render policy is always-redirect
+ // AND NOT
+ // it's redirect-to-render
+ // AND NOT
+ // its ajax and the targetUrl matches current url
+ // AND NOT
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
+
+ ajax=false;
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+ sessionTemporary=false;
+
+ Assert.assertFalse(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+ }
private int countVariations(AbstractVariations variations) {
int count=1;
[03/11] git commit: start with unit test to prove the code
Posted by mg...@apache.org.
start with unit test to prove the code
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/0a192b5d
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/0a192b5d
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/0a192b5d
Branch: refs/heads/master
Commit: 0a192b5d16106e02e5aa827fa6de63beff4d091d
Parents: 3da1d65
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Wed Sep 26 22:33:00 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Wed Sep 26 22:33:00 2012 +0200
----------------------------------------------------------------------
.../handler/render/WebPageRendererTest.java | 41 ++++++++++++++++++++
1 file changed, 41 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/0a192b5d/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 3ce620c..9935f6d 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@ -625,6 +625,47 @@ public class WebPageRendererTest
Assert.assertTrue(stored.get());
}
+ // or one pass render mode is on
+ // or the targetUrl matches current url and the page is not stateless
+ // or the targetUrl matches current url, page is stateless but it's redirect-to-render
+ // or the request determines that the current url should be preserved
+ // just render the page
+ @Test
+ public void testShouldRenderPageAndWriteResponseCondition() {
+
+ RedirectPolicy redirectPolicy;
+ boolean ajax;
+ boolean onePassRender;
+ boolean redirectToRender;
+ boolean shouldPreserveClientUrl;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+
+ // if the policy is never to redirect
+ redirectPolicy=RedirectPolicy.NEVER_REDIRECT;
+ ajax=true;
+ onePassRender=true;
+ redirectToRender=true;
+ shouldPreserveClientUrl=true;
+ targetEqualsCurrentUrl=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ ajax=false;
+ onePassRender=false;
+ redirectToRender=false;
+ shouldPreserveClientUrl=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ }
+
/**
* Tests that when the page is stateful and the urls are the same then the response is written
* directly
[09/11] git commit: refactor done an comment changed
Posted by mg...@apache.org.
refactor done an comment changed
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/58daafa5
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/58daafa5
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/58daafa5
Branch: refs/heads/master
Commit: 58daafa556ccf334bd7d03c83eab9973d83fb497
Parents: 4950a77
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Thu Sep 27 01:08:45 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Thu Sep 27 01:08:45 2012 +0200
----------------------------------------------------------------------
.../request/handler/render/WebPageRenderer.java | 56 ++++++++++----------
1 file changed, 27 insertions(+), 29 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/58daafa5/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
index 6bb7b90..5854ed4 100644
--- a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
+++ b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
@@ -201,6 +201,13 @@ public class WebPageRenderer extends PageRenderer
if (shouldRedirectToTargetUrl(isAjax, redirectPolicy, isRedirectToRender, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless, sessionTemporary))
{
redirectTo(targetUrl, requestCycle);
+
+ // note: if we had session here we would render the page to buffer and then redirect to
+ // URL generated *after* page has been rendered (the statelessness may change during
+ // render). this would save one redirect because now we have to render to URL generated
+ // *before* page is rendered, render the page, get URL after render and if the URL is
+ // different (meaning page is not stateless), save the buffer and redirect again (which
+ // is pretty much what the next step does)
}
else
{
@@ -265,47 +272,38 @@ public class WebPageRenderer extends PageRenderer
}
}
- protected static boolean shouldRedirectToTargetUrl(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless,boolean sessionTemporary) {
- return shouldRedirectToTargetUrlConditionA(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl)
- ||
- shouldAlsoRedirectToTargetUrlConditionB(targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary);
- }
-
// if
// render policy is always-redirect
- // or
+ // or
// it's redirect-to-render
// or
// its ajax and the targetUrl matches current url
+ // or
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
// just redirect
- private static boolean shouldRedirectToTargetUrlConditionA(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl) {
+
+ protected static boolean shouldRedirectToTargetUrl(boolean ajax, RedirectPolicy redirectPolicy, boolean redirectToRender, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless,boolean sessionTemporary) {
return alwaysRedirect(redirectPolicy) //
||
redirectToRender //
||
- (ajax && targetEqualsCurrentUrl);
- }
-
- // if target URL is different and session is temporary and page is stateless
- // this is special case when page is stateless but there is no session so we can't
- // render it to buffer
-
- // alternatively if URLs are different and we have a page class and not an instance we
- // can redirect to the url which will instantiate the instance of us
-
- // note: if we had session here we would render the page to buffer and then redirect to
- // URL generated *after* page has been rendered (the statelessness may change during
- // render). this would save one redirect because now we have to render to URL generated
- // *before* page is rendered, render the page, get URL after render and if the URL is
- // different (meaning page is not stateless), save the buffer and redirect again (which
- // is pretty much what the next step does)
- private static boolean shouldAlsoRedirectToTargetUrlConditionB(boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless, boolean sessionTemporary) {
- return !targetEqualsCurrentUrl //
- &&
- (newPageInstance || (sessionTemporary && pageStateless));
+ (ajax && targetEqualsCurrentUrl)
+ ||
+ (!targetEqualsCurrentUrl //
+ &&
+ (newPageInstance || (sessionTemporary && pageStateless))
+ );
+ // if target URL is different and session is temporary and page is stateless
+ // this is special case when page is stateless but there is no session so we can't
+ // render it to buffer
+
+ // alternatively if URLs are different and we have a page class and not an instance we
+ // can redirect to the url which will instantiate the instance of us
}
-
// if
// the policy is never to redirect
// or
[02/11] git commit: condition refactor for unit test before
refactoring
Posted by mg...@apache.org.
condition refactor for unit test before refactoring
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/3da1d656
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/3da1d656
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/3da1d656
Branch: refs/heads/master
Commit: 3da1d656cd4c85efe0919d1a32c33b300ef35490
Parents: f5af56b
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Wed Sep 26 22:09:58 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Wed Sep 26 22:09:58 2012 +0200
----------------------------------------------------------------------
.../request/handler/render/WebPageRenderer.java | 205 ++++++++++---------
1 file changed, 110 insertions(+), 95 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/3da1d656/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
index 46ee1b4..66b1224 100644
--- a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
+++ b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
@@ -177,114 +177,129 @@ public class WebPageRenderer extends PageRenderer
// if there is saved response for this URL render it
bufferedResponse.writeTo((WebResponse)requestCycle.getResponse());
}
- else if (getRedirectPolicy() == RedirectPolicy.NEVER_REDIRECT ||
- (isOnePassRender() && isAjax == false && getRedirectPolicy() != RedirectPolicy.ALWAYS_REDIRECT) //
- ||
- (!isAjax //
- &&
- (targetUrl.equals(currentUrl) && !getPageProvider().isNewPageInstance() && !getPage().isPageStateless()) //
- || (targetUrl.equals(currentUrl) && isRedirectToRender()) //
- ) //
- || shouldPreserveClientUrl) //
- {
- // if the policy is never to redirect
- // or one pass render mode is on
- // or the targetUrl matches current url and the page is not stateless
- // or the targetUrl matches current url, page is stateless but it's redirect-to-render
- // or the request determines that the current url should be preserved
- // just render the page
- BufferedWebResponse response = renderPage(currentUrl, requestCycle);
- if (response != null)
- {
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- }
- else if (getRedirectPolicy() == RedirectPolicy.ALWAYS_REDIRECT //
- ||
- isRedirectToRender() //
- || (isAjax && targetUrl.equals(currentUrl)))
- {
- // if target URL is different
- // and render policy is always-redirect or it's redirect-to-render
- redirectTo(targetUrl, requestCycle);
- }
- else if (!targetUrl.equals(currentUrl) //
- &&
- (getPageProvider().isNewPageInstance() || (isSessionTemporary() && getPage().isPageStateless())))
- {
- // if target URL is different and session is temporary and page is stateless
- // this is special case when page is stateless but there is no session so we can't
- // render it to buffer
-
- // alternatively if URLs are different and we have a page class and not an instance we
- // can redirect to the url which will instantiate the instance of us
-
- // note: if we had session here we would render the page to buffer and then redirect to
- // URL generated *after* page has been rendered (the statelessness may change during
- // render). this would save one redirect because now we have to render to URL generated
- // *before* page is rendered, render the page, get URL after render and if the URL is
- // different (meaning page is not stateless), save the buffer and redirect again (which
- // is pretty much what the next step does)
- redirectTo(targetUrl, requestCycle);
- }
- else
- {
- if (isRedirectToBuffer() == false && logger.isDebugEnabled())
- {
- String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
- "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
- Application.get().getRequestCycleSettings().getRenderStrategy(),
- isAjax, getRedirectPolicy(), currentUrl, targetUrl, getPageProvider().isNewPageInstance(),
- getPage().isPageStateless(), isSessionTemporary());
- logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
- "matched. Details: " + details);
- }
-
- // redirect to buffer
- BufferedWebResponse response = renderPage(targetUrl, requestCycle);
+ else {
+ RedirectPolicy redirectPolicy = getRedirectPolicy();
- if (response == null)
- {
- return;
- }
+ boolean onePassRender = isOnePassRender();
+ boolean isRedirectToRender = isRedirectToRender();
- // check if the url hasn't changed after page has been rendered
- // (i.e. the stateless flag might have changed which could result in different page url)
- Url targetUrl2 = requestCycle.mapUrlFor(getRenderPageRequestHandler());
+ boolean targetEqualsCurrentUrl = targetUrl.equals(currentUrl);
+ boolean isNewPageInstance = getPageProvider().isNewPageInstance();
+ boolean isPageStateless = getPage().isPageStateless();
- if (targetUrl.getSegments().equals(targetUrl2.getSegments()) == false)
+ if (shouldRenderPageAndWriteResponse(isAjax, onePassRender, isRedirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless)) //
{
- // the amount of segments is different - generated relative URLs will not work, we
- // need to rerender the page. This shouldn't happen, but in theory it can - with
- // RequestHandlerEncoders that produce different URLs with different amount of
- // segments for stateless and stateful pages
- response = renderPage(targetUrl2, requestCycle);
+ BufferedWebResponse response = renderPage(currentUrl, requestCycle);
+ if (response != null)
+ {
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
}
-
- if (currentUrl.equals(targetUrl2))
+ else if (redirectPolicy == RedirectPolicy.ALWAYS_REDIRECT //
+ ||
+ isRedirectToRender //
+ || (isAjax && targetEqualsCurrentUrl))
{
- // no need to redirect when both urls are exactly the same
- response.writeTo((WebResponse)requestCycle.getResponse());
+ // if target URL is different
+ // and render policy is always-redirect or it's redirect-to-render
+ redirectTo(targetUrl, requestCycle);
}
- // if page is still stateless after render
- else if (getPage().isPageStateless() && !enableRedirectForStatelessPage())
+ else if (!targetEqualsCurrentUrl //
+ &&
+ (isNewPageInstance || (isSessionTemporary() && isPageStateless)))
{
- // we don't want the redirect to happen for stateless page
- // example:
- // when a normal mounted stateful page is hit at /mount/point
- // wicket renders the page to buffer and redirects to /mount/point?12
- // but for stateless page the redirect is not necessary
- // also for listener interface on stateful page we want to redirect
- // after the listener is invoked, but on stateless page the user
- // must ask for redirect explicitly
- response.writeTo((WebResponse)requestCycle.getResponse());
+ // if target URL is different and session is temporary and page is stateless
+ // this is special case when page is stateless but there is no session so we can't
+ // render it to buffer
+
+ // alternatively if URLs are different and we have a page class and not an instance we
+ // can redirect to the url which will instantiate the instance of us
+
+ // note: if we had session here we would render the page to buffer and then redirect to
+ // URL generated *after* page has been rendered (the statelessness may change during
+ // render). this would save one redirect because now we have to render to URL generated
+ // *before* page is rendered, render the page, get URL after render and if the URL is
+ // different (meaning page is not stateless), save the buffer and redirect again (which
+ // is pretty much what the next step does)
+ redirectTo(targetUrl, requestCycle);
}
else
{
- storeBufferedResponse(targetUrl2, response);
+ if (isRedirectToBuffer() == false && logger.isDebugEnabled())
+ {
+ String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
+ "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
+ Application.get().getRequestCycleSettings().getRenderStrategy(),
+ isAjax, redirectPolicy, currentUrl, targetUrl, isNewPageInstance,
+ isPageStateless, isSessionTemporary());
+ logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
+ "matched. Details: " + details);
+ }
+
+ // redirect to buffer
+ BufferedWebResponse response = renderPage(targetUrl, requestCycle);
+
+ if (response == null)
+ {
+ return;
+ }
- redirectTo(targetUrl2, requestCycle);
+ // check if the url hasn't changed after page has been rendered
+ // (i.e. the stateless flag might have changed which could result in different page url)
+ Url targetUrl2 = requestCycle.mapUrlFor(getRenderPageRequestHandler());
+
+ if (targetUrl.getSegments().equals(targetUrl2.getSegments()) == false)
+ {
+ // the amount of segments is different - generated relative URLs will not work, we
+ // need to rerender the page. This shouldn't happen, but in theory it can - with
+ // RequestHandlerEncoders that produce different URLs with different amount of
+ // segments for stateless and stateful pages
+ response = renderPage(targetUrl2, requestCycle);
+ }
+
+ if (currentUrl.equals(targetUrl2))
+ {
+ // no need to redirect when both urls are exactly the same
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ // if page is still stateless after render
+ else if (isPageStateless && !enableRedirectForStatelessPage())
+ {
+ // we don't want the redirect to happen for stateless page
+ // example:
+ // when a normal mounted stateful page is hit at /mount/point
+ // wicket renders the page to buffer and redirects to /mount/point?12
+ // but for stateless page the redirect is not necessary
+ // also for listener interface on stateful page we want to redirect
+ // after the listener is invoked, but on stateless page the user
+ // must ask for redirect explicitly
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ else
+ {
+ storeBufferedResponse(targetUrl2, response);
+
+ redirectTo(targetUrl2, requestCycle);
+ }
}
}
}
+
+ // if the policy is never to redirect
+ // or one pass render mode is on
+ // or the targetUrl matches current url and the page is not stateless
+ // or the targetUrl matches current url, page is stateless but it's redirect-to-render
+ // or the request determines that the current url should be preserved
+ // just render the page
+ protected static boolean shouldRenderPageAndWriteResponse(boolean ajax, boolean onePassRender, boolean redirectToRender, RedirectPolicy redirectPolicy, boolean shouldPreserveClientUrl, boolean targetEqualsCurrentUrl, boolean newPageInstance, boolean pageStateless) {
+ return redirectPolicy == RedirectPolicy.NEVER_REDIRECT ||
+ (onePassRender && ajax == false && redirectPolicy != RedirectPolicy.ALWAYS_REDIRECT) //
+ ||
+ (!ajax //
+ &&
+ (targetEqualsCurrentUrl && !newPageInstance && !pageStateless) //
+ || (targetEqualsCurrentUrl && redirectToRender) //
+ ) //
+ || shouldPreserveClientUrl;
+ }
}
[05/11] git commit: full test webpagerender method for current
implementation state
Posted by mg...@apache.org.
full test webpagerender method for current implementation state
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/96e0babb
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/96e0babb
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/96e0babb
Branch: refs/heads/master
Commit: 96e0babb393f942eaf482858ea809e49696d5312
Parents: 74ba777
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Thu Sep 27 00:01:26 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Thu Sep 27 00:01:26 2012 +0200
----------------------------------------------------------------------
...uldRenderPageAndWriteResponseVariations.java | 45 +++++++++++++
.../request/handler/render/TestVariations.java | 66 ++++++++++++++++++
.../request/handler/render/Variation.java | 45 +++++++++++++
.../handler/render/VariationIterator.java | 70 ++++++++++++++++++++
.../handler/render/WebPageRendererTest.java | 59 ++++++++++++++++-
5 files changed, 282 insertions(+), 3 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/96e0babb/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
new file mode 100644
index 0000000..65f9b0c
--- /dev/null
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.wicket.request.handler.render;
+
+import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
+
+public class ShouldRenderPageAndWriteResponseVariations {
+
+ VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
+ VariationIterator<Boolean> ajax=VariationIterator.of(redirectPolicy, Variation.ofBoolean());
+ VariationIterator<Boolean> onePassRender=VariationIterator.of(ajax,Variation.ofBoolean());
+ VariationIterator<Boolean> redirectToRender=VariationIterator.of(onePassRender,Variation.ofBoolean());
+ VariationIterator<Boolean> shouldPreserveClientUrl=VariationIterator.of(redirectToRender,Variation.ofBoolean());
+ VariationIterator<Boolean> targetEqualsCurrentUrl=VariationIterator.of(shouldPreserveClientUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> newPageInstance=VariationIterator.of(targetEqualsCurrentUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> pageStateless=VariationIterator.of(newPageInstance,Variation.ofBoolean());
+
+ VariationIterator<Boolean> last=pageStateless;
+
+ public boolean getResult() {
+ return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.value(),onePassRender.value(),redirectToRender.value(),redirectPolicy.value(),shouldPreserveClientUrl.value(),targetEqualsCurrentUrl.value(),newPageInstance.value(),pageStateless.value());
+ }
+
+ public boolean hasNextVariation() {
+ return last.hasNextVariation();
+ }
+
+ public void nextVariation() {
+ last.nextVariation();
+ }
+}
http://git-wip-us.apache.org/repos/asf/wicket/blob/96e0babb/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
new file mode 100644
index 0000000..b976e26
--- /dev/null
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.wicket.request.handler.render;
+
+import junit.framework.Assert;
+import org.junit.Test;
+
+public class TestVariations {
+
+ @Test
+ public void testSingle() {
+ VariationIterator<Boolean> single = VariationIterator.of(Variation.ofBoolean());
+ Assert.assertTrue(single.hasNextVariation());
+ single.nextVariation();
+ Assert.assertFalse(single.hasNextVariation());
+
+ Exception ex=null;
+ try {
+ single.nextVariation();
+ } catch (Exception e) {
+ ex=e;
+ }
+ Assert.assertNotNull(ex);
+ }
+
+ @Test
+ public void testDouble() {
+ VariationIterator<Integer> numbers = VariationIterator.of(new Variation<Integer>(1,2,3));
+ VariationIterator<Boolean> flag = VariationIterator.of(numbers,Variation.ofBoolean());
+ VariationIterator<?> last=flag;
+
+ Assert.assertTrue(last.hasNextVariation());
+ last.nextVariation();
+ Assert.assertTrue(last.hasNextVariation());
+ last.nextVariation();
+ Assert.assertTrue(last.hasNextVariation());
+ last.nextVariation();
+ Assert.assertTrue(last.hasNextVariation());
+ last.nextVariation();
+ Assert.assertTrue(last.hasNextVariation());
+ last.nextVariation();
+ Assert.assertFalse(last.hasNextVariation());
+
+ Exception ex=null;
+ try {
+ last.nextVariation();
+ } catch (Exception e) {
+ ex=e;
+ }
+ Assert.assertNotNull(ex);
+ }
+}
http://git-wip-us.apache.org/repos/asf/wicket/blob/96e0babb/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
new file mode 100644
index 0000000..c8b751d
--- /dev/null
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.wicket.request.handler.render;
+
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.List;
+
+/**
+ * provides some value variations for tests
+ */
+public class Variation<T> {
+
+ private List<T> value;
+
+ public Variation(T...values) {
+ this.value=Arrays.asList(values);
+ }
+
+ public List<T> values() {
+ return value;
+ }
+
+ public static Variation<Boolean> ofBoolean() {
+ return new Variation<Boolean>(Boolean.FALSE,Boolean.TRUE);
+ }
+
+ public static <T extends Enum<T>> Variation<T> of(Class<T> enumType) {
+ return new Variation<T>(enumType.getEnumConstants());
+ }
+}
http://git-wip-us.apache.org/repos/asf/wicket/blob/96e0babb/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
new file mode 100644
index 0000000..f552b7c
--- /dev/null
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.wicket.request.handler.render;
+
+public class VariationIterator<T> {
+
+ private VariationIterator<?> prev;
+ private final Variation<T> variation;
+ int idx=0;
+
+ public VariationIterator(Variation<T> variation) {
+ this.variation = variation;
+ }
+
+ public VariationIterator(VariationIterator<?> prev,Variation<T> variation) {
+ this.prev = prev;
+ this.variation = variation;
+ }
+
+ public static <T> VariationIterator<T> of(Variation<T> variation) {
+ return new VariationIterator<T>(variation);
+ }
+
+ public static <T> VariationIterator<T> of(VariationIterator<?> prev,Variation<T> variation) {
+ return new VariationIterator<T>(prev,variation);
+ }
+
+ public T value() {
+ return variation.values().get(idx);
+ }
+
+ public boolean hasNextVariation() {
+ return thisHasNextVariation() || prevHasNextVariation();
+ }
+
+ private boolean prevHasNextVariation() {
+ return (prev!=null ? prev.hasNextVariation() : false);
+ }
+
+ private boolean thisHasNextVariation() {
+ return variation.values().size() > idx+1;
+ }
+
+ public void nextVariation() {
+ if (thisHasNextVariation()) {
+ idx++;
+ } else {
+ if (prevHasNextVariation()) {
+ idx=0;
+ prev.nextVariation();
+ } else {
+ throw new IllegalArgumentException("no variation left, but next called");
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/wicket/blob/96e0babb/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 709d070..75dfecf 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@ -759,10 +759,63 @@ public class WebPageRendererTest
Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
}
+ @Test
+ public void testShouldRenderPageAndWriteResponseVariationIntegrity() {
+ int count=1;
+ ShouldRenderPageAndWriteResponseVariations variations=new ShouldRenderPageAndWriteResponseVariations();
+ while (variations.hasNextVariation()) {
+ count++;
+ variations.nextVariation();
+ }
+ Assert.assertEquals(2*2*2*2*2*2*2*3,count);
+ }
+
+ @Test
+ public void testShouldRenderPageAndWriteResponseVariation() {
+
+ int idx=0;
+
+ String match =
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXX";
+
+ ShouldRenderPageAndWriteResponseVariations variations=new ShouldRenderPageAndWriteResponseVariations();
+ while (variations.hasNextVariation()) {
+ char c = variations.getResult() ? 'X' : ' ';
+ Assert.assertEquals(match.charAt(idx),c);
+ variations.nextVariation();
+ idx++;
+ }
+
+
+ }
+
/**
- * Tests that when the page is stateful and the urls are the same then the response is written
- * directly
- */
+ * Tests that when the page is stateful and the urls are the same then the response is written
+ * directly
+ */
@Test
public void testRedirectToBufferStatefulPageAndSameUrls()
{
[06/11] git commit: full test webpagerender method for current
implementation state
Posted by mg...@apache.org.
full test webpagerender method for current implementation state
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/0d284b57
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/0d284b57
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/0d284b57
Branch: refs/heads/master
Commit: 0d284b577afc114ebc21da0c0be3292064fc02fd
Parents: 96e0bab
Author: Michael Mosmann <mi...@mosmann.de>
Authored: Thu Sep 27 00:07:30 2012 +0200
Committer: Michael Mosmann <mi...@mosmann.de>
Committed: Thu Sep 27 00:07:30 2012 +0200
----------------------------------------------------------------------
...ShouldRenderPageAndWriteResponseVariations.java | 17 +++++++++++++++++
.../handler/render/WebPageRendererTest.java | 3 +--
2 files changed, 18 insertions(+), 2 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/0d284b57/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
index 65f9b0c..f1bad05 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
@@ -42,4 +42,21 @@ public class ShouldRenderPageAndWriteResponseVariations {
public void nextVariation() {
last.nextVariation();
}
+
+ public String toString() {
+ StringBuilder sb=new StringBuilder();
+ toString(sb,"ajax",ajax);
+ toString(sb,"onePassRender",onePassRender);
+ toString(sb,"redirectToRender",redirectToRender);
+ toString(sb,"redirectPolicy",redirectPolicy);
+ toString(sb,"shouldPreserveClientUrl",shouldPreserveClientUrl);
+ toString(sb,"targetEqualsCurrentUrl",targetEqualsCurrentUrl);
+ toString(sb,"newPageInstance",newPageInstance);
+ toString(sb,"pageStateless",pageStateless);
+ return sb.toString();
+ }
+
+ static void toString(StringBuilder sb,String label, VariationIterator<?> iterator) {
+ sb.append(label).append("=").append(iterator.value()).append(",");
+ }
}
http://git-wip-us.apache.org/repos/asf/wicket/blob/0d284b57/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --git a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 75dfecf..47022a3 100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@ -803,8 +803,7 @@ public class WebPageRendererTest
ShouldRenderPageAndWriteResponseVariations variations=new ShouldRenderPageAndWriteResponseVariations();
while (variations.hasNextVariation()) {
- char c = variations.getResult() ? 'X' : ' ';
- Assert.assertEquals(match.charAt(idx),c);
+ Assert.assertEquals(variations.toString(), match.charAt(idx) == 'X',variations.getResult());
variations.nextVariation();
idx++;
}
[11/11] git commit: WICKET-3347 Simplify somehow the code in
org.apache.wicket.request.handler.render.WebPageRenderer.respond(RequestCycle)
Posted by mg...@apache.org.
WICKET-3347 Simplify somehow the code in org.apache.wicket.request.handler.render.WebPageRenderer.respond(RequestCycle)
Merge branch 'Refactor-WebPageRenderer' of https://github.com/michaelmosmann/wicket into WebPageRendererRefactor
Project: http://git-wip-us.apache.org/repos/asf/wicket/repo
Commit: http://git-wip-us.apache.org/repos/asf/wicket/commit/22f1e048
Tree: http://git-wip-us.apache.org/repos/asf/wicket/tree/22f1e048
Diff: http://git-wip-us.apache.org/repos/asf/wicket/diff/22f1e048
Branch: refs/heads/master
Commit: 22f1e048923cf5b6e020a81b66e0a8512c24fe79
Parents: b5d53c5 d3055f7
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
Authored: Thu Jun 13 12:46:09 2013 +0300
Committer: Martin Tzvetanov Grigorov <mg...@apache.org>
Committed: Thu Jun 13 12:46:09 2013 +0300
----------------------------------------------------------------------
.gitignore | 2 +-
.../request/handler/render/WebPageRenderer.java | 242 ++++++++------
.../handler/render/AbstractVariations.java | 37 +++
.../render/ShouldRedirectToTargetUrl.java | 57 ++++
...uldRenderPageAndWriteResponseVariations.java | 59 ++++
.../request/handler/render/TestVariations.java | 66 ++++
.../request/handler/render/Variation.java | 46 +++
.../handler/render/VariationIterator.java | 92 ++++++
.../handler/render/WebPageRendererTest.java | 324 ++++++++++++++++++-
9 files changed, 830 insertions(+), 95 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/.gitignore
----------------------------------------------------------------------
diff --cc .gitignore
index b1d5e2c,bbefc81..83c0f7e
--- a/.gitignore
+++ b/.gitignore
@@@ -1,10 -1,9 +1,10 @@@
-target
+**target*
velocity.log
-.project
-.classpath
+**.project
+**.classpath
+**.settings
*velocity.log*
-.idea/
+*.idea/
*.iml
*~
- node_modules/
-
++node_modules/
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
----------------------------------------------------------------------
diff --cc wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
index 2f20845,5854ed4..6b95240
--- a/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
+++ b/wicket-core/src/main/java/org/apache/wicket/request/handler/render/WebPageRenderer.java
@@@ -177,105 -177,97 +177,89 @@@ public class WebPageRenderer extends Pa
// if there is saved response for this URL render it
bufferedResponse.writeTo((WebResponse)requestCycle.getResponse());
}
- else if (getRedirectPolicy() == RedirectPolicy.NEVER_REDIRECT ||
- (isOnePassRender() && isAjax == false && getRedirectPolicy() != RedirectPolicy.ALWAYS_REDIRECT) //
- ||
- (!isAjax //
- &&
- (targetUrl.equals(currentUrl) && !getPageProvider().isNewPageInstance() && !getPage().isPageStateless()) //
- || (targetUrl.equals(currentUrl) && isRedirectToRender()) //
- ) //
- || shouldPreserveClientUrl) //
- {
- // if the policy is never to redirect
- // or one pass render mode is on
- // or the targetUrl matches current url and the page is not stateless
- // or the targetUrl matches current url, page is stateless but it's redirect-to-render
- // or the request determines that the current url should be preserved
- // just render the page
- BufferedWebResponse response = renderPage(currentUrl, requestCycle);
- if (response != null)
- {
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- }
- else if (getRedirectPolicy() == RedirectPolicy.ALWAYS_REDIRECT //
- ||
- isRedirectToRender() //
- || (isAjax && targetUrl.equals(currentUrl)))
- {
- // if target URL is different
- // and render policy is always-redirect or it's redirect-to-render
- redirectTo(targetUrl, requestCycle);
- }
- else if (!targetUrl.equals(currentUrl) //
- &&
- (getPageProvider().isNewPageInstance() || (isSessionTemporary() && getPage().isPageStateless())))
- {
- // if target URL is different and session is temporary and page is stateless
- // this is special case when page is stateless but there is no session so we can't
- // render it to buffer
-
- // alternatively if URLs are different and we have a page class and not an instance we
- // can redirect to the url which will instantiate the instance of us
-
- // note: if we had session here we would render the page to buffer and then redirect to
- // URL generated *after* page has been rendered (the statelessness may change during
- // render). this would save one redirect because now we have to render to URL generated
- // *before* page is rendered, render the page, get URL after render and if the URL is
- // different (meaning page is not stateless), save the buffer and redirect again (which
- // is pretty much what the next step does)
- redirectTo(targetUrl, requestCycle);
- }
- else
- {
- if (isRedirectToBuffer() == false && logger.isDebugEnabled())
+ else {
+ RedirectPolicy redirectPolicy = getRedirectPolicy();
+
+ boolean onePassRender = isOnePassRender();
+ boolean isRedirectToRender = isRedirectToRender();
+ boolean redirectToBuffer = isRedirectToBuffer();
+
+ boolean targetEqualsCurrentUrl = targetUrl.equals(currentUrl);
+ boolean isNewPageInstance = getPageProvider().isNewPageInstance();
+ boolean isPageStateless = getPage().isPageStateless();
+
+ if (shouldRenderPageAndWriteResponse(isAjax, onePassRender, isRedirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless)) //
{
- String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
- "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
- Application.get().getRequestCycleSettings().getRenderStrategy(),
- isAjax, getRedirectPolicy(), currentUrl, targetUrl, getPageProvider().isNewPageInstance(),
- getPage().isPageStateless(), isSessionTemporary());
- logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
- "matched. Details: " + details);
+ BufferedWebResponse response = renderPage(currentUrl, requestCycle);
+ if (response != null)
+ {
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
}
+ else {
+ boolean sessionTemporary = isSessionTemporary();
+ if (shouldRedirectToTargetUrl(isAjax, redirectPolicy, isRedirectToRender, targetEqualsCurrentUrl, isNewPageInstance, isPageStateless, sessionTemporary))
+ {
+ redirectTo(targetUrl, requestCycle);
- // force creation of possible stateful page to get the final target url
- getPage();
+ // note: if we had session here we would render the page to buffer and then redirect to
+ // URL generated *after* page has been rendered (the statelessness may change during
+ // render). this would save one redirect because now we have to render to URL generated
+ // *before* page is rendered, render the page, get URL after render and if the URL is
+ // different (meaning page is not stateless), save the buffer and redirect again (which
+ // is pretty much what the next step does)
+ }
+ else
+ {
+ if (redirectToBuffer == false && logger.isDebugEnabled())
+ {
+ String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " +
+ "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'",
+ Application.get().getRequestCycleSettings().getRenderStrategy(),
+ isAjax, redirectPolicy, currentUrl, targetUrl, isNewPageInstance,
+ isPageStateless, sessionTemporary);
+ logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " +
+ "matched. Details: " + details);
+ }
- Url renderTargetUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler());
++ // force creation of possible stateful page to get the final target url
++ getPage();
+
- // redirect to buffer
- BufferedWebResponse response = renderPage(renderTargetUrl, requestCycle);
++ Url renderTargetUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler());
+
- if (response == null)
- {
- return;
- }
+ // redirect to buffer
- BufferedWebResponse response = renderPage(targetUrl, requestCycle);
++ BufferedWebResponse response = renderPage(renderTargetUrl, requestCycle);
- if (currentUrl.equals(renderTargetUrl))
- {
- // no need to redirect when both urls are exactly the same
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- // if page is still stateless after render
- else if (getPage().isPageStateless() && !enableRedirectForStatelessPage())
- {
- // we don't want the redirect to happen for stateless page
- // example:
- // when a normal mounted stateful page is hit at /mount/point
- // wicket renders the page to buffer and redirects to /mount/point?12
- // but for stateless page the redirect is not necessary
- // also for listener interface on stateful page we want to redirect
- // after the listener is invoked, but on stateless page the user
- // must ask for redirect explicitly
- response.writeTo((WebResponse)requestCycle.getResponse());
- }
- else
- {
- storeBufferedResponse(renderTargetUrl, response);
+ if (response == null)
+ {
+ return;
+ }
+
- // check if the url hasn't changed after page has been rendered
- // (i.e. the stateless flag might have changed which could result in different page url)
- Url targetUrl2 = requestCycle.mapUrlFor(getRenderPageRequestHandler());
-
- if (targetUrl.getSegments().equals(targetUrl2.getSegments()) == false)
- {
- // the amount of segments is different - generated relative URLs will not work, we
- // need to rerender the page. This shouldn't happen, but in theory it can - with
- // RequestHandlerEncoders that produce different URLs with different amount of
- // segments for stateless and stateful pages
- response = renderPage(targetUrl2, requestCycle);
- }
-
- if (currentUrl.equals(targetUrl2))
++ if (currentUrl.equals(renderTargetUrl))
+ {
+ // no need to redirect when both urls are exactly the same
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ // if page is still stateless after render
+ else if (isPageStateless && !enableRedirectForStatelessPage())
+ {
+ // we don't want the redirect to happen for stateless page
+ // example:
+ // when a normal mounted stateful page is hit at /mount/point
+ // wicket renders the page to buffer and redirects to /mount/point?12
+ // but for stateless page the redirect is not necessary
+ // also for listener interface on stateful page we want to redirect
+ // after the listener is invoked, but on stateless page the user
+ // must ask for redirect explicitly
+ response.writeTo((WebResponse)requestCycle.getResponse());
+ }
+ else
+ {
- storeBufferedResponse(targetUrl2, response);
++ storeBufferedResponse(renderTargetUrl, response);
- redirectTo(renderTargetUrl, requestCycle);
- redirectTo(targetUrl2, requestCycle);
++ redirectTo(renderTargetUrl, requestCycle);
+ }
+ }
}
}
}
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
index 0000000,ddec3ca..b15b4e7
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/AbstractVariations.java
@@@ -1,0 -1,37 +1,37 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package org.apache.wicket.request.handler.render;
+
+ public abstract class AbstractVariations {
+
+ protected abstract VariationIterator<?> last();
+
+ public abstract boolean getResult();
+
+ public boolean hasNextVariation() {
- return last().hasNextVariation();
++ return last().hasNext();
+ }
+
+ public void nextVariation() {
+ last().nextVariation();
+ }
+
+ protected static void toString(StringBuilder sb,String label, VariationIterator<?> iterator) {
- sb.append(label).append("=").append(iterator.value()).append(",");
++ sb.append(label).append('=').append(iterator.next()).append(',');
+ }
+
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
index 0000000,e54768c..4a6f389
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRedirectToTargetUrl.java
@@@ -1,0 -1,55 +1,57 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package org.apache.wicket.request.handler.render;
+
+ import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
+
+ public class ShouldRedirectToTargetUrl extends AbstractVariations {
+
+ VariationIterator<Boolean> ajax=VariationIterator.of(Variation.ofBoolean());
+ VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(ajax,Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
+ VariationIterator<Boolean> redirectToRender=VariationIterator.of(redirectPolicy,Variation.ofBoolean());
+ VariationIterator<Boolean> targetEqualsCurrentUrl=VariationIterator.of(redirectToRender,Variation.ofBoolean());
+ VariationIterator<Boolean> newPageInstance=VariationIterator.of(targetEqualsCurrentUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> pageStateless=VariationIterator.of(newPageInstance,Variation.ofBoolean());
+ VariationIterator<Boolean> sessionTemporary=VariationIterator.of(pageStateless,Variation.ofBoolean());
+
+ VariationIterator<Boolean> last=sessionTemporary;
+
+
+ public String toString() {
+ StringBuilder sb=new StringBuilder();
+ toString(sb,"ajax",ajax);
+ toString(sb,"redirectPolicy",redirectPolicy);
+ toString(sb,"redirectToRender",redirectToRender);
+ toString(sb,"targetEqualsCurrentUrl",targetEqualsCurrentUrl);
+ toString(sb,"newPageInstance",newPageInstance);
+ toString(sb,"pageStateless",pageStateless);
+ toString(sb,"sessionTemporary",sessionTemporary);
+ return sb.toString();
+ }
+
+ @Override
+ protected VariationIterator<?> last() {
+ return last;
+ }
+
+ @Override
+ public boolean getResult() {
- return WebPageRenderer.shouldRedirectToTargetUrl(ajax.value(), redirectPolicy.value(), redirectToRender.value(), targetEqualsCurrentUrl.value(), newPageInstance.value(), pageStateless.value(),sessionTemporary.value());
++ return WebPageRenderer.shouldRedirectToTargetUrl(ajax.next(), redirectPolicy.next(),
++ redirectToRender.next(), targetEqualsCurrentUrl.next(), newPageInstance.next(),
++ pageStateless.next(), sessionTemporary.next());
+ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
index 0000000,213c395..3f7b5d6
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/ShouldRenderPageAndWriteResponseVariations.java
@@@ -1,0 -1,57 +1,59 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package org.apache.wicket.request.handler.render;
+
+ import org.apache.wicket.core.request.handler.RenderPageRequestHandler;
+
+ public class ShouldRenderPageAndWriteResponseVariations extends AbstractVariations {
+
+ VariationIterator<RenderPageRequestHandler.RedirectPolicy> redirectPolicy=VariationIterator.of(Variation.of(RenderPageRequestHandler.RedirectPolicy.class));
+ VariationIterator<Boolean> ajax=VariationIterator.of(redirectPolicy, Variation.ofBoolean());
+ VariationIterator<Boolean> onePassRender=VariationIterator.of(ajax,Variation.ofBoolean());
+ VariationIterator<Boolean> redirectToRender=VariationIterator.of(onePassRender,Variation.ofBoolean());
+ VariationIterator<Boolean> shouldPreserveClientUrl=VariationIterator.of(redirectToRender,Variation.ofBoolean());
+ VariationIterator<Boolean> targetEqualsCurrentUrl=VariationIterator.of(shouldPreserveClientUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> newPageInstance=VariationIterator.of(targetEqualsCurrentUrl,Variation.ofBoolean());
+ VariationIterator<Boolean> pageStateless=VariationIterator.of(newPageInstance,Variation.ofBoolean());
+
+ VariationIterator<Boolean> last=pageStateless;
+
+ @Override
+ protected VariationIterator<?> last() {
+ return last;
+ }
+
+ public boolean getResult() {
- return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.value(),onePassRender.value(),redirectToRender.value(),redirectPolicy.value(),shouldPreserveClientUrl.value(),targetEqualsCurrentUrl.value(),newPageInstance.value(),pageStateless.value());
++ return WebPageRenderer.shouldRenderPageAndWriteResponse(ajax.next(), onePassRender.next(),
++ redirectToRender.next(), redirectPolicy.next(), shouldPreserveClientUrl.next(),
++ targetEqualsCurrentUrl.next(), newPageInstance.next(), pageStateless.next());
+ }
+
+ public String toString() {
+ StringBuilder sb=new StringBuilder();
+ toString(sb,"ajax",ajax);
+ toString(sb,"onePassRender",onePassRender);
+ toString(sb,"redirectToRender",redirectToRender);
+ toString(sb,"redirectPolicy",redirectPolicy);
+ toString(sb,"shouldPreserveClientUrl",shouldPreserveClientUrl);
+ toString(sb,"targetEqualsCurrentUrl",targetEqualsCurrentUrl);
+ toString(sb,"newPageInstance",newPageInstance);
+ toString(sb,"pageStateless",pageStateless);
+ return sb.toString();
+ }
+
+
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
index 0000000,b976e26..5a11266
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/TestVariations.java
@@@ -1,0 -1,66 +1,66 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package org.apache.wicket.request.handler.render;
+
-import junit.framework.Assert;
++import org.junit.Assert;
+ import org.junit.Test;
+
+ public class TestVariations {
+
+ @Test
+ public void testSingle() {
+ VariationIterator<Boolean> single = VariationIterator.of(Variation.ofBoolean());
- Assert.assertTrue(single.hasNextVariation());
++ Assert.assertTrue(single.hasNext());
+ single.nextVariation();
- Assert.assertFalse(single.hasNextVariation());
++ Assert.assertFalse(single.hasNext());
+
- Exception ex=null;
++ Exception ex = null;
+ try {
+ single.nextVariation();
+ } catch (Exception e) {
- ex=e;
++ ex = e;
+ }
+ Assert.assertNotNull(ex);
+ }
+
+ @Test
+ public void testDouble() {
- VariationIterator<Integer> numbers = VariationIterator.of(new Variation<Integer>(1,2,3));
++ VariationIterator<Integer> numbers = VariationIterator.of(new Variation<>(1,2,3));
+ VariationIterator<Boolean> flag = VariationIterator.of(numbers,Variation.ofBoolean());
+ VariationIterator<?> last=flag;
+
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertTrue(last.hasNextVariation());
++ Assert.assertTrue(last.hasNext());
+ last.nextVariation();
- Assert.assertFalse(last.hasNextVariation());
++ Assert.assertFalse(last.hasNext());
+
- Exception ex=null;
++ Exception ex = null;
+ try {
+ last.nextVariation();
+ } catch (Exception e) {
- ex=e;
++ ex = e;
+ }
+ Assert.assertNotNull(ex);
+ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
index 0000000,c8b751d..d086c34
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/Variation.java
@@@ -1,0 -1,45 +1,46 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package org.apache.wicket.request.handler.render;
+
+ import java.util.Arrays;
-import java.util.EnumSet;
+ import java.util.List;
+
+ /**
- * provides some value variations for tests
++ * Provides some value variations that can be used for tests
++ *
++ * Similar to <a href="https://github.com/rickynils/scalacheck">Scala Check</a>
+ */
+ public class Variation<T> {
+
- private List<T> value;
++ private final List<T> value;
+
+ public Variation(T...values) {
- this.value=Arrays.asList(values);
++ this.value = Arrays.asList(values);
+ }
+
+ public List<T> values() {
+ return value;
+ }
+
+ public static Variation<Boolean> ofBoolean() {
- return new Variation<Boolean>(Boolean.FALSE,Boolean.TRUE);
++ return new Variation<>(Boolean.FALSE,Boolean.TRUE);
+ }
+
+ public static <T extends Enum<T>> Variation<T> of(Class<T> enumType) {
- return new Variation<T>(enumType.getEnumConstants());
++ return new Variation<>(enumType.getEnumConstants());
+ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
index 0000000,f552b7c..741d3d2
mode 000000,100644..100644
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/VariationIterator.java
@@@ -1,0 -1,70 +1,92 @@@
+ /*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ package org.apache.wicket.request.handler.render;
+
-public class VariationIterator<T> {
++import java.util.Iterator;
++import java.util.NoSuchElementException;
++
++public class VariationIterator<T> implements Iterator<T>
++{
++ private final VariationIterator<?> prev;
+
- private VariationIterator<?> prev;
+ private final Variation<T> variation;
- int idx=0;
++
++ private int idx = 0;
+
+ public VariationIterator(Variation<T> variation) {
- this.variation = variation;
++ this(null, variation);
+ }
+
- public VariationIterator(VariationIterator<?> prev,Variation<T> variation) {
++ public VariationIterator(VariationIterator<?> prev, Variation<T> variation) {
+ this.prev = prev;
+ this.variation = variation;
+ }
+
+ public static <T> VariationIterator<T> of(Variation<T> variation) {
- return new VariationIterator<T>(variation);
++ return new VariationIterator<>(variation);
+ }
+
- public static <T> VariationIterator<T> of(VariationIterator<?> prev,Variation<T> variation) {
- return new VariationIterator<T>(prev,variation);
++ public static <T> VariationIterator<T> of(VariationIterator<?> prev, Variation<T> variation)
++ {
++ return new VariationIterator<>(prev,variation);
+ }
+
- public T value() {
++ @Override
++ public T next()
++ {
+ return variation.values().get(idx);
+ }
+
- public boolean hasNextVariation() {
++ @Override
++ public boolean hasNext()
++ {
+ return thisHasNextVariation() || prevHasNextVariation();
+ }
+
- private boolean prevHasNextVariation() {
- return (prev!=null ? prev.hasNextVariation() : false);
++ private boolean prevHasNextVariation()
++ {
++ return (prev != null && prev.hasNext());
+ }
+
- private boolean thisHasNextVariation() {
- return variation.values().size() > idx+1;
++ private boolean thisHasNextVariation()
++ {
++ return variation.values().size() > idx + 1;
+ }
+
+ public void nextVariation() {
- if (thisHasNextVariation()) {
++ if (thisHasNextVariation())
++ {
+ idx++;
- } else {
- if (prevHasNextVariation()) {
++ } else
++ {
++ if (prevHasNextVariation())
++ {
+ idx=0;
+ prev.nextVariation();
- } else {
- throw new IllegalArgumentException("no variation left, but next called");
++ }
++ else
++ {
++ throw new NoSuchElementException("no variation left, but next called");
+ }
+ }
+ }
++
++ @Override
++ public void remove()
++ {
++ }
+ }
http://git-wip-us.apache.org/repos/asf/wicket/blob/22f1e048/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
----------------------------------------------------------------------
diff --cc wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
index 3ce620c,bce93cb..0f32673
--- a/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
+++ b/wicket-core/src/test/java/org/apache/wicket/request/handler/render/WebPageRendererTest.java
@@@ -625,10 -625,328 +625,328 @@@ public class WebPageRendererTes
Assert.assertTrue(stored.get());
}
+ @Test
+ public void testShouldRenderPageAndWriteResponseCondition() {
+
+ RedirectPolicy redirectPolicy;
+ boolean ajax;
+ boolean onePassRender;
+ boolean redirectToRender;
+ boolean shouldPreserveClientUrl;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+
+
+ // if
+ // the policy is never to redirect
+ redirectPolicy=RedirectPolicy.NEVER_REDIRECT;
+ ajax=true;
+ onePassRender=true;
+ redirectToRender=true;
+ shouldPreserveClientUrl=true;
+ targetEqualsCurrentUrl=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ ajax=false;
+ onePassRender=false;
+ redirectToRender=false;
+ shouldPreserveClientUrl=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or
+ // its NOT ajax and
+ // one pass render mode is on and NOT forced to redirect
+ // or
+ // the targetUrl matches current url and page is NOT stateless and NOT a new instance
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ ajax=false;
+ onePassRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ targetEqualsCurrentUrl=true;
+ redirectPolicy=RedirectPolicy.ALWAYS_REDIRECT;
+ onePassRender=false;
+
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or
+ // the targetUrl matches current url and it's redirect-to-render
+ redirectToRender=true;
+ targetEqualsCurrentUrl=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ targetEqualsCurrentUrl=true;
+ pageStateless=true;
+ newPageInstance=true;
+ redirectToRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ // or
+ // the request determines that the current url should be preserved
+ // just render the page
+ shouldPreserveClientUrl=true;
+
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ ajax=true;
+ onePassRender=false;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ }
+
+ @Test
+ public void testShouldNOTRenderPageAndWriteResponseCondition() {
+
+ RedirectPolicy redirectPolicy;
+ boolean ajax;
+ boolean onePassRender;
+ boolean redirectToRender;
+ boolean shouldPreserveClientUrl;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+
+ // NOT if the policy is never to redirect
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+
+ // NOT or one pass render mode is on
+ // -> or one pass render mode is on and its NOT ajax and its NOT always redirect
+ ajax=true;
+ onePassRender=false;
+
+ // NOT or the targetUrl matches current url and the page is not stateless
+ // or the targetUrl matches current url, page is stateless but it's redirect-to-render
+ // --> its NOT ajax and
+ // the targetUrl matches current url and the page is NOT stateless and its NOT a new instance
+ // or the targetUrl matches current url and it's redirect-to-render
+ targetEqualsCurrentUrl=false;
+
+ // or the request determines that the current url should be preserved
+ // just render the page
+ shouldPreserveClientUrl=false;
+
+ redirectToRender=true;
+ newPageInstance=true;
+ pageStateless=true;
+
+ Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+
+ redirectToRender=false;
+ newPageInstance=false;
+ pageStateless=false;
+
+ Assert.assertFalse(WebPageRenderer.shouldRenderPageAndWriteResponse(ajax, onePassRender, redirectToRender, redirectPolicy, shouldPreserveClientUrl, targetEqualsCurrentUrl, newPageInstance, pageStateless));
+ }
+
+ @Test
+ public void testShouldRenderPageAndWriteResponseVariationIntegrity() {
+ int count = countVariations(new ShouldRenderPageAndWriteResponseVariations());
+ Assert.assertEquals(2*2*2*2*2*2*2*3,count);
+ }
+
+ @Test
+ public void testShouldRenderPageAndWriteResponseVariation() {
+
+ String match =
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " X XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXXX" +
+ " XXXXXXXX" +
+ " XXXXXXXXXXX";
+
+ checkVariations(match,new ShouldRenderPageAndWriteResponseVariations());
+ }
+
+ @Test
+ public void testShouldRedirectToTargetUrlIntegrity() {
+ int count = countVariations(new ShouldRedirectToTargetUrl());
+ Assert.assertEquals(2*3*2*2*2*2*2,count);
+ }
+
+ @Test
+ public void testShouldRedirectToTargetUrl() {
+
+ String match =
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXX " +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXX " +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXXX" +
+ " XXXXXXXXXXXXX" +
+ "XXXXXXXXXXXXXXX";
+
+ checkVariations(match,new ShouldRedirectToTargetUrl());
+ }
+
+ public void testShouldRedirectToTargetUrlCondition() {
+
+ boolean ajax;
+ RedirectPolicy redirectPolicy;
+ boolean redirectToRender;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+ boolean sessionTemporary;
+
+ // if
+ // render policy is always-redirect
+
+ ajax=false;
+ redirectPolicy=RedirectPolicy.ALWAYS_REDIRECT;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+ sessionTemporary=false;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // it's redirect-to-render
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ redirectToRender=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // its ajax and the targetUrl matches current url
+ redirectToRender=false;
+ ajax=true;
+ targetEqualsCurrentUrl=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ // or
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
+ ajax=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+
+ newPageInstance=false;
+ sessionTemporary=true;
+ pageStateless=true;
+
+ Assert.assertTrue(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+ // just redirect
+ }
+
+ public void testShouldNOTRedirectToTargetUrlCondition() {
+
+ boolean ajax;
+ RedirectPolicy redirectPolicy;
+ boolean redirectToRender;
+ boolean targetEqualsCurrentUrl;
+ boolean newPageInstance;
+ boolean pageStateless;
+ boolean sessionTemporary;
+
+ // NOT if
+ // render policy is always-redirect
+ // AND NOT
+ // it's redirect-to-render
+ // AND NOT
+ // its ajax and the targetUrl matches current url
+ // AND NOT
+ // targetUrl DONT matches current url and
+ // is new page instance
+ // or
+ // session is temporary and page is stateless
+
+ ajax=false;
+ redirectPolicy=RedirectPolicy.AUTO_REDIRECT;
+ redirectToRender=false;
+ targetEqualsCurrentUrl=false;
+ newPageInstance=false;
+ pageStateless=false;
+ sessionTemporary=false;
+
+ Assert.assertFalse(WebPageRenderer.shouldRedirectToTargetUrl(ajax, redirectPolicy, redirectToRender, targetEqualsCurrentUrl, newPageInstance, pageStateless,sessionTemporary));
+ }
+
+ private int countVariations(AbstractVariations variations) {
+ int count=1;
+ while (variations.hasNextVariation()) {
+ count++;
+ variations.nextVariation();
+ }
+ return count;
+ }
+
- private void checkVariations(String match,AbstractVariations variations) {
++ private void checkVariations(String match, AbstractVariations variations) {
+ int idx=0;
+ while (variations.hasNextVariation()) {
+ Assert.assertEquals(variations.toString(), match.charAt(idx) == 'X', variations.getResult());
+ variations.nextVariation();
+ idx++;
+ }
+ }
+
+ private void printVariations(AbstractVariations variations) {
+ int idx=0;
+ System.out.print("\"");
+ while (variations.hasNextVariation()) {
+ System.out.print(variations.getResult() ? 'X': ' ');
+ variations.nextVariation();
+ idx++;
+ if (idx>=16) {
+ System.out.print("\"+\n\"");
+ idx=0;
+ }
+ }
+ System.out.println("\";");
+ }
+
/**
- * Tests that when the page is stateful and the urls are the same then the response is written
- * directly
- */
+ * Tests that when the page is stateful and the urls are the same then the response is written
+ * directly
+ */
@Test
public void testRedirectToBufferStatefulPageAndSameUrls()
{