add unit tests for EntryBuilder

Author: dcrissman

lightblue-ldap-crud/src/test/java/com/redhat/lightblue/crud/ldap/EntryBuilderTest.java

@@ -22,6 +22,8 @@
 import static com.redhat.lightblue.util.test.AbstractJsonNodeTest.loadResource;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -35,52 +37,17 @@
 import org.junit.runners.Parameterized.Parameters;
 
 import com.redhat.lightblue.common.ldap.LdapConstant;
+import com.redhat.lightblue.common.ldap.LightblueUtil;
 import com.redhat.lightblue.metadata.EntityMetadata;
 import com.redhat.lightblue.metadata.types.DateType;
 import com.redhat.lightblue.test.MetadataUtil;
 import com.redhat.lightblue.util.JsonDoc;
 import com.unboundid.ldap.sdk.Entry;
 import com.unboundid.util.StaticUtils;
 
-@RunWith(value = Parameterized.class)
 public class EntryBuilderTest {
 
-    private final static Date now = new Date();
-
-    @Parameters(name= "{index}: {0}")
-    public static Collection<Object[]> data() {
-        return Arrays.asList(new Object[][] {
-                {"{\"type\": \"string\"}", quote("teststring"), "teststring"},
-                {"{\"type\": \"integer\"}", "4", null},
-                {"{\"type\": \"boolean\"}", "true", null},
-                {"{\"type\": \"date\"}", quote(DateType.getDateFormat().format(now)), StaticUtils.encodeGeneralizedTime(now)},
-                {"{\"type\": \"binary\"}", quote(DatatypeConverter.printBase64Binary("test binary data".getBytes())), "test binary data"},
-                {"{\"type\": \"array\", \"items\": {\"type\": \"string\"}}", "[\"hello\",\"world\"]", new String[]{"hello", "world"}},
-                {"{\"type\": \"array\", \"items\": {\"type\": \"binary\"}}",
-                    "[" + quote(DatatypeConverter.printBase64Binary("hello".getBytes())) + ","
-                            + quote(DatatypeConverter.printBase64Binary("world".getBytes())) + "]",
-                            new String[]{"hello", "world"}
-                },
-        });
-    }
-
-    private static String quote(String text){
-        return '"' + text + '"';
-    }
-
-    private final String fieldName = "testfield";
-    private final String metadataType;
-    private final String crudValue;
-    private final Object expectedValue;
-
-    public EntryBuilderTest(String metadataType, String crudValue, Object expectedValue){
-        this.metadataType = metadataType;
-        this.crudValue = crudValue;
-        this.expectedValue = (expectedValue == null) ? crudValue : expectedValue;
-    }
-
-    @Test
-    public void test() throws Exception{
+    protected static Entry buildEntry(String fieldName, String metadataType, String crudValue) throws Exception{
         String metadata = loadResource("./metadata/entryBuilderTest-metadata-template.json")
                 .replaceFirst("#fieldname", fieldName)
                 .replaceFirst("#type", metadataType);
@@ -91,15 +58,104 @@ public void test() throws Exception{
         EntityMetadata md = MetadataUtil.createEntityMetadata(LdapConstant.BACKEND, json(metadata), null, null);
         EntryBuilder builder = new EntryBuilder(md);
 
-        Entry entry = builder.build("uid=someuid,dc=example,dc=com",
+        return builder.build("uid=someuid,dc=example,dc=com",
                 new JsonDoc(json(crud).get("data")));
+    }
+
+    protected static String quote(String text){
+        return '"' + text + '"';
+    }
+
+    public static class SpecializedTests {
+
+        @Test
+        public void testFieldIsObjectType() throws Exception{
+            Entry entry = buildEntry(LightblueUtil.FIELD_OBJECT_TYPE, "{\"type\": \"string\"}", quote("someEntity"));
+
+            assertNotNull(entry);
+            assertNull(entry.getAttribute(LightblueUtil.FIELD_OBJECT_TYPE));
+        }
 
-        if(expectedValue.getClass().isArray()){
-            assertArrayEquals((String[]) expectedValue, entry.getAttributeValues("testfield"));
+        /**
+         * This test is kind of hacky as it requires json injection in order to make it work because
+         * it requires two fields.
+         */
+        @Test
+        public void testFieldIsArrayField() throws Exception{
+            String arrayFieldName = "someArray";
+            String arrayCountFieldName = LightblueUtil.createArrayCountFieldName(arrayFieldName);
+            Entry entry = buildEntry(
+                    arrayCountFieldName,
+                    "{\"type\": \"integer\"}, " + quote(arrayFieldName) + ": {\"type\": \"array\", \"items\": {\"type\": \"string\"}}",
+                    "2");
+
+            assertNotNull(entry);
+            assertNull(entry.getAttribute(arrayFieldName));
         }
-        else{
-            assertEquals(expectedValue, entry.getAttributeValue("testfield"));
+
+        @Test
+        public void testFieldIsArrayFieldWithoutMatchArray() throws Exception{
+            String arrayCountFieldName = LightblueUtil.createArrayCountFieldName("someArray");
+            Entry entry = buildEntry(arrayCountFieldName, "{\"type\": \"integer\"}", "2");
+
+            assertNotNull(entry);
+            assertNotNull(entry.getAttribute(arrayCountFieldName));
+        }
+
+        @Test(expected = IllegalArgumentException.class)
+        public void testFieldIsDN() throws Exception{
+            buildEntry(LdapConstant.FIELD_DN, "{\"type\": \"string\"}", quote("uid=someuid,dc=example,dc=com"));
+        }
+
+    }
+
+    @RunWith(value = Parameterized.class)
+    public static class ParameterizedTests {
+
+        private final static Date now = new Date();
+
+        @Parameters(name= "{index}: {0}")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][] {
+                    {"{\"type\": \"string\"}", quote("teststring"), "teststring"},
+                    {"{\"type\": \"integer\"}", "4", null},
+                    {"{\"type\": \"boolean\"}", "true", null},
+                    {"{\"type\": \"date\"}", quote(DateType.getDateFormat().format(now)), StaticUtils.encodeGeneralizedTime(now)},
+                    {"{\"type\": \"binary\"}", quote(DatatypeConverter.printBase64Binary("test binary data".getBytes())), "test binary data"},
+                    {"{\"type\": \"array\", \"items\": {\"type\": \"string\"}}", "[\"hello\",\"world\"]", new String[]{"hello", "world"}},
+                    {"{\"type\": \"array\", \"items\": {\"type\": \"binary\"}}",
+                        "[" + quote(DatatypeConverter.printBase64Binary("hello".getBytes())) + ","
+                                + quote(DatatypeConverter.printBase64Binary("world".getBytes())) + "]",
+                                new String[]{"hello", "world"}
+                    },
+            });
         }
+
+        private final String fieldName = "testfield";
+        private final String metadataType;
+        private final String crudValue;
+        private final Object expectedValue;
+
+        public ParameterizedTests(String metadataType, String crudValue, Object expectedValue){
+            this.metadataType = metadataType;
+            this.crudValue = crudValue;
+            this.expectedValue = (expectedValue == null) ? crudValue : expectedValue;
+        }
+
+        @Test
+        public void test() throws Exception{
+            Entry entry = buildEntry(fieldName, metadataType, crudValue);
+
+            assertNotNull(entry);
+
+            if(expectedValue.getClass().isArray()){
+                assertArrayEquals((String[]) expectedValue, entry.getAttributeValues("testfield"));
+            }
+            else{
+                assertEquals(expectedValue, entry.getAttributeValue("testfield"));
+            }
+        }
+
     }
 
 }