continue working on ITCaseLdapCRUDControllerTest

Author: dcrissman

lightblue-ldap-config/src/main/java/com/redhat/lightblue/config/ldap/LdapControllerFactory.java

@@ -18,6 +18,8 @@
  */
 package com.redhat.lightblue.config.ldap;
 
+import java.util.HashSet;
+
 import com.redhat.lightblue.config.ControllerConfiguration;
 import com.redhat.lightblue.config.ControllerFactory;
 import com.redhat.lightblue.config.DataSourcesConfiguration;
@@ -27,8 +29,8 @@
 public class LdapControllerFactory implements ControllerFactory{
 
     public CRUDController createController(ControllerConfiguration cfg, DataSourcesConfiguration ds) {
-        return new LdapCRUDController(
-                new LdapDBResolver(ds.getDataSourcesByType(LdapDataSourceConfiguration.class)));
+        return new LdapCRUDController(new LdapDBResolver(
+                new HashSet<LdapDataSourceConfiguration>(ds.getDataSourcesByType(LdapDataSourceConfiguration.class).values())));
     }
 
 }

lightblue-ldap-config/src/main/java/com/redhat/lightblue/config/ldap/LdapDBResolver.java

@@ -18,7 +18,7 @@
  */
 package com.redhat.lightblue.config.ldap;
 
-import java.util.Map;
+import java.util.Set;
 
 import com.redhat.lightblue.common.ldap.DBResolver;
 import com.redhat.lightblue.common.ldap.LdapDataStore;
@@ -28,9 +28,9 @@
 
 public class LdapDBResolver implements DBResolver{
 
-    private final Map<String, LdapDataSourceConfiguration> ldapDataSources;
+    private final Set<LdapDataSourceConfiguration> ldapDataSources;
 
-    public LdapDBResolver(Map<String, LdapDataSourceConfiguration> ldapDataSources){
+    public LdapDBResolver(Set<LdapDataSourceConfiguration> ldapDataSources){
         this.ldapDataSources = ldapDataSources;
     }
 
@@ -43,11 +43,24 @@ public LDAPConnection get(DataStore store) throws LDAPException {
     }
 
     public LDAPConnection get(String database) throws LDAPException{
-        LdapDataSourceConfiguration cnf = ldapDataSources.get(database);
+        LdapDataSourceConfiguration cnf = findByDatabase(database);
         if(cnf == null){
             throw new IllegalArgumentException("No database for " + database);
         }
         return cnf.getLdapConnection();
     }
 
+    private LdapDataSourceConfiguration findByDatabase(String database){
+        if(database == null){
+            return null;
+        }
+
+        for(LdapDataSourceConfiguration cnf : ldapDataSources){
+            if(database.equals(cnf.getDatabaseName())){
+                return cnf;
+            }
+        }
+        return null;
+    }
+
 }

lightblue-ldap-config/src/test/java/com/redhat/lightblue/config/ldap/LdapDBResolverTest.java

@@ -18,7 +18,7 @@
  */
 package com.redhat.lightblue.config.ldap;
 
-import java.util.HashMap;
+import java.util.HashSet;
 
 import org.junit.Test;
 
@@ -28,7 +28,7 @@ public class LdapDBResolverTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void testGet_UnknownDatabase() throws LDAPException{
-        LdapDBResolver resolver = new LdapDBResolver(new HashMap<String, LdapDataSourceConfiguration>());
+        LdapDBResolver resolver = new LdapDBResolver(new HashSet<LdapDataSourceConfiguration>());
         resolver.get("Does Not Exist");
     }
 

lightblue-ldap-crud/src/main/java/com/redhat/lightblue/crud/ldap/LdapCRUDController.java

@@ -18,12 +18,15 @@
  */
 package com.redhat.lightblue.crud.ldap;
 
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.JsonNode;
 import com.redhat.lightblue.common.ldap.DBResolver;
 import com.redhat.lightblue.crud.CRUDController;
 import com.redhat.lightblue.crud.CRUDDeleteResponse;
@@ -34,7 +37,6 @@
 import com.redhat.lightblue.crud.CRUDUpdateResponse;
 import com.redhat.lightblue.crud.DocCtx;
 import com.redhat.lightblue.eval.FieldAccessRoleEvaluator;
-import com.redhat.lightblue.eval.Projector;
 import com.redhat.lightblue.hystrix.ldap.InsertCommand;
 import com.redhat.lightblue.metadata.EntityMetadata;
 import com.redhat.lightblue.metadata.MetadataListener;
@@ -43,6 +45,7 @@
 import com.redhat.lightblue.query.Sort;
 import com.redhat.lightblue.query.UpdateExpression;
 import com.redhat.lightblue.util.JsonDoc;
+import com.unboundid.ldap.sdk.Attribute;
 import com.unboundid.ldap.sdk.Entry;
 import com.unboundid.ldap.sdk.LDAPConnection;
 import com.unboundid.ldap.sdk.LDAPException;
@@ -53,6 +56,8 @@ public class LdapCRUDController implements CRUDController{
 
     private static final Logger LOGGER = LoggerFactory.getLogger(LdapCRUDController.class);
 
+    private static final String DN = "dn";
+
     private final DBResolver dbResolver;
 
     public LdapCRUDController(DBResolver dbResolver){
@@ -76,16 +81,44 @@ public CRUDInsertionResponse insert(CRUDOperationContext ctx,
                 projection,
                 roleEval.getExcludedFields(FieldAccessRoleEvaluator.Operation.insert));
 
-        Projector projector = null;
+        //TODO Revisit Projection
+        /*        Projector projector = null;
         if(combinedProjection != null){
             projector = Projector.getInstance(combinedProjection, md);
-        }
+        }*/
 
         try {
             LDAPConnection connection = dbResolver.get(md.getDataStore());
 
             for(DocCtx document : documents){
-                Entry entry = new Entry(""); //TODO populate Entry
+                //document.setOriginalDocument(document);
+                JsonNode rootNode = document.getRoot();
+                JsonNode dnNode = rootNode.get(DN);
+                if(dnNode == null){
+                    throw new IllegalArgumentException("dn is a required field");
+                }
+
+                Entry entry = new Entry(dnNode.asText());
+
+                Iterator<Map.Entry<String, JsonNode>> nodeIterator = rootNode.fields();
+                while(nodeIterator.hasNext()){
+                    Map.Entry<String, JsonNode> node = nodeIterator.next();
+                    if(DN.equalsIgnoreCase(node.getKey())){
+                        continue;
+                    }
+
+                    JsonNode valueNode = node.getValue();
+                    if(valueNode.isArray()){
+                        List<String> values = new ArrayList<String>();
+                        for(JsonNode string : valueNode){
+                            values.add(string.asText());
+                        }
+                        entry.addAttribute(new Attribute(node.getKey(), values));
+                    }
+                    else{
+                        entry.addAttribute(new Attribute(node.getKey(), node.getValue().asText()));
+                    }
+                }
 
                 InsertCommand command = new InsertCommand(connection, entry);
 
@@ -95,13 +128,13 @@ public CRUDInsertionResponse insert(CRUDOperationContext ctx,
                     continue;
                 }
 
-                if(projector != null){
+                /*if(projector != null){
                     JsonDoc jsonDoc = null; //TODO: actually populate field.
                     document.setOutputDocument(projector.project(jsonDoc, ctx.getFactory().getNodeFactory()));
                 }
-                else{
-                    document.setOutputDocument(new JsonDoc(new ObjectNode(ctx.getFactory().getNodeFactory())));
-                }
+                else{*/
+                //document.setOutputDocument(new JsonDoc(new ObjectNode(ctx.getFactory().getNodeFactory())));
+                //}
 
                 response.setNumInserted(response.getNumInserted() + 1);
             }

lightblue-ldap-crud/src/test/resources/crud/insert/insert-many.json

@@ -18,15 +18,18 @@
  */
 package com.redhat.lightblue.crud.ldap;
 
+import static com.redhat.lightblue.util.test.AbstractJsonNodeTest.loadJsonNode;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
 
 import java.io.IOException;
 
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ErrorCollector;
 
 import com.redhat.lightblue.DataError;
 import com.redhat.lightblue.Response;
@@ -36,11 +39,12 @@
 import com.redhat.lightblue.crud.InsertionRequest;
 import com.redhat.lightblue.ldap.test.LdapServerExternalResource;
 import com.redhat.lightblue.ldap.test.LdapServerExternalResource.InMemoryLdapServer;
+import com.redhat.lightblue.mediator.Mediator;
+import com.redhat.lightblue.metadata.EntityMetadata;
+import com.redhat.lightblue.metadata.Metadata;
 import com.redhat.lightblue.mongo.test.MongoServerExternalResource;
 import com.redhat.lightblue.mongo.test.MongoServerExternalResource.InMemoryMongoServer;
 import com.redhat.lightblue.util.Error;
-import com.redhat.lightblue.util.JsonUtils;
-import com.redhat.lightblue.util.test.AbstractJsonNodeTest;
 
 @InMemoryLdapServer
 @InMemoryMongoServer
@@ -52,18 +56,23 @@ public class ITCaseLdapCRUDControllerTest{
     @ClassRule
     public static MongoServerExternalResource mongoServer = new MongoServerExternalResource();
 
+    @Rule
+    public ErrorCollector collector = new ErrorCollector();
+
     public static LightblueFactory lightblueFactory;
 
     @BeforeClass
     public static void beforeClass() throws IOException {
         System.setProperty("ldap.host", "localhost");
         System.setProperty("ldap.port", String.valueOf(LdapServerExternalResource.DEFAULT_PORT));
+        System.setProperty("ldap.database", "test");
 
         System.setProperty("mongo.host", "localhost");
         System.setProperty("mongo.port", String.valueOf(MongoServerExternalResource.DEFAULT_PORT));
-        
+        System.setProperty("mongo.database", "lightblue");
+
         lightblueFactory = new LightblueFactory(
-                new DataSourcesConfiguration(AbstractJsonNodeTest.loadJsonNode("./datasources.json")));
+                new DataSourcesConfiguration(loadJsonNode("./datasources.json")));
     }
 
     @AfterClass
@@ -74,35 +83,32 @@ public static void after(){
     @Test
     public void testInsert() throws Exception{
         JsonTranslator tx = lightblueFactory.getJsonTranslator();
-        InsertionRequest insertIequest = tx.parse(InsertionRequest.class, JsonUtils.json("{}"));
-        Response response = lightblueFactory.getMediator().insert(insertIequest);
+
+        Metadata metadata = lightblueFactory.getMetadata();
+        metadata.createNewMetadata(tx.parse(EntityMetadata.class, loadJsonNode("./metadata/ldap-person-metadata.json")));
+
+        InsertionRequest insertIequest = tx.parse(InsertionRequest.class, loadJsonNode("./crud/insert/insert-single.json"));
+
+        Mediator mediator = lightblueFactory.getMediator();
+        Response response = mediator.insert(insertIequest);
 
         assertNotNull(response);
-        //assertNoErrors(response);
+        assertNoErrors(response);
+        assertEquals(1, response.getModifiedCount());
     }
 
     private void assertNoErrors(Response response){
-        if(response.getErrors().isEmpty() && response.getDataErrors().isEmpty()){
-            return;
+        for(Error error : response.getErrors()){
+            Exception e = new Exception(error.getMessage(), error);
+            e.printStackTrace();
+            collector.addError(e);
         }
 
-        StringBuilder builder = new StringBuilder();
-
-        if(!response.getErrors().isEmpty()){
-            builder.append("Response has Errors: \n");
-            for(Error error : response.getErrors()){
-                builder.append(error.toJson()+ "\n");
-            }
-        }
-
-        if(!response.getDataErrors().isEmpty()){
-            builder.append("Response has Data Errors: \n");
-            for(DataError error : response.getDataErrors()){
-                builder.append(error.toJson() + "\n");
-            }
+        for(DataError error : response.getDataErrors()){
+            Exception e = new Exception("DataError: " + error.toJson().asText());
+            e.printStackTrace();
+            collector.addError(e);
         }
-
-        fail(builder.toString());
     }
 
 }

lightblue-ldap-integration-test/src/test/java/com/redhat/lightblue/crud/ldap/ITCaseLdapCRUDControllerTest.java

@@ -0,0 +1,4 @@
+# set default isolation strategy for tests to SEMAPHORE else breakpoints in IDE
+# when debugging unit tests will timeout with default strategy (THREAD).
+hystrix.command.default.execution.isolation.strategy=SEMAPHORE
+

lightblue-ldap-integration-test/src/test/resources/config.properties

@@ -1,7 +1,7 @@
 {
     "ldap": {
         "type" : "com.redhat.lightblue.config.ldap.LdapDataSourceConfiguration",
-        "database" : "name of ldap server",
+        "database" : "${ldap.database}",
 
         "bindableDn" : "uid=admin,dc=example,dc=com",
         "password" : "password",
@@ -18,11 +18,11 @@
         "type" : "com.redhat.lightblue.mongo.config.MongoConfiguration",
          "metadataBackendParser" : "com.redhat.lightblue.metadata.mongo.MongoBackendParser",
         "ssl" : false,
-        "database" : "mongo",
+        "database" : "${mongo.database}",
         "servers" : [
             {
-                "host" : "${mongodb.host}",
-                "port" : "${mongodb.port}"
+                "host" : "${mongo.host}",
+                "port" : "${mongo.port}"
             }
         ]
    }

lightblue-ldap-integration-test/src/test/resources/datasources.json

@@ -1,5 +1,17 @@
 {
     "type" : "com.redhat.lightblue.mongo.config.MongoMetadataConfiguration",
     "dataSource" : "mongo",
-    "collection": "metadata"
+    "collection": "metadata",
+    "backendParsers": [
+        {
+            "name": "ldap",
+            "clazz": "com.redhat.lightblue.metadata.ldap.parser.LdapDataStoreParser"
+        }
+    ],
+    "propertyParsers": [
+        {
+            "name": "ldap",
+            "clazz": "com.redhat.lightblue.metadata.ldap.parser.LdapPropertyParser"
+        }
+    ]
 }

lightblue-ldap-integration-test/src/test/resources/lightblue-metadata.json

@@ -33,6 +33,7 @@ public DataStore parse(String name, MetadataParser<T> p, T node) {
         }
 
         LdapDataStore dataStore = new LdapDataStore();
+        dataStore.setDatabase(p.getRequiredStringProperty(node, "database"));
 
         return dataStore;
     }