Refactor Java version check in tests, and ignore a Java 8-specific test when Java version is not at least 7

Author: jyemin

driver-core/src/test/functional/com/mongodb/ClusterFixture.java

@@ -160,6 +160,18 @@ private static ServerVersion getConnectedServerVersion() {
         return clusterDescription.getAny().get(0).getVersion();
     }
 
+    public static boolean isNotAtLeastJava7() {
+        return javaVersionStartsWith("1.6");
+    }
+
+    public static boolean isNotAtLeastJava8() {
+        return isNotAtLeastJava7() || javaVersionStartsWith("1.7");
+    }
+
+    private static boolean javaVersionStartsWith(final String versionPrefix) {
+        return System.getProperty("java.version").startsWith(versionPrefix + ".");
+    }
+
     static class ShutdownHook extends Thread {
         @Override
         public void run() {

driver-core/src/test/functional/com/mongodb/connection/AsyncStreamTimeoutsSpecification.groovy

@@ -33,6 +33,7 @@ import java.util.concurrent.TimeUnit
 import static com.mongodb.ClusterFixture.getCredentialList
 import static com.mongodb.ClusterFixture.getPrimary
 import static com.mongodb.ClusterFixture.getSslSettings
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7
 import static com.mongodb.connection.CommandHelper.executeCommand
 
 @IgnoreIf({ System.getProperty('ignoreSlowUnitTests') == 'true' })
@@ -42,7 +43,7 @@ class AsyncStreamTimeoutsSpecification extends OperationFunctionalSpecification
     static SocketSettings openSocketSettings = SocketSettings.builder().connectTimeout(1, TimeUnit.MILLISECONDS).build();
     static SocketSettings readSocketSettings = SocketSettings.builder().readTimeout(5, TimeUnit.SECONDS).build();
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') || getSslSettings().isEnabled() })
+    @IgnoreIf({ isNotAtLeastJava7() || getSslSettings().isEnabled() })
     def 'should throw a MongoSocketOpenException when the AsynchronousSocket Stream fails to open'() {
         given:
         def connection = new InternalStreamConnectionFactory(
@@ -57,7 +58,7 @@ class AsyncStreamTimeoutsSpecification extends OperationFunctionalSpecification
         thrown(MongoSocketOpenException)
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') || getSslSettings().isEnabled() })
+    @IgnoreIf({ isNotAtLeastJava7() || getSslSettings().isEnabled() })
     def 'should throw a MongoSocketReadTimeoutException with the AsynchronousSocket stream'() {
         given:
         def connection = new InternalStreamConnectionFactory(

driver-core/src/test/functional/com/mongodb/connection/SocketStreamHelperSpecification.groovy

@@ -28,6 +28,8 @@ import javax.net.ssl.SSLSocket
 import javax.net.ssl.SSLSocketFactory
 
 import static com.mongodb.ClusterFixture.getPrimary
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7
+import static com.mongodb.ClusterFixture.isNotAtLeastJava8
 import static java.util.concurrent.TimeUnit.MILLISECONDS
 import static java.util.concurrent.TimeUnit.SECONDS
 
@@ -67,8 +69,8 @@ class SocketStreamHelperSpecification extends Specification {
         socket?.close()
     }
 
-    @IgnoreIf({ !ClusterFixture.sslSettings.enabled || System.getProperty('java.version').startsWith('1.6.') })
-    def 'should enable SSL options if socket is an instance of SSLSocket'() {
+    @IgnoreIf({ !ClusterFixture.sslSettings.enabled || isNotAtLeastJava7() })
+    def 'should enable host name verification if socket is an instance of SSLSocket'() {
         given:
         SSLSocket socket = SSLSocketFactory.default.createSocket()
 
@@ -77,7 +79,6 @@ class SocketStreamHelperSpecification extends Specification {
 
         then:
         socket.getSSLParameters().endpointIdentificationAlgorithm == (sslSettings.invalidHostNameAllowed ? null : 'HTTPS')
-        socket.getSSLParameters().getServerNames() == [new SNIHostName(getPrimary().getHost())]
 
         cleanup:
         socket?.close()
@@ -88,6 +89,25 @@ class SocketStreamHelperSpecification extends Specification {
                         SslSettings.builder().enabled(true).invalidHostNameAllowed(true).build()]
     }
 
+    @IgnoreIf({ !ClusterFixture.sslSettings.enabled || isNotAtLeastJava8() })
+    def 'should enable SNI if socket is an instance of SSLSocket'() {
+        given:
+        SSLSocket socket = SSLSocketFactory.default.createSocket()
+
+        when:
+        SocketStreamHelper.initialize(socket, getPrimary(), SocketSettings.builder().build(), sslSettings)
+
+        then:
+        socket.getSSLParameters().getServerNames() == [new SNIHostName(getPrimary().getHost())]
+
+        cleanup:
+        socket?.close()
+
+        where:
+        sslSettings << [SslSettings.builder().enabled(true).build(),
+                        SslSettings.builder().enabled(false).build()]
+    }
+
     def 'should throw MongoInternalException is ssl is enabled and the socket is not an instance of SSLSocket'() {
         given:
         Socket socket = SocketFactory.default.createSocket()

driver-core/src/test/unit/com/mongodb/connection/SslSettingsSpecification.groovy

@@ -21,6 +21,7 @@ import com.mongodb.MongoInternalException
 import spock.lang.IgnoreIf
 import spock.lang.Specification
 
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7
 import static com.mongodb.connection.SslSettings.builder
 
 
@@ -30,7 +31,7 @@ class SslSettingsSpecification extends Specification {
         !builder().build().enabled
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'should enable'() {
         expect:
         builder().enabled(true).build().enabled
@@ -70,14 +71,14 @@ class SslSettingsSpecification extends Specification {
         !builder().applyConnectionString(new ConnectionString('mongodb://localhost/?ssl=false')).build().invalidHostNameAllowed
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'should apply connection string with ssl'() {
         expect:
         builder().applyConnectionString(new ConnectionString('mongodb://localhost/?ssl=true')).build().enabled
         !builder().applyConnectionString(new ConnectionString('mongodb://localhost/?ssl=true')).build().invalidHostNameAllowed
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'should apply connection string with ssl and sslInvalidHostNameAllowed'() {
         expect:
         builder().applyConnectionString(new ConnectionString('mongodb://localhost/?ssl=true&sslInvalidHostNameAllowed=true'))
@@ -100,7 +101,7 @@ class SslSettingsSpecification extends Specification {
         builder().enabled(true).invalidHostNameAllowed(true).build().hashCode()
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'unequivalent settings should not be equal or have the same hash code'() {
         expect:
         builder().build() != builder().enabled(true).build()

driver-core/src/test/unit/com/mongodb/internal/SslHelperSpecification.groovy

@@ -24,8 +24,10 @@ import spock.lang.Specification
 import javax.net.ssl.SNIHostName
 import javax.net.ssl.SSLParameters
 
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7
+import static com.mongodb.ClusterFixture.isNotAtLeastJava8
 
-@IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+@IgnoreIf({ isNotAtLeastJava7() })
 class SslHelperSpecification extends Specification {
     def 'should enable HTTPS host name verification'() {
         given:
@@ -38,7 +40,7 @@ class SslHelperSpecification extends Specification {
         sslParameters.getEndpointIdentificationAlgorithm() == 'HTTPS'
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.7.') })
+    @IgnoreIf({ isNotAtLeastJava8() })
     def 'should enable server name indicator'() {
         given:
         def serverName = 'server.me'

driver/src/test/unit/com/mongodb/MongoClientOptionsSpecification.groovy

@@ -30,6 +30,7 @@ import spock.lang.Specification
 import javax.net.SocketFactory
 import javax.net.ssl.SSLSocketFactory
 
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7
 import static com.mongodb.CustomMatchers.isTheSameAs
 import static java.util.concurrent.TimeUnit.MILLISECONDS
 import static java.util.concurrent.TimeUnit.SECONDS
@@ -214,7 +215,7 @@ class MongoClientOptionsSpecification extends Specification {
         options.sslSettings == SslSettings.builder().enabled(true).invalidHostNameAllowed(true).build()
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'should get socketFactory based on sslEnabled'() {
         when:
         MongoClientOptions.Builder builder = MongoClientOptions.builder()

driver/src/test/unit/com/mongodb/MongoClientURISpecification.groovy

@@ -20,6 +20,7 @@ import spock.lang.IgnoreIf
 import spock.lang.Specification
 import spock.lang.Unroll
 
+import static com.mongodb.ClusterFixture.isNotAtLeastJava7
 import static com.mongodb.MongoCredential.createCredential
 import static com.mongodb.MongoCredential.createGSSAPICredential
 import static com.mongodb.MongoCredential.createMongoCRCredential
@@ -123,7 +124,7 @@ class MongoClientURISpecification extends Specification {
                                                                                                          .withWTimeout(5, MILLISECONDS)
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'should correctly parse URI options for #type'() {
         given:
         def uri = new MongoClientURI('mongodb://localhost/?minPoolSize=5&maxPoolSize=10&waitQueueMultiple=7&waitQueueTimeoutMS=150&'
@@ -248,7 +249,7 @@ class MongoClientURISpecification extends Specification {
         options.getConnectionsPerHost() == 250
     }
 
-    @IgnoreIf({ System.getProperty('java.version').startsWith('1.6.') })
+    @IgnoreIf({ isNotAtLeastJava7() })
     def 'should be equal to another MongoClientURI with the same string values'() {
         expect:
         uri1 == uri2