Merge pull request #140 from pontusmelke/1.0-order-keys

Preserve order in Extract.map

Author: jakewins

driver/src/main/java/org/neo4j/driver/internal/util/Extract.java

@@ -20,16 +20,16 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.neo4j.driver.internal.InternalPair;
-import org.neo4j.driver.v1.util.Function;
-import org.neo4j.driver.v1.types.MapAccessor;
-import org.neo4j.driver.v1.util.Pair;
 import org.neo4j.driver.v1.Record;
 import org.neo4j.driver.v1.Value;
+import org.neo4j.driver.v1.types.MapAccessor;
+import org.neo4j.driver.v1.util.Function;
+import org.neo4j.driver.v1.util.Pair;
 
 import static java.util.Collections.emptyList;
 import static java.util.Collections.emptyMap;
@@ -102,7 +102,7 @@ public static <T> Map<String, T> map( Map<String, Value> data, Function<Value, T
                 Map.Entry<String, Value> head = data.entrySet().iterator().next();
                 return singletonMap( head.getKey(), mapFunction.apply( head.getValue() ) );
             } else {
-                Map<String, T> map = new HashMap<>( size );
+                Map<String, T> map = new LinkedHashMap<>( size );
                 for ( Map.Entry<String, Value> entry : data.entrySet() )
                 {
                     map.put( entry.getKey(), mapFunction.apply( entry.getValue() ) );
@@ -124,7 +124,7 @@ public static <T> Map<String, T> map( Record record, Function<Value, T> mapFunct
                 return singletonMap( record.keys().get( 0 ), mapFunction.apply( record.get( 0 ) ) );
 
             default:
-                Map<String, T> map = new HashMap<>( size );
+                Map<String, T> map = new LinkedHashMap<>( size );
                 List<String> keys = record.keys();
                 for ( int i = 0; i < size; i++ )
                 {

driver/src/test/java/org/neo4j/driver/internal/ExtractTest.java

@@ -27,27 +27,29 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.util.Extract;
 import org.neo4j.driver.v1.Statement;
+import org.neo4j.driver.v1.Value;
 import org.neo4j.driver.v1.Values;
 import org.neo4j.driver.v1.util.Function;
 import org.neo4j.driver.v1.util.Pair;
-import org.neo4j.driver.v1.Value;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.singletonList;
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.empty;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
-import static org.neo4j.driver.v1.Values.value;
 import static org.neo4j.driver.v1.Values.ofValue;
+import static org.neo4j.driver.v1.Values.value;
 
 public class ExtractTest
 {
@@ -125,6 +127,23 @@ public void testMapValues() throws Exception
 
     }
 
+    @Test
+    public void testShouldPreserveMapOrderMapValues() throws Exception
+    {
+        // GIVEN
+        Map<String,Value> map = new LinkedHashMap<>();
+        map.put( "k2", value( 43 ) );
+        map.put( "k1", value( 42 ) );
+
+        // WHEN
+        Map<String,Integer> mappedMap = Extract.map( map, integerExtractor() );
+
+        // THEN
+        Collection<Integer> values = mappedMap.values();
+        assertThat( values, contains( 43, 42) );
+
+    }
+
     @Test
     public void testProperties() throws Exception
     {

driver/src/test/java/org/neo4j/driver/internal/InternalRecordTest.java

@@ -21,6 +21,7 @@
 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -31,6 +32,7 @@
 import org.neo4j.driver.v1.util.Function;
 
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
@@ -143,11 +145,36 @@ public Integer apply( Value value )
         Map<String,Integer> map = Extract.map( record, addOne );
 
         // THEN
-        assertThat( map.keySet(), containsInAnyOrder( "k1", "k2" ) );
+        assertThat( map.keySet(), contains( "k1", "k2" ) );
         assertThat( map.get( "k1" ), equalTo( 1 ) );
         assertThat( map.get( "k2" ), equalTo( 2 ) );
     }
 
+    @Test
+    public void mapExtractionShouldPreserveIterationOrder()
+    {
+        // GIVEN
+        List<String> keys = Arrays.asList( "k2", "k1" );
+        InternalRecord record =  new InternalRecord( keys, new Value[]{value( 0 ), value( 1 )} );
+        Function<Value,Integer> addOne = new Function<Value,Integer>()
+        {
+            @Override
+            public Integer apply( Value value )
+            {
+                return value.asInt() + 1;
+            }
+        };
+
+        // WHEN
+        Map<String,Integer> map = Extract.map( record, addOne );
+
+        // THEN
+        assertThat( map.keySet(), contains( "k2", "k1" )  );
+        Iterator<Integer> values = map.values().iterator();
+        assertThat( values.next(), equalTo( 1 ) );
+        assertThat( values.next(), equalTo( 2 ) );
+    }
+
     @Test
     public void testToString()
     {