mockwebapplication.java

Wicket一个开发Java Web应用程序框架。它使得开发web应用程序变得容易而轻松。 Wicket利用一个POJO data beans组件使得它可以与任何持久层技术相结合。

	 * Get the wicket response object.
	 * 
	 * @return The wicket response object
	 */
	public WebResponse getWicketResponse()
	{
		return wicketResponse;
	}

	/**
	 * Get the wicket session.
	 * 
	 * @return The wicket session object
	 */
	public WebSession getWicketSession()
	{
		return wicketSession;
	}

	/**
	 * Initialize a new WebRequestCycle and all its dependent objects
	 * 
	 * @param component
	 */
	public void processRequestCycle(final Component component)
	{
		setupRequestAndResponse();
		final WebRequestCycle cycle = createRequestCycle();
		cycle.request(component);

		if (component instanceof Page)
		{
			lastRenderedPage = (Page)component;
		}
		postProcessRequestCycle(cycle);
	}

	/**
	 * Initialize a new WebRequestCycle and all its dependent objects
	 * 
	 * @param pageClass
	 */
	public void processRequestCycle(final Class pageClass)
	{
		processRequestCycle(pageClass, null);
	}

	/**
	 * Initialize a new WebRequestCycle and all its dependent objects
	 * 
	 * @param pageClass
	 * @param params
	 */
	public void processRequestCycle(final Class pageClass, PageParameters params)
	{
		setupRequestAndResponse();
		final WebRequestCycle cycle = createRequestCycle();
		try
		{
			cycle.request(new BookmarkablePageRequestTarget(pageClass, params));
		}
		finally
		{
			cycle.getResponse().close();
		}
		postProcessRequestCycle(cycle);
	}

	/**
	 * Create and process the request cycle using the current request and response information.
	 */
	public void processRequestCycle()
	{
		processRequestCycle(createRequestCycle());
	}

	/**
	 * Create and process the request cycle using the current request and response information.
	 * 
	 * @param cycle
	 */
	public void processRequestCycle(WebRequestCycle cycle)
	{
		try
		{
			cycle.request();
			createRequestCycle();
		}
		finally
		{
			cycle.getResponse().close();
		}
		postProcessRequestCycle(cycle);
	}

	/**
	 * 
	 * @param cycle
	 */
	private void postProcessRequestCycle(WebRequestCycle cycle)
	{
		previousRenderedPage = lastRenderedPage;

		if (cycle.getResponse() instanceof WebResponse)
		{
			// handle redirects which are usually managed by the browser
			// transparently
			final MockHttpServletResponse httpResponse = (MockHttpServletResponse)cycle.getWebResponse()
				.getHttpServletResponse();

			if (httpResponse.isRedirect())
			{
				lastRenderedPage = generateLastRenderedPage(cycle);

				MockHttpServletRequest newHttpRequest = new MockHttpServletRequest(application,
					servletSession, application.getServletContext());
				newHttpRequest.setRequestToRedirectString(httpResponse.getRedirectLocation());
				wicketRequest = application.newWebRequest(newHttpRequest);

				cycle = createRequestCycle();
				cycle.request();
			}
		}
		lastRenderedPage = generateLastRenderedPage(cycle);

		Session.set(getWicketSession());

		if (getLastRenderedPage() instanceof ExceptionErrorPage)
		{
			throw (RuntimeException)((ExceptionErrorPage)getLastRenderedPage()).getThrowable();
		}
	}

	/**
	 * 
	 * @param cycle
	 * @return Last page
	 */
	private Page generateLastRenderedPage(WebRequestCycle cycle)
	{
		Page newLastRenderedPage = cycle.getResponsePage();
		if (newLastRenderedPage == null)
		{
			Class responseClass = cycle.getResponsePageClass();
			if (responseClass != null)
			{
				Session.set(cycle.getSession());
				IRequestTarget target = cycle.getRequestTarget();
				if (target instanceof IPageRequestTarget)
				{
					newLastRenderedPage = ((IPageRequestTarget)target).getPage();
				}
				else if (target instanceof IBookmarkablePageRequestTarget)
				{
					// create a new request cycle for the newPage call
					createRequestCycle();
					IBookmarkablePageRequestTarget pageClassRequestTarget = (IBookmarkablePageRequestTarget)target;
					Class pageClass = pageClassRequestTarget.getPageClass();
					PageParameters parameters = pageClassRequestTarget.getPageParameters();
					if (parameters == null || parameters.size() == 0)
					{
						newLastRenderedPage = application.getSessionSettings()
							.getPageFactory()
							.newPage(pageClass);
					}
					else
					{
						newLastRenderedPage = application.getSessionSettings()
							.getPageFactory()
							.newPage(pageClass, parameters);
					}
				}
			}
		}

		if (newLastRenderedPage == null)
		{
			newLastRenderedPage = lastRenderedPage;
		}

		return newLastRenderedPage;
	}

	/**
	 * Create and process the request cycle using the current request and response information.
	 * 
	 * @return A new and initialized WebRequestCyle
	 */
	public WebRequestCycle createRequestCycle()
	{
		// Create a web request cycle using factory

		final WebRequestCycle cycle = (WebRequestCycle)application.newRequestCycle(wicketRequest,
			wicketResponse);

		// Construct session
		wicketSession = (WebSession)Session.findOrCreate();

		// Set request cycle so it won't detach automatically and clear messages
		// we want to check
		cycle.setAutomaticallyClearFeedbackMessages(false);
		return cycle;
	}

	/**
	 * Reset the request and the response back to a starting state and recreate the necessary wicket
	 * request, response and session objects. The request and response objects can be accessed and
	 * Initialized at this point.
	 * 
	 * @param isAjax
	 *            indicates whether the request should be initialized as an ajax request (ajax
	 *            header "Wicket-Ajax" is set)
	 */
	public WebRequestCycle setupRequestAndResponse(boolean isAjax)
	{
		servletRequest.initialize();
		servletResponse.initialize();
		servletRequest.setParameters(parametersForNextRequest);
		if (isAjax)
		{
			servletRequest.addHeader("Wicket-Ajax", "Yes");
		}
		parametersForNextRequest.clear();
		wicketRequest = application.newWebRequest(servletRequest);
		wicketResponse = application.newWebResponse(servletResponse);
		WebRequestCycle requestCycle = createRequestCycle();
		application.getSessionStore().bind(wicketRequest, wicketSession);
		wicketResponse.setAjax(wicketRequest.isAjax());
		return requestCycle;
	}

	/**
	 * Reset the request and the response back to a starting state and recreate the necessary wicket
	 * request, response and session objects. The request and response objects can be accessed and
	 * Initialized at this point.
	 */
	public WebRequestCycle setupRequestAndResponse()
	{
		return setupRequestAndResponse(false);
	}

	/**
	 * Gets the parameters to be set on the next request.
	 * 
	 * @return the parameters to be set on the next request
	 */
	public Map getParametersForNextRequest()
	{
		return parametersForNextRequest;
	}

	/**
	 * Sets the parameters to be set on the next request.
	 * 
	 * @param parametersForNextRequest
	 *            the parameters to be set on the next request
	 */
	public void setParametersForNextRequest(Map parametersForNextRequest)
	{
		this.parametersForNextRequest = parametersForNextRequest;
	}

	/**
	 * clears this mock application
	 */
	public void destroy()
	{
		filter.destroy();
		File dir = (File)context.getAttribute("javax.servlet.context.tempdir");
		deleteDir(dir);
	}

	private void deleteDir(File dir)
	{
		if (dir != null && dir.isDirectory())
		{
			File[] files = dir.listFiles();
			if (files != null)
			{
				for (int i = 0; i < files.length; i++)
				{
					File element = files[i];
					if (element.isDirectory())
					{
						deleteDir(element);
					}
					else
					{
						element.delete();
					}
				}
			}
			dir.delete();
		}
	}
}