// Copyright 2006, 2007, 2008, 2009 The Apache Software Foundation

 //

 // 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 org.apache.tapestry5.test;

 import org.apache.tapestry5.Link;

 import org.apache.tapestry5.dom.Document;

 import org.apache.tapestry5.dom.Element;

 import org.apache.tapestry5.dom.Visitor;

 import org.apache.tapestry5.internal.InternalConstants;

 import org.apache.tapestry5.internal.SingleKeySymbolProvider;

 import org.apache.tapestry5.internal.TapestryAppInitializer;

 import org.apache.tapestry5.internal.test.PageTesterContext;

 import org.apache.tapestry5.internal.test.PageTesterModule;

 import org.apache.tapestry5.internal.test.TestableRequest;

 import org.apache.tapestry5.internal.test.TestableResponse;

 import org.apache.tapestry5.ioc.Registry;

 import org.apache.tapestry5.ioc.def.ModuleDef;

 import org.apache.tapestry5.ioc.internal.util.Defense;

 import org.apache.tapestry5.ioc.internal.util.InternalUtils;

 import org.apache.tapestry5.ioc.services.SymbolProvider;

 import org.apache.tapestry5.services.ApplicationGlobals;

 import org.apache.tapestry5.services.RequestHandler;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 import java.io.IOException;

 import java.util.Locale;

 import java.util.Map;

 /**

  * This class is used to run a Tapestry app in a single-threaded, in-process testing environment. You can ask it to

  * render a certain page and check the DOM object created. You can also ask it to click on a link element in the DOM

  * object to get the next page. Because no servlet container is required, it is very fast and you can directly debug

  * into your code in your IDE.

  */

 public class PageTester

 {

     @SuppressWarnings({ "FieldCanBeLocal" })

     private final Logger logger = LoggerFactory.getLogger(PageTester.class);

     private final Registry registry;

     private final TestableRequest request;

     private final TestableResponse response;

     // private final StrategyRegistry<ComponentInvoker> invokerRegistry;

     private final RequestHandler requestHandler;

     public static final String DEFAULT_CONTEXT_PATH = "src/main/webapp";

     private static final String DEFAULT_SUBMIT_VALUE_ATTRIBUTE = "Submit Query";

     /**

      * Initializes a PageTester without overriding any services and assuming that the context root is in

      * src/main/webapp.

      *

      * @see #PageTester(String, String, String, Class[])

      */

     public PageTester(String appPackage, String appName)

     {

         this(appPackage, appName, DEFAULT_CONTEXT_PATH);

     }

     /**

      * Initializes a PageTester that acts as a browser and a servlet container to test drive your Tapestry pages.

      *

      * @param appPackage    The same value you would specify using the tapestry.app-package context parameter. As this

      *                      testing environment is not run in a servlet container, you need to specify it.

      * @param appName       The same value you would specify as the filter name. It is used to form the name of the

      *                      module class for your app. If you don't have one, pass an empty string.

      * @param contextPath   The path to the context root so that Tapestry can find the templates (if they're put

      *                      there).

      * @param moduleClasses Classes of additional modules to load

      */

     public PageTester(String appPackage, String appName, String contextPath, Class... moduleClasses)

     {

         Defense.notBlank(appPackage, "appPackage");

         Defense.notBlank(appName, "appName");

         Defense.notBlank(contextPath, "contextPath");

         SymbolProvider provider = new SingleKeySymbolProvider(InternalConstants.TAPESTRY_APP_PACKAGE_PARAM, appPackage);

         TapestryAppInitializer initializer = new TapestryAppInitializer(logger, provider, appName,

                                                                         PageTesterModule.TEST_MODE);

         initializer.addModules(PageTesterModule.class);

         initializer.addModules(moduleClasses);

         initializer.addModules(provideExtraModuleDefs());

         registry = initializer.createRegistry();

         request = registry.getService(TestableRequest.class);

         response = registry.getService(TestableResponse.class);

         ApplicationGlobals globals = registry.getObject(ApplicationGlobals.class, null);

         globals.storeContext(new PageTesterContext(contextPath));

         requestHandler = registry.getService("RequestHandler", RequestHandler.class);

         request.setLocale(Locale.ENGLISH);

     }

     /**

      * Overridden in subclasses to provide additional module definitions beyond those normally located. This

      * implementation returns an empty array.

      */

     protected ModuleDef[] provideExtraModuleDefs()

     {

         return new ModuleDef[0];

     }

     /**

      * Invoke this method when done using the PageTester; it shuts down the internal {@link

      * org.apache.tapestry5.ioc.Registry} used by the tester.

      */

     public void shutdown()

     {

         registry.shutdown();

     }

     /**

      * Returns the Registry that was created for the application.

      */

     public Registry getRegistry()

     {

         return registry;

     }

     /**

      * Allows a service to be retrieved via its service interface.  Use {@link #getRegistry()} for more complicated

      * queries.

      *

      * @param serviceInterface used to select the service

      */

     public <T> T getService(Class<T> serviceInterface)

     {

         return registry.getService(serviceInterface);

     }

     /**

      * Renders a page specified by its name.

      *

      * @param pageName The name of the page to be rendered.

      * @return The DOM created. Typically you will assert against it.

      */

     public Document renderPage(String pageName)

     {

         request.clear().setPath("/" + pageName);

         while (true)

         {

             try

             {

                 response.clear();

                 boolean handled = requestHandler.service(request, response);

                 if (!handled)

                 {

                     throw new RuntimeException(

                             String.format("Request was not handled: '%s' may not be a valid page name.", pageName));

                 }

                 Link link = response.getRedirectLink();

                 if (link != null)

                 {

                     setupRequestFromLink(link);

                     continue;

                 }

                 Document result = response.getRenderedDocument();

                 if (result == null)

                     throw new RuntimeException(

                             String.format("Render of page '%s' did not result in a Document.", pageName));

                 return result;

             }

             catch (IOException ex)

             {

                 throw new RuntimeException(ex);

             }

         }

     }

     /**

      * Simulates a click on a link.

      *

      * @param linkElement The Link object to be "clicked" on.

      * @return The DOM created. Typically you will assert against it.

      */

     public Document clickLink(Element linkElement)

     {

         Defense.notNull(linkElement, "link");

         validateElementName(linkElement, "a");

         String href = extractNonBlank(linkElement, "href");

         setupRequestFromURI(href);

         return runComponentEventRequest();

     }

     private String extractNonBlank(Element element, String attributeName)

     {

         String result = element.getAttribute(attributeName);

         if (InternalUtils.isBlank(result))

             throw new RuntimeException(

                     String.format("The %s attribute of the <%s> element was blank or missing.",

                                   element.getName(), attributeName));

         return result;

     }

     private void validateElementName(Element element, String expectedElementName)

     {

         if (!element.getName().equalsIgnoreCase(expectedElementName))

             throw new RuntimeException(

                     String.format("The element must be type '%s', not '%s'.", expectedElementName, element.getName()));

     }

     private Document runComponentEventRequest()

     {

         while (true)

         {

             response.clear();

             try

             {

                 boolean handled = requestHandler.service(request, response);

                 if (!handled)

                     throw new RuntimeException(String.format("Request for path '%s' was not handled by Tapestry.",

                                                              request.getPath()));

                 Link link = response.getRedirectLink();

                 if (link != null)

                 {

                     setupRequestFromLink(link);

                     continue;

                 }

                 Document result = response.getRenderedDocument();

                 if (result == null)

                     throw new RuntimeException(

                             String.format("Render request '%s' did not result in a Document.", request.getPath()));

                 return result;

             }

             catch (IOException ex)

             {

                 throw new RuntimeException(ex);

             }

         }

     }

     private void setupRequestFromLink(Link link)

     {

         setupRequestFromURI(link.toRedirectURI());

     }

     private void setupRequestFromURI(String URI)

     {

         String linkPath = stripContextFromPath(URI);

         int comma = linkPath.indexOf('?');

         String path = comma < 0

                       ? linkPath

                       : linkPath.substring(0, comma);

         request.clear().setPath(path);

         if (comma > 0)

             decodeParametersIntoRequest(path.substring(comma + 1));

     }

     private void decodeParametersIntoRequest(String queryString)

     {

         if (InternalUtils.isNonBlank(queryString))

             throw new RuntimeException("Have not yet implemented this method.");

     }

     private String stripContextFromPath(String path)

     {

         String contextPath = request.getContextPath();

         if (contextPath.equals("")) return path;

         if (!path.startsWith(contextPath))

             throw new RuntimeException(String.format("Path '%s' does not start with context path '%s'.",

                                                      path, contextPath));

         return path.substring(contextPath.length());

     }

     /**

      * Simulates a submission of the form specified. The caller can specify values for the form fields, which act as

      * overrides on the values stored inside the elements.

      *

      * @param form       the form to be submitted.

      * @param parameters the query parameter name/value pairs

      * @return The DOM created. Typically you will assert against it.

      */

     public Document submitForm(Element form, Map<String, String> parameters)

     {

         Defense.notNull(form, "form");

         validateElementName(form, "form");

         request.clear().setPath(stripContextFromPath(extractNonBlank(form, "action")));

         pushFieldValuesIntoRequest(form);

         overrideParameters(parameters);

         // addHiddenFormFields(form);

         // ComponentInvocation invocation = getInvocation(form);

         return runComponentEventRequest();

     }

     private void overrideParameters(Map<String, String> fieldValues)

     {

         for (Map.Entry<String, String> e : fieldValues.entrySet())

         {

             request.overrideParameter(e.getKey(), e.getValue());

         }

     }

     private void pushFieldValuesIntoRequest(Element form)

     {

         Visitor visitor = new Visitor()

         {

             public void visit(Element element)

             {

                 if (InternalUtils.isNonBlank(element.getAttribute("disabled")))

                     return;

                 String name = element.getName();

                 if (name.equals("input"))

                 {

                     String type = extractNonBlank(element, "type");

                     if (type.equals("radio") || type.equals("checkbox"))

                     {

                         if (InternalUtils.isBlank(element.getAttribute("checked")))

                             return;

                     }

                     // Assume that, if the element is a button/submit, it wasn't clicked,

                     // and therefore, is not part of the submission.

                     if (type.equals("button") || type.equals("submit"))

                         return;

                     // Handle radio, checkbox, text, radio, hidden

                     String value = element.getAttribute("value");

                     if (InternalUtils.isNonBlank(value))

                         request.loadParameter(extractNonBlank(element, "name"), value);

                     return;

                 }

                 if (name.equals("option"))

                 {

                     String value = element.getAttribute("value");

                     // TODO: If value is blank do we use the content, or is the content only the label?

                     if (InternalUtils.isNonBlank(element.getAttribute("selected")))

                     {

                         String selectName = extractNonBlank(findAncestor(element, "select"), "name");

                         request.loadParameter(selectName, value);

                     }

                     return;

                 }

                 if (name.equals("textarea"))

                 {

                     String content = element.getChildMarkup();

                     if (InternalUtils.isNonBlank(content))

                         request.loadParameter(extractNonBlank(element, "name"), content);

                     return;

                 }

             }

         };

         form.visit(visitor);

     }

     /**

      * Simulates a submission of the form by clicking the specified submit button. The caller can specify values for the

      * form fields.

      *

      * @param submitButton the submit button to be clicked.

      * @param fieldValues  the field values keyed on field names.

      * @return The DOM created. Typically you will assert against it.

      */

     public Document clickSubmit(Element submitButton, Map<String, String> fieldValues)

     {

         Defense.notNull(submitButton, "submitButton");

         assertIsSubmit(submitButton);

         Element form = getFormAncestor(submitButton);

         request.clear().setPath(stripContextFromPath(extractNonBlank(form, "action")));

         pushFieldValuesIntoRequest(form);

         overrideParameters(fieldValues);

         String value = submitButton.getAttribute("value");

         if (value == null)

             value = DEFAULT_SUBMIT_VALUE_ATTRIBUTE;

         request.overrideParameter(extractNonBlank(submitButton, "name"), value);

         return runComponentEventRequest();

     }

     private void assertIsSubmit(Element element)

     {

         if (element.getName().equals("input"))

         {

             String type = element.getAttribute("type");

             if ("submit".equals(type)) return;

         }

         throw new IllegalArgumentException("The specified element is not a submit button.");

     }

     private Element getFormAncestor(Element element)

     {

         return findAncestor(element, "form");

     }

     private Element findAncestor(Element element, String ancestorName)

     {

         Element e = element;

         while (e != null)

         {

             if (e.getName().equalsIgnoreCase(ancestorName))

                 return e;

             e = e.getParent();

         }

         throw new RuntimeException(

                 String.format("Could not locate an ancestor element of type '%s'.", ancestorName));

     }

     /**

      * Sets the simulated browser's preferred language, i.e., the value returned from {@link

      * org.apache.tapestry5.services.Request#getLocale()}.

      *

      * @param preferedLanguage preferred language setting

      */

     public void setPreferedLanguage(Locale preferedLanguage)

     {

         request.setLocale(preferedLanguage);

     }

 }