AJ-841:add test case about SCRAM login;

Author: weisun123

test/com/xxdb/ConnectionPoolTest.java

@@ -15,9 +15,11 @@
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.ResourceBundle;
 
+import static com.xxdb.Prepare.PrepareUser_authMode;
 import static org.junit.Assert.assertEquals;
 
 public class ConnectionPoolTest {
@@ -130,6 +132,45 @@ public void test_DBConnectionPool_count_1() throws IOException {
         pool1.shutdown();
     }
 
+    @Test
+    public void test_DBConnectionPool_user_authMode_scream() throws Exception {
+        PrepareUser_authMode("scramUser","123456","scram");
+        conn.run("if(existsDatabase(\"dfs://testArrayVector\")){\n" +
+                "dropDatabase(\"dfs://testArrayVector\")\n" +
+                "}\n" +
+                "db=database(\"dfs://testArrayVector\",RANGE,int(1..10),,\"TSDB\")\n" +
+                "t = table(1000000:0,`sym`tradeDate`volume`valueTrade,[INT,DATETIME,INT[],DOUBLE])\n" +
+                "pt = db.createPartitionedTable(t,`pt,`sym,,`tradeDate)");
+        conn.run("grant(\"scramUser\", DB_OWNER, \"dfs://test*\");\n grant(\"scramUser\", DB_MANAGE);\n grant(\"scramUser\", TABLE_READ,\"*\");\n grant(\"scramUser\", TABLE_WRITE,\"dfs://testArrayVector/pt\");");
+        ExclusiveDBConnectionPool pool = new ExclusiveDBConnectionPool(HOST,PORT,"scramUser","123456",3,false,false);
+        PartitionedTableAppender appender = new PartitionedTableAppender("dfs://testArrayVector","pt","sym",pool);
+        List<String> colNames = new ArrayList<>();
+        colNames.add("sym");
+        colNames.add("tradesDate");
+        colNames.add("volume");
+        colNames.add("valueTrade");
+        List<Vector> cols = new ArrayList<>();
+        BasicIntVector biv = new BasicIntVector(new int[]{1,2,3});
+        cols.add(biv);
+        BasicDateTimeVector bdtv = new BasicDateTimeVector(new int[]{10,20,30});
+        cols.add(bdtv);
+        List<Vector> value = new ArrayList<>();
+        value.add(new BasicIntVector(new int[]{1,2,3}));
+        value.add(new BasicIntVector(new int[]{4,5,6,7,8}));
+        value.add(new BasicIntVector(new int[]{9,10,11,13,17,21}));
+        BasicArrayVector bav = new BasicArrayVector(value);
+        cols.add(bav);
+        BasicDoubleVector bdv = new BasicDoubleVector(new double[]{1.1,3.6,7.9});
+        cols.add(bdv);
+        BasicTable bt = new BasicTable(colNames,cols);
+        int x = appender.append(bt);
+        BasicTable res = (BasicTable) conn.run("select * from loadTable(\"dfs://testArrayVector\",\"pt\");");
+        assertEquals(3,res.rows());
+        assertEquals(Entity.DATA_TYPE.DT_INT_ARRAY,res.getColumn(2).getDataType());
+        System.out.println(res.getColumn(2).getString());
+        pool.shutdown();
+    }
+
 
     @Test
     public void testHashHashstring() throws Exception {
@@ -2529,5 +2570,53 @@ public void Test_PartitionedTableAppender_iotAnyVector_big_data() throws Excepti
         assertEquals("9000000", bt10.getColumn(0).getString(0));
         pool.shutdown();
     }
+
+    //@Test
+    public void Test_PartitionedTableAppender_iotAnyVector_1() throws Exception {
+        String script = "if(existsDatabase(\"dfs://testIOT_allDateType1\")) dropDatabase(\"dfs://testIOT_allDateType1\")\n" +
+                "     create database \"dfs://testIOT_allDateType1\" partitioned by   RANGE(100000*(0..10)),RANGE(2020.01.01 2022.01.01 2038.01.01), engine='IOTDB'\n" +
+                "     create table \"dfs://testIOT_allDateType1\".\"pt\"(\n" +
+                "     deviceId INT,\n" +
+                "     timestamp TIMESTAMP,\n" +
+                "     location SYMBOL,\n" +
+                "     value IOTANY,\n" +
+                " )\n" +
+                "partitioned by deviceId, timestamp,\n" +
+                "sortColumns=[`deviceId, `location, `timestamp],\n" +
+                "latestKeyCache=true;\n" +
+                "pt = loadTable(\"dfs://testIOT_allDateType1\",\"pt\");\n" ;
+        conn.run(script);
+        BasicByte bbyte = new BasicByte((byte) 127);
+        BasicShort bshort = new BasicShort((short) 0);
+        BasicInt bint = new BasicInt(-4);
+        BasicLong blong = new BasicLong(-4);
+        BasicBoolean bbool = new BasicBoolean(false);
+        BasicFloat bfloat = new BasicFloat((float) 1.99);
+        BasicDouble bdouble = new BasicDouble(1.99);
+        BasicString bsting = new BasicString("最新特殊字符：!@#$%^&*()_++_}{|{\":>?</.,';\\][=-0987654321`~asdQWHH这个点做工&&，。、te长qqa");
+        Scalar[] scalar = new Scalar[]{bbyte, bshort, bint, blong, bbool, bfloat, bdouble, bsting, bdouble, bsting};
+        BasicIotAnyVector BIV = new BasicIotAnyVector(scalar);
+        BasicIntVector deviceId = new BasicIntVector(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
+
+        BasicAnyVector BIV1 = new BasicAnyVector(10);
+        for (int i = 0; i < 10; i++) {
+            BIV1.set(i, new BasicInt(i));
+        }
+
+        BasicTimestampVector timestamp = new BasicTimestampVector(new long[]{1577836800001l, 1577836800002l, 1577836800003l, 1577836800004l, 1577836800005l, 1577836800006l, 1577836800007l, 1577836800008l, 1577836800009l, 1577836800010l});
+        BasicSymbolVector location = new BasicSymbolVector(Arrays.asList(new String[]{"d1d", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10"}));
+
+        List<Entity> args = Arrays.asList(deviceId, timestamp, location, BIV);
+        List<String> colNames = Arrays.asList("deviceId", "timestamp", "location", "BIV");
+        List<Vector> cols = Arrays.asList(deviceId, timestamp, location, BIV);
+        BasicTable table = new BasicTable(colNames, cols);
+
+        ExclusiveDBConnectionPool pool = new ExclusiveDBConnectionPool(HOST,PORT,"admin","123456",3,false,false);
+        PartitionedTableAppender appender = new PartitionedTableAppender("dfs://testIOT_allDateType1","pt","deviceId", pool);
+        appender.append(table);
+        BasicTable bt10 = (BasicTable) conn.run("select count(*) from loadTable(\"dfs://testIOT_allDateType1\",`pt);");
+        assertEquals("10", bt10.getColumn(0).getString(0));
+        pool.shutdown();
+    }
 }
 

test/com/xxdb/DBConnectionTest.java

@@ -23,6 +23,8 @@
 
 import static com.xxdb.Prepare.*;
 import static com.xxdb.comm.SqlStdEnum.*;
+import static com.xxdb.data.Entity.DATA_FORM.DF_TABLE;
+import static com.xxdb.data.Entity.DATA_TYPE.*;
 import static java.lang.Thread.sleep;
 import static org.junit.Assert.*;
 
@@ -606,7 +608,7 @@ public void testIntScalar() throws Exception {
         scalar.setNull();
         assertTrue(scalar.isNull());
         assertEquals(Entity.DATA_CATEGORY.INTEGRAL,scalar.getDataCategory());
-        assertEquals(Entity.DATA_TYPE.DT_INT,scalar.getDataType());
+        assertEquals(DT_INT,scalar.getDataType());
         assertEquals(-1,scalar.hashBucket(1));
         assertEquals(-2147483648,scalar.hashCode());
         assertEquals("null",scalar.getJsonString());
@@ -758,7 +760,7 @@ public void testSecondScalar() throws Exception {
         scalar.setNull();
         assertTrue(scalar.isNull());
         assertEquals(Entity.DATA_CATEGORY.TEMPORAL,scalar.getDataCategory());
-        assertEquals(Entity.DATA_TYPE.DT_SECOND,scalar.getDataType());
+        assertEquals(DT_SECOND,scalar.getDataType());
         assertEquals(-1,scalar.hashBucket(1));
         assertEquals(-2147483648,scalar.hashCode());
         assertEquals("null",scalar.getJsonString());
@@ -887,7 +889,7 @@ public void testStringScalar() throws Exception {
         scalar.setNull();
         assertTrue(scalar.isNull());
         assertEquals(Entity.DATA_CATEGORY.LITERAL,scalar.getDataCategory());
-        assertEquals(Entity.DATA_TYPE.DT_STRING,scalar.getDataType());
+        assertEquals(DT_STRING,scalar.getDataType());
         assertEquals(0,scalar.hashBucket(1));
         assertEquals(0,scalar.hashCode());
         assertEquals("null",scalar.getJsonString());
@@ -1767,7 +1769,7 @@ public void testDictionaryUpload() throws IOException {
     public void testDictionaryUpload_1() throws IOException {
         DBConnection conn = new DBConnection();
         conn.connect(HOST,PORT,"admin","123456");
-        BasicDictionary bd = new BasicDictionary(Entity.DATA_TYPE.DT_INT, Entity.DATA_TYPE.DT_ANY);
+        BasicDictionary bd = new BasicDictionary(DT_INT, Entity.DATA_TYPE.DT_ANY);
         Map<String,Entity> data = new HashMap<>();
         data.put("bd",bd);
         conn.upload(data);
@@ -1837,7 +1839,7 @@ public void testAnyVector_Duration_Upload() throws Exception {
     @Test
     public void testSet() throws IOException {
         BasicSet result = (BasicSet) conn.run("set(1+3*1..100)");
-        assertEquals(Entity.DATA_TYPE.DT_INT, result.getDataType());
+        assertEquals(DT_INT, result.getDataType());
         assertEquals(Entity.DATA_FORM.DF_SET, result.getDataForm());
 
     }
@@ -1849,7 +1851,7 @@ public void testSetUpload() throws IOException {
         map.put("set", set);
         conn.upload(map);
         Entity sets = conn.run("set");
-        assertEquals(Entity.DATA_TYPE.DT_INT, sets.getDataType());
+        assertEquals(DT_INT, sets.getDataType());
         assertEquals(Entity.DATA_FORM.DF_SET, sets.getDataForm());
     }
 
@@ -3919,6 +3921,7 @@ public void test_tryUpload() throws IOException{
 @Test
 public void test_SSL() throws Exception {
     DBConnection conn = new DBConnection(false,true);
+    conn.connect(HOST,18922,"admin","123456");
     assertTrue(conn.connect(HOST,PORT,"admin","123456"));
     HashMap<String,Entity> map = new HashMap<>();
     map.put("x",conn.run("x=[1 3 6 10];"));
@@ -5154,8 +5157,9 @@ public void test_DBConnection_run_parallelism_1() throws IOException {
 
         DBConnection conn1 = new DBConnection();
         conn1.connect(HOST,PORT,"parallelism_test","123456");
-        BasicTable re1 = (BasicTable)conn.run("getConsoleJobs();",4,5,false);
+        BasicTable re1 = (BasicTable)conn.run("getConsoleJobs();",3,5,false);
         Assert.assertEquals("5",re1.getColumn(6).get(0).getString());
+        System.out.println(re1.getColumn(5).get(0).getString());
     }
     @Test//api设置的parallelism大于server的setMaxJobParallelism
     public void test_DBConnection_run_parallelism_2() throws IOException {
@@ -5300,4 +5304,164 @@ public void progress(String message) {
         Entity print = db.run("print", entity, 3, 3, 0, true, listener);
         System.out.println("print:" + print.getString());
     }
-}
+    @Test
+    public void TestDownloadUpload_hugeTable() throws Exception {
+        DBConnection conn = new DBConnection();
+        conn.connect(HOST,PORT,"admin","123456");
+        BasicTable re = (BasicTable)conn.run("t=table(second(0..999999) as sd, take(`AAPL, 1000000) as str, 0..999999 as cint, arrayVector(1..1000000*3, take(NULL 1.123 -9928345.0, 3000000)) as cdoublev); \n t");
+        assertEquals(DF_TABLE,re.getDataForm());
+        assertEquals(1000000,re.rows());
+        assertEquals(4,re.columns());
+        assertEquals(DT_SECOND,re.getColumn(0).getDataType());
+        assertEquals(DT_STRING,re.getColumn(1).getDataType());
+        assertEquals(DT_INT,re.getColumn(2).getDataType());
+        assertEquals(DT_DOUBLE_ARRAY,re.getColumn(3).getDataType());
+        Entity ex_col0 = conn.run("take(second(0..999999), 1000000)");
+        Entity ex_col1 = conn.run("take(`AAPL, 1000000)");
+        Entity ex_col2 = conn.run("0..999999");
+        Entity ex_col3 = conn.run("arrayVector(1..1000000*3, take(NULL 1.123 -9928345.0, 3000000))");
+
+        assertEquals(ex_col0.getString(),re.getColumn(0).getString());
+        assertEquals(ex_col1.getString(),re.getColumn(1).getString());
+        assertEquals(ex_col2.getString(),re.getColumn(2).getString());
+        assertEquals(ex_col3.getString(),re.getColumn(3).getString());
+
+        Map<String, Entity> map = new HashMap<String, Entity>();
+        map.put("res", re);
+        conn.upload(map);
+        Entity assertion_result = conn.run("all(each(eqObj, values res, values t, 5))");
+        assertEquals("true", assertion_result.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_false() throws Exception {
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,false );
+        conn.connect(HOST,PORT,"admin","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_false_user_authMode_scram() throws Exception {
+        PrepareUser_authMode("scramUser","123456","scram");
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,false);
+        conn.connect(HOST,PORT,"scramUser","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+        conn.close();
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_user_admin() throws Exception {
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,true );
+        String re = null;
+        try{
+            conn.connect(HOST,PORT,"admin","123456");
+        }catch(Exception e){
+            re = e.getMessage();
+        }
+        assertEquals("user 'admin' doesn't support scram authMode.", re);
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_user_not_support() throws Exception {
+        PrepareUser_authMode("test2","123456","sha256");
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,true );
+        String re = null;
+        try{
+            conn.connect(HOST,PORT,"test2","123456");
+        }catch(Exception e){
+            re = e.getMessage();
+        }
+        assertEquals("user 'test2' doesn't support scram authMode.", re);
+    }
+    @Test
+    public void Test_DBConnection_enableSCRAM_true() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,true);
+        conn.connect(HOST,PORT,"test1","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_asynchronousTask_true() throws Exception {
+        PrepareUser_authMode("scramUser","123456","scram");
+        DBConnection conn = new DBConnection(true, false,false,false,false,null,true);
+        conn.connect(HOST,PORT,"test1","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_useSSL_true() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, true,false,false,false,null,true);
+        conn.connect(HOST,PORT,"test1","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_compress_true() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, false,true,false,false,null,true);
+        conn.connect(HOST,PORT,"test1","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_usePython_true() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, false,false,true,false,null,true);
+        conn.connect(HOST,PORT,"test1","123456");
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_login() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,true);
+        conn.connect(HOST,PORT);
+        conn.login("test1","123456",true);
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_login_enableEncryption() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,true);
+        conn.connect(HOST,PORT);
+        conn.login("test1","123456",false);
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+    @Test
+    public void Test_DBConnection_enableSCRAM_true_login_function() throws Exception {
+        PrepareUser_authMode("test1","123456","scram");
+        DBConnection conn = new DBConnection(false, false,false,false,false,null,true);
+        conn.connect(HOST,PORT);
+        List<Entity> list = new ArrayList<>();
+        list.add(new BasicString("test1"));
+        list.add(new BasicString("123456"));
+        conn.run("login",list);
+        BasicInt re = (BasicInt) conn.run("1+1");
+        System.out.println(re.getString());
+        assertEquals("2", re.getString());
+    }
+
+
+}

test/com/xxdb/MultithreadedTableWriterTest.java

@@ -23,6 +23,7 @@
 import java.util.*;
 import java.util.logging.Logger;
 
+import static com.xxdb.Prepare.PrepareUser_authMode;
 import static com.xxdb.Prepare.checkData;
 import static org.junit.Assert.*;
 import static org.junit.Assert.assertEquals;
@@ -7099,5 +7100,29 @@ public void test_MultithreadedTableWriter_allDataType_array_null() throws Except
 //        //assertEquals(11, bt10.rows());
 //        System.out.println(bt10.getString());
 //    }
+
+    @Test(timeout = 120000)
+    public void test_MultithreadedTableWriter_user_authMode_scream() throws Exception {
+        PrepareUser_authMode("scramUser","123456","scram");
+        StringBuilder sb = new StringBuilder();
+        sb.append("t = streamTable(1000:0, `char`int`long`short`id," +
+                "[CHAR,INT,LONG,SHORT,INT]);" +
+                "share t as t1;");
+        conn.run(sb.toString());
+        mutithreadTableWriter_ = new MultithreadedTableWriter(HOST, PORT, "scramUser", "123456",
+                "", "t1", false, false, null, 1, 1,
+                1, "id");
+        ErrorCodeInfo pErrorInfo = mutithreadTableWriter_.insert( (int)1, (int)1, (int)-1, (int)0, (int)-1);
+        pErrorInfo=mutithreadTableWriter_.insert( null, (int)1, (int)1, (int)0, (int)1);
+        assertEquals("code= info=",pErrorInfo.toString());
+        mutithreadTableWriter_.waitForThreadCompletion();
+        BasicTable bt = (BasicTable) conn.run("select * from t1;");
+        assertEquals(2, bt.rows());
+        assertEquals("[1,]", bt.getColumn("char").getString());
+        assertEquals("[1,1]", bt.getColumn("int").getString());
+        assertEquals("[-1,1]", bt.getColumn("long").getString());
+        assertEquals("[0,0]", bt.getColumn("short").getString());
+        conn.run("undef(`t1,SHARED)");
+    }
 }