Fragment handling and asynchronous UI update conflict (#13997)

Auto tests to check that back and forward buttons in browser work
correctly during UI update

Change-Id: I435723dd97cf8ec3fe2cd8cf6d4ed081442e2c04

2 files changed, 263 insertions, 0 deletions

diff --git a/uitest/src/com/vaadin/tests/urifragments/FragmentHandlingAndAsynchUIUpdate.java b/uitest/src/com/vaadin/tests/urifragments/FragmentHandlingAndAsynchUIUpdate.java
new file mode 100644
index 0000000000..9cd2929ca6
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/urifragments/FragmentHandlingAndAsynchUIUpdate.java
@@ -0,0 +1,135 @@
+package com.vaadin.tests.urifragments;
+
+import java.util.Iterator;
+
+import com.vaadin.server.Page;
+import com.vaadin.server.Page.UriFragmentChangedEvent;
+import com.vaadin.server.Page.UriFragmentChangedListener;
+import com.vaadin.server.VaadinRequest;
+import com.vaadin.tests.components.AbstractTestUIWithLog;
+import com.vaadin.ui.Button;
+import com.vaadin.ui.Button.ClickEvent;
+import com.vaadin.ui.Component;
+import com.vaadin.ui.Label;
+import com.vaadin.ui.UI;
+
+@SuppressWarnings("serial")
+public class FragmentHandlingAndAsynchUIUpdate extends AbstractTestUIWithLog {
+    protected static final int START_FRAG_ID = 1000;
+    protected static final String FRAG_NAME_TPL = "FRAG%s";
+    protected static final String BUTTON_ID = "SetNextFragmentButton";
+
+    private int fragmentId = START_FRAG_ID;
+
+    @Override
+    protected void setup(VaadinRequest request) {
+        Button button = new Button(
+                "Click Me 10 times, wait for ui to settle (10 seconds) then click the back button 10 times.");
+
+        button.setId(BUTTON_ID);
+
+        button.addClickListener(new Button.ClickListener() {
+            @Override
+            public void buttonClick(ClickEvent event) {
+                Label c = new Label("Thank you for clicking");
+                c.setId(String.valueOf(fragmentId));
+                getLayout().addComponent(c);
+
+                log(String.format("Button was clicked for fragmentId %s",
+                        fragmentId));
+                Page.getCurrent().setUriFragment(
+                        String.format(FRAG_NAME_TPL, fragmentId++));
+            }
+        });
+
+        getLayout().addComponent(button);
+
+        Page.getCurrent().addUriFragmentChangedListener(
+                createUriFragmentChangedListener());
+    }
+
+    private UriFragmentChangedListener createUriFragmentChangedListener() {
+        return new UriFragmentChangedListener() {
+
+            @Override
+            public void uriFragmentChanged(final UriFragmentChangedEvent event) {
+
+                log(String.format("uriFragmentChanged %s",
+                        event.getUriFragment()));
+
+                if (!event.getUriFragment().startsWith("FRAG")) {
+                    return;
+                }
+
+                Iterator<Component> it = getLayout().iterator();
+                final String frag = event.getUriFragment().substring(4);
+
+                Component fragComp = null;
+                while (it.hasNext()) {
+                    Component comp = it.next();
+                    if (comp.getId() != null && comp instanceof Label
+                            && comp.getId().equals(frag)) {
+                        fragComp = comp;
+                        break;
+                    }
+                }
+
+                if (fragComp == null) {
+                    return;
+                }
+                final Label fragLabel = (Label) fragComp;
+
+                createThread(frag, fragLabel).start();
+
+                fragLabel.setCaption(String.format("Thread running for %s!",
+                        frag));
+                UI.getCurrent().setPollInterval(1000);
+            }
+        };
+    }
+
+    private Thread createThread(final String frag, final Label fragLabel) {
+        return new Thread() {
+
+            @Override
+            public void run() {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+
+                UI.getCurrent().access(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        try {
+                            Thread.sleep(1000);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+
+                        log(String.format(
+                                "setCaption in synch mode for fragment %s",
+                                frag));
+                        java.util.Random rand = new java.util.Random();
+                        fragLabel.setCaption(String.format(
+                                "Thread finished on %s (%s)", frag,
+                                rand.nextInt()));
+                    }
+                });
+
+            };
+        };
+    }
+
+    @Override
+    protected String getTestDescription() {
+        return "Back and Forward buttons in browser should work correctly during asynchronous ui update";
+    }
+
+    @Override
+    protected Integer getTicketNumber() {
+        return 13997;
+    }
+}
diff --git a/uitest/src/com/vaadin/tests/urifragments/FragmentHandlingAndAsynchUIUpdateTest.java b/uitest/src/com/vaadin/tests/urifragments/FragmentHandlingAndAsynchUIUpdateTest.java
new file mode 100644
index 0000000000..01ea890cec
--- /dev/null
+++ b/uitest/src/com/vaadin/tests/urifragments/FragmentHandlingAndAsynchUIUpdateTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ * 
+ * Licensed 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 com.vaadin.tests.urifragments;
+
+import static com.vaadin.tests.urifragments.FragmentHandlingAndAsynchUIUpdate.FRAG_NAME_TPL;
+import static com.vaadin.tests.urifragments.FragmentHandlingAndAsynchUIUpdate.START_FRAG_ID;
+
+import org.junit.Test;
+import org.openqa.selenium.JavascriptExecutor;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.support.ui.ExpectedCondition;
+
+import com.vaadin.testbench.By;
+import com.vaadin.tests.tb3.MultiBrowserTest;
+
+/**
+ * Back and Forward buttons in browser should work correctly during UI update
+ * 
+ * @author Vaadin Ltd
+ */
+public class FragmentHandlingAndAsynchUIUpdateTest extends MultiBrowserTest {
+
+    /**
+     * The case when we successively set 10 fragments, go back 9 times and then
+     * go forward 9 times
+     */
+    @Test
+    public void testBackwardForwardHistoryWithWaitingForSettingFrag()
+            throws Exception {
+        openTestURL();
+
+        for (int i = 0; i < 10; i++) {
+            // here we wait for setting fragment in URI. If not to do it -
+            // history will be "loss"
+            getDriver().findElement(
+                    By.id(FragmentHandlingAndAsynchUIUpdate.BUTTON_ID)).click();
+            assertFragment(String.format(FRAG_NAME_TPL, START_FRAG_ID + i));
+        }
+
+        for (int i = 8; i >= 0; i--) {
+            ((JavascriptExecutor) driver).executeScript("history.back()");
+            assertFragment(String.format(FRAG_NAME_TPL, START_FRAG_ID + i));
+        }
+
+        for (int i = 1; i < 10; i++) {
+            ((JavascriptExecutor) driver).executeScript("history.forward()");
+            assertFragment(String.format(FRAG_NAME_TPL, START_FRAG_ID + i));
+        }
+    }
+
+    /**
+     * The case when it seems than history is loss
+     */
+    @Test
+    public void testBackwardForwardHistoryWithoutWaitingForSettingFrag()
+            throws Exception {
+        openTestURL();
+
+        // begin to wait for setting 3th fragment and then click backward
+        // history and then wait for 9th fragment
+        new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                // wait for setting 3th fragment
+                assertFragment(String.format(FRAG_NAME_TPL, START_FRAG_ID + 3));
+                // go back one time after we wait for 3th fragment and then we
+                // will see the "loss" of "forward history"
+                ((JavascriptExecutor) driver).executeScript("history.back()");
+
+                // now at some time new fragments will be set
+                // wait for last fragment setting..
+                // of course forward history is empty now..
+                assertFragment(String.format(FRAG_NAME_TPL, START_FRAG_ID + 9));
+            }
+
+        }).start();
+
+        // not wait for setting fragment in URI
+        // (simulated situation when users clicks some times in row on
+        // button)
+        new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                for (int i = 0; i < 10; i++) {
+                    getDriver().findElement(
+                            By.id(FragmentHandlingAndAsynchUIUpdate.BUTTON_ID))
+                            .click();
+                }
+
+            }
+
+        }).start();
+
+    }
+
+    private void assertFragment(String fragment) {
+        final String expectedText = fragment;
+
+        waitUntil(new ExpectedCondition<Boolean>() {
+
+            @Override
+            public Boolean apply(WebDriver input) {
+                String currentURL = getDriver().getCurrentUrl();
+                String currentURIFragment = "";
+                if (currentURL.contains("#") && !currentURL.endsWith("#")) {
+                    currentURIFragment = currentURL.split("#")[1];
+                }
+                return expectedText.equals(currentURIFragment);
+            }
+        }, 20);
+    }
+
+}