Merge pull request #46 from geosolutions-it/master-45-featureTypeEncoder-attributes

Master 45 feature type encoder attributes

src/main/java/it/geosolutions/geoserver/rest/decoder/RESTFeatureType.java

@@ -27,6 +27,7 @@ package it.geosolutions.geoserver.rest.decoder;
 
 import it.geosolutions.geoserver.rest.decoder.utils.JDOMBuilder;
 import it.geosolutions.geoserver.rest.decoder.utils.JDOMListIterator;
+
 import java.util.Iterator;
 import org.jdom.Element;
 

src/main/java/it/geosolutions/geoserver/rest/decoder/RESTResource.java

@@ -26,6 +26,14 @@
 package it.geosolutions.geoserver.rest.decoder;
 
 import it.geosolutions.geoserver.rest.decoder.utils.JDOMBuilder;
+import it.geosolutions.geoserver.rest.encoder.feature.FeatureTypeAttribute;
+import it.geosolutions.geoserver.rest.encoder.feature.GSAttributeEncoder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import org.jdom.Element;
 import org.jdom.Namespace;
 
@@ -35,71 +43,154 @@ import org.jdom.Namespace;
  * @author etj
  */
 public class RESTResource {
-	protected final Element rootElem;
+    protected final Element rootElem;
 
     public static RESTResource build(String response) {
         Element elem = JDOMBuilder.buildElement(response);
-        return elem == null? null : new RESTCoverage(elem);
+        return elem == null ? null : new RESTCoverage(elem);
-	}
+    }
 
-	public RESTResource(Element resource) {
+    public RESTResource(Element resource) {
-		this.rootElem = resource;
+        this.rootElem = resource;
-	}
+    }
 
-	public String getName() {
+    public String getName() {
-		return rootElem.getChildText("name");
+        return rootElem.getChildText("name");
-	}
+    }
 
     public String getTitle() {
-		return rootElem.getChildText("title");
+        return rootElem.getChildText("title");
-	}
+    }
 
-	public String getNativeName() {
+    public String getNativeName() {
-		return rootElem.getChildText("nativeName");
+        return rootElem.getChildText("nativeName");
-	}
+    }
 
-	public String getAbstract() {
+    public String getAbstract() {
-		return rootElem.getChildText("abstract");
+        return rootElem.getChildText("abstract");
-	}
+    }
 
-	public String getNameSpace() {
+    public String getNameSpace() {
-		return rootElem.getChild("namespace").getChildText("name");
+        return rootElem.getChild("namespace").getChildText("name");
-	}
+    }
 
-	public String getStoreName() {
+    public String getStoreName() {
-		return rootElem.getChild("store").getChildText("name");
+        return rootElem.getChild("store").getChildText("name");
-	}
+    }
 
-	public String getStoreType() {
+    public String getStoreType() {
-		return rootElem.getChild("store").getAttributeValue("class");
+        return rootElem.getChild("store").getAttributeValue("class");
-	}
+    }
 
     public String getStoreUrl() {
-		Element store = rootElem.getChild("store");
+        Element store = rootElem.getChild("store");
-        Element atom = store.getChild("link", Namespace.getNamespace("atom", "http://www.w3.org/2005/Atom"));
+        Element atom = store.getChild("link",
+                Namespace.getNamespace("atom", "http://www.w3.org/2005/Atom"));
         return atom.getAttributeValue("href");
     }
 
-	public String getCRS() {
+    public String getCRS() {
-		Element elBBox = rootElem.getChild("latLonBoundingBox");
+        Element elBBox = rootElem.getChild("latLonBoundingBox");
-		return elBBox.getChildText("crs");
+        return elBBox.getChildText("crs");
-	}
+    }
 
-	protected double getLatLonEdge(String edge) {
+    protected double getLatLonEdge(String edge) {
-		Element elBBox = rootElem.getChild("latLonBoundingBox");
+        Element elBBox = rootElem.getChild("latLonBoundingBox");
-		return Double.parseDouble(elBBox.getChildText(edge));
+        return Double.parseDouble(elBBox.getChildText(edge));
-	}
+    }
 
-	public double getMinX() {
+    public double getMinX() {
-		return getLatLonEdge("minx");
+        return getLatLonEdge("minx");
-	}
+    }
-	public double getMaxX() {
+
-		return getLatLonEdge("maxx");
+    public double getMaxX() {
-	}
+        return getLatLonEdge("maxx");
-	public double getMinY() {
+    }
-		return getLatLonEdge("miny");
+
-	}
+    public double getMinY() {
-	public double getMaxY() {
+        return getLatLonEdge("miny");
-		return getLatLonEdge("maxy");
+    }
-	}
+
+    public double getMaxY() {
+        return getLatLonEdge("maxy");
+    }
+
+    public List<Map<FeatureTypeAttribute, String>> getAttributeList() {
+        List<Map<FeatureTypeAttribute, String>> attrsList = null;
+
+        final Element attrsRoot = rootElem.getChild("attributes");
+        final List<Element> attrs = attrsRoot.getChildren();
+        if (attrs != null) {
+            attrsList = new ArrayList<Map<FeatureTypeAttribute, String>>(attrs.size());
+            for (Element attr : attrs) {
+                Map<FeatureTypeAttribute, String> attrsMap = new HashMap<FeatureTypeAttribute, String>();
+                attrsList.add(attrsMap);
+                for (FeatureTypeAttribute at : FeatureTypeAttribute.values()) {
+                    String key = at.toString();
+                    attrsMap.put(at, attr.getChildText(key));
+                }
+            }
+        }
+        return attrsList;
+    }
+
+    public List<GSAttributeEncoder> getEncodedAttributeList() {
+        List<GSAttributeEncoder> attrsList = null;
+
+        final Element attrsRoot = rootElem.getChild("attributes");
+        final List<Element> attrs = attrsRoot.getChildren();
+        if (attrs != null) {
+            attrsList = new ArrayList<GSAttributeEncoder>(attrs.size());
+            for (Element attr : attrs) {
+                final GSAttributeEncoder attrEnc = new GSAttributeEncoder();
+                for (FeatureTypeAttribute at : FeatureTypeAttribute.values()) {
+                    String key = at.toString();
+                    attrEnc.setAttribute(at, attr.getChildText(key));
+                }
+                attrsList.add(attrEnc);
+            }
+
+        }
+        return attrsList;
+    }
+
+    // /**
+    // * @return the list of available attribute names
+    // */
+    // public List<String> getAttributeNames() {
+    // return getAttributes("name");
+    // }
+    //
+    // /**
+    // * @return a list of object which are String representation of Classes
+    // */
+    // public List<String> getAttributeBinding() {
+    // return getAttributes("binding");
+    // }
+
+    // /**
+    // * <attribute><br>
+    // * <name>NATION</name><br>
+    // * <minOccurs>0</minOccurs><br>
+    // * <maxOccurs>1</maxOccurs><br>
+    // * <nillable>true</nillable><br>
+    // * <binding>java.lang.Integer</binding><br>
+    // * <length>3</length><br>
+    // * </attribute><br>
+    // *
+    // * @param name
+    // * @return
+    // */
+    // private List<String> getAttributes(String name) {
+    // final Element attrsRoot = rootElem.getChild("attributes");
+    // final List<Element> attrs = attrsRoot.getChildren();
+    // List<String> attrNames = null;
+    // if (attrs != null) {
+    // attrNames = new ArrayList<String>(attrs.size());
+    // for (Element attr : attrs) {
+    // attrNames.add(attr.getChildText(name));
+    // }
+    // }
+    // return attrNames;
+    // }
 }

src/main/java/it/geosolutions/geoserver/rest/encoder/GSLayerEncoder.java

@@ -61,20 +61,20 @@ public class GSLayerEncoder extends PropertyXMLEncoder {
     		set("enabled","false");
     }
         
-    private final static String DESCRIPTION = "description";
+//    private final static String DESCRIPTION = "description";
-    /**
+//    /**
-     * Add the 'description' node with a text value from 'description'
+//     * Add the 'description' node with a text value from 'description'
-     * 
+//     * 
-     */
+//     */
-    protected void addDescription(final String description) {
+//    protected void addDescription(final String description) {
-        add(DESCRIPTION, description);
+//        add(DESCRIPTION, description);
-    }
+//    }
-    /**
+//    /**
-     * Set or modify the 'description' node with a text value from 'description'
+//     * Set or modify the 'description' node with a text value from 'description'
-     */
+//     */
-    public void setDescription(final String description) {
+//    public void setDescription(final String description) {
-        set(DESCRIPTION, description);
+//        set(DESCRIPTION, description);
-    }
+//    }
     
 //    queryable
     private final static String QUERYABLE = "queryable";

src/main/java/it/geosolutions/geoserver/rest/encoder/GSResourceEncoder.java

@@ -29,6 +29,7 @@ import it.geosolutions.geoserver.rest.encoder.coverage.GSCoverageEncoder;
 import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSDimensionInfoEncoder;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSFeatureDimensionInfoEncoder;
+import it.geosolutions.geoserver.rest.encoder.utils.ElementUtils;
 import it.geosolutions.geoserver.rest.encoder.utils.NestedElementEncoder;
 import it.geosolutions.geoserver.rest.encoder.utils.PropertyXMLEncoder;
 import it.geosolutions.geoserver.rest.encoder.utils.XmlElement;
@@ -188,7 +189,7 @@ public abstract class GSResourceEncoder
 	}
 
 	public String getName() {
-		final Element nameNode = get(NAME);
+		final Element nameNode = ElementUtils.contains(getRoot(), NAME, 1);
 		if (nameNode != null)
 			return nameNode.getText();
 		else

src/main/java/it/geosolutions/geoserver/rest/encoder/feature/FeatureTypeAttribute.java

@@ -0,0 +1,32 @@
+/*
+ *  GeoServer-Manager - Simple Manager Library for GeoServer
+ *  
+ *  Copyright (C) 2007,2012 GeoSolutions S.A.S.
+ *  http://www.geo-solutions.it
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package it.geosolutions.geoserver.rest.encoder.feature;
+
+/**
+ * Enumeration of featureType attribute members
+ */
+public enum FeatureTypeAttribute {
+    name, minOccurs, maxOccurs, nillable, binding, length
+}

src/main/java/it/geosolutions/geoserver/rest/encoder/feature/GSAttributeEncoder.java

@@ -0,0 +1,92 @@
+/*
+ *  GeoServer-Manager - Simple Manager Library for GeoServer
+ *  
+ *  Copyright (C) 2007,2012 GeoSolutions S.A.S.
+ *  http://www.geo-solutions.it
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package it.geosolutions.geoserver.rest.encoder.feature;
+
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.jdom.Element;
+import org.jdom.filter.Filter;
+
+import it.geosolutions.geoserver.rest.encoder.utils.ElementUtils;
+import it.geosolutions.geoserver.rest.encoder.utils.PropertyXMLEncoder;
+
+/**
+ * 
+ * @author carlo cancellieri - GeoSolutions
+ *
+ */
+public class GSAttributeEncoder extends PropertyXMLEncoder {
+    
+    public static class filterByName implements Filter {
+        
+        final private String key;
+        
+        public filterByName(String keyword){
+            this.key=keyword;
+        }
+        
+        private static final long serialVersionUID = 1L;
+
+        public boolean matches(Object obj) {
+                Element el=((Element) obj).getChild(FeatureTypeAttribute.name.toString());
+                if (el!=null && el.getTextTrim().equals(key)) {
+                        return true;
+                }
+                return false;
+        }
+    }
+    
+    public static Filter getFilterByName(String name){
+        return new filterByName(name);
+    }
+
+    public GSAttributeEncoder() {
+        super("attribute");
+    }
+    
+    public void setup(Map<FeatureTypeAttribute, String> attributes){
+        for (Entry<FeatureTypeAttribute,String> attr:attributes.entrySet()){
+            set(attr.getKey().toString(),attr.getValue());
+        }
+    }
+    
+    public void setAttribute(FeatureTypeAttribute type, String value){
+        set(type.toString(),value);
+    }
+    
+    public void delAttribute(FeatureTypeAttribute type){
+        ElementUtils.remove(this.getRoot(), get(type.toString()));
+    }
+    
+    public String getAttribute(FeatureTypeAttribute type){
+        Element el = get(type.toString());
+        if (el!=null)
+            return el.getTextTrim();
+        else
+            return null;
+    }
+}
+

src/main/java/it/geosolutions/geoserver/rest/encoder/feature/GSFeatureTypeEncoder.java

@@ -28,6 +28,8 @@ package it.geosolutions.geoserver.rest.encoder.feature;
 import it.geosolutions.geoserver.rest.encoder.GSResourceEncoder;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSFeatureDimensionInfoEncoder;
 
+import org.jdom.Element;
+
 /**
  * 
  * Encode a GeoServer resource as FeatureType
@@ -37,19 +39,53 @@ import it.geosolutions.geoserver.rest.encoder.metadata.GSFeatureDimensionInfoEnc
  */
 public class GSFeatureTypeEncoder extends GSResourceEncoder {
 
+    public final static String ATTRIBUTES = "attributes";
+
+    final private Element attributes = new Element(ATTRIBUTES);
+
     public GSFeatureTypeEncoder() {
         super("featureType");
+        addContent(attributes);
     }
 
     /**
-	 * @param key
+     * @param key
-	 * @param dimensionInfo
+     * @param dimensionInfo
-	 */
+     */
-	protected void addMetadata(String key, GSFeatureDimensionInfoEncoder dimensionInfo) {
+    protected void addMetadata(String key, GSFeatureDimensionInfoEncoder dimensionInfo) {
-		super.addMetadata(key, dimensionInfo);
+        super.addMetadata(key, dimensionInfo);
-	}
+    }
+
+    public void setMetadata(String key, GSFeatureDimensionInfoEncoder dimensionInfo) {
+        super.setMetadata(key, dimensionInfo);
+    }
+
+    /**
+     * delete a keyword from the list
+     * 
+     * @param keyword
+     * @return true if something is removed, false otherwise
+     */
+    public boolean delAttribute(final String keyword) {
+        final Element el = new Element("string");
+        el.setText(keyword);
+        return (attributes.removeContent(GSAttributeEncoder.getFilterByName(keyword))).size() == 0 ? false
+                : true;
+    }
+
+    /**
+     * @param attribute the attribute to add
+     */
+    protected void addAttribute(GSAttributeEncoder attribute) {
+        attributes.addContent(attribute.getRoot());
+    }
+
+    /**
+     * @param attribute the attribute to set (overriding an attribute with the same name if present)
+     */
+    public void setAttribute(GSAttributeEncoder attribute) {
+        delAttribute(attribute.getAttribute(FeatureTypeAttribute.name));
+        addAttribute(attribute);
+    }
     
-	public void setMetadata(String key, GSFeatureDimensionInfoEncoder dimensionInfo) {
-		super.setMetadata(key, dimensionInfo);
-	}
 }

src/main/java/it/geosolutions/geoserver/rest/encoder/utils/ElementUtils.java

@@ -93,7 +93,7 @@ public abstract class ElementUtils {
 			final Filter filter, final int depth)
 			throws IllegalArgumentException {
 
-		if (root == null || filter == null || depth < 0) {
+		if (root == null || filter == null) {
 			throw new IllegalArgumentException("Bad arguments: root=" + root
 					+ " filter=" + filter + " depth=" + depth);
 		}
@@ -106,7 +106,7 @@ public abstract class ElementUtils {
 			ret.add(root);
 		}
 		// check my children
-		if (depth > 1) {
+		if (depth != 0) {
 			final List<?> childrenList = root.getContent();
 			final Iterator<?> it = childrenList.iterator();
 			while (it.hasNext()) {
@@ -201,6 +201,18 @@ public abstract class ElementUtils {
 			return null;
 	}
 
+	
+	/**
+         * return the FIRST element with name equals to the passed key
+         * 
+         * @param root
+         * @param name
+         * @return
+         */
+        public static Element contains(final Element root, final String name){
+            return contains(root, name, -1);
+        }
+	
 	/**
 	 * return the FIRST element with name equals to the passed key
 	 * 
@@ -208,7 +220,7 @@ public abstract class ElementUtils {
 	 * @param name
 	 * @return
 	 */
-	public static Element contains(final Element root, final String name)
+	public static Element contains(final Element root, final String name, final int deep)
 			throws IllegalArgumentException {
 		if (root == null || name == null) {
 			throw new IllegalArgumentException("Bad arguments: root=" + root
@@ -228,7 +240,7 @@ public abstract class ElementUtils {
 				return false;
 			}
 		};
-		final Iterator<Element> it = search(root, filter).iterator();
+		final Iterator<Element> it = search(root, filter, deep).iterator();
 		if (it.hasNext())
 			return it.next();
 		else

src/main/java/it/geosolutions/geoserver/rest/encoder/utils/PropertyXMLEncoder.java

@@ -57,9 +57,9 @@ public class PropertyXMLEncoder extends XmlElement {
 		super(rootName);
 	}
 
-	protected void get(final String key, final String value) {
+	protected Element get(final String key, int deep) {
-
+            return get(getRoot(), key);
-	}
+        }
 	
 	protected Element get(final String key) {
 		return get(getRoot(), key);

src/test/java/it/geosolutions/geoserver/rest/ConfigTest.java

@@ -54,24 +54,24 @@ public class ConfigTest extends GeoserverRESTTest {
 
     private static final String DEFAULT_WS = "geosolutions";
 
-    @Test
+//    @Test
-    public void testEtj() throws FileNotFoundException, IOException {
+//    public void testEtj() throws FileNotFoundException, IOException {
-    	if(!enabled()){
+//    	if(!enabled()){
-    		LOGGER.info("Skipping test "+"testEtj"+"for class:"+this.getClass().getSimpleName());
+//    		LOGGER.info("Skipping test "+"testEtj"+"for class:"+this.getClass().getSimpleName());
-    		return;
+//    		return;
-    	}
+//    	}
-        deleteAll();
+//        deleteAll();
-
+//
-        assertTrue(reader.getWorkspaces().isEmpty());
+//        assertTrue(reader.getWorkspaces().isEmpty());
-        assertTrue(publisher.createWorkspace(DEFAULT_WS));
+//        assertTrue(publisher.createWorkspace(DEFAULT_WS));
-
+//
-        insertStyles();
+//        insertStyles();
-        insertExternalGeotiff();
+//        insertExternalGeotiff();
-        insertExternalShape();
+//        insertExternalShape();
-
+//
-        boolean ok = publisher.publishDBLayer(DEFAULT_WS, "pg_kids", "easia_gaul_0_aggr", "EPSG:4326", "default_polygon");
+//        boolean ok = publisher.publishDBLayer(DEFAULT_WS, "pg_kids", "easia_gaul_0_aggr", "EPSG:4326", "default_polygon");
-//        assertTrue(ok);
+////        assertTrue(ok);
-    }
+//    }
 
     @Test
     public void insertStyles() throws FileNotFoundException, IOException {
@@ -79,6 +79,8 @@ public class ConfigTest extends GeoserverRESTTest {
     		LOGGER.info("Skipping test "+"insertStyles"+"for class:"+this.getClass().getSimpleName());
     		return;
     	}
+    	deleteAllStyles();
+    	
         File sldDir = new ClassPathResource("testdata").getFile();
         for(File sldFile : sldDir.listFiles((FilenameFilter)new SuffixFileFilter(".sld"))) {
             LOGGER.info("Existing styles: " + reader.getStyles().getNames());
@@ -94,20 +96,31 @@ public class ConfigTest extends GeoserverRESTTest {
     		LOGGER.info("Skipping test "+"insertExternalGeotiff"+"for class:"+this.getClass().getSimpleName());
     		return;
     	}
+    	deleteAll();
+    	
         String storeName = "testRESTStoreGeotiff";
         String layerName = "resttestdem";
 
+        publisher.createWorkspace(DEFAULT_WS);
+        publisher.publishStyle(new File(new ClassPathResource("testdata").getFile(),"raster.sld"));
+        
         File geotiff = new ClassPathResource("testdata/resttestdem.tif").getFile();
         boolean pc = publisher.publishExternalGeoTIFF(DEFAULT_WS, storeName, geotiff, layerName,"EPSG:4326",ProjectionPolicy.FORCE_DECLARED,"raster");
         
         assertTrue(pc);
     }
+    
     @Test
     public void insertExternalShape() throws FileNotFoundException, IOException {
     	if(!enabled()){
     		LOGGER.info("Skipping test "+"insertExternalShape"+"for class:"+this.getClass().getSimpleName());
     		return;
     	}
+    	deleteAll();
+    	
+    	publisher.createWorkspace(DEFAULT_WS);
+    	publisher.publishStyle(new File(new ClassPathResource("testdata").getFile(),"default_point.sld"));
+    	
         File zipFile = new ClassPathResource("testdata/resttestshp.zip").getFile();
 
         boolean published = publisher.publishShp(DEFAULT_WS, "anyname", "cities", zipFile, "EPSG:41001", "default_point");

src/test/java/it/geosolutions/geoserver/rest/GeoserverRESTTest.java

@@ -37,8 +37,6 @@ import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.List;
 
-import junit.framework.TestCase;
-
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.slf4j.Logger;
@@ -47,76 +45,84 @@ import org.slf4j.LoggerFactory;
 /**
  * Initializes REST params.
  * <P>
- * <B>These tests are destructive, so you have to explicitly enable them</B>
+ * <B>These tests are destructive, so you have to explicitly enable them</B> by setting the env var <TT>resttest</TT> to <TT>true</TT>.
- * by setting the env var <TT>resttest</TT> to <TT>true</TT>.
  * <P>
- * The target geoserver instance can be customized by defining the following env vars: <ul>
+ * The target geoserver instance can be customized by defining the following env vars:
+ * <ul>
  * <LI><TT>resturl</TT> (default <TT>http://localhost:8080/geoserver</TT>)</LI>
  * <LI><TT>restuser</TT> (default: <TT>admin</TT>)</LI>
  * <LI><TT>restpw</TT> (default: <TT>geoserver</TT>)</LI>
  * </ul>
  * 
  * @author etj
+ * @author carlo cancellieri - GeoSolutions
  */
 public abstract class GeoserverRESTTest extends Assert {
     private final static Logger LOGGER = LoggerFactory.getLogger(GeoserverRESTTest.class);
 
-    protected static final String DEFAULT_WS = "geosolutions";
+    public static final String DEFAULT_WS = "geosolutions";
 
-	public static final String RESTURL;
+    public static final String RESTURL;
-	public static final String RESTUSER;
-	public static final String RESTPW;
 
-	public static URL URL;
+    public static final String RESTUSER;
-	public static GeoServerRESTManager manager;
+
-	public static GeoServerRESTReader reader;
+    public static final String RESTPW;
-	public static GeoServerRESTPublisher publisher;
+
+    public static URL URL;
+
+    public static GeoServerRESTManager manager;
+
+    public static GeoServerRESTReader reader;
+
+    public static GeoServerRESTPublisher publisher;
 
     private static boolean enabled = false;
+
     private static Boolean existgs = null;
 
-	static {
+    static {
-        RESTURL  = getenv("gsmgr_resturl",  "http://localhost:8080/geoserver");
+        RESTURL = getenv("gsmgr_resturl", "http://localhost:8080/geoserver");
         RESTUSER = getenv("gsmgr_restuser", "admin");
-        RESTPW   = getenv("gsmgr_restpw",   "geoserver");
+        RESTPW = getenv("gsmgr_restpw", "geoserver");
 
         // These tests will destroy data, so let's make sure we do want to run them
-        enabled  = getenv("gsmgr_resttest", "false").equalsIgnoreCase("true");
+        enabled = getenv("gsmgr_resttest", "false").equalsIgnoreCase("true");
-        if( ! enabled )
+        if (!enabled)
             LOGGER.warn("Tests are disabled. Please read the documentation to enable them.");
 
         try {
-        	URL = new URL(RESTURL);
+            URL = new URL(RESTURL);
-			manager = new GeoServerRESTManager(URL, RESTUSER, RESTPW);
+            manager = new GeoServerRESTManager(URL, RESTUSER, RESTPW);
-			reader = manager.getReader();
+            reader = manager.getReader();
-			publisher = manager.getPublisher();
+            publisher = manager.getPublisher();
-		} catch (MalformedURLException e) {
+        } catch (MalformedURLException e) {
-			e.printStackTrace();
+            e.printStackTrace();
-		}
+        }
-	}
+    }
 
     private static String getenv(String envName, String envDefault) {
         String env = System.getenv(envName);
         String ret = System.getProperty(envName, env);
         LOGGER.debug("env var " + envName + " is " + ret);
-        return ret != null? ret : envDefault;
+        return ret != null ? ret : envDefault;
     }
 
     @BeforeClass
     public static void setUp() throws Exception {
 
-
+        if (enabled) {
-        if(enabled) {
+            if (existgs == null) {
-            if(existgs == null) {
                 existgs = reader.existGeoserver();
-                if ( ! existgs ) {
+                if (!existgs) {
-                    LOGGER.error("TESTS WILL FAIL BECAUSE NO GEOSERVER WAS FOUND AT " + RESTURL + " ("+ RESTUSER+":"+RESTPW+")");
+                    LOGGER.error("TESTS WILL FAIL BECAUSE NO GEOSERVER WAS FOUND AT " + RESTURL
+                            + " (" + RESTUSER + ":" + RESTPW + ")");
                 } else {
-                    LOGGER.info("Using geoserver instance " + RESTUSER+":"+RESTPW+ " @ " + RESTURL);
+                    LOGGER.info("Using geoserver instance " + RESTUSER + ":" + RESTPW + " @ "
+                            + RESTURL);
                 }
             }
 
-            if ( ! existgs ) {
+            if (!existgs) {
                 System.out.println("Failing tests  : geoserver not found");
                 fail("GeoServer not found");
             }
@@ -141,7 +147,7 @@ public abstract class GeoserverRESTTest extends Assert {
         deleteAllDataStores();
 
         deleteAllWorkspaces();
-//        assertTrue("Some workspaces were not removed", reader.getWorkspaces().isEmpty());
+        // assertTrue("Some workspaces were not removed", reader.getWorkspaces().isEmpty());
 
         deleteAllStyles();
         assertTrue("Some styles were not removed", reader.getStyles().isEmpty());
@@ -160,7 +166,7 @@ public abstract class GeoserverRESTTest extends Assert {
             }
 
             boolean removed = publisher.removeLayerGroup(groupName);
-            LOGGER.info(sb.toString()+ ": removed: " + removed);
+            LOGGER.info(sb.toString() + ": removed: " + removed);
             assertTrue("LayerGroup not removed: " + groupName, removed);
         }
 
@@ -170,9 +176,9 @@ public abstract class GeoserverRESTTest extends Assert {
         List<String> layers = reader.getLayers().getNames();
         for (String layerName : layers) {
             RESTLayer layer = reader.getLayer(layerName);
-            if(layer.getType() == RESTLayer.Type.VECTOR)
+            if (layer.getType() == RESTLayer.Type.VECTOR)
                 deleteFeatureType(layer);
-            else if(layer.getType() == RESTLayer.Type.RASTER)
+            else if (layer.getType() == RESTLayer.Type.RASTER)
                 deleteCoverage(layer);
             else
                 LOGGER.error("Unknown layer type " + layer.getType());
@@ -186,7 +192,7 @@ public abstract class GeoserverRESTTest extends Assert {
             List<String> stores = reader.getCoverageStores(workspace).getNames();
 
             for (String storename : stores) {
-//                RESTCoverageStore store = reader.getCoverageStore(workspace, storename);
+                // RESTCoverageStore store = reader.getCoverageStore(workspace, storename);
 
                 LOGGER.warn("Deleting CoverageStore " + workspace + " : " + storename);
                 boolean removed = publisher.removeCoverageStore(workspace, storename, false);
@@ -201,12 +207,12 @@ public abstract class GeoserverRESTTest extends Assert {
             List<String> stores = reader.getDatastores(workspace).getNames();
 
             for (String storename : stores) {
-//                RESTDataStore store = reader.getDatastore(workspace, storename);
+                // RESTDataStore store = reader.getDatastore(workspace, storename);
 
-//                if(store.getType() == RESTDataStore.DBType.POSTGIS) {
+                // if(store.getType() == RESTDataStore.DBType.POSTGIS) {
-//                    LOGGER.info("Skipping PG datastore " + store.getWorkspaceName()+":"+store.getName());
+                // LOGGER.info("Skipping PG datastore " + store.getWorkspaceName()+":"+store.getName());
-//                    continue;
+                // continue;
-//                }
+                // }
 
                 LOGGER.warn("Deleting DataStore " + workspace + " : " + storename);
                 boolean removed = publisher.removeDatastore(workspace, storename, false);
@@ -218,9 +224,9 @@ public abstract class GeoserverRESTTest extends Assert {
     protected void deleteAllWorkspacesRecursively() {
         List<String> workspaces = reader.getWorkspaceNames();
         for (String workspace : workspaces) {
-                LOGGER.warn("Deleting Workspace " + workspace );
+            LOGGER.warn("Deleting Workspace " + workspace);
-                boolean removed = publisher.removeWorkspace(workspace,true);
+            boolean removed = publisher.removeWorkspace(workspace, true);
-                assertTrue("Workspace not removed " + workspace, removed );
+            assertTrue("Workspace not removed " + workspace, removed);
 
         }
     }
@@ -228,19 +234,19 @@ public abstract class GeoserverRESTTest extends Assert {
     protected void deleteAllWorkspaces() {
         List<String> workspaces = reader.getWorkspaceNames();
         for (String workspace : workspaces) {
-                LOGGER.warn("Deleting Workspace " + workspace );
+            LOGGER.warn("Deleting Workspace " + workspace);
-                boolean removed = publisher.removeWorkspace(workspace,true);
+            boolean removed = publisher.removeWorkspace(workspace, true);
-                assertTrue("Workspace not removed " + workspace, removed );
+            assertTrue("Workspace not removed " + workspace, removed);
 
         }
     }
 
-    private void deleteAllStyles() {
+    protected void deleteAllStyles() {
         List<String> styles = reader.getStyles().getNames();
         for (String style : styles) {
-                LOGGER.warn("Deleting Style " + style );
+            LOGGER.warn("Deleting Style " + style);
-                boolean removed = publisher.removeStyle(style);
+            boolean removed = publisher.removeStyle(style,true);
-                assertTrue("Style not removed " + style, removed );
+            assertTrue("Style not removed " + style, removed);
 
         }
     }
@@ -249,18 +255,14 @@ public abstract class GeoserverRESTTest extends Assert {
         RESTFeatureType featureType = reader.getFeatureType(layer);
         RESTDataStore datastore = reader.getDatastore(featureType);
 
-        LOGGER.warn("Deleting FeatureType"
+        LOGGER.warn("Deleting FeatureType" + datastore.getWorkspaceName() + " : "
-                + datastore.getWorkspaceName() + " : "
+                + datastore.getName() + " / " + featureType.getName());
-                + datastore.getName() + " / "
-                + featureType.getName()
-                );
 
-        boolean removed = publisher.unpublishFeatureType(datastore.getWorkspaceName(), datastore.getName(), layer.getName());
+        boolean removed = publisher.unpublishFeatureType(datastore.getWorkspaceName(),
-        assertTrue("FeatureType not removed:"
+                datastore.getName(), layer.getName());
-                + datastore.getWorkspaceName() + " : "
+        assertTrue(
-                + datastore.getName() + " / "
+                "FeatureType not removed:" + datastore.getWorkspaceName() + " : "
-                + featureType.getName(),
+                        + datastore.getName() + " / " + featureType.getName(), removed);
-                removed);
 
     }
 
@@ -268,19 +270,13 @@ public abstract class GeoserverRESTTest extends Assert {
         RESTCoverage coverage = reader.getCoverage(layer);
         RESTCoverageStore coverageStore = reader.getCoverageStore(coverage);
 
-        LOGGER.warn("Deleting Coverage "
+        LOGGER.warn("Deleting Coverage " + coverageStore.getWorkspaceName() + " : "
-                + coverageStore.getWorkspaceName() + " : "
+                + coverageStore.getName() + " / " + coverage.getName());
-                + coverageStore.getName() + " / "
-                + coverage.getName());
 
         boolean removed = publisher.unpublishCoverage(coverageStore.getWorkspaceName(),
-                                                        coverageStore.getName(),
+                coverageStore.getName(), coverage.getName());
-                                                        coverage.getName());
+        assertTrue("Coverage not deleted " + coverageStore.getWorkspaceName() + " : "
-        assertTrue("Coverage not deleted "
+                + coverageStore.getName() + " / " + coverage.getName(), removed);
-                + coverageStore.getWorkspaceName() + " : "
-                + coverageStore.getName() + " / "
-                + coverage.getName(),
-                removed);
     }
 
     protected boolean existsLayer(String layername) {

src/test/java/it/geosolutions/geoserver/rest/encoder/feature/GSFeatureEncoderTest.java

@@ -19,123 +19,199 @@
  */
 package it.geosolutions.geoserver.rest.encoder.feature;
 
+import it.geosolutions.geoserver.rest.GeoServerRESTPublisher;
+import it.geosolutions.geoserver.rest.decoder.RESTLayer;
+import it.geosolutions.geoserver.rest.decoder.RESTResource;
+import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder;
 import it.geosolutions.geoserver.rest.encoder.GSResourceEncoder;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSDimensionInfoEncoder;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSDimensionInfoEncoder.Presentation;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSDimensionInfoEncoder.PresentationDiscrete;
 import it.geosolutions.geoserver.rest.encoder.metadata.GSFeatureDimensionInfoEncoder;
 import it.geosolutions.geoserver.rest.encoder.utils.ElementUtils;
+import it.geosolutions.geoserver.rest.publisher.GeoserverRESTPublisherTest;
 
+import java.io.File;
+import java.io.IOException;
 import java.math.BigDecimal;
-
+import java.util.List;
-import junit.framework.TestCase;
 
 import org.jdom.Element;
 import org.junit.Assert;
 import org.junit.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.core.io.ClassPathResource;
 
 /**
  * 
  * @author ETj (etj at geo-solutions.it)
  * @author Carlo Cancellieri - carlo.cancellieri@geo-solutions.it
  */
-public class GSFeatureEncoderTest extends TestCase {
+public class GSFeatureEncoderTest extends GeoserverRESTPublisherTest {
-	protected final static Logger LOGGER = LoggerFactory.getLogger(GSFeatureEncoderTest.class);
+    protected final static Logger LOGGER = LoggerFactory.getLogger(GSFeatureEncoderTest.class);
 
-	@Test
+    @Test
-	public void testAll() {
+    public void testIntegration() throws IOException {
 
-		GSFeatureTypeEncoder encoder = new GSFeatureTypeEncoder();
+        if (!enabled())
-		encoder.addKeyword("KEYWORD_1");
+            return;
-		encoder.addKeyword("KEYWORD_2");
+        deleteAll();
-		encoder.addKeyword("...");
-		encoder.addKeyword("KEYWORD_N");
 
-		GSFeatureDimensionInfoEncoder dim2 = new GSFeatureDimensionInfoEncoder("ELE");
+        GeoServerRESTPublisher publisher = new GeoServerRESTPublisher(RESTURL, RESTUSER, RESTPW);
 
-    	if (LOGGER.isInfoEnabled())
+        String storeName = "resttestshp";
-    		LOGGER.info(encoder.toString());
+        String layerName = "cities";
 
-		encoder.addMetadata("elevation", dim2);
+        GSFeatureTypeEncoder fte = new GSFeatureTypeEncoder();
+        fte.setName(layerName + "_NEW");
+        fte.setTitle("title");
+        // fte.addKeyword("TODO");
+        fte.setNativeCRS("EPSG:4326");
+        fte.setDescription("desc");
+        fte.setEnabled(true);
 
-		dim2.setPresentation(PresentationDiscrete.DISCRETE_INTERVAL,
+        GSLayerEncoder layerEncoder = new GSLayerEncoder();
-				BigDecimal.valueOf(10));
+        layerEncoder.setEnabled(true);
+        layerEncoder.setQueryable(true);
 
-		Element el=ElementUtils.contains(encoder.getRoot(),GSDimensionInfoEncoder.PRESENTATION);
+        layerEncoder.setDefaultStyle("point");
-    	Assert.assertNotNull(el);
 
+        publisher.createWorkspace(DEFAULT_WS);
 
-    	LOGGER.info("contains_key:"+el.toString());
+        File zipFile = new ClassPathResource("testdata/resttestshp.zip").getFile();
 
-		dim2.setPresentation(PresentationDiscrete.DISCRETE_INTERVAL,
+        // test insert
-				BigDecimal.valueOf(12));
+        boolean published = publisher.publishShp(DEFAULT_WS, storeName, layerName, zipFile);
+        assertTrue("publish() failed", published);
+        assertTrue(existsLayer(layerName));
 
-		el=ElementUtils.contains(encoder.getRoot(),GSDimensionInfoEncoder.RESOLUTION);
+        publisher.publishStyle(new File(new ClassPathResource("testdata").getFile(),
-    	Assert.assertNotNull(el);
+                "default_point.sld"));
-    	Assert.assertEquals("12", el.getText());
 
-		dim2.setPresentation(Presentation.CONTINUOUS_INTERVAL);
+        // optionally select the attributes to publish
+        RESTLayer layer = reader.getLayer(layerName);
+        RESTResource resource = reader.getResource(layer);
+        List<GSAttributeEncoder> attrs = resource.getEncodedAttributeList();
+        assertNotNull(attrs);
+        for (GSAttributeEncoder enc : attrs) {
+            fte.setAttribute(enc);
+        }
 
+        assertTrue(publisher.publishDBLayer(DEFAULT_WS, storeName, fte, layerEncoder));
+    }
 
+    @Test
+    public void testFeatureTypeEncoder() {
 
-		encoder.setMetadata("time", new GSFeatureDimensionInfoEncoder("time"));
+        GSFeatureTypeEncoder encoder = new GSFeatureTypeEncoder();
+        encoder.addKeyword("KEYWORD_1");
+        encoder.addKeyword("KEYWORD_2");
+        encoder.addKeyword("...");
+        encoder.addKeyword("KEYWORD_N");
         
-		el=ElementUtils.contains(encoder.getRoot(),GSDimensionInfoEncoder.PRESENTATION);
+        encoder.setName("Layername");
-    	Assert.assertNotNull(el);
-    	el=ElementUtils.contains(encoder.getRoot(),GSDimensionInfoEncoder.RESOLUTION);
-    	Assert.assertNull(el);
         
-    	el=ElementUtils.contains(encoder.getRoot(),GSResourceEncoder.METADATA);
+        encoder.setTitle("title");
-    	Assert.assertNotNull(el);
+        encoder.addKeyword("TODO");
-    	LOGGER.info("contains_key:"+el.toString());
+        encoder.setNativeCRS("EPSG:4326");
+        encoder.setDescription("desc");
+        encoder.setEnabled(true);
 
-    	final boolean removed=ElementUtils.remove(encoder.getRoot(),el);
+        GSAttributeEncoder attribute = new GSAttributeEncoder();
-    	LOGGER.info("remove:"+removed);
+        attribute.setAttribute(FeatureTypeAttribute.name, "NAME");
-    	Assert.assertTrue(removed);
+        attribute.setAttribute(FeatureTypeAttribute.binding, "java.lang.String");
+        attribute.setAttribute(FeatureTypeAttribute.maxOccurs, "1");
+        attribute.setAttribute(FeatureTypeAttribute.minOccurs, "0");
+        attribute.setAttribute(FeatureTypeAttribute.nillable, "true");
         
-    	el=ElementUtils.contains(encoder.getRoot(),"metadata");
+        encoder.setAttribute(attribute);
-    	Assert.assertNull(el);
-    	if (el==null)
-    		LOGGER.info("REMOVED");
         
-	}
+        encoder.delAttribute("NAME");
         
-	@Test
+        attribute.setAttribute(FeatureTypeAttribute.name, "NEW_NAME");
-	public void testModifyFeature() {
-		GSFeatureTypeEncoder encoder = new GSFeatureTypeEncoder();
-		encoder.addKeyword("KEYWORD_1");
-		encoder.addKeyword("KEYWORD_2");
-		encoder.addKeyword("...");
-		encoder.addKeyword("KEYWORD_N");
         
-		Assert.assertTrue(encoder.delKeyword("KEYWORD_2"));
+        encoder.setAttribute(attribute);
-		Assert.assertFalse(encoder.delKeyword("KEYWORD_M"));
         
-		final GSFeatureDimensionInfoEncoder elevationDimension = new GSFeatureDimensionInfoEncoder("elevation_field");
+        // TODO encoder.getAttribute("NAME");
         
-//    	if (LOGGER.isInfoEnabled())
+        GSFeatureDimensionInfoEncoder dim2 = new GSFeatureDimensionInfoEncoder("ELE");
-//    		LOGGER.info(encoder.toString());
         
-		final String metadata="elevation";
+        encoder.addMetadata("elevation", dim2);
-		encoder.setMetadata(metadata, elevationDimension);
+        dim2.setPresentation(PresentationDiscrete.DISCRETE_INTERVAL, BigDecimal.valueOf(10));
+        Element el = ElementUtils.contains(encoder.getRoot(), GSDimensionInfoEncoder.PRESENTATION);
+        Assert.assertNotNull(el);
         
-		elevationDimension.setPresentation(PresentationDiscrete.DISCRETE_INTERVAL,
+        LOGGER.info("contains_key:" + el.toString());
-				BigDecimal.valueOf(10));
 
-		if (LOGGER.isInfoEnabled())
+        dim2.setPresentation(PresentationDiscrete.DISCRETE_INTERVAL, BigDecimal.valueOf(12));
-    		LOGGER.info(encoder.toString());
+        el = ElementUtils.contains(encoder.getRoot(), GSDimensionInfoEncoder.RESOLUTION);
+        Assert.assertNotNull(el);
+        Assert.assertEquals("12", el.getText());
 
-		Assert.assertTrue(encoder.delMetadata(metadata));
+        dim2.setPresentation(Presentation.CONTINUOUS_INTERVAL);
         
-		if (LOGGER.isInfoEnabled())
+        encoder.setMetadata("time", new GSFeatureDimensionInfoEncoder("time"));
-    		LOGGER.info(encoder.toString());
+        el = ElementUtils.contains(encoder.getRoot(), GSDimensionInfoEncoder.PRESENTATION);
+        Assert.assertNotNull(el);
+        el = ElementUtils.contains(encoder.getRoot(), GSDimensionInfoEncoder.RESOLUTION);
+        Assert.assertNull(el);
 
-    	final Element el=ElementUtils.contains(encoder.getRoot(),GSDimensionInfoEncoder.DIMENSIONINFO);
+        el = ElementUtils.contains(encoder.getRoot(), GSResourceEncoder.METADATA);
-    	Assert.assertNull(el);
+        Assert.assertNotNull(el);
-    	if (el==null)
+        LOGGER.info("contains_key:" + el.toString());
-    		LOGGER.info("REMOVED");
 
-	}
+        final boolean removed = ElementUtils.remove(encoder.getRoot(), el);
+        LOGGER.info("remove:" + removed);
+        Assert.assertTrue(removed);
+
+        el = ElementUtils.contains(encoder.getRoot(), "metadata");
+        Assert.assertNull(el);
+        if (el == null)
+            LOGGER.info("REMOVED");
+        
+        if (LOGGER.isInfoEnabled())
+            LOGGER.info(encoder.toString());
+
+        assertEquals(encoder.getName(),"Layername");
+    }
+
+    @Test
+    public void testModifyFeature() {
+        GSFeatureTypeEncoder encoder = new GSFeatureTypeEncoder();
+        encoder.addKeyword("KEYWORD_1");
+        encoder.addKeyword("KEYWORD_2");
+        encoder.addKeyword("...");
+        encoder.addKeyword("KEYWORD_N");
+
+        Assert.assertTrue(encoder.delKeyword("KEYWORD_2"));
+        Assert.assertFalse(encoder.delKeyword("KEYWORD_M"));
+
+        final GSFeatureDimensionInfoEncoder elevationDimension = new GSFeatureDimensionInfoEncoder(
+                "elevation_field");
+
+        // if (LOGGER.isInfoEnabled())
+        // LOGGER.info(encoder.toString());
+
+        final String metadata = "elevation";
+        encoder.setMetadata(metadata, elevationDimension);
+
+        elevationDimension.setPresentation(PresentationDiscrete.DISCRETE_INTERVAL,
+                BigDecimal.valueOf(10));
+
+        if (LOGGER.isInfoEnabled())
+            LOGGER.info(encoder.toString());
+
+        Assert.assertTrue(encoder.delMetadata(metadata));
+
+        if (LOGGER.isInfoEnabled())
+            LOGGER.info(encoder.toString());
+
+        final Element el = ElementUtils.contains(encoder.getRoot(),
+                GSDimensionInfoEncoder.DIMENSIONINFO);
+        Assert.assertNull(el);
+        if (el == null)
+            LOGGER.info("REMOVED");
+
+    }
 }

src/test/java/it/geosolutions/geoserver/rest/encoder/utils/ElementUtilsTest.java

@@ -63,7 +63,7 @@ public class ElementUtilsTest {
 	public void containsFilterDepthTest(){
 		LOGGER.info("STARTING-> containsFilterDepthTest");
 		
-		final List<Element> list=ElementUtils.search(this.root, filter, 1);
+		final List<Element> list=ElementUtils.search(this.root, filter, 0);
 		Assert.assertEquals(1,list.size());
 		
 		final List<Element> list2=ElementUtils.search(this.root, filter, 6);