jdbc: fix NPE in update

Updated constants to be in sync with tarantool IPROTO.
Added integration tests for the working JDBC functionality.
Fixed travis script to use tarantool 2.0 which is required for SQL.
Fixed failing user permission calls in tarantool initialization script.

Closes #39

----

Rebase fixes (Alexander Turenko):

* Perform cleanup of the test directory once before all tests (move it
  from the TarantoolControl constructor).
* Added starting of jdk-testing instance using TarantoolControl to JDBC
  tests.
* Wait for the instance to be started / stopped in setupEnv() /
  cleanupEnv().

Author: ztarvos

src/main/java/org/tarantool/Key.java

@@ -18,13 +18,13 @@ public enum Key implements Callable<Integer> {
     UPSERT_OPS(0x28),
     DATA(0x30), ERROR(0x31),
 
-    SQL_FIELD_NAME(0x29),
+    SQL_FIELD_NAME(0),
     SQL_METADATA(0x32),
     SQL_TEXT(0x40),
     SQL_BIND(0x41),
     SQL_OPTIONS(0x42),
-    SQL_INFO(0x43),
-    SQL_ROW_COUNT(0x44);
+    SQL_INFO(0x42),
+    SQL_ROW_COUNT(0);
 
     int id;
 

src/test/java/org/tarantool/TarantoolControl.java

@@ -22,24 +22,46 @@ public class TarantoolControl {
     protected static final String tarantoolCtlConfig = new File("src/test/.tarantoolctl").getAbsolutePath();
     protected static final int RESTART_TIMEOUT = 2000;
 
+    static {
+        try {
+            setupWorkDirectory();
+        } catch (IOException e) {
+            throw new RuntimeException("Can't setup test root directory!", e);
+        }
+    }
+
+    protected static void setupWorkDirectory() throws IOException {
+        try {
+            rmdir(tntCtlWorkDir);
+        } catch (IOException ignored) {
+            /* No-op. */
+        }
+
+        mkdir(tntCtlWorkDir);
+        for (File c : new File(instanceDir).listFiles())
+            if (c.getName().endsWith(".lua"))
+                copyFile(c, tntCtlWorkDir);
+        copyFile(tarantoolCtlConfig, tntCtlWorkDir);
+    }
+
     // Based on https://stackoverflow.com/a/779529
-    private void rmdir(File f) throws IOException {
+    private static void rmdir(File f) throws IOException {
         if (f.isDirectory()) {
             for (File c : f.listFiles())
                 rmdir(c);
         }
         f.delete();
     }
 
-    private void rmdir(String f) throws IOException {
+    private static void rmdir(String f) throws IOException {
         rmdir(new File(f));
     }
 
-    private void mkdir(File f) throws IOException {
+    private static void mkdir(File f) throws IOException {
         f.mkdirs();
     }
 
-    private void mkdir(String f) throws IOException {
+    private static void mkdir(String f) throws IOException {
         mkdir(new File(f));
     }
 
@@ -79,23 +101,6 @@ private static String loadStream(InputStream s) throws IOException {
         return sb.toString();
     }
 
-    protected void setupWorkDirectory() throws IOException {
-        rmdir(tntCtlWorkDir);
-        mkdir(tntCtlWorkDir);
-        for (File c : new File(instanceDir).listFiles())
-            if (c.getName().endsWith(".lua"))
-                copyFile(c, tntCtlWorkDir);
-        copyFile(tarantoolCtlConfig, tntCtlWorkDir);
-    }
-
-    TarantoolControl() {
-        try {
-            setupWorkDirectory();
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     /**
      * Control the given tarantool instance via tarantoolctl utility.
      *
@@ -163,11 +168,54 @@ public void run() {
         }
     }
 
+    /**
+     * Wait until the instance will be started.
+     *
+     * Test connection using text console (TarantoolTcpConsole) to ensure the
+     * instance was entirely started or fallback to binary port
+     * (TarantoolLocalConsole) when the test console was not opened.
+     */
+    public void waitStarted(String instanceName) {
+        while (true) {
+            try {
+                openConsole(instanceName).close();
+                return;
+            } catch (Exception ignored) {
+                /* No-op */
+            }
+        }
+    }
+
+    /**
+     * Wait until the instance will be stopped.
+     *
+     * Test connection using binary port (TarantoolLocalConsole) to ensure the
+     * instance was entirely stopped.
+     */
+    public void waitStopped(String instanceName) {
+        while (true) {
+            try {
+                TarantoolConsole.open(tntCtlWorkDir, instanceName).close();
+            } catch (Exception ignored) {
+                return;
+            }
+        }
+    }
+
     public void start(String instanceName) {
         executeCommand("start", instanceName);
     }
 
     public void stop(String instanceName) {
         executeCommand("stop", instanceName);
     }
+
+    /*
+     * XXX: This function is planned to use text console (from ADMIN
+     * environment variable) when it is availiable for the instance and
+     * fallback to TarantoolLocalConsole.
+     */
+    public TarantoolConsole openConsole(String instanceName) {
+        return TarantoolConsole.open(tntCtlWorkDir, instanceName);
+    }
 }

src/test/java/org/tarantool/jdbc/AbstractJdbcIT.java

@@ -0,0 +1,188 @@
+package org.tarantool.jdbc;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.tarantool.TarantoolConnection;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.tarantool.TarantoolControl;
+
+//mvn -DtntHost=localhost -DtntPort=3301 -DtntUser=test -DtntPass=test verify
+public abstract class AbstractJdbcIT {
+    private static final String host = System.getProperty("tntHost", "localhost");
+    private static final Integer port = Integer.valueOf(System.getProperty("tntPort", "3301"));
+    private static final String user = System.getProperty("tntUser", "test_admin");
+    private static final String pass = System.getProperty("tntPass", "4pWBZmLEgkmKK5WP");
+    private static String URL = String.format("tarantool://%s:%d?user=%s&password=%s", host, port, user, pass);
+
+    private static String[] initSql = new String[] {
+            "DROP TABLE IF EXISTS test",
+            "DROP TABLE IF EXISTS test_types",
+
+            "CREATE TABLE test(id INT PRIMARY KEY, val VARCHAR(100))",
+            "INSERT INTO test VALUES (1, 'one'), (2, 'two'), (3, 'three')",
+
+            "CREATE TABLE test_types(" +
+                    "f1 INT PRIMARY KEY, " +
+                    "f2 CHAR(4), " +
+                    "f3 VARCHAR(100), " +
+                    "f4 LONGVARCHAR(100), " +
+                    "f5 NUMERIC, " +
+                    "f6 DECIMAL, " +
+                    "f7 BIT, " +
+                    "f8 TINYINT, " +
+                    "f9 SMALLINT, " +
+                    "f10 INTEGER, " +
+                    "f11 BIGINT," +
+                    "f12 REAL, " +
+                    "f13 FLOAT, " +
+                    "f14 BINARY(4), " +
+                    "f15 VARBINARY(128), " +
+                    "f16 LONGVARBINARY(2048), " +
+                    "f17 DATE, " +
+                    "f18 TIME, " +
+                    "f19 TIMESTAMP)",
+
+            "INSERT INTO test_types VALUES(" +
+                    "1," +
+                    "'abcd'," + //CHAR
+                    "'000000000000000000001'," + //VARCHAR
+                    "'0000000000000000000000000000000001'," + //LONGVARCHAR
+                    "100," + // NUMERIC
+                    "100.1," + // DECIMAL
+                    "1," + //BIT
+                    "7," + //TINYINT
+                    "1000," + //SMALLINT
+                    "100," + //INTEGER
+                    "100000000000000000," + //BIGINT
+                    "-100.2," + //REAL
+                    "100.3," + //FLOAT
+                    "X'01020304'," + //BINARY
+                    "X'0102030405'," +//VARBINARY
+                    "X'010203040506'," + //LONGVARBINARY
+                    "'1983-03-14'," + //DATE
+                    "'12:01:06'," + //TIME
+                    "129479994)" //TIMESTAMP
+    };
+
+    private static String[] cleanSql = new String[] {
+            "DROP TABLE IF EXISTS test",
+            "DROP TABLE IF EXISTS test_types"
+    };
+
+    static Object[] testRow = new Object[] {
+        1,
+        "abcd",
+        "000000000000000000001",
+        "0000000000000000000000000000000001",
+        BigDecimal.valueOf(100),
+        BigDecimal.valueOf(100.1),
+        Boolean.FALSE,
+        (byte)7,
+        (short)1000,
+        100,
+        100000000000000000L,
+        -100.2f,
+        100.3d,
+        new BigInteger("01020304", 16).toByteArray(),
+        new BigInteger("0102030405", 16).toByteArray(),
+        new BigInteger("010203040506", 16).toByteArray(),
+        Date.valueOf("1983-03-14"),
+        Time.valueOf("12:01:06"),
+        new Timestamp(129479994)
+    };
+
+    protected static TarantoolControl control;
+    Connection conn;
+
+    @BeforeAll
+    public static void setupEnv() throws Exception {
+        control = new TarantoolControl();
+        control.start("jdk-testing");
+        control.waitStarted("jdk-testing");
+
+        sqlExec(initSql);
+    }
+
+    @AfterAll
+    public static void teardownEnv() throws Exception {
+        try {
+            sqlExec(cleanSql);
+        } finally {
+            control.stop("jdk-testing");
+            control.waitStopped("jdk-testing");
+        }
+    }
+
+    @BeforeEach
+    public void setUpConnection() throws SQLException {
+        conn = DriverManager.getConnection(URL);
+        assertNotNull(conn);
+    }
+
+    @AfterEach
+    public void tearDownConnection() throws SQLException {
+        if (conn != null && !conn.isClosed())
+            conn.close();
+    }
+
+    private static void sqlExec(String[] text) throws IOException {
+        Socket socket = new Socket();
+        try {
+            socket.connect(new InetSocketAddress(host, port));
+            TarantoolConnection con = new TarantoolConnection(user, pass, socket);
+            try {
+                for (String cmd : text)
+                    con.eval("box.sql.execute(\"" + cmd + "\")");
+            }
+            finally {
+                con.close();
+                socket = null;
+            }
+        }
+        finally {
+            if (socket != null)
+                socket.close();
+        }
+    }
+
+    static List<?> getRow(String space, Object key) throws IOException {
+        Socket socket = new Socket();
+        try {
+            socket.connect(new InetSocketAddress(host, port));
+            TarantoolConnection con = new TarantoolConnection(user, pass, socket);
+            try {
+                List<?> l = con.select(281, 2, Arrays.asList(space.toUpperCase()), 0, 1, 0);
+                Integer spaceId = (Integer) ((List) l.get(0)).get(0);
+                l = con.select(spaceId, 0, Arrays.asList(key), 0, 1, 0);
+                return (l == null || l.size() == 0) ? Collections.emptyList() : (List<?>) l.get(0);
+            }
+            finally {
+                con.close();
+                socket = null;
+            }
+        }
+        finally {
+            if (socket != null)
+                socket.close();
+        }
+    }
+}

src/test/java/org/tarantool/jdbc/JdbcConnectionIT.java

@@ -0,0 +1,42 @@
+package org.tarantool.jdbc;
+
+import org.junit.jupiter.api.Test;
+
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class JdbcConnectionIT extends AbstractJdbcIT {
+    @Test
+    public void testCreateStatement() throws SQLException {
+        Statement stmt = conn.createStatement();
+        assertNotNull(stmt);
+        stmt.close();
+    }
+
+    @Test
+    public void testPrepareStatement() throws SQLException {
+        PreparedStatement prep = conn.prepareStatement("INSERT INTO test(id, val) VALUES(?, ?)");
+        assertNotNull(prep);
+        prep.close();
+    }
+
+    @Test
+    public void testCloseIsClosed() throws SQLException {
+        assertFalse(conn.isClosed());
+        conn.close();
+        assertTrue(conn.isClosed());
+        conn.close();
+    }
+
+    @Test
+    public void testGetMetaData() throws SQLException {
+        DatabaseMetaData meta = conn.getMetaData();
+        assertNotNull(meta);
+    }
+}