Added conditional test so it runs with 3.0.X

Author: pontusmelke

driver/src/main/java/org/neo4j/driver/internal/summary/SummaryBuilder.java

@@ -43,8 +43,8 @@ public class SummaryBuilder implements StreamCollector
     private Plan plan = null;
     private ProfiledPlan profile;
     private List<Notification> notifications = null;
-    private long resultAvailableAfter;
-    private long resultConsumedAfter;
+    private long resultAvailableAfter = -1L;
+    private long resultConsumedAfter = -1L;
 
     public SummaryBuilder( Statement statement )
     {

driver/src/test/java/org/neo4j/driver/v1/integration/SessionIT.java

@@ -34,7 +34,6 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -174,19 +173,6 @@ public void shouldKillLongStreamingResult() throws Throwable
         }
     }
 
-    @Test
-    public void shouldShowServerVersion() throws Throwable
-    {
-        // Given
-        try( Driver driver = GraphDatabase.driver( neo4j.uri() ) )
-        {
-            try ( Session session = driver.session() )
-            {
-                assertNotNull( session.server() );
-            }
-        }
-    }
-
     private void resetSessionAfterTimeout( final Session session, final int timeout )
     {
         new Thread( new Runnable()

driver/src/test/java/org/neo4j/driver/v1/integration/SummaryIT.java

@@ -43,6 +43,8 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
+import static org.neo4j.driver.v1.util.ServerVersion.v3_1_0;
+import static org.neo4j.driver.v1.util.ServerVersion.version;
 
 public class SummaryIT
 {
@@ -73,8 +75,27 @@ public void shouldContainBasicMetadata() throws Throwable
         assertFalse( summary.hasPlan() );
         assertFalse( summary.hasProfile() );
         assertThat( summary, equalTo( result.consume() ) );
-        assertThat( summary.resultAvailableAfter( TimeUnit.MILLISECONDS ), greaterThan( 0L ) );
-        assertThat( summary.resultConsumedAfter( TimeUnit.MILLISECONDS ), greaterThan( 0L ) );
+
+    }
+
+    @Test
+    public void shouldContainTimeInformation()
+    {
+        // Given
+        ResultSummary summary = session.run( "UNWIND range(1,1000) AS n RETURN n AS number" ).consume();
+
+        // Then
+        if ( version( session.server() ).greaterThanOrEqual( v3_1_0 ) )
+        {
+            assertThat( summary.resultAvailableAfter( TimeUnit.MILLISECONDS ), greaterThan( 0L ) );
+            assertThat( summary.resultConsumedAfter( TimeUnit.MILLISECONDS ), greaterThan( 0L ) );
+        }
+        else
+        {
+            //Not passed through by older versions of the server
+            assertThat( summary.resultAvailableAfter( TimeUnit.MILLISECONDS ), equalTo( -1L ) );
+            assertThat( summary.resultConsumedAfter( TimeUnit.MILLISECONDS ), equalTo( -1L ) );
+        }
     }
 
     @Test

driver/src/test/java/org/neo4j/driver/v1/util/ServerVersion.java

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2002-2016 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.v1.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static java.lang.Integer.compare;
+
+public class ServerVersion
+{
+    private final int major;
+    private final int minor;
+    private final int patch;
+
+    private static final Pattern PATTERN =
+            Pattern.compile("Neo4j/(\\d+)\\.(\\d+)(?:\\.)?(\\d*)(\\.|-|\\+)?([0-9A-Za-z-.]*)?");
+
+    private ServerVersion( int major, int minor, int patch )
+    {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+    }
+    public static final ServerVersion v3_1_0 = new ServerVersion(3, 1, 0);
+    public static final ServerVersion v3_0_0 = new ServerVersion(3, 1, 0);
+
+    public static ServerVersion version( String server )
+    {
+        if ( server == null )
+        {
+            return new ServerVersion( 3, 0, 0 );
+        }
+        else
+        {
+            Matcher matcher = PATTERN.matcher( server );
+            if ( matcher.matches() )
+            {
+                int major = Integer.valueOf( matcher.group( 1 ) );
+                int minor = Integer.valueOf( matcher.group( 2 ) );
+                String patchString = matcher.group( 3 );
+                int patch = 0;
+                if ( patchString != null && !patchString.isEmpty() )
+                {
+                    patch = Integer.valueOf( patchString );
+                }
+                return new ServerVersion( major, minor, patch );
+            }
+            else
+            {
+                throw new IllegalArgumentException( "Cannot parse " + server );
+            }
+        }
+    }
+
+    @Override
+    public boolean equals( Object o )
+    {
+        if ( this == o )
+        { return true; }
+        if ( o == null || getClass() != o.getClass() )
+        { return false; }
+
+        ServerVersion that = (ServerVersion) o;
+
+        if ( major != that.major )
+        { return false; }
+        if ( minor != that.minor )
+        { return false; }
+        return patch == that.patch;
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int result = major;
+        result = 31 * result + minor;
+        result = 31 * result + patch;
+        return result;
+    }
+
+    public boolean greaterThan(ServerVersion other)
+    {
+        return compareTo( other ) > 0;
+    }
+
+    public boolean greaterThanOrEqual(ServerVersion other)
+    {
+        return compareTo( other ) >= 0;
+    }
+
+    public boolean lessThan(ServerVersion other)
+    {
+        return compareTo( other ) < 0;
+    }
+
+    public boolean lessThanOrEqual(ServerVersion other)
+    {
+        return compareTo( other ) <= 0;
+    }
+
+    private int compareTo( ServerVersion o )
+    {
+        int c = compare( major, o.major );
+        if (c == 0)
+        {
+            c = compare( minor, o.minor );
+            if (c == 0)
+            {
+                c = compare( patch, o.patch );
+            }
+        }
+
+        return c;
+    }
+}