jdbc: fix NPE in update

Updated constants be in sync with tarantool IPROTO.
Added tests for the working JDBC functionality.

Closes tarantool#39

Author: ztarvos

pom.xml

@@ -7,6 +7,7 @@
     <packaging>jar</packaging>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <junit.jupiter.version>5.3.0</junit.jupiter.version>
     </properties>
     <name>Tarantool Connector for Java</name>
     <url>https://github.com/tarantool/tarantool-java</url>
@@ -43,6 +44,10 @@
                     <target>1.6</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.22.0</version>
+            </plugin>
         </plugins>
     </build>
     <dependencies>
@@ -52,6 +57,30 @@
             <version>4.12</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.vintage</groupId>
+            <artifactId>junit-vintage-engine</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <version>1.9.5</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <parent>

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/jdbc/AbstractJdbcTest.java

@@ -0,0 +1,149 @@
+package org.tarantool.jdbc;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.tarantool.TarantoolConnection;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertNotNull;
+
+//mvn -Dtnt_host=localhost -Dtnt_port=3301 -Dtnt_user=test -Dtnt_pass=test test
+public abstract class AbstractJdbcTest {
+    private static final String host = System.getProperty("tnt_host", "localhost");
+    private static final Integer port = Integer.valueOf(System.getProperty("tnt_port", "3301"));
+    private static final String user = System.getProperty("tnt_user", "test");
+    private static final String pass = System.getProperty("tnt_pass", "test");
+    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"
+    };
+
+    Connection conn;
+
+    @BeforeClass
+    public static void setupEnv() throws Exception {
+        sqlExec(initSql);
+    }
+
+    @AfterClass
+    public static void teardownEnv() throws Exception {
+        sqlExec(cleanSql);
+    }
+
+    @Before
+    public void setUpConnection() throws SQLException {
+        conn = DriverManager.getConnection(URL);
+        assertNotNull(conn);
+    }
+
+    @After
+    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/JdbcConnectionTest.java

@@ -0,0 +1,42 @@
+package org.tarantool.jdbc;
+
+import org.junit.Test;
+
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class JdbcConnectionTest extends AbstractJdbcTest {
+    @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);
+    }
+}

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

@@ -0,0 +1,106 @@
+package org.tarantool.jdbc;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public class JdbcDatabaseMetaDataTest extends AbstractJdbcTest {
+    private DatabaseMetaData meta;
+
+    @Before
+    public void setUp() throws Exception {
+        meta = conn.getMetaData();
+    }
+
+    @Test
+    public void testGetTableTypes() throws SQLException {
+        ResultSet rs = meta.getTableTypes();
+        assertNotNull(rs);
+
+        assertTrue(rs.next());
+        assertEquals("TABLE", rs.getString("TABLE_TYPE"));
+        assertFalse(rs.next());
+
+        rs.close();
+    }
+
+    @Test
+    public void testGetAllTables() throws SQLException {
+        ResultSet rs = meta.getTables(null, null, null, new String[] {"TABLE"});
+        assertNotNull(rs);
+
+        assertTrue(rs.next());
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
+
+        assertTrue(rs.next());
+        assertEquals("TEST_TYPES", rs.getString("TABLE_NAME"));
+
+        assertFalse(rs.next());
+
+        rs.close();
+    }
+
+    @Test
+    public void testGetTable() throws SQLException {
+        ResultSet rs = meta.getTables(null, null, "TEST", new String[] {"TABLE"});
+        assertNotNull(rs);
+        assertTrue(rs.next());
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
+
+        assertFalse(rs.next());
+
+        rs.close();
+    }
+
+    @Test
+    public void testGetColumns() throws SQLException {
+        ResultSet rs = meta.getColumns(null, null, "TEST", null);
+        assertNotNull(rs);
+
+        assertTrue(rs.next());
+
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
+        assertEquals(1, rs.getInt("ORDINAL_POSITION"));
+
+        assertTrue(rs.next());
+
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
+        assertEquals("VAL", rs.getString("COLUMN_NAME"));
+        assertEquals(2, rs.getInt("ORDINAL_POSITION"));
+
+        assertFalse(rs.next());
+
+        rs.close();
+    }
+
+    @Ignore(value="Test ignored, issue#41")
+    @Test
+    public void testGetPrimaryKeys() throws SQLException {
+        ResultSet rs = meta.getPrimaryKeys(null, null, "TEST");
+
+        assertNotNull(rs);
+        assertTrue(rs.next());
+
+        assertNull(rs.getString("TABLE_CAT"));
+        assertNull(rs.getString("TABLE_SCHEM"));
+        assertEquals("TEST", rs.getString("TABLE_NAME"));
+        assertEquals("ID", rs.getString("COLUMN_NAME"));
+        assertEquals(1, rs.getInt("KEY_SEQ"));
+        assertEquals("pk_unnamed_TEST_1", rs.getString("PK_NAME"));
+
+        assertFalse(rs.next());
+
+        rs.close();
+    }
+}