[gatein-commits] gatein SVN: r3768 - in components/wsrp/trunk: producer/src/main/java/org/gatein/exports and 5 other directories.
do-not-reply at jboss.org
do-not-reply at jboss.org
Fri Aug 6 17:36:44 EDT 2010
Author: mwringe
Date: 2010-08-06 17:36:43 -0400 (Fri, 06 Aug 2010)
New Revision: 3768
Modified:
components/wsrp/trunk/common/src/main/java/org/gatein/wsrp/WSRPTypeFactory.java
components/wsrp/trunk/producer/src/main/java/org/gatein/exports/ExportManager.java
components/wsrp/trunk/producer/src/main/java/org/gatein/exports/data/ExportData.java
components/wsrp/trunk/producer/src/main/java/org/gatein/exports/impl/ExportManagerImpl.java
components/wsrp/trunk/producer/src/main/java/org/gatein/wsrp/producer/PortletManagementHandler.java
components/wsrp/trunk/wsrp-producer-war/pom.xml
components/wsrp/trunk/wsrp-producer-war/src/test/java/org/gatein/wsrp/protocol/v2/PortletManagementTestCase.java
Log:
GTNWSRP-55: Import/Export bug fixes and updated tests.
Modified: components/wsrp/trunk/common/src/main/java/org/gatein/wsrp/WSRPTypeFactory.java
===================================================================
--- components/wsrp/trunk/common/src/main/java/org/gatein/wsrp/WSRPTypeFactory.java 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/common/src/main/java/org/gatein/wsrp/WSRPTypeFactory.java 2010-08-06 21:36:43 UTC (rev 3768)
@@ -1433,7 +1433,7 @@
return importPortlets;
}
- public static ImportPortlet createImportPorlet(String importID, byte[] exportData)
+ public static ImportPortlet createImportPortlet(String importID, byte[] exportData)
{
ParameterValidation.throwIllegalArgExceptionIfNull(importID, "ImportID");
ParameterValidation.throwIllegalArgExceptionIfNull(exportData, "ExportData");
Modified: components/wsrp/trunk/producer/src/main/java/org/gatein/exports/ExportManager.java
===================================================================
--- components/wsrp/trunk/producer/src/main/java/org/gatein/exports/ExportManager.java 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/producer/src/main/java/org/gatein/exports/ExportManager.java 2010-08-06 21:36:43 UTC (rev 3768)
@@ -44,11 +44,11 @@
ExportContext createExportContext(boolean exportByValueRequired, Lifetime lifetime) throws UnsupportedEncodingException;
- ExportContext createExportContext(byte[] bytes);
+ ExportContext createExportContext(byte[] bytes) throws OperationFailed;
ExportPortletData createExportPortletData(ExportContext exportContextData, String portletHandle, byte[] portletState) throws UnsupportedEncodingException;
- ExportPortletData createExportPortletData(ExportContext exportContext, Lifetime lifetime, byte[] bytes);
+ ExportPortletData createExportPortletData(ExportContext exportContext, Lifetime lifetime, byte[] bytes) throws OperationFailed;
byte[] encodeExportPortletData(ExportContext exportContextData, ExportPortletData exportPortletData) throws UnsupportedEncodingException;
Modified: components/wsrp/trunk/producer/src/main/java/org/gatein/exports/data/ExportData.java
===================================================================
--- components/wsrp/trunk/producer/src/main/java/org/gatein/exports/data/ExportData.java 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/producer/src/main/java/org/gatein/exports/data/ExportData.java 2010-08-06 21:36:43 UTC (rev 3768)
@@ -56,46 +56,70 @@
public static double getVersion(byte[] bytes) throws UnsupportedEncodingException
{
- String dataString = new String(bytes, ENCODING);
- String[] split = dataString.split(SEPARATOR, 3);
-
- if (split.length >= 2)
+ if (bytes != null && bytes.length > 0)
{
- double version = Double.parseDouble(split[1]);
- return version;
+ String dataString = new String(bytes, ENCODING);
+ String[] split = dataString.split(SEPARATOR, 3);
+
+ if (split.length >= 2)
+ {
+ double version = Double.parseDouble(split[1]);
+ return version;
+ }
+ else
+ {
+ //if a version could not be found, return -1
+ return -1;
+ }
}
-
- //if a version could not be found, return -1
- return -1;
+ else
+ {
+ return -1;
+ }
}
public static String getType(byte[] bytes) throws UnsupportedEncodingException
{
- String dataString = new String(bytes, ENCODING);
- String[] split = dataString.split(SEPARATOR, 2);
-
- if (split.length >= 2)
+ if (bytes != null && bytes.length > 0)
{
- return split[0];
+ String dataString = new String(bytes, ENCODING);
+ String[] split = dataString.split(SEPARATOR, 2);
+
+ if (split.length >= 2)
+ {
+ return split[0];
+ }
+ else
+ {
+ return null;
+ }
}
-
- //if we could not find a type, then return null
- return null;
+ else
+ {
+ return null;
+ }
}
public static byte[] getInternalBytes(byte[] bytes) throws UnsupportedEncodingException
{
- String dataString = new String(bytes, ENCODING);
- String[] split = dataString.split(SEPARATOR, 3);
-
- if (split.length >= 3)
+ if (bytes != null && bytes.length > 0)
{
- String internalString = split[2];
- return internalString.getBytes(ENCODING);
+ String dataString = new String(bytes, ENCODING);
+ String[] split = dataString.split(SEPARATOR, 3);
+
+ if (split.length >= 3)
+ {
+ String internalString = split[2];
+ return internalString.getBytes(ENCODING);
+ }
+ else
+ {
+ //if we could not find the internal bytes, return null
+ return null;
+ }
}
else
{
- //if we could not find the internal bytes, return null
return null;
}
}
Modified: components/wsrp/trunk/producer/src/main/java/org/gatein/exports/impl/ExportManagerImpl.java
===================================================================
--- components/wsrp/trunk/producer/src/main/java/org/gatein/exports/impl/ExportManagerImpl.java 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/producer/src/main/java/org/gatein/exports/impl/ExportManagerImpl.java 2010-08-06 21:36:43 UTC (rev 3768)
@@ -77,28 +77,26 @@
return supportExportByValue;
}
- public ExportContext createExportContext(byte[] bytes)
+ public ExportContext createExportContext(byte[] bytes) throws OperationFailed
{
try
{
- String type = ExportData.getType(bytes);
- double version = ExportData.getVersion(bytes);
- if (ExportContext.TYPE.equals(type) && ExportContext.VERSION==version)
- {
- byte[] internalBytes = ExportData.getInternalBytes(bytes);
- return ExportContext.create(internalBytes);
- }
- else
- {
- //TODO: throw an error here about not being a recognized type
- throw new IllegalArgumentException("byte[] format unreconized.");
- }
+ String type = ExportData.getType(bytes);
+ double version = ExportData.getVersion(bytes);
+ if (ExportContext.TYPE.equals(type) && ExportContext.VERSION==version)
+ {
+ byte[] internalBytes = ExportData.getInternalBytes(bytes);
+ return ExportContext.create(internalBytes);
}
- catch (Exception e)
+ else
{
- e.printStackTrace();
- throw new NotYetImplemented();
+ throw WSRPExceptionFactory.createWSException(OperationFailed.class, "Byte array format not compatible.", null);
}
+ }
+ catch (UnsupportedEncodingException e)
+ {
+ throw WSRPExceptionFactory.createWSException(OperationFailed.class, "Could not decode the byte array.", e);
+ }
}
public ExportPortletData createExportPortletData(ExportContext exportContextData, String portletHandle,
@@ -107,7 +105,7 @@
return new ExportPortletData(portletHandle, portletState);
}
- public ExportPortletData createExportPortletData(ExportContext exportContextData, Lifetime lifetime, byte[] bytes)
+ public ExportPortletData createExportPortletData(ExportContext exportContextData, Lifetime lifetime, byte[] bytes) throws OperationFailed
{
try
{
@@ -120,14 +118,12 @@
}
else
{
- //TODO: throw an error here about not being a recognized type
- throw new IllegalArgumentException("byte[] format unreconized.");
+ throw WSRPExceptionFactory.createWSException(OperationFailed.class, "Bytes array format not compatible", null);
}
}
- catch (Exception e)
+ catch (UnsupportedEncodingException e)
{
- e.printStackTrace();
- throw new NotYetImplemented();
+ throw WSRPExceptionFactory.createWSException(OperationFailed.class, "Could not decode the byte array.", e);
}
}
Modified: components/wsrp/trunk/producer/src/main/java/org/gatein/wsrp/producer/PortletManagementHandler.java
===================================================================
--- components/wsrp/trunk/producer/src/main/java/org/gatein/wsrp/producer/PortletManagementHandler.java 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/producer/src/main/java/org/gatein/wsrp/producer/PortletManagementHandler.java 2010-08-06 21:36:43 UTC (rev 3768)
@@ -28,6 +28,8 @@
import org.gatein.common.NotYetImplemented;
import org.gatein.common.i18n.LocalizedString;
+import org.gatein.common.logging.Logger;
+import org.gatein.common.logging.LoggerFactory;
import org.gatein.exports.data.ExportContext;
import org.gatein.exports.data.ExportPortletData;
import org.gatein.pc.api.InvalidPortletIdException;
@@ -59,7 +61,6 @@
import org.oasis.wsrp.v2.ExportPortlets;
import org.oasis.wsrp.v2.ExportPortletsResponse;
import org.oasis.wsrp.v2.ExportedPortlet;
-import org.oasis.wsrp.v2.ExportNoLongerValid;
import org.oasis.wsrp.v2.Extension;
import org.oasis.wsrp.v2.FailedPortlets;
import org.oasis.wsrp.v2.GetPortletDescription;
@@ -100,7 +101,6 @@
import org.oasis.wsrp.v2.SetPortletsLifetimeResponse;
import org.oasis.wsrp.v2.UserContext;
-import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
@@ -120,10 +120,13 @@
private static final String GET_PORTLET_PROPERTIES = "GetPortletProperties";
private static final String PORTLET_CONTEXT = "PortletContext";
private static final String GET_PORTLET_DESCRIPTION = "GetPortletDescription";
+
+ private final Logger log;
PortletManagementHandler(WSRPProducerImpl producer)
{
super(producer);
+ log = LoggerFactory.getLogger(PortletManagementHandler.class);
}
public PortletDescriptionResponse getPortletDescription(GetPortletDescription getPortletDescription)
@@ -469,19 +472,30 @@
ExportByValueNotSupported, InconsistentParameters, InvalidHandle, InvalidRegistration, InvalidUserCategory,
MissingParameters, ModifyRegistrationRequired, OperationFailed, OperationNotSupported, ResourceSuspended
{
- WSRP2ExceptionFactory.throwOperationFailedIfValueIsMissing(exportPortlets, "ExportPortlets");
+ WSRP2ExceptionFactory.throwMissingParametersIfValueIsMissing(exportPortlets, "ExportPortlets", "ExportPortlets");
List<PortletContext> portletContexts = exportPortlets.getPortletContext();
- WSRP2ExceptionFactory.throwMissingParametersIfValueIsMissing(portletContexts, "PortletContext", "ExportPortlets");
-
+ if (portletContexts == null || portletContexts.isEmpty())
+ {
+ throw WSRP2ExceptionFactory.createWSException(MissingParameters.class, "Missing required portletContext in ExportPortlets.", null);
+ }
Registration registration = producer.getRegistrationOrFailIfInvalid(exportPortlets.getRegistrationContext());
UserContext userContext = exportPortlets.getUserContext();
checkUserAuthorization(userContext);
- boolean exportByValueRequired = exportPortlets.isExportByValueRequired();
+ boolean exportByValueRequired;
+ if (exportPortlets.isExportByValueRequired() != null)
+ {
+ exportByValueRequired = exportPortlets.isExportByValueRequired();
+ }
+ else
+ {
+ exportByValueRequired = false;
+ }
+
//check that the export manager can handle export by value
if (exportByValueRequired && !producer.getExportManager().supportExportByValue())
{
@@ -498,7 +512,7 @@
RegistrationLocal.setRegistration(registration);
//TODO: try catch here?
- ExportContext exportContext = producer.getExportManager().createExportContext(exportPortlets.isExportByValueRequired(), exportPortlets.getLifetime());
+ ExportContext exportContext = producer.getExportManager().createExportContext(exportByValueRequired, exportPortlets.getLifetime());
for (PortletContext portletContext : exportPortlets.getPortletContext())
{
@@ -530,76 +544,42 @@
exportedPortlets.add(exportedPortlet);
}
- //TODO: this is very messy, make this better
- catch (UnsupportedEncodingException e)
+ catch (Exception e)
{
- if(!failedPortletsMap.containsKey(e.getClass().toString()))
+ if (log.isWarnEnabled())
{
- List<String> portletHandles = new ArrayList<String>();
- portletHandles.add(portletContext.getPortletHandle());
-
- FailedPortlets failedPortlets = WSRPTypeFactory.createFailedPortlets(portletHandles, ErrorCodes.Codes.OPERATIONFAILED, "Error encoding the portlet for export.");
- failedPortletsMap.put(e.getClass().toString(), failedPortlets);
+ log.warn("Error occured while trying to export a portlet.", e);
}
- else
+
+ ErrorCodes.Codes errorCode;
+ String reason;
+ if (e instanceof NoSuchPortletException || e instanceof InvalidHandle)
{
- FailedPortlets failedPortlets = failedPortletsMap.get(e.getClass().toString());
- failedPortlets.getPortletHandles().add(portletContext.getPortletHandle());
+ errorCode = ErrorCodes.Codes.INVALIDHANDLE;
+ reason = "The specified portlet handle is invalid";
}
- }
- catch (NoSuchPortletException e)
- {
- if(!failedPortletsMap.containsKey(e.getClass().toString()))
+ else // default error message.
{
- List<String> portletHandles = new ArrayList<String>();
- portletHandles.add(portletContext.getPortletHandle());
-
- FailedPortlets failedPortlets = WSRPTypeFactory.createFailedPortlets(portletHandles, ErrorCodes.Codes.INVALIDHANDLE, "The specified porlet handle is invalid.");
- failedPortletsMap.put(e.getClass().toString(), failedPortlets);
+ errorCode = ErrorCodes.Codes.OPERATIONFAILED;
+ reason = "Error preparing portlet for export";
}
- else
+
+ if(!failedPortletsMap.containsKey(errorCode.name()))
{
- FailedPortlets failedPortlets = failedPortletsMap.get(e.getClass().toString());
- failedPortlets.getPortletHandles().add(portletContext.getPortletHandle());
- }
- }
- catch (InvalidHandle e)
- {
- if(!failedPortletsMap.containsKey(e.getClass().toString()))
- {
List<String> portletHandles = new ArrayList<String>();
portletHandles.add(portletContext.getPortletHandle());
- FailedPortlets failedPortlets = WSRPTypeFactory.createFailedPortlets(portletHandles, ErrorCodes.Codes.INVALIDHANDLE, "The specified portlet handle is invalid.");
- failedPortletsMap.put(e.getClass().toString(), failedPortlets);
+ FailedPortlets failedPortlets = WSRPTypeFactory.createFailedPortlets(portletHandles, errorCode, reason);
+ failedPortletsMap.put(errorCode.name(), failedPortlets);
}
else
{
- FailedPortlets failedPortlets = failedPortletsMap.get(e.getClass().toString());
+ FailedPortlets failedPortlets = failedPortletsMap.get(errorCode.name());
failedPortlets.getPortletHandles().add(portletContext.getPortletHandle());
}
}
- catch (Exception e)
- {
- if(!failedPortletsMap.containsKey(e.getClass().toString()))
- {
- List<String> portletHandles = new ArrayList<String>();
- portletHandles.add(portletContext.getPortletHandle());
-
- FailedPortlets failedPortlets = WSRPTypeFactory.createFailedPortlets(portletHandles, ErrorCodes.Codes.OPERATIONFAILED, "An exception occured when trying to export this portlet for export.");
- e.printStackTrace();
- failedPortletsMap.put(e.getClass().toString(), failedPortlets);
- }
- else
- {
- FailedPortlets failedPortlets = failedPortletsMap.get(e.getClass().toString());
- failedPortlets.getPortletHandles().add(portletContext.getPortletHandle());
- }
- }
}
-
-
//TODO: handle resourceLists better (should be using for things like errors)
ResourceList resourceList = null;
@@ -640,7 +620,15 @@
List<ImportedPortlet> importedPortlets = new ArrayList<ImportedPortlet>();
Map<String, ImportPortletsFailed> failedPortletsMap = new HashMap<String, ImportPortletsFailed>();
- ExportContext exportContext = producer.getExportManager().createExportContext(importContext);
+ ExportContext exportContext;
+ try
+ {
+ exportContext = producer.getExportManager().createExportContext(importContext);
+ }
+ catch (Exception e)
+ {
+ throw WSRPExceptionFactory.createWSException(OperationFailed.class, "Invalid ImportContext.", e);
+ }
for (ImportPortlet importPortlet : importPortletList)
{
@@ -665,19 +653,45 @@
}
catch (Exception e)
{
- e.printStackTrace();
- if(!failedPortletsMap.containsKey(e.getClass().toString()))
+ if (log.isWarnEnabled())
{
- List<String> importIds = new ArrayList<String>();
- importIds.add(importPortlet.getImportID());
+ log.warn("Error occured while trying to import a portlet.", e);
+ }
+
+ ErrorCodes.Codes errorCode;
+ String reason;
+ if (e instanceof NoSuchPortletException || e instanceof InvalidHandle)
+ {
+ errorCode = ErrorCodes.Codes.INVALIDHANDLE;
+ reason = "The specified portlet handle is invalid";
+ }
+ else if (e instanceof OperationFailed)
+ {
+ errorCode = ErrorCodes.Codes.OPERATIONFAILED;
+ reason = e.getMessage();
+ }
+ else if (e instanceof PortletInvokerException || e instanceof UnsupportedOperationException || e instanceof IllegalArgumentException)
+ {
+ errorCode = ErrorCodes.Codes.OPERATIONFAILED;
+ reason = "Error trying to create imported portlet.";
+ }
+ else // default error message.
+ {
+ errorCode = ErrorCodes.Codes.OPERATIONFAILED;
+ reason = "Error preparing portlet for export";
+ }
+
+ if(!failedPortletsMap.containsKey(errorCode.name()))
+ {
+ List<String> portleIDs = new ArrayList<String>();
+ portleIDs.add(importPortlet.getImportID());
- ImportPortletsFailed failedPortlets = WSRPTypeFactory.createImportPortletsFailed(importIds, ErrorCodes.Codes.OPERATIONFAILED, "The import portlet operation failed");
-
- failedPortletsMap.put(e.getClass().toString(), failedPortlets);
+ ImportPortletsFailed failedPortlets = WSRPTypeFactory.createImportPortletsFailed(portleIDs, errorCode, reason);
+ failedPortletsMap.put(errorCode.name(), failedPortlets);
}
else
{
- ImportPortletsFailed failedPortlets = failedPortletsMap.get(e.getClass().toString());
+ ImportPortletsFailed failedPortlets = failedPortletsMap.get(errorCode.name());
failedPortlets.getImportID().add(importPortlet.getImportID());
}
}
@@ -687,12 +701,6 @@
return WSRPTypeFactory.createImportPortletsResponse(importedPortlets, new ArrayList<ImportPortletsFailed>(failedPortletsMap.values()), resourceList);
}
- catch (Exception e)
- {
- //TODO: put proper error messages here
- e.printStackTrace();
- throw new NotYetImplemented();
- }
finally
{
RegistrationLocal.setRegistration(null);
@@ -711,8 +719,10 @@
}
catch (Exception e)
{
- //TODO: this method doesn't return anything, should we do more than just output the stacktrace?
- e.printStackTrace();
+ if (log.isWarnEnabled())
+ {
+ log.warn("Error occured while trying to perform a ReleaseExport", e);
+ }
}
//this method shouldn't return anything
Modified: components/wsrp/trunk/wsrp-producer-war/pom.xml
===================================================================
--- components/wsrp/trunk/wsrp-producer-war/pom.xml 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/wsrp-producer-war/pom.xml 2010-08-06 21:36:43 UTC (rev 3768)
@@ -417,11 +417,12 @@
<configuration>
<skip>${maven.test.skip}</skip>
<includes>
- <include>org/gatein/wsrp/protocol/v1/MarkupTestCase.class</include>
+ <include>org/gatein/wsrp/protocol/v1/MarkupTestCase.class</include>
<include>org/gatein/wsrp/protocol/v1/PortletManagementTestCase.class</include>
<include>org/gatein/wsrp/protocol/v1/ReleaseSessionTestCase.class</include>
<include>org/gatein/wsrp/protocol/v1/ServiceDescriptionTestCase.class</include>
<include>org/gatein/wsrp/protocol/v1/RegistrationTestCase.class</include>
+ <include>org/gatein/wsrp/protocol/v2/MarkupTestCase.class</include>
<!-- <include>org/gatein/wsrp/protocol/v2/ResourceTestCase.class</include> -->
<include>org/gatein/wsrp/protocol/v2/ServiceDescriptionTestCase.class</include>
<include>org/gatein/wsrp/protocol/v2/PortletManagementTestCase.class</include>
Modified: components/wsrp/trunk/wsrp-producer-war/src/test/java/org/gatein/wsrp/protocol/v2/PortletManagementTestCase.java
===================================================================
--- components/wsrp/trunk/wsrp-producer-war/src/test/java/org/gatein/wsrp/protocol/v2/PortletManagementTestCase.java 2010-08-06 19:39:29 UTC (rev 3767)
+++ components/wsrp/trunk/wsrp-producer-war/src/test/java/org/gatein/wsrp/protocol/v2/PortletManagementTestCase.java 2010-08-06 21:36:43 UTC (rev 3768)
@@ -22,11 +22,14 @@
******************************************************************************/
package org.gatein.wsrp.protocol.v2;
+import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
+import org.gatein.exports.ExportManager;
import org.gatein.exports.data.ExportContext;
import org.gatein.exports.data.ExportPortletData;
+import org.gatein.exports.impl.ExportManagerImpl;
import org.gatein.wsrp.WSRPTypeFactory;
import org.gatein.wsrp.producer.WSRPProducerBaseTest;
import org.gatein.wsrp.servlet.ServletAccess;
@@ -45,12 +48,19 @@
import org.oasis.wsrp.v2.ExportPortletsResponse;
import org.oasis.wsrp.v2.ExportedPortlet;
import org.oasis.wsrp.v2.FailedPortlets;
+import org.oasis.wsrp.v2.GetMarkup;
import org.oasis.wsrp.v2.ImportPortlet;
import org.oasis.wsrp.v2.ImportPortlets;
import org.oasis.wsrp.v2.ImportPortletsResponse;
+import org.oasis.wsrp.v2.ImportedPortlet;
+import org.oasis.wsrp.v2.InvalidRegistration;
import org.oasis.wsrp.v2.Lifetime;
+import org.oasis.wsrp.v2.MarkupResponse;
+import org.oasis.wsrp.v2.MissingParameters;
+import org.oasis.wsrp.v2.OperationFailed;
import org.oasis.wsrp.v2.PortletContext;
import org.oasis.wsrp.v2.RegistrationContext;
+import org.oasis.wsrp.v2.RegistrationData;
import org.oasis.wsrp.v2.UserContext;
/**
@@ -60,7 +70,7 @@
@RunWith(Arquillian.class)
public class PortletManagementTestCase extends NeedPortletHandleTest
{
- private static final String TEST_BASIC_PORTLET_WAR = "test-basic-portlet.war";
+ private static final String TEST_BASIC_PORTLET_WAR = "test-markup-portlet.war";
public PortletManagementTestCase() throws Exception
@@ -99,37 +109,18 @@
}
}
- /*TO TEST
- * - export
- * - import
- * - releaseExport
- * - test a valid setup that the producer is no longer holding any data
- * - test an invalid setup that we get back the proper errors
- * - test with invalid portlet handles
- * - setExportLifeTime
- * - test a valid setup that the export lifetime has been updated
- * - test an invalid setup that we get an error back
- * - use an invalid export context
- * - use an export context that is set to export by value
- * - invalid registration, usercontext, etc..
+ /*TODO:
+ * - tests usercontexts (not sure exactly what needs to be tested for this)
+ * - test portlet states
*/
@Test
public void testExport() throws Exception
- {
- boolean exportByValue = true;
- Lifetime lifetime = null;
- UserContext userContext = null;
- RegistrationContext registrationContext = null;
-
+ {
String handle = getDefaultHandle();
- PortletContext defaultContext = WSRPTypeFactory.createPortletContext(handle);
+ List<PortletContext> portletContexts = createPortletContextList(handle);
- List<PortletContext> portletContexts = new ArrayList<PortletContext>();
- portletContexts.add(defaultContext);
-
- ExportPortlets exportPortlets = WSRPTypeFactory.createExportPortlets(registrationContext, portletContexts, userContext, lifetime, exportByValue);
-
+ ExportPortlets exportPortlets = createSimpleExportPortlets(portletContexts);
ExportPortletsResponse response = producer.exportPortlets(exportPortlets);
assertNotNull(response.getExportContext());
@@ -164,14 +155,13 @@
assertTrue(failedPortlet.getPortletHandles().contains(nonExistantHandle));
assertEquals("InvalidHandle",failedPortlet.getErrorCode().getLocalPart());
- assertTrue(failedPortlet.getPortletHandles().contains(nonExistantHandle));
}
@Test
public void testExportNullHandle() throws Exception
{
- String nonExistantHandle = null;
- List<PortletContext> portletContexts = createPortletContextList(nonExistantHandle);
+ String nullHandle = null;
+ List<PortletContext> portletContexts = createPortletContextList(nullHandle);
ExportPortlets exportPortlets = createSimpleExportPortlets(portletContexts);
@@ -184,11 +174,122 @@
assertEquals(1, response.getFailedPortlets().size());
FailedPortlets failedPortlet = response.getFailedPortlets().get(0);
- assertTrue(failedPortlet.getPortletHandles().contains(nonExistantHandle));
+ assertTrue(failedPortlet.getPortletHandles().contains(nullHandle));
assertEquals("InvalidHandle",failedPortlet.getErrorCode().getLocalPart());
- assertTrue(failedPortlet.getPortletHandles().contains(nonExistantHandle));
}
+ @Test
+ public void testExportNullExportContext() throws Exception
+ {
+ ExportPortlets exportPortlets = new ExportPortlets();
+ try
+ {
+ ExportPortletsResponse response = producer.exportPortlets(exportPortlets);
+ ExtendedAssert.fail("Should have thrown a MissingParameters fault if no portlets passed for export.");
+ }
+ catch (MissingParameters e)
+ {
+ //expected
+ }
+ }
+
+ @Test
+ public void testExportNullExportPortlets() throws Exception
+ {
+ try
+ {
+ ExportPortletsResponse response = producer.exportPortlets(null);
+ ExtendedAssert.fail("Should have failed if sending a null exportPortlet object");
+ }
+ catch (MissingParameters e)
+ {
+ //expected
+ }
+ }
+
+ @Test
+ public void testExportNoRegistrationWhenRequired() throws Exception
+ {
+ producer.getConfigurationService().getConfiguration().getRegistrationRequirements().setRegistrationRequired(true);
+
+ String handle = getDefaultHandle();
+ List<PortletContext> portletContexts = createPortletContextList(handle);
+
+ ExportPortlets exportPortlets = createSimpleExportPortlets(portletContexts);
+
+ try
+ {
+ ExportPortletsResponse response = producer.exportPortlets(exportPortlets);
+ ExtendedAssert.fail("ImportPortlets should fail if registration is required and non is provided");
+ }
+ catch (InvalidRegistration e)
+ {
+ //expected
+ }
+ }
+
+ @Test
+ public void testExportRegistrationRequired() throws Exception
+ {
+ producer.getConfigurationService().getConfiguration().getRegistrationRequirements().setRegistrationRequired(true);
+
+ RegistrationData registrationData = WSRPTypeFactory.createRegistrationData("CONSUMER", true);
+ RegistrationContext registrationContext = producer.register(registrationData);
+
+
+ List<PortletContext> portletContexts = createPortletContextList(getDefaultHandle());
+
+ boolean exportByValueRequired = true;
+ Lifetime lifetime = null;
+ UserContext userContext = null;
+
+ ExportPortlets exportPortlets = WSRPTypeFactory.createExportPortlets(registrationContext, portletContexts, userContext, lifetime, exportByValueRequired);
+
+ ExportPortletsResponse response = producer.exportPortlets(exportPortlets);
+
+ assertNotNull(response.getExportContext());
+ assertNull(response.getLifetime());
+ assertTrue(response.getFailedPortlets().isEmpty());
+
+ assertEquals(1, response.getExportedPortlet().size());
+
+ ExportedPortlet exportPortlet = response.getExportedPortlet().get(0);
+
+ assertEquals(getDefaultHandle(), exportPortlet.getPortletHandle());
+ }
+
+ @Test
+ public void testExports() throws Exception
+ {
+ String nullHandle = null;
+ String nonExistantHandle = "123FakeHandle";
+ String handle = getDefaultHandle();
+ List<PortletContext> portletContexts = createPortletContextList(nullHandle, nonExistantHandle, handle);
+
+ ExportPortlets exportPortlets = createSimpleExportPortlets(portletContexts);
+
+ ExportPortletsResponse response = producer.exportPortlets(exportPortlets);
+
+ assertNotNull(response.getExportContext());
+ assertNull(response.getLifetime());
+ assertFalse(response.getExportedPortlet().isEmpty());
+ assertFalse(response.getFailedPortlets().isEmpty());
+
+ assertEquals(1, response.getExportedPortlet().size());
+
+ //Should provide the same error code and so should only produce on set of FailedPortlets
+ assertEquals(1, response.getFailedPortlets().size());
+
+ ExportedPortlet exportPortlet = response.getExportedPortlet().get(0);
+ assertEquals(handle, exportPortlet.getPortletHandle());
+
+ FailedPortlets failedPortlets = response.getFailedPortlets().get(0);
+ assertEquals("InvalidHandle",failedPortlets.getErrorCode().getLocalPart());
+ assertEquals(2, failedPortlets.getPortletHandles().size());
+ assertTrue(failedPortlets.getPortletHandles().contains(nullHandle));
+ assertTrue(failedPortlets.getPortletHandles().contains(nonExistantHandle));
+ }
+
protected List<PortletContext> createPortletContextList(String... portletHandles)
{
List<PortletContext> portletContexts = new ArrayList<PortletContext>();
@@ -212,15 +313,243 @@
return WSRPTypeFactory.createExportPortlets(registrationContext, portletContexts, userContext, lifetime, exportByValueRequired);
}
-
@Test
public void testImport() throws Exception
{
String importID = "foo";
+
+ List<String> portletList = new ArrayList<String>();
+ portletList.add(getDefaultHandle());
+ byte[] importContext = new ExportContext().encodeAsBytes();
- ExportPortletData exportPortletData = new ExportPortletData(getDefaultHandle(), null);
+ ImportPortlet importPortlet = createSimpleImportPortlet(importID, getDefaultHandle());
+
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+
+ assertEquals(1,response.getImportedPortlets().size());
+ ImportedPortlet portlet = response.getImportedPortlets().get(0);
+
+ assertEquals(importID, portlet.getImportID());
+
+ PortletContext portletContext = portlet.getNewPortletContext();
+ //check that we are getting a new portlet handle back and not the original one
+ ExtendedAssert.assertNotSame(getDefaultHandle(), portletContext.getPortletHandle());
+
+ //check that the new portlet handle is valid and we can access the portlet
+ GetMarkup markup = createMarkupRequest(portletContext.getPortletHandle());
+ MarkupResponse markupResponse = producer.getMarkup(markup);
+ assertNotNull(markupResponse.getMarkupContext());
+ assertEquals("<p>symbol unset stock value: value unset</p>", new String(markupResponse.getMarkupContext().getItemString()));
+ }
+
+ @Test
+ public void testImportNoRegistrationWhenRequired() throws Exception
+ {
+ producer.getConfigurationService().getConfiguration().getRegistrationRequirements().setRegistrationRequired(true);
+
+ String importID = "foo";
+
+ List<String> portletList = new ArrayList<String>();
+ portletList.add(getDefaultHandle());
+ byte[] importContext = new ExportContext().encodeAsBytes();
+
+ ImportPortlet importPortlet = createSimpleImportPortlet(importID, getDefaultHandle());
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+
+ try
+ {
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+ ExtendedAssert.fail("ImportPortlets should fail if registration is required and non is provided");
+ }
+ catch (InvalidRegistration e)
+ {
+ //expected
+ }
+ }
+
+ @Test
+ public void testImportRegistrationRequired() throws Exception
+ {
+ producer.getConfigurationService().getConfiguration().getRegistrationRequirements().setRegistrationRequired(true);
+ RegistrationData registrationData = WSRPTypeFactory.createRegistrationData("CONSUMER", true);
+ RegistrationContext registrationContext = producer.register(registrationData);
+
+ String importID = "foo";
+
+ Lifetime lifetime = null;
+ UserContext userContext = null;
+
+ List<String> portletList = new ArrayList<String>();
+ portletList.add(getDefaultHandle());
+ ExportContext exportContextData = new ExportContext();
+ byte[] importContext = exportContextData.encodeAsBytes();
+
+ ImportPortlet importPortlet = createSimpleImportPortlet(importID, getDefaultHandle());
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ ImportPortlets importPortlets = WSRPTypeFactory.createImportPortlets(registrationContext, importContext, importPortletsList, userContext, lifetime);
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+
+ assertEquals(1,response.getImportedPortlets().size());
+ ImportedPortlet portlet = response.getImportedPortlets().get(0);
+
+ assertEquals(importID, portlet.getImportID());
+
+ PortletContext portletContext = portlet.getNewPortletContext();
+ //check that we are getting a new portlet handle back and not the original one
+ ExtendedAssert.assertNotSame(getDefaultHandle(), portletContext.getPortletHandle());
+
+ //check that the new portlet handle is valid and we can access the portlet
+ GetMarkup markup = createMarkupRequest(portletContext.getPortletHandle());
+ markup.setRegistrationContext(registrationContext);
+
+ MarkupResponse markupResponse = producer.getMarkup(markup);
+ assertNotNull(markupResponse.getMarkupContext());
+ assertEquals("<p>symbol unset stock value: value unset</p>", new String(markupResponse.getMarkupContext().getItemString()));
+ }
+
+ @Test
+ public void testImportNullImportContext() throws Exception
+ {
+ String importId = "importInvalidPortletContext";
+
+ ImportPortlet importPortlet = createSimpleImportPortlet(importId, getDefaultHandle());
+
+ byte[] importContext = null;
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+
+ try
+ {
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+ ExtendedAssert.fail("Should have thrown an OperationFailedFault");
+ }
+ catch (OperationFailed e)
+ {
+ //expected
+ }
+ }
+
+ @Test
+ public void testImportInvalidImportContext() throws Exception
+ {
+ String importId = "importInvalidPortletContext";
+
+ ImportPortlet importPortlet = createSimpleImportPortlet(importId, getDefaultHandle());
+
+ byte[] importContext = new byte[]{1,2,3,'f','a','k','e'};
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+
+ try
+ {
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+ ExtendedAssert.fail("Should have thrown an OperationFailedFault");
+ }
+ catch (OperationFailed e)
+ {
+ //expected
+ }
+ }
+
+ @Test
+ public void testImportNullExportData() throws Exception
+ {
+ String importId = "nullExportData";
+
+ ImportPortlet importPortlet = new ImportPortlet();
+ importPortlet.setExportData(null);
+ importPortlet.setImportID(importId);
+
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ byte[] importContext = new ExportContext().encodeAsBytes();
+
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+
+ assertNotNull(response.getImportFailed());
+ assertEquals(1, response.getImportFailed().size());
+
+ assertEquals(importId, response.getImportFailed().get(0).getImportID().get(0));
+ assertEquals("OperationFailed", response.getImportFailed().get(0).getErrorCode().getLocalPart());
+ }
+
+ @Test
+ public void testImportInvalidExportData() throws Exception
+ {
+ String importId = "invalidExportData";
+
+ ImportPortlet importPortlet = new ImportPortlet();
+ importPortlet.setExportData("fake_export_data_123".getBytes());
+ importPortlet.setImportID(importId);
+
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ ExportContext exportContextData = new ExportContext();
+ byte[] importContext = exportContextData.encodeAsBytes();
+
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+
+ assertNotNull(response.getImportFailed());
+ assertEquals(1, response.getImportFailed().size());
+
+ assertEquals(importId, response.getImportFailed().get(0).getImportID().get(0));
+ assertEquals("OperationFailed", response.getImportFailed().get(0).getErrorCode().getLocalPart());
+ }
+
+ @Test
+ public void testImportNonExistantPortletData() throws Exception
+ {
+ String importId = "invalidExportData";
+
+ ExportManager exportManager = new ExportManagerImpl();
+ ExportPortletData exportPortletData = exportManager.createExportPortletData(null, "non_existant_portlet_handle", null);
byte[] exportData = exportPortletData.encodeAsBytes();
+ ImportPortlet importPortlet = WSRPTypeFactory.createImportPortlet(importId, exportData);
+
+ List<ImportPortlet> importPortletsList = createImportPortletList(importPortlet);
+
+ ExportContext exportContextData = new ExportContext();
+ byte[] importContext = exportContextData.encodeAsBytes();
+
+ ImportPortlets importPortlets = createSimpleImportPortlets(importContext, importPortletsList);
+
+ ImportPortletsResponse response = producer.importPortlets(importPortlets);
+
+ assertNotNull(response.getImportFailed());
+ assertEquals(1, response.getImportFailed().size());
+
+ assertEquals(importId, response.getImportFailed().get(0).getImportID().get(0));
+ assertEquals("InvalidHandle", response.getImportFailed().get(0).getErrorCode().getLocalPart());
+ }
+
+ @Test
+ public void testImports() throws Exception
+ {
+ String importID = "foo";
+ String nullImportID = "null";
+ String invalidImportID = "invalid";
+
+ ExportManager exportManager = new ExportManagerImpl();
+ ExportPortletData exportPortletData = exportManager.createExportPortletData(null, getDefaultHandle(), null);
+ byte[] exportData = exportPortletData.encodeAsBytes();
+
+ byte[] nullExportData = null;
+
+ ExportPortletData invalidExportPortletData = exportManager.createExportPortletData(null, "InvalidHandle", null);
+ byte[] invalidExportData = invalidExportPortletData.encodeAsBytes();
+
Lifetime lifetime = null;
UserContext userContext = null;
RegistrationContext registrationContext = null;
@@ -230,17 +559,64 @@
ExportContext exportContextData = new ExportContext();
byte[] importContext = exportContextData.encodeAsBytes();
- ImportPortlet importPortlet = WSRPTypeFactory.createImportPorlet(importID, exportData);
+ ImportPortlet nullPortlet = new ImportPortlet();
+ nullPortlet.setImportID(nullImportID);
+ nullPortlet.setExportData(nullExportData);
+ ImportPortlet importPortlet = WSRPTypeFactory.createImportPortlet(importID, exportData);
+ ImportPortlet invalidPortlet = WSRPTypeFactory.createImportPortlet(invalidImportID, invalidExportData);
List<ImportPortlet> importPortletsList = new ArrayList<ImportPortlet>();
+ importPortletsList.add(invalidPortlet);
importPortletsList.add(importPortlet);
+ importPortletsList.add(nullPortlet);
ImportPortlets importPortlets = WSRPTypeFactory.createImportPortlets(registrationContext, importContext, importPortletsList, userContext, lifetime);
ImportPortletsResponse response = producer.importPortlets(importPortlets);
+
+ assertEquals(2, response.getImportFailed().size());
+
+ assertEquals(1,response.getImportedPortlets().size());
+
+ ImportedPortlet portlet = response.getImportedPortlets().get(0);
+ assertEquals(importID, portlet.getImportID());
+
+ PortletContext portletContext = portlet.getNewPortletContext();
+ //check that we are getting a new portlet handle back and not the original one
+ ExtendedAssert.assertNotSame(getDefaultHandle(), portletContext.getPortletHandle());
+
+ //check that the new portlet handle is valid and we can access the portlet
+ GetMarkup markup = createMarkupRequest(portletContext.getPortletHandle());
+ MarkupResponse markupResponse = producer.getMarkup(markup);
+ assertNotNull(markupResponse.getMarkupContext());
+ assertEquals("<p>symbol unset stock value: value unset</p>", new String(markupResponse.getMarkupContext().getItemString()));
}
+ protected ImportPortlet createSimpleImportPortlet(String importId, String handle) throws UnsupportedEncodingException
+ {
+ ExportPortletData exportPortletData = new ExportPortletData(handle, null);
+ byte[] exportData = exportPortletData.encodeAsBytes();
+ return WSRPTypeFactory.createImportPortlet(importId, exportData);
+ }
+ protected List<ImportPortlet> createImportPortletList(ImportPortlet... importPortlets)
+ {
+ List<ImportPortlet> importPortletList = new ArrayList<ImportPortlet>();
+
+ for (ImportPortlet importPortlet : importPortlets)
+ {
+ importPortletList.add(importPortlet);
+ }
+ return importPortletList;
+ }
+ protected ImportPortlets createSimpleImportPortlets(byte[] importContext, List<ImportPortlet> importPortletsList)
+ {
+ Lifetime lifetime = null;
+ UserContext userContext = null;
+ RegistrationContext registrationContext = null;
+
+ return WSRPTypeFactory.createImportPortlets(registrationContext, importContext, importPortletsList, userContext, lifetime);
+ }
@Override
protected String getMostUsedPortletWARFileName()
More information about the gatein-commits
mailing list