Merge branch '1.0' into 1.0-tck-tests

Author: RagnarW

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

@@ -19,36 +19,40 @@
 package org.neo4j.driver.internal;
 
 
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-
 import org.neo4j.driver.internal.spi.Connection;
 import org.neo4j.driver.internal.value.NullValue;
 import org.neo4j.driver.v1.Record;
-import org.neo4j.driver.v1.Records;
 import org.neo4j.driver.v1.Statement;
 import org.neo4j.driver.v1.StatementResult;
 import org.neo4j.driver.v1.Value;
 import org.neo4j.driver.v1.exceptions.NoSuchRecordException;
 import org.neo4j.driver.v1.util.Pair;
 
+import static java.util.Arrays.asList;
+
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+
+import static org.neo4j.driver.v1.Records.column;
+import static org.neo4j.driver.v1.Values.ofString;
 import static org.neo4j.driver.v1.Values.value;
 
 public class InternalStatementResultTest
@@ -64,16 +68,20 @@ public void iterationShouldWorksAsExpected()
 
         // WHEN
         assertTrue( result.hasNext() );
-        assertThat( values( result.next() ), equalTo(Arrays.asList(value("v1-1"), value( "v2-1" ))));
+        assertThat( values( result.next() ), equalTo( asList(value("v1-1"), value( "v2-1" ))));
 
         assertTrue( result.hasNext() );
-        assertThat( values( result.next() ), equalTo(Arrays.asList(value("v1-2"), value( "v2-2" ))));
+        assertThat( values( result.next() ), equalTo( asList(value("v1-2"), value( "v2-2" ))));
 
         assertTrue( result.hasNext() ); //1 -> 2
 
         // THEN
-        assertThat( values( result.next() ), equalTo(Arrays.asList(value("v1-3"), value( "v2-3" ))));
+        assertThat( values( result.next() ), equalTo( asList(value("v1-3"), value( "v2-3" ))));
         assertFalse( result.hasNext() );
+
+        expectedException.expect( NoSuchRecordException.class );
+
+        // WHEN
         assertNull( result.next() );
     }
 
@@ -100,11 +108,16 @@ public void firstOfFieldIndexShouldWorkAsExpected()
     }
 
     @Test
-    public void singleAfterNextShouldWork()
+    public void singlePastFirstShouldFail()
     {
         // GIVEN
         StatementResult result = createResult( 2 );
         result.next();
+        result.next();
+
+
+        // THEN
+        expectedException.expect( NoSuchRecordException.class );
 
         // THEN
         result.single();
@@ -186,6 +199,84 @@ public void singleShouldThrowOnEmptyResult()
         createResult( 0 ).single();
     }
 
+    @Test
+    public void singleShouldThrowOnConsumedResult()
+    {
+        // Expect
+        expectedException.expect( NoSuchRecordException.class );
+
+        // When
+        StatementResult result = createResult( 2 );
+        result.consume();
+        result.single();
+    }
+
+    @Test
+    public void shouldConsumeTwice()
+    {
+        // GIVEN
+        StatementResult result = createResult( 2 );
+        result.consume();
+
+        // WHEN
+        result.consume();
+
+        // THEN
+        assertFalse( result.hasNext() );
+    }
+
+    @Test
+    public void shouldList()
+    {
+        // GIVEN
+        StatementResult result = createResult( 2 );
+        List<String> records = result.list( column( "k1", ofString() ) );
+
+        // THEN
+        assertThat( records, equalTo( asList( "v1-1", "v1-2" ) ) );
+    }
+
+    @Test
+    public void shouldListTwice()
+    {
+        // GIVEN
+        StatementResult result = createResult( 2 );
+        List<Record> firstList = result.list();
+        assertThat( firstList.size(), equalTo( 2 ) );
+
+        // THEN
+        List<Record> secondList = result.list();
+        assertThat( secondList.size(), equalTo( 0 ) );
+    }
+
+    @Test
+    public void singleShouldNotThrowOnPartiallyConsumedResult()
+    {
+        // Given
+        StatementResult result = createResult( 2 );
+        result.next();
+
+        // When + Then
+        assertNotNull( result.single() );
+    }
+
+    @Test
+    public void singleShouldConsumeIfFailing()
+    {
+        // Given
+        StatementResult result = createResult( 2 );
+
+        try
+        {
+            result.single();
+            fail( "Exception expected" );
+        }
+        catch ( NoSuchRecordException e )
+        {
+            assertFalse( result.hasNext() );
+        }
+    }
+
     @Test
     public void retainShouldWorkAsExpected()
     {
@@ -207,7 +298,7 @@ public void retainAndMapByKeyShouldWorkAsExpected()
         StatementResult result = createResult( 3 );
 
         // WHEN
-        List<Value> records = result.list( Records.column( "k1" ) );
+        List<Value> records = result.list( column( "k1" ) );
 
         // THEN
         assertFalse(result.hasNext());
@@ -221,7 +312,7 @@ public void retainAndMapByIndexShouldWorkAsExpected()
         StatementResult result = createResult( 3 );
 
         // WHEN
-        List<Value> records = result.list( Records.column( 0 ) );
+        List<Value> records = result.list( column( 0 ) );
 
         // THEN
         assertFalse(result.hasNext());
@@ -254,7 +345,7 @@ public void accessingKeysWithoutCallingNextShouldNotFail()
         // not calling next or single
 
         // THEN
-        assertThat( result.keys(), equalTo( Arrays.asList( "k1", "k2" ) ) );
+        assertThat( result.keys(), equalTo( asList( "k1", "k2" ) ) );
     }
 
     @Test
@@ -276,18 +367,23 @@ public void shouldPeekIntoTheFuture()
         result.next();
 
         // THEN
-        assertNull( result.peek() );
+        expectedException.expect( NoSuchRecordException.class );
+
+        // WHEN
+        result.peek();
     }
 
     @Test
     public void shouldNotPeekIntoTheFutureWhenResultIsEmpty()
     {
         // GIVEN
         StatementResult result = createResult( 0 );
-        Record future = result.peek();
+
+        // THEN
+        expectedException.expect( NoSuchRecordException.class );
 
         // WHEN
-        assertNull( future );
+        Record future = result.peek();
     }
 
     private StatementResult createResult( int numberOfRecords )