Java tutorial
/* * Weblounge: Web Content Management System * Copyright (c) 2003 - 2011 The Weblounge Team * http://entwinemedia.com/weblounge * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software Foundation * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ package ch.entwine.weblounge.test.harness.rest; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import ch.entwine.weblounge.common.content.Resource; import ch.entwine.weblounge.common.impl.testing.IntegrationTestBase; import ch.entwine.weblounge.common.impl.util.TestUtils; import ch.entwine.weblounge.common.impl.util.xml.XPathHelper; import ch.entwine.weblounge.common.url.PathUtils; import ch.entwine.weblounge.common.url.UrlUtils; import ch.entwine.weblounge.test.util.TestSiteUtils; import org.apache.http.Header; import org.apache.http.HttpResponse; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpDelete; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.impl.client.DefaultHttpClient; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import java.io.StringWriter; import javax.servlet.http.HttpServletResponse; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; /** * Integration test to test the content repository's <code>restful</code> page * api. */ public class PagesEndpointTest extends IntegrationTestBase { /** The logger */ private static final Logger logger = LoggerFactory.getLogger(PagesEndpointTest.class); /** Page id */ protected String pageId = null; /** Page path */ protected String pagePath = null; /** * Creates a new instance of the content repository's page endpoint test. */ public PagesEndpointTest() { super("Page Endpoint Test", WEBLOUNGE_ENDPOINT_TEST_GROUP); } /** * {@inheritDoc} * * @see ch.entwine.weblounge.testing.kernel.IntegrationTest#execute(java.lang.String) */ @Override public void execute(String serverUrl) throws Exception { logger.info("Preparing test of pages endpoint"); pagePath = "/" + System.currentTimeMillis() + "/"; // Create a new page testCreate(serverUrl); // Test retrieving the work version of the page through the rest endpoint testGetPageById(serverUrl, Resource.WORK, pageId); // Lock the page testLockPage(serverUrl, pageId); // Update the page testUpdatePage(serverUrl, pageId); // Lock the page testUnlockPage(serverUrl, pageId); // Publish the page and test retrieval using the page request handler testPublishPage(serverUrl, pageId, pagePath); // Test retrieving the page through the rest endpoint testGetPageById(serverUrl, Resource.LIVE, pageId); testGetPageByPath(serverUrl, pagePath); // Move the page testMovePage(serverUrl, pageId); // Test referrer testGetReferrer(serverUrl, pageId); // Unpublish the page testUnpublishPage(serverUrl, pageId); // Test page deletion testDeletePage(serverUrl, pageId); } /** * Tests the creation of a page. * * @param serverUrl * the server url * @throws Exception * if page creation fails */ private void testCreate(String serverUrl) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages"); HttpPost createPageRequest = new HttpPost(requestUrl); String[][] params = new String[][] { { "path", pagePath } }; logger.debug("Creating new page at {}", createPageRequest.getURI()); HttpClient httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, createPageRequest, params); assertEquals(HttpServletResponse.SC_CREATED, response.getStatusLine().getStatusCode()); assertEquals(0, response.getEntity().getContentLength()); // Extract the id of the new page assertNotNull(response.getHeaders("Location")); String locationHeader = response.getHeaders("Location")[0].getValue(); assertTrue(locationHeader.startsWith(serverUrl)); pageId = locationHeader.substring(locationHeader.lastIndexOf("/") + 1); assertEquals("Identifier doesn't have correct length", 36, pageId.length()); logger.debug("Id of the new page is {}", pageId); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the page is not yet publicly reachable String requestByIdUrl = UrlUtils.concat(serverUrl, "/weblounge-pages/", pageId); HttpGet getPageRequest = new HttpGet(requestByIdUrl); httpClient = new DefaultHttpClient(); logger.info("Requesting published page at {}", requestByIdUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_NOT_FOUND, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Tries to retrieve a page by its id. * * @param serverUrl * the server url * @param version * the page version * @param id * the page identifier * @throws Exception * if retrieval failed */ private void testGetPageById(String serverUrl, long version, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages", id); HttpGet getPageRequest = new HttpGet(requestUrl); String[][] params = new String[][] { { "version", Long.toString(version) } }; HttpClient httpClient = new DefaultHttpClient(); Document pageXml = null; String eTagValue; String modifiedValue; logger.info("Requesting page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); pageXml = TestUtils.parseXMLResponse(response); assertEquals(id, XPathHelper.valueOf(pageXml, "/page/@id")); // Test ETag header Header eTagHeader = response.getFirstHeader("ETag"); assertNotNull(eTagHeader); assertNotNull(eTagHeader.getValue()); eTagValue = eTagHeader.getValue(); Header modifiedHeader = response.getFirstHeader("Last-Modified"); assertNotNull(modifiedHeader); assertNotNull(modifiedHeader.getValue()); modifiedValue = modifiedHeader.getValue(); } finally { httpClient.getConnectionManager().shutdown(); } // Test E-Tag header TestSiteUtils.testETagHeader(getPageRequest, eTagValue, logger, params); // Test If-Modified-Since header with non-modified page httpClient = new DefaultHttpClient(); try { getPageRequest.removeHeaders("If-None-Match"); getPageRequest.setHeader("If-Modified-Since", modifiedValue); logger.info("Sending 'If-Modified-Since' request to {}", requestUrl); HttpResponse response = TestUtils.request(httpClient, getPageRequest, params); assertEquals(HttpServletResponse.SC_NOT_MODIFIED, response.getStatusLine().getStatusCode()); assertNull(response.getEntity()); } finally { httpClient.getConnectionManager().shutdown(); } // Test If-Modified-Since header with modified page httpClient = new DefaultHttpClient(); try { getPageRequest.removeHeaders("If-None-Match"); getPageRequest.setHeader("If-Modified-Since", "Wed, 10 Feb 1999 21:06:40 GMT"); logger.info("Sending 'If-Modified-Since' request to {}", requestUrl); HttpResponse response = TestUtils.request(httpClient, getPageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); assertNotNull(response.getEntity()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Tries to retrieve a page by its id. * * @param serverUrl * the server url * @param path * the page path * @throws Exception * if retrieval failed */ private void testGetPageByPath(String serverUrl, String path) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages"); HttpGet getPageByPathRequest = new HttpGet(requestUrl); String[][] params = new String[][] { { "path", pagePath } }; HttpClient httpClient = new DefaultHttpClient(); Document pageByPathXml = null; logger.info("Requesting page by path at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageByPathRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); pageByPathXml = TestUtils.parseXMLResponse(response); assertNotNull(XPathHelper.valueOf(pageByPathXml, "/pages/page/@path")); assertEquals(path, XPathHelper.valueOf(pageByPathXml, "/pages/page/@path")); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Tests listing of referrer. * * @param serverUrl * the server url * @param pageId * the page identifier * @throws Exception * if page creation fails */ private void testGetReferrer(String serverUrl, String pageId) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages"); HttpPost createPageRequest = new HttpPost(requestUrl); String referringPageId = null; // Create a new page and add a pagelet with a link to the original page logger.debug("Creating new page"); HttpClient httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, createPageRequest, null); assertEquals(HttpServletResponse.SC_CREATED, response.getStatusLine().getStatusCode()); assertEquals(0, response.getEntity().getContentLength()); // Extract the id of the new page assertNotNull(response.getHeaders("Location")); String locationHeader = response.getHeaders("Location")[0].getValue(); assertTrue(locationHeader.startsWith(serverUrl)); referringPageId = locationHeader.substring(locationHeader.lastIndexOf("/") + 1); logger.debug("Id of the new page is {}", referringPageId); httpClient.getConnectionManager().shutdown(); httpClient = new DefaultHttpClient(); // Load the created page String referringPageUrl = UrlUtils.concat(requestUrl, referringPageId, "?version=1"); HttpGet getPageRequest = new HttpGet(referringPageUrl); response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); String pageXml = TestUtils.parseTextResponse(response); httpClient.getConnectionManager().shutdown(); httpClient = new DefaultHttpClient(); // Lock the page HttpPut lockPageRequest = new HttpPut(UrlUtils.concat(requestUrl, referringPageId, "lock")); logger.info("Locking the page at {}", requestUrl); response = TestUtils.request(httpClient, lockPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); httpClient.getConnectionManager().shutdown(); httpClient = new DefaultHttpClient(); // Add a pagelet and post the updated page String pageletSecurity = "<security><owner><user id=\"hans\" realm=\"testland\"><![CDATA[Hans Muster]]></user></owner></security>"; String pageletCreation = "<created><user id=\"hans\" realm=\"testland\"><![CDATA[Hans Muster]]></user><date>2009-01-07T19:05:41Z</date></created>"; String pageletPublication = "<published><user id=\"hans\" realm=\"testland\"><![CDATA[Hans Muster]]></user><from>2009-01-07T19:05:41Z</from></published>"; String pageletProperties = "<properties><property id=\"resourceid\"><![CDATA[" + pageId + "]]></property></properties>"; pageXml = pageXml.replaceAll("<body/>", "<body><composer id=\"main\"><pagelet module=\"navigation\" id=\"link\">" + pageletSecurity + pageletCreation + pageletPublication + pageletProperties + "</pagelet></composer></body>"); HttpPut updatePageRequest = new HttpPut(referringPageUrl); String[][] params = new String[][] { { "content", pageXml } }; logger.info("Updating page at {}", referringPageUrl); response = TestUtils.request(httpClient, updatePageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); // Publish it HttpPut publishPageRequest = new HttpPut(UrlUtils.concat(requestUrl, referringPageId, "publish")); httpClient = new DefaultHttpClient(); logger.info("Publishing the page at {}", requestUrl); response = TestUtils.request(httpClient, publishPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the page is being issued as a referrer of the original page String requestReferrerUrl = UrlUtils.concat(requestUrl, pageId, "referrer"); HttpGet getPageRequest = new HttpGet(requestReferrerUrl); logger.info("Requesting referrer of {} at {}", pageId, requestReferrerUrl); // Wait as long as 10s for the asynchronous processing boolean success = false; for (int i = 0; i < 5; i++) { httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Document referrer = TestUtils.parseXMLResponse(response); assertEquals(1, XPathHelper.selectList(referrer, "/pages/page").getLength()); assertEquals(referringPageId, XPathHelper.valueOf(referrer, "/pages/page/@id")); success = true; break; } catch (AssertionError a) { logger.debug("Waiting, then retrying due to asynchronous processing"); Thread.sleep(2000); } finally { httpClient.getConnectionManager().shutdown(); } } assertTrue(success); // Delete the new page HttpDelete deleteRequest = new HttpDelete(UrlUtils.concat(requestUrl, referringPageId)); httpClient = new DefaultHttpClient(); // Delete the page logger.info("Sending delete request to {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, deleteRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Locks the page. * * @param serverUrl * the server url * @param id * the page identifier * @throws Exception * if updating failed */ private void testLockPage(String serverUrl, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages/", id); // Lock the page HttpPut lockRequest = new HttpPut(UrlUtils.concat(requestUrl, "lock")); HttpClient httpClient = new DefaultHttpClient(); logger.info("Locking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, lockRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Locks the page. * * @param serverUrl * the server url * @param id * the page identifier * @throws Exception * if updating failed */ private void testUnlockPage(String serverUrl, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages/", id); // Unlock the page HttpDelete unlockRequest = new HttpDelete(UrlUtils.concat(requestUrl, "lock")); HttpClient httpClient = new DefaultHttpClient(); logger.info("Unlocking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, unlockRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the update was successful HttpGet getUpdatedPageRequest = new HttpGet(requestUrl); httpClient = new DefaultHttpClient(); String[][] params = null; params = new String[][] { { "version", Long.toString(Resource.WORK) } }; logger.info("Requesting locked page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, getUpdatedPageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Document pageXml = TestUtils.parseXMLResponse(response); assertNull(XPathHelper.valueOf(pageXml, "/page/head/locked")); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Updates the creator field of the page. * * @param serverUrl * the server url * @param id * the page identifier * @throws Exception * if updating failed */ private void testUpdatePage(String serverUrl, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages"); HttpGet getPageRequest = new HttpGet(UrlUtils.concat(requestUrl, id)); HttpClient httpClient = new DefaultHttpClient(); String[][] params = null; params = new String[][] { { "version", Long.toString(Resource.WORK) } }; Document pageXml = null; String creator = null; // Read what's currently stored logger.info("Requesting page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); pageXml = TestUtils.parseXMLResponse(response); creator = XPathHelper.valueOf(pageXml, "/page/head/created/user"); } finally { httpClient.getConnectionManager().shutdown(); } // Update the creator field HttpPut updatePageRequest = new HttpPut(UrlUtils.concat(requestUrl, id)); String updatedCreator = creator + " (updated)"; NodeList creatorElements = pageXml.getElementsByTagName("created"); creatorElements.item(0).getFirstChild().setTextContent(updatedCreator); params = new String[][] { { "content", serializeDoc(pageXml) } }; httpClient = new DefaultHttpClient(); logger.info("Updating page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, updatePageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the update was successful HttpGet getUpdatedPageRequest = new HttpGet(UrlUtils.concat(requestUrl, id)); httpClient = new DefaultHttpClient(); params = new String[][] { { "version", Long.toString(Resource.WORK) } }; logger.info("Requesting updated page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, getUpdatedPageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); pageXml = TestUtils.parseXMLResponse(response); assertEquals(pageId, XPathHelper.valueOf(pageXml, "/page/@id")); assertEquals(updatedCreator, XPathHelper.valueOf(pageXml, "/page/head/created/user")); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Moves the page to a different url and back. * * @param serverUrl * the server url * @param id * the page id * @throws Exception * if moving fails */ private void testMovePage(String serverUrl, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages"); HttpGet getPageRequest = new HttpGet(UrlUtils.concat(requestUrl, id)); HttpClient httpClient = new DefaultHttpClient(); Document pageXml = null; String oldPath = null; // Read what's currently stored logger.info("Requesting page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); pageXml = TestUtils.parseXMLResponse(response); assertNotNull(XPathHelper.valueOf(pageXml, "/page")); oldPath = XPathHelper.valueOf(pageXml, "/page/@path"); } finally { httpClient.getConnectionManager().shutdown(); } // Lock the page HttpPut lockPageRequest = new HttpPut(UrlUtils.concat(requestUrl, id, "lock")); httpClient = new DefaultHttpClient(); logger.info("Locking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, lockPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Move the page HttpPut movePageRequest = new HttpPut(UrlUtils.concat(requestUrl, id)); String newPath = PathUtils.concat(oldPath, "/new/"); pageXml.getFirstChild().getAttributes().getNamedItem("path").setNodeValue(newPath); String[][] params = new String[][] { { "content", serializeDoc(pageXml) } }; httpClient = new DefaultHttpClient(); logger.info("Moving page from {} to {}", oldPath, newPath); try { HttpResponse response = TestUtils.request(httpClient, movePageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Unlock the page HttpDelete unlockRequest = new HttpDelete(UrlUtils.concat(requestUrl, id, "lock")); httpClient = new DefaultHttpClient(); logger.info("Unlocking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, unlockRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the page is gone from the original path but can be found on // the new one HttpGet getPageByPathRequest = new HttpGet(requestUrl); params = new String[][] { { "path", newPath } }; logger.info("Requesting page by path at {}", newPath); // Wait as long as 10s for the asynchronous processing boolean success = false; for (int i = 0; i < 5; i++) { httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, getPageByPathRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Document pagesXml = TestUtils.parseXMLResponse(response); assertNotNull(XPathHelper.select(pagesXml, "/pages/page[1]")); assertEquals(id, XPathHelper.valueOf(pagesXml, "/pages/page[1]/@id")); assertEquals(newPath, XPathHelper.valueOf(pagesXml, "/pages/page[1]/@path")); success = true; break; } catch (AssertionError a) { logger.debug("Waiting for asynchronous processing"); Thread.sleep(2000); } finally { httpClient.getConnectionManager().shutdown(); } } assertTrue(success); // Check that the page is gone from the old path getPageByPathRequest = new HttpGet(requestUrl); params = new String[][] { { "path", oldPath } }; httpClient = new DefaultHttpClient(); logger.info("Requesting page using the old (no longer valid path) {}", oldPath); success = false; for (int i = 0; i < 5; i++) { httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, getPageByPathRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); assertNull(XPathHelper.select(TestUtils.parseXMLResponse(response), "/pages/page")); success = true; } catch (AssertionError a) { logger.debug("Waiting for asynchronous processing"); Thread.sleep(2000); } finally { httpClient.getConnectionManager().shutdown(); } } assertTrue(success); // Move the page back movePageRequest = new HttpPut(UrlUtils.concat(requestUrl, id)); pageXml.getFirstChild().getAttributes().getNamedItem("path").setNodeValue(oldPath); params = new String[][] { { "content", serializeDoc(pageXml) } }; httpClient = new DefaultHttpClient(); logger.info("Moving page back from {} to {}", newPath, oldPath); try { HttpResponse response = TestUtils.request(httpClient, movePageRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the page is back to the original path getPageByPathRequest = new HttpGet(requestUrl); params = new String[][] { { "path", oldPath } }; logger.info("Requesting page by path at {}", oldPath); // Wait as long as 10s for the asynchronous processing success = false; for (int i = 0; i < 5; i++) { httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, getPageByPathRequest, params); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); Document pagesXml = TestUtils.parseXMLResponse(response); assertNotNull(XPathHelper.select(pagesXml, "/pages/page[1]")); assertEquals(id, XPathHelper.valueOf(pagesXml, "/pages/page[1]/@id")); assertEquals(oldPath, XPathHelper.valueOf(pagesXml, "/pages/page[1]/@path")); success = true; break; } catch (AssertionError a) { logger.debug("Waiting for asynchronous processing"); Thread.sleep(2000); } finally { httpClient.getConnectionManager().shutdown(); } } assertTrue(success); } /** * Publishes the page. * * @param serverUrl * the server url * @param id * the page identifier * @param path * the page path * @throws Exception * if publishing failed */ private void testPublishPage(String serverUrl, String id, String path) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages/"); // Lock the page HttpPut lockPageRequest = new HttpPut(UrlUtils.concat(requestUrl, id, "lock")); HttpClient httpClient = new DefaultHttpClient(); logger.info("Locking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, lockPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Publish it HttpPut publishPageRequest = new HttpPut(UrlUtils.concat(requestUrl, id, "publish")); httpClient = new DefaultHttpClient(); logger.info("Publishing the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, publishPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Unlock the page HttpDelete unlockRequest = new HttpDelete(UrlUtils.concat(requestUrl, id, "lock")); httpClient = new DefaultHttpClient(); logger.info("Unlocking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, unlockRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure the published page is reachable // Wait a second, since when publishing the page, we cut off the millisecond // portion of the publishing start date Thread.sleep(1000); // Get the page using its id String requestByIdUrl = UrlUtils.concat(serverUrl, "/weblounge-pages/", id); HttpGet getPageRequest = new HttpGet(requestByIdUrl); httpClient = new DefaultHttpClient(); logger.info("Requesting published page at {}", requestByIdUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Get the page using its path String requestByPathUrl = UrlUtils.concat(serverUrl, path); getPageRequest = new HttpGet(requestByPathUrl); httpClient = new DefaultHttpClient(); logger.info("Requesting published page at {}", requestByPathUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Publishes the page. * * @param serverUrl * the server url * @param id * the page identifier * @throws Exception * if publishing failed */ private void testUnpublishPage(String serverUrl, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages/"); // Lock the page HttpPut lockPageRequest = new HttpPut(UrlUtils.concat(requestUrl, id, "lock")); HttpClient httpClient = new DefaultHttpClient(); logger.info("Locking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, lockPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Unpublish it HttpDelete unpublishPageRequest = new HttpDelete(UrlUtils.concat(requestUrl, id, "publish")); httpClient = new DefaultHttpClient(); logger.info("Unpublishing the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, unpublishPageRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Unlock the page HttpDelete unlockRequest = new HttpDelete(UrlUtils.concat(requestUrl, id, "lock")); httpClient = new DefaultHttpClient(); logger.info("Unlocking the page at {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, unlockRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } String requestByIdUrl = UrlUtils.concat(serverUrl, "/weblounge-pages/", id); HttpGet getPageRequest = new HttpGet(requestByIdUrl); httpClient = new DefaultHttpClient(); logger.info("Requesting published page at {}", requestByIdUrl); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_NOT_FOUND, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Deletes the page. * * @param serverUrl * the server url * @param id * the page id * @throws Exception * if deletion failed */ private void testDeletePage(String serverUrl, String id) throws Exception { String requestUrl = UrlUtils.concat(serverUrl, "system/weblounge/pages"); HttpDelete deleteRequest = new HttpDelete(UrlUtils.concat(requestUrl, pageId)); HttpClient httpClient = new DefaultHttpClient(); // Delete the page logger.info("Sending delete request to {}", requestUrl); try { HttpResponse response = TestUtils.request(httpClient, deleteRequest, null); assertEquals(HttpServletResponse.SC_OK, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } // Make sure it's gone logger.info("Make sure page {} is gone", id); HttpGet getPageRequest = new HttpGet(UrlUtils.concat(requestUrl, id)); httpClient = new DefaultHttpClient(); try { HttpResponse response = TestUtils.request(httpClient, getPageRequest, null); assertEquals(HttpServletResponse.SC_NOT_FOUND, response.getStatusLine().getStatusCode()); } finally { httpClient.getConnectionManager().shutdown(); } } /** * Returns the serialized version of the given dom node. * * @param doc * the xml document * @return the serialized version */ private static String serializeDoc(Node doc) { StringWriter outText = new StringWriter(); StreamResult sr = new StreamResult(outText); TransformerFactory tf = TransformerFactory.newInstance(); Transformer t = null; try { t = tf.newTransformer(); t.transform(new DOMSource(doc), sr); } catch (Throwable th) { throw new IllegalStateException("Unable to serialize dom", th); } return outText.toString(); } }