Enhancements to handle redis server version during test

Added RedisVersion class
Moved version related information from RedisRunner.RedisProcess to
RedisVersion
Added code that performs redis version check on commands that only
available to redis at or above given version number
Enabled RedissonGeoTest for all versions in travis (Should auto skip
the test class when version number mismatch)

.travis.yml

@@ -42,7 +42,7 @@ env:
         - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonCountDownLatchTest
         - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonDequeReactiveTest
         - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonDequeTest
-#        - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonGeoTest
+        - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonGeoTest
         - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonHyperLogLogReactiveTest
         - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonHyperLogLogTest
         - REDIS_VERSION=3.0.7 REDISSON_TEST=org.redisson.RedissonKeysReactiveTest
@@ -103,7 +103,7 @@ env:
         - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonCountDownLatchTest
         - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonDequeReactiveTest
         - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonDequeTest
-#        - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonGeoTest
+        - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonGeoTest
         - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonHyperLogLogReactiveTest
         - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonHyperLogLogTest
         - REDIS_VERSION=2.8.24 REDISSON_TEST=org.redisson.RedissonKeysReactiveTest

src/test/java/org/redisson/RedisRunner.java

@@ -700,11 +700,8 @@ public class RedisRunner {
 
         private final Process redisProcess;
         private final RedisRunner runner;
-        private String redisFullVersion;
-        private Integer redisMajorVersion;
-        private Integer redisMinorVersion;
-        private Integer redisPatchVersion;
-
+        private RedisVersion redisVersion;
+        
         private RedisProcess(Process redisProcess, RedisRunner runner) {
             this.redisProcess = redisProcess;
             this.runner = runner;
@@ -738,41 +735,13 @@ public class RedisRunner {
             throw new IllegalStateException("Redis server instance is not running.");
         }
 
-        public String getRedisFullVersion() {
-            if (redisFullVersion == null) {
-                redisFullVersion = createRedisClientInstance().serverInfo().get("redis_version");
+        public RedisVersion getRedisVersion() {
+            if (redisVersion == null) {
+                redisVersion = new RedisVersion(createRedisClientInstance().serverInfo().get("redis_version"));
             }
-            return redisFullVersion;
+            return redisVersion;
         }
 
-        public int getRedisMajorVersion() {
-            if (redisMajorVersion == null) {
-                parseVersion();
-            }
-            return redisMajorVersion;
-        }
-        
-        public int getRedisMinorVersion() {
-            if (redisMinorVersion == null) {
-                parseVersion();
-            }
-            return redisMinorVersion;
-        }
-        
-        public int getRedisPatchVersion() {
-            if (redisPatchVersion == null) {
-                parseVersion();
-            }
-            return redisPatchVersion;
-        }
-        
-        private void parseVersion() {
-            Matcher matcher = Pattern.compile("^([\\d]{0,2})\\.([\\d]{0,2})\\.([\\d]{0,2})$").matcher(getRedisFullVersion());
-            matcher.find();
-            redisMajorVersion = Integer.parseInt(matcher.group(1));
-            redisMinorVersion = Integer.parseInt(matcher.group(2));
-            redisPatchVersion = Integer.parseInt(matcher.group(3));
-        }
     }
 
     public static RedisRunner.RedisProcess startDefaultRedisServerInstance() throws IOException, InterruptedException {
@@ -803,7 +772,7 @@ public class RedisRunner {
         return defaultRedisInstanceExitCode;
     }
 
-    public static boolean isDefaultRedisTestInstanceRunning() {
+    public static boolean isDefaultRedisServerInstanceRunning() {
         return defaultRedisInstance != null && defaultRedisInstance.redisProcess.isAlive();
     }
 
@@ -811,4 +780,7 @@ public class RedisRunner {
         return defaultRedisInstance.createRedisClientInstance();
     }
 
+    public static RedisRunner.RedisProcess getDefaultRedisServerInstance() {
+        return defaultRedisInstance;
+    }
 }

src/test/java/org/redisson/RedisVersion.java

@@ -0,0 +1,58 @@
+package org.redisson;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ * @author Jack
+ */
+public class RedisVersion implements Comparable<RedisVersion>{
+
+    private final String fullVersion;
+    private final Integer majorVersion;
+    private final Integer minorVersion;
+    private final Integer patchVersion;
+
+    public RedisVersion(String fullVersion) {
+        this.fullVersion = fullVersion;
+        Matcher matcher = Pattern.compile("^([\\d]{0,2})\\.([\\d]{0,2})\\.([\\d]{0,2})$").matcher(fullVersion);
+        matcher.find();
+        majorVersion = Integer.parseInt(matcher.group(1));
+        minorVersion = Integer.parseInt(matcher.group(2));
+        patchVersion = Integer.parseInt(matcher.group(3));
+    }
+
+    public String getFullVersion() {
+        return fullVersion;
+    }
+
+    public int getMajorVersion() {
+        return majorVersion;
+    }
+
+    public int getMinorVersion() {
+        return minorVersion;
+    }
+
+    public int getPatchVersion() {
+        return patchVersion;
+    }
+
+    @Override
+    public int compareTo(RedisVersion o) {
+        int ma = this.majorVersion.compareTo(o.majorVersion);
+        int mi = this.minorVersion.compareTo(o.minorVersion);
+        int pa = this.patchVersion.compareTo(o.patchVersion);
+        return ma != 0 ? ma : mi != 0 ? mi : pa;
+    }
+    
+    public int compareTo(String redisVersion) {
+        return this.compareTo(new RedisVersion(redisVersion));
+    }
+    
+    public static int compareTo(String redisVersion1, String redisVersion2) {
+        return new RedisVersion(redisVersion1).compareTo(redisVersion2);
+    }
+    
+}

src/test/java/org/redisson/RedissonGeoTest.java

@@ -1,10 +1,13 @@
 package org.redisson;
 
+import java.io.IOException;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import org.junit.Assume;
+import org.junit.BeforeClass;
 
 import org.junit.Test;
 import org.redisson.core.GeoEntry;
@@ -14,6 +17,18 @@ import org.redisson.core.RGeo;
 
 public class RedissonGeoTest extends BaseTest {
 
+    @BeforeClass
+    public static void checkRedisVersion() throws IOException, InterruptedException {
+        boolean running = RedisRunner.isDefaultRedisServerInstanceRunning();
+        if (!running) {
+            RedisRunner.startDefaultRedisServerInstance();
+        }
+        Assume.assumeTrue(RedisRunner.getDefaultRedisServerInstance().getRedisVersion().compareTo("3.1.0") > 0);
+        if (!running) {
+            RedisRunner.shutDownDefaultRedisServerInstance();
+        }
+    }
+    
     @Test
     public void testAdd() {
         RGeo<String> geo = redisson.getGeo("test");

src/test/java/org/redisson/RedissonScoredSortedSetTest.java

@@ -24,6 +24,7 @@ import org.redisson.core.RScoredSortedSet;
 import org.redisson.core.RSortedSet;
 
 import io.netty.util.concurrent.Future;
+import org.junit.Assume;
 
 public class RedissonScoredSortedSetTest extends BaseTest {
 
@@ -42,6 +43,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
 
     @Test
     public void testTryAdd() {
+        Assume.assumeTrue(RedisRunner.getDefaultRedisServerInstance().getRedisVersion().compareTo("3.0.2") >= 0);
         RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
 
         assertThat(set.tryAdd(123.81, "1980")).isTrue();