@zowe/db2-for-zowe-cli 6.1.17 → 6.1.19

package/node_modules/ibm_db/test/test-chinese-char.js

@@ -1,59 +1,59 @@
-var common = require("./common")
-    , ibmdb = require("../")
-    , db = new ibmdb.ODBC()
-    , assert = require("assert")
-    , connStr = common.connectionString;
-
-var sql = "insert into testtab (col1,col2) values('一二三四', '五六七八')"; 
-
-ibmdb.open(connStr,(err,conn)=>{
-  if(err){ console.log(err); return; }
-  try {
-  conn.querySync('create table testtab (col1 VARCHAR(100), col2 VARCHAR(100))');
-  } catch(err) {console.log(err);}
-
-  // Insert Chinese characters in table using all possible ways.
-  conn.querySync(sql);  // Insert Row1
-  var stmt = conn.prepareSync(sql);
-  stmt.executeSync();   // Insert Row2
-  stmt.closeSync();
-  conn.query(sql, function(err, data) { // Insert Row3
-    if(err){ console.log(err); return; }
-    conn.prepare(sql, function(err, stmt) {
-     if(err){ console.log(err); return; }
-     stmt.execute(function(err, data) { // Insert Row4
-      if(err){ console.log(err); return; }
-      stmt.closeSync();
-
-      // Create another connection using alternate way.
-      var conn2 = db.createConnectionSync();
-      conn2.openSync(connStr);
-      stmt = conn2.createStatementSync();
-      stmt.executeDirectSync(sql);   // Insert Row5
-      stmt.prepareSync(sql);
-      console.log("Inserted row = ",stmt.executeNonQuerySync()); // Insert Row6
-      stmt.closeSync();
-      conn2.createStatement(function(err, stmt){
-        if(err){ console.log(err); return; }
-        stmt.executeDirect(sql, function(err, result){ // Insert Row7
-          if(err){ console.log(err); return; }
-          stmt.prepare(sql, function(err, result) { //dont use err, stmt here
-            stmt.executeNonQuery(function(err, rowCount){ // Insert Row8
-              if(err){ console.log(err); return; }
-              console.log("Inserted rowcount = ", rowCount);
-              stmt.closeSync();
-              var data = conn.querySync("select * from testtab");
-              console.log("Inserted rows = ", data);
-              conn2.querySync("drop table testtab");
-              conn2.closeSync();
-              conn.closeSync();
-              assert(data.length, 8);
-            });
-          });
-        });
-      });
-     });
-    });
-  });
-});
-
+var common = require("./common")
+    , ibmdb = require("../")
+    , db = new ibmdb.ODBC()
+    , assert = require("assert")
+    , connStr = common.connectionString;
+
+var sql = "insert into testtab (col1,col2) values('一二三四', '五六七八')";
+
+ibmdb.open(connStr,(err,conn)=>{
+  if(err){ console.log(err); return; }
+  try {
+  conn.querySync('create table testtab (col1 VARCHAR(100), col2 VARCHAR(100))');
+  } catch(err) {console.log(err);}
+
+  // Insert Chinese characters in table using all possible ways.
+  conn.querySync(sql);  // Insert Row1
+  var stmt = conn.prepareSync(sql);
+  stmt.executeSync();   // Insert Row2
+  stmt.closeSync();
+  conn.query(sql, function(err, data) { // Insert Row3
+    if(err){ console.log(err); return; }
+    conn.prepare(sql, function(err, stmt) {
+     if(err){ console.log(err); return; }
+     stmt.execute(function(err, data) { // Insert Row4
+      if(err){ console.log(err); return; }
+      stmt.closeSync();
+
+      // Create another connection using alternate way.
+      var conn2 = db.createConnectionSync();
+      conn2.openSync(connStr);
+      stmt = conn2.createStatementSync();
+      stmt.executeDirectSync(sql);   // Insert Row5
+      stmt.prepareSync(sql);
+      console.log("Inserted row = ",stmt.executeNonQuerySync()); // Insert Row6
+      stmt.closeSync();
+      conn2.createStatement(function(err, stmt){
+        if(err){ console.log(err); return; }
+        stmt.executeDirect(sql, function(err, result){ // Insert Row7
+          if(err){ console.log(err); return; }
+          stmt.prepare(sql, function(err, result) { //dont use err, stmt here
+            stmt.executeNonQuery(function(err, rowCount){ // Insert Row8
+              if(err){ console.log(err); return; }
+              console.log("Inserted rowcount = ", rowCount);
+              stmt.closeSync();
+              var data = conn.querySync("select * from testtab");
+              console.log("Inserted rows = ", data);
+              conn2.querySync("drop table testtab");
+              conn2.closeSync();
+              conn.closeSync();
+              assert(data.length, 8);
+            });
+          });
+        });
+      });
+     });
+    });
+  });
+});
+

package/node_modules/ibm_db/test/test-connection.js

@@ -0,0 +1,306 @@
+// Consolidated connection test: open/close (async, sync, promise), multi-connection,
+// bad connection string, query on closed connection, connection object, connectTimeout.
+// Replaces: test-open-close, test-openSync, test-global-open-close, test-connection-object,
+//   test-bad-connection-string, test-closed, test-multi-open-close, test-multi-openSync-closeSync,
+//   test-instantiate-one-and-end, test-require-and-end, test-promise-open-close,
+//   test-open-connectTimeout, test-binding-connection-timeOut.
+
+var common = require("./common")
+  , ibmdb = require("../")
+  , assert = require("assert")
+  , os = require("os")
+  , cn = common.connectionString
+  ;
+
+var passed = 0, failed = 0;
+
+function ok(label) { passed++; console.log("  PASS: " + label); }
+function fail(label, detail) { failed++; console.log("  FAIL: " + label + " " + (detail || "")); }
+
+main();
+
+async function main() {
+  await testInstantiateOnly();
+  await testQueryOnClosedConnection();
+  await testOpenCloseAsync();
+  await testOpenCloseSync();
+  await testOpenWithConnectionObject();
+  await testOpenClosePromise();
+  await testBadConnectionString();
+  await testConnectTimeout();
+  await testMultiOpenCloseAsync();
+  await testMultiOpenCloseSync();
+  await testGlobalOpenClose();
+
+  console.log("\n===== Connection Tests: %d passed, %d failed =====", passed, failed);
+  process.exit(failed ? 1 : 0);
+}
+
+// Test: just instantiating Database should not keep process alive
+async function testInstantiateOnly() {
+  console.log("\n[testInstantiateOnly]");
+  var db = new ibmdb.Database();
+  assert.equal(db.connected, false);
+  ok("Database instantiation without open does not hang");
+}
+
+// Test: query on a connection that was never opened
+async function testQueryOnClosedConnection() {
+  console.log("\n[testQueryOnClosedConnection]");
+  var db = new ibmdb.Database();
+  assert.equal(db.connected, false);
+
+  return new Promise(function(resolve) {
+    db.query("select 1 from sysibm.sysdummy1", function(err, rs, sqlca) {
+      try {
+        assert.deepEqual(err.message, 'Connection not open.');
+        assert.deepEqual(rs, []);
+        assert.equal(sqlca.sqlcode, -30081);
+        assert.equal(db.connected, false);
+        ok("query on unopened connection returns error");
+      } catch(e) {
+        fail("query on unopened connection", e.message);
+      }
+      resolve();
+    });
+  });
+}
+
+// Test: open and close with callbacks
+async function testOpenCloseAsync() {
+  console.log("\n[testOpenCloseAsync]");
+  return new Promise(function(resolve) {
+    var db = new ibmdb.Database();
+    db.open(cn, function(err) {
+      try {
+        assert.equal(err, null);
+        assert.equal(db.connected, true);
+      } catch(e) { fail("async open", e.message); resolve(); return; }
+
+      db.close(function() {
+        try {
+          assert.equal(db.connected, false);
+          ok("open and close with callbacks");
+        } catch(e) { fail("async close", e.message); }
+
+        // Verify query after close fails
+        db.query("select 1 from sysibm.sysdummy1", function(err, rs, sqlca) {
+          try {
+            assert.deepEqual(err.message, 'Connection not open.');
+            assert.deepEqual(rs, []);
+            assert.equal(sqlca.sqlcode, -30081);
+            ok("query after close returns error");
+          } catch(e) { fail("query after close", e.message); }
+          resolve();
+        });
+      });
+    });
+  });
+}
+
+// Test: openSync / closeSync
+async function testOpenCloseSync() {
+  console.log("\n[testOpenCloseSync]");
+  var db = new ibmdb.Database();
+  try {
+    db.openSync(cn);
+    assert.equal(db.connected, true);
+    db.closeSync();
+    assert.equal(db.connected, false);
+    ok("openSync and closeSync");
+  } catch(e) {
+    fail("openSync/closeSync", e.message);
+  }
+}
+
+// Test: open with connection object (not string)
+async function testOpenWithConnectionObject() {
+  console.log("\n[testOpenWithConnectionObject]");
+  return new Promise(function(resolve) {
+    var db = new ibmdb.Database();
+    db.open(common.connectionObject, function(err) {
+      try {
+        assert.equal(err, null);
+        assert.equal(db.connected, true);
+        var result = db.querySync("select 1 as COL1 from sysibm.sysdummy1");
+        assert.equal(result.length, 1);
+        ok("open with connectionObject");
+      } catch(e) { fail("open with connectionObject", e.message); }
+      db.close(function() { resolve(); });
+    });
+  });
+}
+
+// Test: open/close using Promises
+async function testOpenClosePromise() {
+  console.log("\n[testOpenClosePromise]");
+  var db = new ibmdb.Database();
+  try {
+    // query before open should reject
+    var err = await db.query("select 1 from sysibm.sysdummy1").then(null, function(e) { return e; });
+    assert.deepEqual(err, { message: 'Connection not open.', sqlstate: '08001', sqlcode: -30081 });
+    assert.equal(db.connected, false);
+    ok("promise: query before open rejects");
+
+    await db.open(cn);
+    assert.equal(db.connected, true);
+    ok("promise: open resolves");
+
+    await db.close();
+    assert.equal(db.connected, false);
+    ok("promise: close resolves");
+
+    // query after close
+    err = await db.query("select 1 from sysibm.sysdummy1").then(null, function(e) { return e; });
+    assert.deepEqual(err, { message: 'Connection not open.', sqlstate: '08001', sqlcode: -30081 });
+    ok("promise: query after close rejects");
+  } catch(e) {
+    fail("promise open/close", e.message);
+  }
+}
+
+// Test: bad connection string
+async function testBadConnectionString() {
+  console.log("\n[testBadConnectionString]");
+  var db = new ibmdb.Database();
+
+  // Sync: should throw
+  try {
+    db.openSync("this is wrong");
+    fail("bad connstr sync should throw");
+  } catch(e) {
+    assert.equal(db.connected, false);
+    ok("openSync with bad connstr throws");
+  }
+
+  // Async: should return error with platform-specific message
+  return new Promise(function(resolve) {
+    db.open("this is wrong", function(err) {
+      try {
+        assert.ok(err);
+        assert.equal(db.connected, false);
+        if (/^win/.test(process.platform)) {
+          assert.ok(err.message.indexOf('SQL1024N') >= 0);
+        } else if (os.type() === "OS/390") {
+          assert.ok(/SQLCODE\s*=\s*-950/.test(err.message));
+        } else {
+          assert.ok(err.message.indexOf('SQL1024N') >= 0);
+        }
+        ok("open with bad connstr returns platform-specific error");
+      } catch(e) { fail("bad connstr async", e.message); }
+      resolve();
+    });
+  });
+}
+
+// Test: connectTimeout property
+async function testConnectTimeout() {
+  console.log("\n[testConnectTimeout]");
+  try {
+    // Constructor option sets connectTimeout
+    var db = new ibmdb.Database({ connectTimeout: 10, systemNaming: true });
+    await db.open(cn);
+    assert.equal(db.conn.connectTimeout, 10);
+    assert.equal(db.conn.systemNaming, true);
+    assert.equal(db.connected, true);
+    ok("connectTimeout and systemNaming via constructor");
+    await db.close();
+  } catch(e) {
+    fail("connectTimeout", e.message);
+  }
+
+  // Binding-level connectTimeout default and setter
+  return new Promise(function(resolve) {
+    var odbc = new ibmdb.ODBC();
+    odbc.createConnection(function(err, conn) {
+      if (err) { fail("binding createConnection", err.message); resolve(); return; }
+      try {
+        assert.equal(conn.connectTimeout, 30); // default is 30
+        conn.connectTimeout = 99;
+        assert.equal(conn.connectTimeout, 99);
+        ok("binding-level connectTimeout default and setter");
+      } catch(e) { fail("binding connectTimeout", e.message); }
+
+      try { conn.openSync(cn); conn.closeSync(); } catch(e) { /* DB may be unreachable */ }
+      resolve();
+    });
+  });
+}
+
+// Test: multiple async open/close in parallel
+async function testMultiOpenCloseAsync() {
+  console.log("\n[testMultiOpenCloseAsync]");
+  var count = 5;
+  var connections = [];
+
+  return new Promise(function(resolve) {
+    var opened = 0;
+    var openFailed = false;
+    for (var x = 0; x < count; x++) {
+      (function() {
+        var db = new ibmdb.Database();
+        connections.push(db);
+        db.open(cn, function(err) {
+          if (err) {
+            if (!openFailed) { openFailed = true; fail("multi open async", err.message); resolve(); }
+            return;
+          }
+          opened++;
+          if (opened === count) doClose();
+        });
+      })();
+    }
+
+    function doClose() {
+      var closed = 0;
+      connections.forEach(function(db) {
+        db.close(function() {
+          closed++;
+          if (closed === count) {
+            ok("multi open/close async (" + count + " connections)");
+            resolve();
+          }
+        });
+      });
+    }
+  });
+}
+
+// Test: multiple sync open/close
+async function testMultiOpenCloseSync() {
+  console.log("\n[testMultiOpenCloseSync]");
+  var count = 5;
+  var connections = [];
+
+  try {
+    for (var x = 0; x < count; x++) {
+      var db = new ibmdb.Database();
+      db.openSync(cn);
+      assert.equal(db.connected, true);
+      connections.push(db);
+    }
+    connections.forEach(function(db) {
+      db.closeSync();
+      assert.equal(db.connected, false);
+    });
+    ok("multi openSync/closeSync (" + count + " connections)");
+  } catch(e) {
+    fail("multi sync open/close", e.message);
+  }
+}
+
+// Test: global open helper (ibmdb.open)
+async function testGlobalOpenClose() {
+  console.log("\n[testGlobalOpenClose]");
+  return new Promise(function(resolve) {
+    ibmdb.open(cn, function(err, conn) {
+      try {
+        assert.equal(err, null);
+        assert.equal(conn.constructor.name, 'Database');
+        assert.equal(conn.connected, true);
+        ok("ibmdb.open() global helper");
+      } catch(e) { fail("global open", e.message); }
+      conn.close(function() { resolve(); });
+    });
+  });
+}

package/node_modules/ibm_db/test/test-date.js

@@ -1,32 +1,32 @@
-var common = require("./common")
-  , odbc = require("../")
-  , db = new odbc.Database()
-  , assert = require("assert")
-  ;
-
-db.open(common.connectionString, function(err) {
-  assert.equal(err, null);
-  assert.equal(db.connected, true);
-  
-  var dt = new Date();
-  var dtString = dt.toISOString().replace('Z','').replace('T', ' ') + '000';
-  var sql = "SELECT cast('" + dtString + "' as timestamp) as DT1 FROM SYSIBM.SYSDUMMY1";
-  
-  console.log(sql);
-  
-  db.query(sql, function (err, data) {
-    assert.equal(err, null);
-    assert.equal(data.length, 1);
-
-    db.close(function () {
-      assert.equal(db.connected, false);
-      console.log(dt);
-      console.log(data);
-      
-      //test selected data after the connection
-      //is closed, in case the assertion fails
-	  assert.equal(data[0].DT1.constructor.name, "String", "DT1 is not an instance of a String object");
-      //assert.equal(data[0].DT1.getTime(), dt.getTime());
-    });
-  });
-});
+var common = require("./common")
+  , odbc = require("../")
+  , db = new odbc.Database()
+  , assert = require("assert")
+  ;
+
+db.open(common.connectionString, function(err) {
+  assert.equal(err, null);
+  assert.equal(db.connected, true);
+
+  var dt = new Date();
+  var dtString = dt.toISOString().replace('Z','').replace('T', ' ') + '000';
+  var sql = "SELECT cast('" + dtString + "' as timestamp) as DT1 FROM SYSIBM.SYSDUMMY1";
+
+  console.log(sql);
+
+  db.query(sql, function (err, data) {
+    assert.equal(err, null);
+    assert.equal(data.length, 1);
+
+    db.close(function () {
+      assert.equal(db.connected, false);
+      console.log(dt);
+      console.log(data);
+
+      //test selected data after the connection
+      //is closed, in case the assertion fails
+	  assert.equal(data[0].DT1.constructor.name, "String", "DT1 is not an instance of a String object");
+      //assert.equal(data[0].DT1.getTime(), dt.getTime());
+    });
+  });
+});

package/node_modules/ibm_db/test/test-dbclob.js

@@ -1,93 +1,93 @@
-var common = require("./common")
-    , ibmdb = require("../")
-    , crypt = require('crypto')
-    , assert = require('assert')
-    , cn = common.connectionString;
-
-async function main() {	
-    const BLOB_LENGTH = 1024 * 16;
-    const conn = await ibmdb.open(cn)
-    let results;
-
-    results = await conn.querySync(`create table DBCLOB_TAB (id int, B1 DBCLOB(${BLOB_LENGTH}))`);
-    console.log(results);
-
-    const filler = 'X'.repeat(1000);
-
-    const source = {
-     "V1" : filler
-   , "V2" : "Oops"
-   }
-
-   const data = JSON.stringify(source," ",2);
-   console.log(data.length,Buffer.byteLength(data));
-
-    try {
-      results = await conn.query(`insert into DBCLOB_TAB (ID, B1) values (?, ?)`,[1,data]);
-      console.log(results);
-    } catch (e) {
-      console.log(1,e);
-    }
-
-    results = await conn.query(`select ID, length(B1) L1, B1 from DBCLOB_TAB`);
-    console.log("result = ", results);
-    console.log("data =   ", data);
-
-    let target;
-    try {
-      target = JSON.parse(results[0].B1);
-      console.log(source.V1.length,target.V1.length);
-    } catch (e) {
-      console.log('Oops',e);
-    }
-
-    for (var i = 0; i < data.length; i++) {
-      if (data.charAt(i) !== results[0].B1.charAt(i)) {
-        console.log(i,data.charAt(i), results[0].B1.charAt(i));
-        assert.equal(data.charAt(i), results[0].B1.charAt(i));
-        break;
-      }
-    }
-    await conn.query(`drop table DBCLOB_TAB`);
-}
-
-async function blobTest() {
-    const BLOB_LENGTH = 256;
-    const conn = await ibmdb.open(cn);
-    let results;
-
-    results = await conn.querySync(`create table BLOB_TAB (id int, B1 BLOB(${BLOB_LENGTH}))`);
-    console.log(results);
-
-    const values = Array.from(Array(BLOB_LENGTH).keys());
-    console.log("values = ", values);
-    const buf = Buffer.from(values);
-    console.log("buffer = ", buf);
-    console.log("buflen = ", buf.length);
-
-    const blobParam = {DataType: "BLOB", Data:buf};
-
-    try {
-      const query = {
-        sql   : `insert into BLOB_TAB (ID, B1) values (?, ?)`
-      ,	params:  [1, blobParam]
-      }
-
-      results = await conn.query(query);
-      console.log(results);
-    } catch (e) {
-      console.log(1,e);
-    }
-    results = await conn.query(`select ID, length(B1) L1, B1 from BLOB_TAB`);
-    console.log("result = ", results);
-    await conn.query(`drop table BLOB_TAB`);
-}
-
-main().then(() => {
-    console.log('DBCLOB test success');
-    console.log("==================\n");
-    blobTest().then(() => {
-        console.log('BLOB test success');
-        console.log("==================\n");
-        })
-    }).catch((e) => { console.log(e); })
+var common = require("./common")
+    , ibmdb = require("../")
+    , crypt = require('crypto')
+    , assert = require('assert')
+    , cn = common.connectionString;
+
+async function main() {
+    const BLOB_LENGTH = 1024 * 16;
+    const conn = await ibmdb.open(cn)
+    let results;
+
+    results = await conn.querySync(`create table DBCLOB_TAB (id int, B1 DBCLOB(${BLOB_LENGTH}))`);
+    console.log(results);
+
+    const filler = 'X'.repeat(1000);
+
+    const source = {
+     "V1" : filler
+   , "V2" : "Oops"
+   }
+
+   const data = JSON.stringify(source," ",2);
+   console.log(data.length,Buffer.byteLength(data));
+
+    try {
+      results = await conn.query(`insert into DBCLOB_TAB (ID, B1) values (?, ?)`,[1,data]);
+      console.log(results);
+    } catch (e) {
+      console.log(1,e);
+    }
+
+    results = await conn.query(`select ID, length(B1) L1, B1 from DBCLOB_TAB`);
+    console.log("result = ", results);
+    console.log("data =   ", data);
+
+    let target;
+    try {
+      target = JSON.parse(results[0].B1);
+      console.log(source.V1.length,target.V1.length);
+    } catch (e) {
+      console.log('Oops',e);
+    }
+
+    for (var i = 0; i < data.length; i++) {
+      if (data.charAt(i) !== results[0].B1.charAt(i)) {
+        console.log(i,data.charAt(i), results[0].B1.charAt(i));
+        assert.equal(data.charAt(i), results[0].B1.charAt(i));
+        break;
+      }
+    }
+    await conn.query(`drop table DBCLOB_TAB`);
+}
+
+async function blobTest() {
+    const BLOB_LENGTH = 256;
+    const conn = await ibmdb.open(cn);
+    let results;
+
+    results = await conn.querySync(`create table BLOB_TAB (id int, B1 BLOB(${BLOB_LENGTH}))`);
+    console.log(results);
+
+    const values = Array.from(Array(BLOB_LENGTH).keys());
+    console.log("values = ", values);
+    const buf = Buffer.from(values);
+    console.log("buffer = ", buf);
+    console.log("buflen = ", buf.length);
+
+    const blobParam = {DataType: "BLOB", Data:buf};
+
+    try {
+      const query = {
+        sql   : `insert into BLOB_TAB (ID, B1) values (?, ?)`
+      ,	params:  [1, blobParam]
+      }
+
+      results = await conn.query(query);
+      console.log(results);
+    } catch (e) {
+      console.log(1,e);
+    }
+    results = await conn.query(`select ID, length(B1) L1, B1 from BLOB_TAB`);
+    console.log("result = ", results);
+    await conn.query(`drop table BLOB_TAB`);
+}
+
+main().then(() => {
+    console.log('DBCLOB test success');
+    console.log("==================\n");
+    blobTest().then(() => {
+        console.log('BLOB test success');
+        console.log("==================\n");
+        })
+    }).catch((e) => { console.log(e); })