dnrops
/
node-oracledb
mirror of https://github.com/oracle/node-oracledb
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor tests

This commit is contained in:
Christopher Jones 2023-02-21 14:27:04 +11:00
parent 93dcfb58fe
commit 147189bf9f
17 changed files with 3089 additions and 6318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

470
test/dmlReturning.js
View File

@ -35,19 +35,19 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var should = require('should');
var async = require('async');
var dbConfig = require('./dbconfig.js');
var assist = require('./dataTypeAssist.js');
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
const assist = require('./dataTypeAssist.js');
const testsUtil = require('./testsUtil.js');
describe('6. dmlReturning.js', function() {
describe('6.1 NUMBER & STRING driver data type', function() {
var connection = null;
beforeEach('get connection and prepare table', function(done) {
var makeTable =
let connection;
beforeEach('get connection and prepare table', async function() {
const makeTable =
"BEGIN \
DECLARE \
e_table_missing EXCEPTION; \
@ -80,105 +80,57 @@ describe('6. dmlReturning.js', function() {
(2001, ''Karen Morton'') \
'); \
END; ";
oracledb.getConnection(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString
},
function(err, conn) {
should.not.exist(err);
connection = conn;
conn.execute(
makeTable,
function(err) {
should.not.exist(err);
done();
}
);
}
);
connection = await oracledb.getConnection(dbConfig);
await connection.execute(makeTable);
});
afterEach('drop table and release connection', function(done) {
connection.execute(
"DROP TABLE nodb_dmlreturn PURGE",
function(err) {
if (err) {
console.error(err.message); return;
}
connection.release(function(err) {
if (err) {
console.error(err.message); return;
}
done();
});
}
);
afterEach('drop table and release connection', async function() {
await connection.execute("DROP TABLE nodb_dmlreturn PURGE");
await connection.close();
});
it('6.1.1 INSERT statement with Object binding', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.1 INSERT statement with Object binding', async function() {
const result = await connection.execute(
"INSERT INTO nodb_dmlreturn VALUES (1003, 'Robyn Sands') RETURNING id, name INTO :rid, :rname",
{
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT},
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT}
},
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.be.exactly(1);
result.outBinds.rid.should.eql([1003]);
result.outBinds.rname.should.eql(['Robyn Sands']);
done();
}
);
});
assert.strictEqual(result.rowsAffected, 1);
assert.strictEqual(result.outBinds.rid[0], 1003);
assert.strictEqual(result.outBinds.rname[0], 'Robyn Sands');
});
it('6.1.2 INSERT statement with Array binding', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.2 INSERT statement with Array binding', async function() {
const result = await connection.execute(
"INSERT INTO nodb_dmlreturn VALUES (1003, 'Robyn Sands') RETURNING id, name INTO :rid, :rname",
[
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.STRING, dir: oracledb.BIND_OUT }
],
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.be.exactly(1);
result.outBinds[0].should.eql([1003]);
result.outBinds[1].should.eql(['Robyn Sands']);
done();
}
]);
assert.strictEqual(result.rowsAffected, 1);
assert.strictEqual(result.outBinds[0][0], 1003);
assert.strictEqual(result.outBinds[1][0], 'Robyn Sands');
});
it('6.1.3 INSERT statement with small maxSize restriction', async function() {
const sql = "INSERT INTO nodb_dmlreturn VALUES (1003, 'Robyn Sands Delaware') RETURNING id, name INTO :rid, :rname";
const binds = {
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT, maxSize: 2 }
};
const options = {
autoCommit: true
};
await testsUtil.assertThrowsAsync(
async () => await connection.execute(sql, binds, options),
/NJS-016:/
);
});
it('6.1.3 INSERT statement with small maxSize restriction', function(done) {
connection.should.be.ok();
connection.execute(
"INSERT INTO nodb_dmlreturn VALUES (1003, 'Robyn Sands Delaware') RETURNING id, name INTO :rid, :rname",
{
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT, maxSize: 2 }
},
{ autoCommit: true },
function(err, result) {
should.exist(err);
should.strictEqual(
err.message,
"NJS-016: buffer is too small for OUT binds"
);
should.not.exist(result);
done();
}
);
});
it('6.1.4 UPDATE statement with single row matched', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.4 UPDATE statement with single row matched', async function() {
const result = await connection.execute(
"UPDATE nodb_dmlreturn SET name = :n WHERE id = :i RETURNING id, name INTO :rid, :rname",
{
n: "Kerry Osborne",
@ -186,21 +138,14 @@ describe('6. dmlReturning.js', function() {
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT }
},
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.be.exactly(1);
result.outBinds.rid.should.eql([2001]);
result.outBinds.rname.should.eql(['Kerry Osborne']);
done();
}
);
{ autoCommit: true });
assert.strictEqual(result.rowsAffected, 1);
assert.strictEqual(result.outBinds.rid[0], 2001);
assert.strictEqual(result.outBinds.rname[0], 'Kerry Osborne');
});
it('6.1.5 UPDATE statement with single row matched & Array binding', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.5 UPDATE statement with single row matched & Array binding', async function() {
const result = await connection.execute(
"UPDATE nodb_dmlreturn SET name = :n WHERE id = :i RETURNING id, name INTO :rid, :rname",
[
"Kerry Osborne",
@ -208,113 +153,78 @@ describe('6. dmlReturning.js', function() {
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.STRING, dir: oracledb.BIND_OUT }
],
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.be.exactly(1);
result.outBinds[0].should.eql([2001]);
result.outBinds[1].should.eql(['Kerry Osborne']);
done();
}
);
{ autoCommit: true });
assert.strictEqual(result.rowsAffected, 1);
assert.strictEqual(result.outBinds[0][0], 2001);
assert.strictEqual(result.outBinds[1][0], 'Kerry Osborne');
});
it('6.1.6 UPDATE statements with multiple rows matched', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.6 UPDATE statements with multiple rows matched', async function() {
const result = await connection.execute(
"UPDATE nodb_dmlreturn SET id = :i RETURNING id, name INTO :rid, :rname",
{
i: 999,
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT }
},
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.be.exactly(3);
result.outBinds.rid.should.eql([999, 999, 999]);
result.outBinds.rname.should.eql([ 'Chris Jones', 'Tom Kyte', 'Karen Morton' ]);
done();
}
);
{ autoCommit: true });
assert.strictEqual(result.rowsAffected, 3);
assert.deepEqual(result.outBinds.rid, [999, 999, 999]);
assert.deepEqual(result.outBinds.rname, [ 'Chris Jones', 'Tom Kyte', 'Karen Morton' ]);
});
it('6.1.7 UPDATE statements with multiple rows matched & Array binding', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.7 UPDATE statements with multiple rows matched & Array binding', async function() {
const result = await connection.execute(
"UPDATE nodb_dmlreturn SET id = :i RETURNING id, name INTO :rid, :rname",
[
999,
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.STRING, dir: oracledb.BIND_OUT }
],
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.be.exactly(3);
result.outBinds[0].should.eql([999, 999, 999]);
result.outBinds[1].should.eql([ 'Chris Jones', 'Tom Kyte', 'Karen Morton' ]);
done();
}
);
{ autoCommit: true });
assert.strictEqual(result.rowsAffected, 3);
assert.deepEqual(result.outBinds[0], [999, 999, 999]);
assert.deepEqual(result.outBinds[1], [ 'Chris Jones', 'Tom Kyte', 'Karen Morton' ]);
});
it('6.1.8 DELETE statement with Object binding', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.8 DELETE statement with Object binding', async function() {
const result = await connection.execute(
"DELETE FROM nodb_dmlreturn WHERE name like '%Chris%' RETURNING id, name INTO :rid, :rname",
{
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT }
},
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.exactly(1);
result.outBinds.rid.should.eql([1001]);
result.outBinds.rname.should.eql([ 'Chris Jones' ]);
done();
}
);
{ autoCommit: true });
assert.strictEqual(result.rowsAffected, 1);
assert.deepEqual(result.outBinds.rid, [1001]);
assert.deepEqual(result.outBinds.rname, ['Chris Jones']);
});
it('6.1.9 DELETE statement with Array binding', function(done) {
connection.should.be.ok();
connection.execute(
it('6.1.9 DELETE statement with Array binding', async function() {
const result = await connection.execute(
"DELETE FROM nodb_dmlreturn WHERE name like '%Chris%' RETURNING id, name INTO :rid, :rname",
[
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.STRING, dir: oracledb.BIND_OUT }
],
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.rowsAffected.should.exactly(1);
result.outBinds[0].should.eql([1001]);
result.outBinds[1].should.eql([ 'Chris Jones' ]);
done();
}
);
{ autoCommit: true });
assert.strictEqual(result.rowsAffected, 1);
assert.deepEqual(result.outBinds[0], [1001]);
assert.deepEqual(result.outBinds[1], ['Chris Jones']);
});
// it currently fails with 11.2 database
it('6.1.10 Stress test - support 4k varchars', function(done) {
it('6.1.10 Stress test - support 4k varchars', async function() {
/*** Helper functions ***/
var makeString = function(size) {
var buffer = new StringBuffer();
for (var i = 0; i < size; i++)
const makeString = function(size) {
const buffer = new StringBuffer();
for (let i = 0; i < size; i++)
buffer.append('A');
return buffer.toString();
};
var StringBuffer = function() {
const StringBuffer = function() {
this.buffer = [];
this.index = 0;
};
@ -331,10 +241,9 @@ describe('6. dmlReturning.js', function() {
}
};
/*** string length **/
var size = 4000;
const size = 4000;
connection.should.be.ok();
connection.execute(
const result = await connection.execute(
"INSERT INTO nodb_dmlreturn VALUES (:i, :n) RETURNING id, name INTO :rid, :rname",
{
i: size,
@ -342,34 +251,21 @@ describe('6. dmlReturning.js', function() {
rid: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT},
rname: { type: oracledb.STRING, dir: oracledb.BIND_OUT, maxSize: 4000}
},
{ autoCommit: true },
function(err, result) {
should.not.exist(err);
// console.log(result);
result.outBinds.rid.should.eql([size]);
result.outBinds.rname[0].length.should.be.exactly(size);
done();
}
);
{ autoCommit: true });
assert.deepEqual(result.outBinds.rid, [size]);
assert.strictEqual(result.outBinds.rname[0].length, size);
});
it('6.1.11 Negative test - wrong SQL got correct error thrown', function(done) {
connection.should.be.ok();
var wrongSQL = "UPDATE nodb_dmlreturn SET doesnotexist = 'X' WHERE id = :id RETURNING name INTO :rn";
it('6.1.11 Negative test - wrong SQL got correct error thrown', async function() {
const wrongSQL = "UPDATE nodb_dmlreturn SET doesnotexist = 'X' WHERE id = :id RETURNING name INTO :rn";
const binds = {
id: 2001,
rn: { type: oracledb.STRING, dir: oracledb.BIND_OUT }
};
connection.execute(
wrongSQL,
{
id: 2001,
rn: { type: oracledb.STRING, dir: oracledb.BIND_OUT }
},
function(err, result) {
should.exist(err);
// console.log(err.message);
(err.message).should.startWith('ORA-00904: ');
should.not.exist(result);
done();
}
await testsUtil.assertThrowsAsync(
async () => await connection.execute(wrongSQL, binds),
/ORA-00904:/
);
});
@ -377,185 +273,144 @@ describe('6. dmlReturning.js', function() {
describe('6.2 DATE and TIMESTAMP data', function() {
var connection = null;
var tableName = "nodb_date";
var dates = assist.DATE_STRINGS;
let connection;
const tableName = "nodb_date";
const dates = assist.DATE_STRINGS;
beforeEach('get connection, prepare table', function(done) {
async.series([
function(callback) {
oracledb.getConnection(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString
},
function(err, conn) {
should.not.exist(err);
connection = conn;
callback();
}
);
},
function(callback) {
assist.setUp4sql(connection, tableName, dates, callback);
}
], done);
beforeEach('get connection, prepare table', async function() {
connection = await oracledb.getConnection(dbConfig);
await new Promise((resolve) => {
assist.setUp4sql(connection, tableName, dates, resolve);
});
}); // before
afterEach('drop table, release connection', function(done) {
async.series([
function(callback) {
connection.execute(
"DROP table " + tableName + " PURGE",
function(err) {
should.not.exist(err);
callback();
}
);
},
function(callback) {
connection.release(function(err) {
should.not.exist(err);
callback();
});
}
], done);
afterEach('drop table, release connection', async function() {
await connection.execute("DROP table " + tableName + " PURGE");
await connection.close();
});
function runSQL(sql, bindVar, isSingleMatch, callback) {
var beAffectedRows = (isSingleMatch ? 1 : dates.length);
connection.execute(
sql,
bindVar,
function(err, result) {
should.not.exist(err);
result.rowsAffected.should.be.exactly(beAffectedRows);
// console.log(result);
callback();
}
);
async function runSQL(sql, bindVar, isSingleMatch) {
const beAffectedRows = (isSingleMatch ? 1 : dates.length);
const result = await connection.execute(sql, bindVar);
assert.strictEqual(result.rowsAffected, beAffectedRows);
}
it('6.2.1 INSERT statement, single row matched, Object binding, no bind in data', function(done) {
var sql = "INSERT INTO " + tableName + " VALUES (50, TO_DATE('2015-01-11','YYYY-DD-MM')) RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.1 INSERT statement, single row matched, Object binding, no bind in data', async function() {
const sql = "INSERT INTO " + tableName + " VALUES (50, TO_DATE('2015-01-11','YYYY-DD-MM')) RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
{
rnum: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rcontent: { type: oracledb.DATE, dir: oracledb.BIND_OUT }
};
var isSingleMatch = true;
runSQL(sql, bindVar, isSingleMatch, done);
const isSingleMatch = true;
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.2 INSERT statement with JavaScript date bind in ', function(done) {
var sql = "INSERT INTO " + tableName + " VALUES (:no, :c) RETURNING num, content INTO :rnum, :rcontent";
var ndate = new Date(2003, 9, 23, 11, 50, 30, 12);
it('6.2.2 INSERT statement with JavaScript date bind in ', async function() {
const sql = "INSERT INTO " + tableName + " VALUES (:no, :c) RETURNING num, content INTO :rnum, :rcontent";
const ndate = new Date(2003, 9, 23, 11, 50, 30, 12);
var bindVar =
const bindVar =
{
no: 51,
c: ndate,
rnum: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rcontent: { type: oracledb.DATE, dir: oracledb.BIND_OUT }
};
var isSingleMatch = true;
const isSingleMatch = true;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.3 INSERT statement with Array binding', function(done) {
var sql = "INSERT INTO " + tableName + " VALUES (50, TO_TIMESTAMP_TZ('1999-12-01 11:00:00.123456 -8:00', 'YYYY-MM-DD HH:MI:SS.FF TZH:TZM')) RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.3 INSERT statement with Array binding', async function() {
const sql = "INSERT INTO " + tableName + " VALUES (50, TO_TIMESTAMP_TZ('1999-12-01 11:00:00.123456 -8:00', 'YYYY-MM-DD HH:MI:SS.FF TZH:TZM')) RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
[
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.DATE, dir: oracledb.BIND_OUT }
];
var isSingleMatch = true;
const isSingleMatch = true;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.4 UPDATE statement with single row matched', function(done) {
var sql = "UPDATE " + tableName + " SET content = :c WHERE num = :n RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.4 UPDATE statement with single row matched', async function() {
const sql = "UPDATE " + tableName + " SET content = :c WHERE num = :n RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
{
c: { type: oracledb.DATE, dir: oracledb.BIND_IN, val: new Date(2003, 9, 23, 11, 50, 30, 123) },
n: 0,
rnum: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rcontent: { type: oracledb.DATE, dir: oracledb.BIND_OUT }
};
var isSingleMatch = true;
const isSingleMatch = true;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.5 UPDATE statements with multiple rows matched, ARRAY binding format', function(done) {
var sql = "UPDATE " + tableName + " SET content = :c WHERE num < :n RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.5 UPDATE statements with multiple rows matched, ARRAY binding format', async function() {
const sql = "UPDATE " + tableName + " SET content = :c WHERE num < :n RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
[
{ type: oracledb.DATE, dir: oracledb.BIND_IN, val: new Date(2003, 9, 23, 11, 50, 30, 123) },
100,
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.DATE, dir: oracledb.BIND_OUT }
];
var isSingleMatch = false;
const isSingleMatch = false;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.6 UPDATE statements, multiple rows, TIMESTAMP data', function(done) {
var sql = "UPDATE " + tableName + " SET content = TO_TIMESTAMP_TZ('1999-12-01 11:00:00.123456 -8:00', 'YYYY-MM-DD HH:MI:SS.FF TZH:TZM') " +
it('6.2.6 UPDATE statements, multiple rows, TIMESTAMP data', async function() {
const sql = "UPDATE " + tableName + " SET content = TO_TIMESTAMP_TZ('1999-12-01 11:00:00.123456 -8:00', 'YYYY-MM-DD HH:MI:SS.FF TZH:TZM') " +
" WHERE num < :n RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
const bindVar =
{
n: 100,
rnum: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rcontent: { type: oracledb.DATE, dir: oracledb.BIND_OUT }
};
var isSingleMatch = false;
const isSingleMatch = false;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.7 DELETE statement, single row matched, Object binding format', function(done) {
var sql = "DELETE FROM " + tableName + " WHERE num = :n RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.7 DELETE statement, single row matched, Object binding format', async function() {
const sql = "DELETE FROM " + tableName + " WHERE num = :n RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
{
n: 0,
rnum: { type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
rcontent: { type: oracledb.DATE, dir: oracledb.BIND_OUT }
};
var isSingleMatch = true;
const isSingleMatch = true;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.8 DELETE statement, multiple rows matched, Array binding format', function(done) {
var sql = "DELETE FROM " + tableName + " WHERE num >= :n RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.8 DELETE statement, multiple rows matched, Array binding format', async function() {
const sql = "DELETE FROM " + tableName + " WHERE num >= :n RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
[
0,
{ type: oracledb.NUMBER, dir: oracledb.BIND_OUT },
{ type: oracledb.DATE, dir: oracledb.BIND_OUT }
];
var isSingleMatch = false;
const isSingleMatch = false;
runSQL(sql, bindVar, isSingleMatch, done);
await runSQL(sql, bindVar, isSingleMatch);
});
it('6.2.9 Negative test - bind value and type mismatch', function(done) {
var wrongSQL = "UPDATE " + tableName + " SET content = :c WHERE num = :n RETURNING num, content INTO :rnum, :rcontent";
var bindVar =
it('6.2.9 Negative test - bind value and type mismatch', async function() {
const wrongSQL = "UPDATE " + tableName + " SET content = :c WHERE num = :n RETURNING num, content INTO :rnum, :rcontent";
const bindVar =
{
n: 0,
c: { type: oracledb.STRING, dir: oracledb.BIND_IN, val: new Date(2003, 9, 23, 11, 50, 30, 123) },
@ -563,20 +418,11 @@ describe('6. dmlReturning.js', function() {
rcontent: { type: oracledb.DATE, dir: oracledb.BIND_OUT }
};
connection.execute(
wrongSQL,
bindVar,
function(err, result) {
should.exist(err);
// console.log(err.message);
// NJS-011: encountered bind value and type mismatch
(err.message).should.startWith('NJS-011:');
should.not.exist(result);
done();
}
await testsUtil.assertThrowsAsync(
async () => await connection.execute(wrongSQL, bindVar),
/NJS-011:/
);
// NJS-011: encountered bind value and type mismatch
});
}); // 6.2

77
test/errorOffset.js
View File

@ -32,54 +32,48 @@
'use strict';
const oracledb = require('oracledb');
const should = require('should');
const assert = require('assert');
const dbconfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
describe('240. errorOffset.js', function() {
let conn;
before(async () => {
try {
conn = await oracledb.getConnection(dbconfig);
} catch (error) {
should.not.exist(error);
}
conn = await oracledb.getConnection(dbconfig);
});
after(async () => {
try {
await conn.close();
} catch (error) {
should.not.exist(error);
}
await conn.close();
});
it('240.1 checks the offset value of the error', async () => {
try {
await conn.execute("begin t_Missing := 5; end;");
} catch (error) {
should.exist(error);
should.strictEqual(error.offset, 6);
should.strictEqual(error.errorNum, 6550);
}
await testsUtil.assertThrowsAsync(
async () => await conn.execute("begin t_Missing := 5; end;"),
(err) => {
assert.strictEqual(err.offset, 6);
assert.strictEqual(err.errorNum, 6550);
return true;
}
);
}); // 240.1
it('240.2 database error', async () => {
const plsql = `
begin
execute immediate ('drop table nodb_table_nonexistent');
end;
`;
try {
await conn.execute(plsql);
} catch (error) {
should.exist(error);
should.strictEqual(error.offset, 0);
should.strictEqual(error.errorNum, 942);
}
await testsUtil.assertThrowsAsync(
async () => await conn.execute(plsql),
(err) => {
assert.strictEqual(err.offset, 0);
assert.strictEqual(err.errorNum, 942);
return true;
}
);
}); // 240.2
@ -92,13 +86,14 @@ describe('240. errorOffset.js', function() {
END;
END;
`;
try {
await conn.execute(plsql);
} catch (error) {
should.exist(error);
should.strictEqual(error.offset, 0);
should.strictEqual(error.errorNum, 1476);
}
await testsUtil.assertThrowsAsync(
async () => await conn.execute(plsql),
(err) => {
assert.strictEqual(err.offset, 0);
assert.strictEqual(err.errorNum, 1476);
return true;
}
);
});// 240.3
it('240.4 PL/SQL syntax error', async () => {
@ -106,12 +101,14 @@ describe('240. errorOffset.js', function() {
BEGIN
v_missing_semicolon := 46;
END;`;
try {
await conn.execute(plsql);
} catch (error) {
should.exist(error);
should.strictEqual(error.offset, 46);
should.strictEqual(error.errorNum, 6550);
}
await testsUtil.assertThrowsAsync(
async () => await conn.execute(plsql),
(err) => {
assert.strictEqual(err.offset, 46);
assert.strictEqual(err.errorNum, 6550);
return true;
}
);
}); // 240.4
});

1111
test/executeMany1.js
View File

File diff suppressed because it is too large Load Diff

164
test/lastRowid.js
View File

@ -32,7 +32,7 @@
'use strict';
const oracledb = require('oracledb');
const should = require('should');
const assert = require('assert');
const dbconfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
@ -42,68 +42,55 @@ describe('228. lastRowid.js', function() {
const TABLE = 'nodb_lastrowid';
before('get connection and create table', async () => {
try {
conn = await oracledb.getConnection(dbconfig);
let sql =
`create table ${TABLE} (
id number(9) not null,
value varchar2(100) not null
)`;
let plsql = testsUtil.sqlCreateTable(TABLE, sql);
await conn.execute(plsql);
} catch (err) {
should.not.exist(err);
}
conn = await oracledb.getConnection(dbconfig);
const sql =
`create table ${TABLE} (
id number(9) not null,
value varchar2(100) not null
)`;
const plsql = testsUtil.sqlCreateTable(TABLE, sql);
await conn.execute(plsql);
});
after(async () => {
try {
let sql = `drop table ${TABLE} purge`;
await conn.execute(sql);
await conn.close();
} catch (err) {
should.not.exist(err);
}
await conn.close();
await testsUtil.dropTable(TABLE);
});
it('228.1 examples', async () => {
const row1 = [1, "First"];
const row2 = [2, "Second"];
try {
// insert some rows and retain the rowid of each
let sql = `insert into ${TABLE} values (:1, :2)`;
const result1 = await conn.execute(sql, row1);
should.exist(result1.lastRowid);
should.strictEqual(result1.rowsAffected, 1);
const result2 = await conn.execute(sql, row2);
should.exist(result2.lastRowid);
should.strictEqual(result2.rowsAffected, 1);
const rowid2 = result2.lastRowid;
// insert some rows and retain the rowid of each
let sql = `insert into ${TABLE} values (:1, :2)`;
const result1 = await conn.execute(sql, row1);
assert(result1.lastRowid);
assert.strictEqual(result1.rowsAffected, 1);
const result2 = await conn.execute(sql, row2);
assert(result2.lastRowid);
assert.strictEqual(result2.rowsAffected, 1);
const rowid2 = result2.lastRowid;
// the row can be fetched with the rowid that was retained
sql = `select * from ${TABLE} where rowid = :1`;
let result = await conn.execute(sql, [result1.lastRowid]);
should.deepEqual(result.rows[0], row1);
result = await conn.execute(sql, [result2.lastRowid]);
should.deepEqual(result.rows[0], row2);
// the row can be fetched with the rowid that was retained
sql = `select * from ${TABLE} where rowid = :1`;
let result = await conn.execute(sql, [result1.lastRowid]);
assert.deepEqual(result.rows[0], row1);
result = await conn.execute(sql, [result2.lastRowid]);
assert.deepEqual(result.rows[0], row2);
// updating multiple rows only returns the rowid of the last updated row
sql = `update ${TABLE} set value = value || ' (Modified)'`;
result = await conn.execute(sql);
should.strictEqual(result.lastRowid, rowid2);
// updating multiple rows only returns the rowid of the last updated row
sql = `update ${TABLE} set value = value || ' (Modified)'`;
result = await conn.execute(sql);
assert.strictEqual(result.lastRowid, rowid2);
// deleting multiple rows only returns the rowid of the last deleted row
sql = `delete from ${TABLE}`;
result = await conn.execute(sql);
should.strictEqual(result.lastRowid, rowid2);
// deleting multiple rows only returns the rowid of the last deleted row
sql = `delete from ${TABLE}`;
result = await conn.execute(sql);
assert.strictEqual(result.lastRowid, rowid2);
// deleting no rows results in an undefined value
result = await conn.execute(sql);
should.not.exist(result.lastRowid);
} catch (err) {
should.not.exist(err);
}
// deleting no rows results in an undefined value
result = await conn.execute(sql);
assert(result.lastRowid === undefined);
}); // 228.1
it('228.2 MERGE statement', async () => {
@ -118,20 +105,15 @@ describe('228. lastRowid.js', function() {
insert (x.id, x.value)
values (y.tempId, y.tempValue)
`;
try {
const result1 = await conn.execute(sqlMerge, row1, { autoCommit: true });
should.exist(result1.lastRowid);
should.strictEqual(result1.rowsAffected, 1);
const rowID = result1.lastRowid;
const result1 = await conn.execute(sqlMerge, row1, { autoCommit: true });
assert.ok(result1.lastRowid);
assert.strictEqual(result1.rowsAffected, 1);
const rowID = result1.lastRowid;
// check it out
let sql = `select * from ${TABLE} where rowid = :1`;
let result2 = await conn.execute(sql, [ rowID ]);
should.deepEqual(result2.rows[0], row1);
} catch (err) {
should.not.exist(err);
}
// check it out
let sql = `select * from ${TABLE} where rowid = :1`;
let result2 = await conn.execute(sql, [ rowID ]);
assert.deepEqual(result2.rows[0], row1);
}); // 228.2
it('228.3 Negative - not applicable to executeMany()', async () => {
@ -157,49 +139,41 @@ describe('228. lastRowid.js', function() {
}
};
try {
const result1 = await conn.executeMany(sqlMerge, rows, options);
should.not.exist(result1.lastRowid);
should.strictEqual(result1.rowsAffected, 2);
const result1 = await conn.executeMany(sqlMerge, rows, options);
assert(result1.lastRowid === undefined);
assert.strictEqual(result1.rowsAffected, 2);
let sql = `select * from ${TABLE} where id >= :1`;
let result2 = await conn.execute(
sql,
[ rows[0].id ],
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
);
should.strictEqual(result2.rows[0].ID, rows[0].id);
should.strictEqual(result2.rows[0].VALUE, rows[0].value);
should.strictEqual(result2.rows[1].ID, rows[1].id);
should.strictEqual(result2.rows[1].VALUE, rows[1].value);
} catch (err) {
should.not.exist(err);
}
let sql = `select * from ${TABLE} where id >= :1`;
let result2 = await conn.execute(
sql,
[ rows[0].id ],
{ outFormat: oracledb.OUT_FORMAT_OBJECT }
);
assert.strictEqual(result2.rows[0].ID, rows[0].id);
assert.strictEqual(result2.rows[0].VALUE, rows[0].value);
assert.strictEqual(result2.rows[1].ID, rows[1].id);
assert.strictEqual(result2.rows[1].VALUE, rows[1].value);
}); // 228.3
it('228.4 INSERT ALL statement', async () => {
const rows = ['Redwood city', 'Sydney', 'Shenzhen'];
const sqlInsertAll = `
insert all
into ${TABLE} (id, value) values (100, :v)
into ${TABLE} (id, value) values (200, :v)
into ${TABLE} (id, value) values (300, :v)
into ${TABLE} (id, value) values (100, :v1)
into ${TABLE} (id, value) values (200, :v2)
into ${TABLE} (id, value) values (300, :v3)
select * from dual
`;
try {
let result = await conn.execute(sqlInsertAll, rows);
should.not.exist(result.lastRowid);
should.strictEqual(result.rowsAffected, 3);
let result = await conn.execute(sqlInsertAll, rows);
assert(result.lastRowid === undefined);
assert.strictEqual(result.rowsAffected, 3);
let sql = `select * from ${TABLE} where id >= 100 order by id asc`;
result = await conn.execute(sql);
let sql = `select * from ${TABLE} where id >= 100 order by id asc`;
result = await conn.execute(sql);
should.strictEqual(result.rows[0][1], rows[0]);
should.strictEqual(result.rows[1][1], rows[1]);
should.strictEqual(result.rows[2][1], rows[2]);
} catch (err) {
should.not.exist(err);
}
assert.strictEqual(result.rows[0][1], rows[0]);
assert.strictEqual(result.rows[1][1], rows[1]);
assert.strictEqual(result.rows[2][1], rows[2]);
}); // 228.4
});

1118
test/lobBind2.js
View File

File diff suppressed because it is too large Load Diff

201
test/lobClose.js
View File

@ -31,168 +31,79 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var should = require('should');
var dbConfig = require('./dbconfig.js');
var fs = require('fs');
var async = require('async');
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
const fs = require('fs');
const testsUtil = require('./testsUtil.js');
describe('54. lobClose.js', function() {
var conn;
before(function(done) {
oracledb.getConnection(
dbConfig,
function(err, connection) {
should.not.exist(err);
conn = connection;
done();
}
);
let conn;
before(async function() {
conn = await oracledb.getConnection(dbConfig);
});
after(function(done) {
conn.close(function(err) {
should.not.exist(err);
done();
});
after(async function() {
await conn.close();
});
it('54.1 can access properties of closed LOB without error', function(done) {
conn.createLob(
oracledb.CLOB,
function(err, lob) {
should.not.exist(err);
(lob.chunkSize).should.be.a.Number();
(lob.pieceSize).should.be.a.Number();
should.strictEqual(lob.length, 0);
should.strictEqual(lob.type, oracledb.CLOB);
lob.close(function(err) {
should.not.exist(err);
(lob.chunkSize).should.be.a.Number();
(lob.pieceSize).should.be.a.Number();
should.strictEqual(lob.length, 0);
should.strictEqual(lob.type, oracledb.CLOB);
done();
});
}
);
it('54.1 can access properties of closed LOB without error', async function() {
const lob = await conn.createLob(oracledb.CLOB);
assert.strictEqual(typeof lob.chunkSize, 'number');
assert.strictEqual(typeof lob.pieceSize, 'number');
assert.strictEqual(lob.length, 0);
assert.strictEqual(lob.type, oracledb.CLOB);
await lob.close();
assert.strictEqual(typeof lob.chunkSize, 'number');
assert.strictEqual(typeof lob.pieceSize, 'number');
assert.strictEqual(lob.length, 0);
assert.strictEqual(lob.type, oracledb.CLOB);
}); // 54.1
it('54.2 can not call close() multiple times', function(done) {
conn.createLob(
oracledb.CLOB,
function(err, lob) {
should.not.exist(err);
lob.close(function(err) {
should.not.exist(err);
lob.close(function(err) {
should.not.exist(err);
done();
});
}); // first close();
}
);
it('54.2 can call close() multiple times', async function() {
const lob = await conn.createLob(oracledb.CLOB);
await lob.close();
await lob.close();
}); // 54.2
it('54.3 verify closed LOB', function(done) {
conn.createLob(
oracledb.CLOB,
function(err, lob) {
should.not.exist(err);
lob.close(function(err) {
should.not.exist(err);
var inFileName = './test/clobexample.txt';
var inStream = fs.createReadStream(inFileName);
inStream.pipe(lob);
inStream.on("error", function(err) {
should.not.exist(err, "inStream.on 'error' event.");
});
lob.on("error", function(err) {
should.strictEqual(
err.message,
"NJS-022: invalid Lob"
);
done();
});
lob.on('finish', function() {
done(new Error("LOB emits 'finish' event!"));
});
}); // lob.close()
}
it('54.3 verify closed LOB', async function() {
const lob = await conn.createLob(oracledb.CLOB);
await lob.close();
const inFileName = './test/clobexample.txt';
const inStream = fs.createReadStream(inFileName);
inStream.pipe(lob);
await testsUtil.assertThrowsAsync(
async () => {
await new Promise((resolve, reject) => {
inStream.on("error", reject);
lob.on("error", reject);
lob.on('finish', resolve);
});
},
/NJS-022:/
);
}); // 54.3
it('54.4 automatically close result sets and LOBs when the connection is closed', function(done) {
it('54.4 automatically close result sets and LOBs when the connection is closed', async function() {
const conn2 = await oracledb.getConnection(dbConfig);
const lob2 = await conn2.createLob(oracledb.CLOB);
await conn2.close();
var conn2 = null;
var lob2 = null;
async.series([
function creatConn(cb) {
oracledb.getConnection(
dbConfig,
function(err, connection) {
should.not.exist(err);
conn2 = connection;
cb();
}
);
},
function createLOB(cb) {
conn2.createLob(
oracledb.CLOB,
function(err, lob) {
should.not.exist(err);
lob2 = lob;
cb();
}
);
},
function closeConn(cb) {
conn2.close(cb);
},
function dotest(cb) {
// Verify that lob2 gets closed automatically
var inFileName = './test/clobexample.txt';
var inStream = fs.createReadStream(inFileName);
inStream.pipe(lob2);
inStream.on("error", function(err) {
should.not.exist(err, "inStream.on 'error' event.");
});
lob2.on("error", function(err) {
should.strictEqual(
err.message,
"DPI-1040: LOB was already closed"
);
cb();
// Verify that lob2 gets closed automatically
const inFileName = './test/clobexample.txt';
const inStream = fs.createReadStream(inFileName);
inStream.pipe(lob2);
await testsUtil.assertThrowsAsync(
async () => {
await new Promise((resolve, reject) => {
inStream.on("error", reject);
lob2.on("error", reject);
lob2.on('finish', resolve);
});
},
function(cb) {
(lob2.chunkSize).should.be.a.Number();
(lob2.pieceSize).should.be.a.Number();
should.strictEqual(lob2.length, 0);
should.strictEqual(lob2.type, oracledb.CLOB);
cb();
}
], done);
/DPI-1040:/
);
}); // 54.4
});

586
test/lobProperties1.js
View File

@ -32,22 +32,21 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var fs = require('fs');
var should = require('should');
var async = require('async');
var dbConfig = require('./dbconfig.js');
const oracledb = require('oracledb');
const fs = require('fs');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
describe('62. lobProperties1.js', function() {
var tableName = "nodb_tab_mylobprops";
var connection = null;
var sqlSelect = "SELECT * FROM " + tableName + " WHERE id = :i";
var defaultChunkSize = null;
const tableName = "nodb_tab_mylobprops";
let connection;
const sqlSelect = "SELECT * FROM " + tableName + " WHERE id = :i";
let defaultChunkSize = null;
before('prepare table and LOB data', function(done) {
before('prepare table and LOB data', async function() {
var sqlCreateTab =
const sqlCreateTab =
" BEGIN "
+ " DECLARE "
+ " e_table_missing EXCEPTION; "
@ -65,446 +64,199 @@ describe('62. lobProperties1.js', function() {
+ " '); "
+ " END; ";
var sqlInsert = "INSERT INTO " + tableName + " VALUES (:i, EMPTY_CLOB(), EMPTY_BLOB()) "
const sqlInsert = "INSERT INTO " + tableName + " VALUES (:i, EMPTY_CLOB(), EMPTY_BLOB()) "
+ " RETURNING c, b INTO :clob, :blob";
var bindVar =
const bindVar =
{
i: 1,
clob: { type: oracledb.CLOB, dir: oracledb.BIND_OUT },
blob: { type: oracledb.BLOB, dir: oracledb.BIND_OUT }
};
var clobFileName = './test/clobexample.txt';
var blobFileName = './test/fuzzydinosaur.jpg';
const clobFileName = './test/clobexample.txt';
const blobFileName = './test/fuzzydinosaur.jpg';
async.series([
function(cb) {
oracledb.getConnection(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString
},
function(err, conn) {
should.not.exist(err);
connection = conn;
cb();
}
);
},
function(cb) {
connection.execute(
sqlCreateTab,
function(err) {
should.not.exist(err);
cb();
}
);
},
function insertLobData(cb) {
connection.execute(
sqlInsert,
bindVar,
function(err, result) {
should.not.exist(err);
var clob = result.outBinds.clob[0];
var blob = result.outBinds.blob[0];
var clobStream = fs.createReadStream(clobFileName);
var blobStream = fs.createReadStream(blobFileName);
clobStream.on('error', function(err) {
should.not.exist(err);
});
blobStream.on('error', function(err) {
should.not.exist(err);
});
clob.on('error', function(err) {
should.not.exist(err);
});
blob.on('error', function(err) {
should.not.exist(err);
});
async.parallel([
function(callback) {
clob.on('finish', function() {
callback();
});
},
function(callback) {
blob.on('finish', function() {
callback();
});
}
], function() {
connection.commit(function(err) {
should.not.exist(err);
cb();
});
});
clobStream.pipe(clob);
blobStream.pipe(blob);
}
);
},
function saveDefaultChunkSize(cb) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1];
var blob = result.rows[0][2];
defaultChunkSize = clob.chunkSize;
blob.close(function(err) {
if (err) return cb(err);
clob.close(cb);
});
}
);
}
], done);
connection = await oracledb.getConnection(dbConfig);
await connection.execute(sqlCreateTab);
let result = await connection.execute(sqlInsert, bindVar);
let clob = result.outBinds.clob[0];
let blob = result.outBinds.blob[0];
const clobStream = fs.createReadStream(clobFileName);
const blobStream = fs.createReadStream(blobFileName);
clobStream.pipe(clob);
blobStream.pipe(blob);
await new Promise((resolve, reject) => {
clobStream.on('error', reject);
blobStream.on('error', reject);
clob.on('error', reject);
blob.on('error', reject);
const waitForClob = async function() {
await new Promise((resolve) => {
clob.on('finish', resolve);
});
};
const waitForBlob = async function() {
await new Promise((resolve) => {
blob.on('finish', resolve);
});
};
Promise.all([waitForClob(), waitForBlob()]).then(resolve);
});
result = await connection.execute(sqlSelect, { i: 1 });
clob = result.rows[0][1];
blob = result.rows[0][2];
defaultChunkSize = clob.chunkSize;
await blob.close();
await clob.close();
}); // before
after(function(done) {
after(async function() {
await connection.execute("DROP TABLE " + tableName + " PURGE");
await connection.close();
});
async.series([
function(cb) {
connection.execute(
"DROP TABLE " + tableName + " PURGE",
function(err) {
should.not.exist(err);
cb();
}
);
},
function(cb) {
connection.release(function(err) {
should.not.exist(err);
cb();
});
}
], done);
}); // after
it('62.1 chunkSize (read-only)', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
var t1 = clob.chunkSize,
t2 = blob.chunkSize;
t1.should.be.a.Number();
t2.should.be.a.Number();
t1.should.eql(t2);
defaultChunkSize = clob.chunkSize;
try {
clob.chunkSize = t1 + 1;
} catch (err) {
should.exist(err);
// console.log(err.message);
// Cannot assign to read only property 'chunkSize' of #<Lob>
}
try {
blob.chunkSize = t2 + 1;
} catch (err) {
should.exist(err);
// console.log(err.message);
// Cannot assign to read only property 'chunkSize' of #<Lob>
}
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
it('62.1 chunkSize (read-only)', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
const t1 = clob.chunkSize;
const t2 = blob.chunkSize;
assert.strictEqual(typeof t1, 'number');
assert.strictEqual(typeof t2, 'number');
assert.strictEqual(t1, t2);
defaultChunkSize = clob.chunkSize;
assert.throws(
() => clob.chunkSize = t1 + 1,
/TypeError: Cannot set property/
);
assert.throws(
() => blob.chunkSize = t2 + 1,
/TypeError: Cannot set property/
);
await clob.close();
await blob.close();
}); // 62.1
it('62.2 length (read-only)', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
var t1 = clob.length,
t2 = blob.length;
t1.should.be.a.Number();
t2.should.be.a.Number();
t1.should.not.eql(t2);
try {
clob.length = t1 + 1;
} catch (err) {
should.exist(err);
//console.log(err.message);
// Cannot set property length of #<Lob> which has only a getter
}
try {
blob.length = t2 + 1;
} catch (err) {
should.exist(err);
//console.log(err.message);
// Cannot set property length of #<Lob> which has only a getter
}
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
it('62.2 length (read-only)', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
const t1 = clob.length;
const t2 = blob.length;
assert.throws(
() => clob.length = t1 + 1,
/TypeError: Cannot set property/
);
assert.throws(
() => blob.length = t2 + 1,
/TypeError: Cannot set property/
);
await clob.close();
await blob.close();
}); // 62.2
it('62.3 pieceSize -default value is chunkSize', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
var t1 = clob.pieceSize,
t2 = blob.pieceSize;
t1.should.eql(defaultChunkSize);
t2.should.eql(defaultChunkSize);
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
);
it('62.3 pieceSize -default value is chunkSize', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
assert.strictEqual(clob.pieceSize, defaultChunkSize);
assert.strictEqual(blob.pieceSize, defaultChunkSize);
await clob.close();
await blob.close();
}); // 62.3
it('62.4 pieceSize - can be increased', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
var newValue = clob.pieceSize * 5;
clob.pieceSize = clob.pieceSize * 5;
blob.pieceSize = blob.pieceSize * 5;
(clob.pieceSize).should.eql(newValue);
(blob.pieceSize).should.eql(newValue);
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
);
it('62.4 pieceSize - can be increased', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
const newValue = clob.pieceSize * 5;
clob.pieceSize = clob.pieceSize * 5;
blob.pieceSize = blob.pieceSize * 5;
assert.strictEqual(clob.pieceSize, newValue);
assert.strictEqual(blob.pieceSize, newValue);
await clob.close();
await blob.close();
}); // 62.4
it('62.5 pieceSize - can be decreased', function(done) {
if (defaultChunkSize <= 500) {
console.log('As default chunkSize is too small, this case is not applicable');
done();
} else {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
var newValue = clob.pieceSize - 500;
clob.pieceSize -= 500;
blob.pieceSize -= 500;
(clob.pieceSize).should.eql(newValue);
(blob.pieceSize).should.eql(newValue);
// Restore
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
);
}
it('62.5 pieceSize - can be decreased', async function() {
if (defaultChunkSize <= 500)
return this.skip();
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
const newValue = clob.pieceSize - 500;
clob.pieceSize -= 500;
blob.pieceSize -= 500;
assert.strictEqual(clob.pieceSize, newValue);
assert.strictEqual(blob.pieceSize, newValue);
await clob.close();
await blob.close();
}); // 62.5
it('62.6 pieceSize - can be zero', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
clob.pieceSize = 0;
blob.pieceSize = 0;
(clob.pieceSize).should.eql(0);
(blob.pieceSize).should.eql(0);
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
);
it('62.6 pieceSize - can be zero', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
clob.pieceSize = 0;
blob.pieceSize = 0;
assert.strictEqual(clob.pieceSize, 0);
assert.strictEqual(blob.pieceSize, 0);
await clob.close();
await blob.close();
}); // 62.6
it('62.7 pieceSize - cannot be less than zero', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
try {
clob.pieceSize = -100;
} catch (err) {
should.exist(err);
(err.message).should.startWith('NJS-004:');
// NJS-004: invalid value for property pieceSize
}
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
it('62.7 pieceSize - cannot be less than zero', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
assert.throws(
() => clob.pieceSize = -100,
/NJS-004:/
);
await clob.close();
await blob.close();
}); // 62.7
it('62.8 pieceSize - cannot be null', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
try {
clob.pieceSize = null;
} catch (err) {
should.exist(err);
(err.message).should.startWith('NJS-004:');
// NJS-004: invalid value for property pieceSize
}
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
it('62.8 pieceSize - cannot be null', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
assert.throws(
() => clob.pieceSize = null,
/NJS-004:/
);
await clob.close();
await blob.close();
}); // 62.8
it('62.9 pieceSize - must be a number', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
try {
clob.pieceSize = NaN;
} catch (err) {
should.exist(err);
(err.message).should.startWith('NJS-004:');
// NJS-004: invalid value for property pieceSize
}
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
it('62.9 pieceSize - must be a number', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
assert.throws(
() => clob.pieceSize = NaN,
/NJS-004:/
);
await clob.close();
await blob.close();
}); // 62.9
it('62.10 type (read-only)', function(done) {
connection.execute(
sqlSelect,
{ i: 1 },
function(err, result) {
should.not.exist(err);
var clob = result.rows[0][1],
blob = result.rows[0][2];
var t1 = clob.type,
t2 = blob.type;
t1.should.eql(oracledb.CLOB);
t2.should.eql(oracledb.BLOB);
try {
clob.type = t2;
} catch (err) {
should.exist(err);
// console.log(err);
// [TypeError: Cannot set property type of #<Lob> which has only a getter]
}
try {
blob.type = t1;
} catch (err) {
should.exist(err);
// console.log(err);
// [TypeError: Cannot set property type of #<Lob> which has only a getter]
}
clob.close(function(err) {
if (err) return done(err);
blob.close(done);
});
}
it('62.10 type (read-only)', async function() {
const result = await connection.execute(sqlSelect, { i: 1 });
const clob = result.rows[0][1];
const blob = result.rows[0][2];
assert.strictEqual(clob.type, oracledb.CLOB);
assert.strictEqual(blob.type, oracledb.BLOB);
assert.throws(
() => clob.type = oracledb.BLOB,
/TypeError: Cannot set/
);
assert.throws(
() => blob.type = oracledb.CLOB,
/TypeError: Cannot set/
);
await clob.close();
await blob.close();
}); // 62.10
});

298
test/lobProperties2.js
View File

@ -32,118 +32,76 @@
'use strict';
const oracledb = require('oracledb');
const should = require('should');
const async = require('async');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
describe("83. lobProperties2.js", function() {
let connection;
before(function(done) {
oracledb.getConnection(dbConfig, function(err, conn) {
should.not.exist(err);
connection = conn;
done();
});
}); // before
after(function(done) {
connection.close(function(err) {
should.not.exist(err);
done();
});
before(async function() {
connection = await oracledb.getConnection(dbConfig);
});
const checkChunkSize = function(type, callback) {
connection.createLob(type, function(err, lob) {
should.not.exist(err);
const t = lob.chunkSize;
t.should.be.a.Number();
try {
lob.chunkSize = t + 1;
} catch (err) {
should.exist(err);
// Cannot assign to read only property 'chunkSize' of object '#<Lob>'
}
lob.close(function(err) {
should.not.exist(err);
return callback();
});
});
}; // checkChunkSize
it("83.1 CLOB: chunkSize (read-only)", function(done) {
checkChunkSize(oracledb.CLOB, done);
after(async function() {
await connection.close();
});
it("83.2 BLOB: chunkSize (read-only)", function(done) {
checkChunkSize(oracledb.BLOB, done);
const checkChunkSize = async function(type) {
const lob = await connection.createLob(type);
const t = lob.chunkSize;
assert.strictEqual(typeof t, 'number');
assert.throws(
() => lob.chunkSize = t + 1,
/TypeError: Cannot set property chunkSize/
);
await lob.close();
};
it("83.1 CLOB: chunkSize (read-only)", async function() {
await checkChunkSize(oracledb.CLOB);
});
const checkLength = function(type, callback) {
it("83.2 BLOB: chunkSize (read-only)", async function() {
await checkChunkSize(oracledb.BLOB);
});
connection.createLob(type, function(err, lob) {
should.not.exist(err);
const t = lob.length;
t.should.be.a.Number();
try {
lob.length = t + 1;
} catch (err) {
should.exist(err);
// Cannot set property length of #<Lob> which has only a getter
}
lob.close(function(err) {
should.not.exist(err);
return callback();
});
});
const checkLength = async function(type) {
const lob = await connection.createLob(type);
const t = lob.length;
assert.strictEqual(typeof t, 'number');
assert.throws(
() => lob.length = t + 1,
/TypeError: Cannot set property length/
);
await lob.close();
}; // checkLength
it("83.3 CLOB: length (read-only)", function(done) {
checkLength(oracledb.CLOB, done);
it("83.3 CLOB: length (read-only)", async function() {
await checkLength(oracledb.CLOB);
});
it("83.4 BLOB: length (read-only)", function(done) {
checkLength(oracledb.BLOB, done);
it("83.4 BLOB: length (read-only)", async function() {
await checkLength(oracledb.BLOB);
});
const checkType = function(lobtype, callback) {
connection.createLob(lobtype, function(err, lob) {
should.not.exist(err);
const t = lob.type;
t.should.eql(lobtype);
try {
lob.type = oracledb.BUFFER;
} catch (err) {
should.exist(err);
// Cannot set property type of #<Lob> which has only a getter
}
lob.close(function(err) {
should.not.exist(err);
return callback();
});
});
const checkType = async function(lobtype) {
const lob = await connection.createLob(lobtype);
const t = lob.type;
assert.strictEqual(t, lobtype);
assert.throws(
() => lob.type = oracledb.BUFFER,
/TypeError: Cannot set property type/
);
await lob.close();
}; // checkType
it("83.5 CLOB: type (read-only)", function(done) {
checkType(oracledb.CLOB, done);
it("83.5 CLOB: type (read-only)", async function() {
await checkType(oracledb.CLOB);
});
it("83.6 BLOB: type (read-only)", function(done) {
checkType(oracledb.CLOB, done);
it("83.6 BLOB: type (read-only)", async function() {
await checkType(oracledb.CLOB);
});
describe("83.7 pieceSize", function() {
@ -151,141 +109,75 @@ describe("83. lobProperties2.js", function() {
let defaultChunkSize;
let clob, blob;
before("get the lobs", function(done) {
async.series([
function(cb) {
connection.createLob(oracledb.CLOB, function(err, lob) {
should.not.exist(err);
clob = lob;
defaultChunkSize = clob.chunkSize;
cb();
});
},
function(cb) {
connection.createLob(oracledb.BLOB, function(err, lob) {
should.not.exist(err);
blob = lob;
cb();
});
}
], done);
}); // before
after("close the lobs", function(done) {
async.series([
function(cb) {
clob.close(cb);
},
function(cb) {
blob.close(cb);
}
], done);
}); // after
it("83.7.1 default value is chunkSize", function(done) {
const t1 = clob.pieceSize,
t2 = blob.pieceSize;
t1.should.eql(defaultChunkSize);
t2.should.eql(defaultChunkSize);
done();
before("get the lobs", async function() {
clob = await connection.createLob(oracledb.CLOB);
defaultChunkSize = clob.chunkSize;
blob = await connection.createLob(oracledb.BLOB);
});
it("83.7.2 can be increased", function(done) {
after("close the lobs", async function() {
await clob.close();
await blob.close();
});
afterEach(function() {
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
});
it("83.7.1 default value is chunkSize", function() {
assert.strictEqual(clob.pieceSize, defaultChunkSize);
assert.strictEqual(blob.pieceSize, defaultChunkSize);
});
it("83.7.2 can be increased", function() {
const newValue = clob.pieceSize * 5;
clob.pieceSize = clob.pieceSize * 5;
blob.pieceSize = blob.pieceSize * 5;
(clob.pieceSize).should.eql(newValue);
(blob.pieceSize).should.eql(newValue);
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
done();
assert.strictEqual(clob.pieceSize, newValue);
assert.strictEqual(blob.pieceSize, newValue);
});
it("83.7.3 can be decreased", function(done) {
if (defaultChunkSize <= 500) {
console.log('As default chunkSize is too small, this case is not applicable');
} else {
const newValue = clob.pieceSize - 500;
it("83.7.3 can be decreased", function() {
if (defaultChunkSize <= 500)
return this.skip();
const newValue = clob.pieceSize - 500;
clob.pieceSize -= 500;
blob.pieceSize -= 500;
(clob.pieceSize).should.eql(newValue);
(blob.pieceSize).should.eql(newValue);
// Restore
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
}
return done();
clob.pieceSize -= 500;
blob.pieceSize -= 500;
assert.strictEqual(clob.pieceSize, newValue);
assert.strictEqual(blob.pieceSize, newValue);
});
it("83.7.4 can be zero", function(done) {
it("83.7.4 can be zero", function() {
clob.pieceSize = 0;
blob.pieceSize = 0;
(clob.pieceSize).should.eql(0);
(blob.pieceSize).should.eql(0);
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
done();
assert.strictEqual(clob.pieceSize, 0);
assert.strictEqual(blob.pieceSize, 0);
});
it("83.7.5 cannot be less than zero", function(done) {
try {
clob.pieceSize = -100;
} catch (err) {
should.exist(err);
(err.message).should.startWith('NJS-004:');
// NJS-004: invalid value for property pieceSize
}
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
done();
it("83.7.5 cannot be less than zero", function() {
assert.throws(
() => clob.pieceSize = -100,
/NJS-004:/
);
});
it("83.7.6 cannot be null", function(done) {
try {
clob.pieceSize = null;
} catch (err) {
should.exist(err);
(err.message).should.startWith('NJS-004:');
// NJS-004: invalid value for property pieceSize
}
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
done();
it("83.7.6 cannot be null", function() {
assert.throws(
() => clob.pieceSize = null,
/NJS-004:/
);
});
it("83.7.7 must be a number", function(done) {
try {
clob.pieceSize = NaN;
} catch (err) {
should.exist(err);
(err.message).should.startWith('NJS-004:');
// NJS-004: invalid value for property pieceSize
}
// Remember to restore the value
clob.pieceSize = defaultChunkSize;
blob.pieceSize = defaultChunkSize;
done();
it("83.7.7 must be a number", function() {
assert.throws(
() => clob.pieceSize = NaN,
/NJS-004:/
);
});
}); // 83.7

7
test/notes.js
View File

@ -94,13 +94,10 @@ if (dbconfig.test.proxySessionUser) {
}
before(async function() {
let connection = null;
await Promise.all(configList.map(async function(conf) {
connection = await oracledb.getConnection(conf);
let result = await connection.execute(
const connection = await oracledb.getConnection(conf);
const result = await connection.execute(
"select * from dual", [], { outFormat: oracledb.OUT_FORMAT_ARRAY });
assert(result);
assert.strictEqual(result.rows[0][0], "X");
await connection.close();
}));

2283
test/pool.js
View File

File diff suppressed because it is too large Load Diff

777
test/poolCache.js
View File

@ -31,497 +31,199 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var async = require('async');
var should = require('should');
var dbConfig = require('./dbconfig.js');
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
describe('67. poolCache.js', function() {
beforeEach(function() {
// ensure that no poolAlias has been specified
delete dbConfig.poolAlias;
});
after(function() {
// ensure that no poolAlias has been specified
delete dbConfig.poolAlias;
});
describe('67.1 basic functional tests', function() {
it('67.1.1 caches pool as default if pool is created when cache is empty', function(done) {
oracledb.createPool(dbConfig, function(err, pool) {
var defaultPool;
should.not.exist(err);
pool.should.be.ok();
// Not specifying a name, default will be used
defaultPool = oracledb.getPool();
should.strictEqual(pool, defaultPool);
(defaultPool.poolAlias).should.equal('default');
pool.close(function(err) {
should.not.exist(err);
done();
});
});
it('67.1.1 caches pool as default if pool is created when cache is empty', async function() {
const pool = await oracledb.createPool(dbConfig);
const defaultPool = oracledb.getPool();
assert.strictEqual(pool, defaultPool);
assert.strictEqual(pool.poolAlias, "default");
await pool.close();
});
it('67.1.2 removes the pool from the cache on terminate', function(done) {
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
pool.close(function(err) {
var defaultPool;
should.not.exist(err);
(function() {
defaultPool = oracledb.getPool();
}).should.throw(/^NJS-047:/);
should.not.exist(defaultPool);
done();
});
});
it('67.1.2 removes the pool from the cache on terminate', async function() {
const pool = await oracledb.createPool(dbConfig);
await pool.close();
assert.throws(
() => oracledb.getPool(),
/NJS-047:/
);
});
it('67.1.3 can cache and retrieve an aliased pool', function(done) {
var poolAlias = 'random-pool-alias';
dbConfig.poolAlias = poolAlias;
oracledb.createPool(dbConfig, function(err, pool) {
var aliasedPool;
should.not.exist(err);
pool.should.be.ok();
pool.poolAlias.should.equal(poolAlias);
aliasedPool = oracledb.getPool(poolAlias);
should.strictEqual(pool, aliasedPool);
pool.close(function(err) {
should.not.exist(err);
done();
});
});
it('67.1.3 can cache and retrieve an aliased pool', async function() {
const config = {...dbConfig, poolAlias: 'random-pool-alias'};
const pool = await oracledb.createPool(config);
assert.strictEqual(pool.poolAlias, config.poolAlias);
const aliasedPool = oracledb.getPool(config.poolAlias);
assert.strictEqual(pool, aliasedPool);
await pool.close();
});
it('67.1.4 throws an error if the poolAlias already exists in the cache', function(done) {
dbConfig.poolAlias = 'pool1';
oracledb.createPool(dbConfig, function(err, pool1) {
should.not.exist(err);
pool1.should.be.ok();
// Creating another pool with the same poolAlias as before
oracledb.createPool(dbConfig, function(err, pool2) {
should.exist(err);
(err.message).should.startWith('NJS-046:');
should.not.exist(pool2);
pool1.close(function(err) {
should.not.exist(err);
done();
});
});
});
it('67.1.4 throws an error if the poolAlias already exists in the cache', async function() {
const config = {...dbConfig, poolAlias: 'pool1'};
const pool = await oracledb.createPool(config);
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-046:/
);
await pool.close();
});
it('67.1.5 does not throw an error if multiple pools are created without a poolAlias', function(done) {
oracledb.createPool(dbConfig, function(err, pool1) {
should.not.exist(err);
pool1.should.be.ok();
// Creating another pool with no poolAlias
oracledb.createPool(dbConfig, function(err, pool2) {
should.not.exist(err);
pool2.should.be.ok();
pool1.close(function(err) {
should.not.exist(err);
pool2.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
it('67.1.5 does not throw an error if multiple pools are created without a poolAlias', async function() {
const pool1 = await oracledb.createPool(dbConfig);
const pool2 = await oracledb.createPool(dbConfig);
await pool1.close();
await pool2.close();
});
it('67.1.6 throws an error if poolAttrs.poolAlias is not a string', function(done) {
it('67.1.6 throws an error if poolAttrs.poolAlias is not a string', async function() {
// Setting poolAlias to something other than a string. Could be
// boolean, object, array, etc.
dbConfig.poolAlias = {};
oracledb.createPool(dbConfig, function(err, pool) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
should.not.exist(pool);
done();
});
});
it('67.1.7 makes poolAttrs.poolAlias a read-only attribute on the pool named poolAlias', function(done) {
dbConfig.poolAlias = 'my-pool';
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
(pool.poolAlias).should.equal(dbConfig.poolAlias);
(function() {
pool.poolAlias = 'some-new-value';
}).should.throw('Cannot set property poolAlias of #<Pool> which has only a getter');
(pool.poolAlias).should.equal(dbConfig.poolAlias);
pool.close(function(err) {
should.not.exist(err);
done();
});
});
});
it('67.1.8 retrieves the default pool, even after an aliased pool is created', function(done) {
oracledb.createPool(dbConfig, function(err, pool1) {
should.not.exist(err);
pool1.should.be.ok();
dbConfig.poolAlias = 'random-pool-alias';
oracledb.createPool(dbConfig, function(err, pool2) {
var defaultPool;
should.not.exist(err);
pool2.should.be.ok();
// Not specifying a name, default will be used
defaultPool = oracledb.getPool();
should.strictEqual(pool1, defaultPool);
(defaultPool.poolAlias).should.equal('default');
pool1.close(function(err) {
should.not.exist(err);
pool2.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
});
it('67.1.9 retrieves the right pool, even after multiple pools are created', function(done) {
var aliasToGet = 'random-pool-alias-2';
dbConfig.poolAlias = 'random-pool-alias';
oracledb.createPool(dbConfig, function(err, pool1) {
should.not.exist(err);
pool1.should.be.ok();
dbConfig.poolAlias = aliasToGet;
oracledb.createPool(dbConfig, function(err, pool2) {
should.not.exist(err);
pool2.should.be.ok();
dbConfig.poolAlias = 'random-pool-alias-3';
oracledb.createPool(dbConfig, function(err, pool3) {
var secondPool;
should.not.exist(err);
secondPool = oracledb.getPool(aliasToGet);
should.strictEqual(pool2, secondPool);
(secondPool.poolAlias).should.equal(aliasToGet);
pool1.close(function(err) {
should.not.exist(err);
pool2.close(function(err) {
should.not.exist(err);
pool3.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
});
});
});
it('67.1.10 throws an error if the pool specified in getPool doesn\'t exist', function(done) {
(function() {
oracledb.getPool();
}).should.throw(/^NJS-047:/);
(function() {
oracledb.getPool('some-random-alias');
}).should.throw(/^NJS-047:/);
done();
});
it('67.1.11 does not throw an error if multiple pools are created without a poolAlias in the same call stack', function(done) {
var pool1;
var pool2;
async.parallel(
[
function(callback) {
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
pool1 = pool;
callback();
});
},
function(callback) {
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
pool2 = pool;
callback();
});
}
],
function(createPoolErr) {
should.not.exist(createPoolErr);
pool1.close(function(err) {
should.not.exist(err);
pool2.close(function(err) {
should.not.exist(err);
done(createPoolErr);
});
});
}
const config = {...dbConfig, poolAlias: {}};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.1.7 makes poolAttrs.poolAlias a read-only attribute on the pool named poolAlias', async function() {
const config = {...dbConfig, poolAlias: "my-pool"};
const pool = await oracledb.createPool(config);
assert.strictEqual(pool.poolAlias, config.poolAlias);
assert.throws(
() => pool.poolAlias = "some-new-value",
/TypeError: Cannot set/
);
assert.strictEqual(pool.poolAlias, config.poolAlias);
await pool.close();
});
it('67.1.8 retrieves the default pool, even after an aliased pool is created', async function() {
const pool1 = await oracledb.createPool(dbConfig);
const config = {...dbConfig, poolAlias: 'random-pool-alias'};
const pool2 = await oracledb.createPool(config);
// Not specifying a name, default will be used
const defaultPool = oracledb.getPool();
assert.strictEqual(pool1, defaultPool);
assert.strictEqual(pool1.poolAlias, "default");
await pool1.close();
await pool2.close();
});
it('67.1.9 retrieves the right pool, even after multiple pools are created', async function() {
const config1 = {...dbConfig, poolAlias: 'random-pool-alias-1'};
const config2 = {...dbConfig, poolAlias: 'random-pool-alias-2'};
const config3 = {...dbConfig, poolAlias: 'random-pool-alias-3'};
const pool1 = await oracledb.createPool(config1);
const pool2 = await oracledb.createPool(config2);
const pool3 = await oracledb.createPool(config3);
assert.strictEqual(pool1, oracledb.getPool(config1.poolAlias));
assert.strictEqual(pool2, oracledb.getPool(config2.poolAlias));
assert.strictEqual(pool3, oracledb.getPool(config3.poolAlias));
await pool1.close();
await pool2.close();
await pool3.close();
});
it('67.1.10 throws an error if the pool specified in getPool doesn\'t exist', function() {
assert.throws(
() => oracledb.getPool(),
/NJS-047:/
);
assert.throws(
() => oracledb.getPool("some-random-alias"),
/NJS-047:/
);
});
it('67.1.11 does not throw an error if multiple pools are created without a poolAlias in the same call stack', async function() {
let pool1, pool2;
const routine1 = async function() {
pool1 = await oracledb.createPool(dbConfig);
};
const routine2 = async function() {
pool2 = await oracledb.createPool(dbConfig);
};
await Promise.all([routine1(), routine2()]);
await pool1.close();
await pool2.close();
});
});
describe('67.2 oracledb.getConnection functional tests', function() {
it('67.2.1 gets a connection from the default pool when no alias is specified', function(done) {
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
// Not specifying a poolAlias, default will be used
oracledb.getConnection(function(err, conn) {
should.not.exist(err);
conn.release(function(err) {
should.not.exist(err);
pool.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
it('67.2.1 gets a connection from the default pool when no alias is specified', async function() {
const pool = await oracledb.createPool(dbConfig);
const conn = await oracledb.getConnection();
await conn.close();
await pool.close();
});
it('67.2.2 gets a connection from the pool with the specified poolAlias', function(done) {
var poolAlias = 'random-pool-alias';
dbConfig.poolAlias = poolAlias;
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
oracledb.getConnection(poolAlias, function(err, conn) {
should.not.exist(err);
conn.release(function(err) {
should.not.exist(err);
pool.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
it('67.2.2 gets a connection from the pool with the specified poolAlias', async function() {
const config = {...dbConfig, poolAlias: 'random-pool-alias'};
const pool = await oracledb.createPool(config);
const conn = await oracledb.getConnection(config.poolAlias);
await conn.close();
await pool.close();
});
it('67.2.3 throws an error if an attempt is made to use the default pool when it does not exist', function(done) {
dbConfig.poolAlias = 'random-pool-alias';
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
// Not specifying a poolAlias, default will be used
oracledb.getConnection(function(err) {
should.exist(err);
(err.message).should.startWith('NJS-047:');
pool.close(function(err) {
should.not.exist(err);
done();
});
});
});
it('67.2.3 throws an error if an attempt is made to use the default pool when it does not exist', async function() {
const config = {...dbConfig, poolAlias: 'random-pool-alias'};
const pool = await oracledb.createPool(config);
await testsUtil.assertThrowsAsync(
async () => await oracledb.getConnection(),
/NJS-047:/
);
await pool.close();
});
it('67.2.4 throws an error if an attempt is made to use a poolAlias for a pool that is not in the cache', function(done) {
dbConfig.poolAlias = 'random-pool-alias';
oracledb.createPool(dbConfig, function(err, pool) {
should.not.exist(err);
oracledb.getConnection('pool-alias-that-does-not-exist', function(err) {
should.exist(err);
(err.message).should.startWith('NJS-047:');
pool.close(function(err) {
should.not.exist(err);
done();
});
});
});
it('67.2.4 throws an error if an attempt is made to use a poolAlias for a pool that is not in the cache', async function() {
const config = {...dbConfig, poolAlias: 'random-pool-alias'};
const pool = await oracledb.createPool(config);
await testsUtil.assertThrowsAsync(
async () => await oracledb.getConnection("pool-alias-that-does-not-exist"),
/NJS-047:/
);
await pool.close();
});
it('67.2.5 gets a connection from the default pool, even after an aliased pool is created', function(done) {
oracledb.createPool(dbConfig, function(err, pool1) {
should.not.exist(err);
pool1.should.be.ok();
dbConfig.poolAlias = 'random-pool-alias';
oracledb.createPool(dbConfig, function(err, pool2) {
should.not.exist(err);
pool2.should.be.ok();
oracledb.getConnection(function(err, conn) {
should.not.exist(err);
// Using the hidden pool property to check where the connection came from
should.strictEqual(pool1, conn._pool);
(conn._pool.poolAlias).should.equal('default');
conn.close(function(err) {
should.not.exist(err);
pool1.close(function(err) {
should.not.exist(err);
pool2.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
});
});
it('67.2.5 gets a connection from the default pool, even after an aliased pool is created', async function() {
const config = {...dbConfig, poolAlias: 'random-pool-alias'};
const pool1 = await oracledb.createPool(dbConfig);
const pool2 = await oracledb.createPool(config);
const conn = await oracledb.getConnection();
// Using the hidden pool property to check where the connection came from
assert.strictEqual(pool1, conn._pool);
await conn.close();
await pool1.close();
await pool2.close();
});
it('67.2.6 uses the right pool, even after multiple pools are created', function(done) {
var aliasToUse = 'random-pool-alias-2';
dbConfig.poolAlias = 'random-pool-alias';
oracledb.createPool(dbConfig, function(err, pool1) {
should.not.exist(err);
pool1.should.be.ok();
dbConfig.poolAlias = aliasToUse;
oracledb.createPool(dbConfig, function(err, pool2) {
should.not.exist(err);
pool2.should.be.ok();
dbConfig.poolAlias = 'random-pool-alias-3';
oracledb.createPool(dbConfig, function(err, pool3) {
should.not.exist(err);
oracledb.getConnection(aliasToUse, function(err, conn) {
// Using the hidden pool property to check where the connection came from
should.strictEqual(pool2, conn._pool);
(conn._pool.poolAlias).should.equal(aliasToUse);
conn.close(function(err) {
should.not.exist(err);
pool1.close(function(err) {
should.not.exist(err);
pool2.close(function(err) {
should.not.exist(err);
pool3.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
});
});
});
});
it('67.2.6 uses the right pool, even after multiple pools are created', async function() {
const config1 = {...dbConfig, poolAlias: 'random-pool-alias-1'};
const config2 = {...dbConfig, poolAlias: 'random-pool-alias-2'};
const config3 = {...dbConfig, poolAlias: 'random-pool-alias-3'};
const pool1 = await oracledb.createPool(config1);
const pool2 = await oracledb.createPool(config2);
const pool3 = await oracledb.createPool(config3);
const conn = await oracledb.getConnection(config2.poolAlias);
assert.strictEqual(pool2, conn._pool);
await conn.close();
await pool1.close();
await pool2.close();
await pool3.close();
});
it('67.2.7 gets a connection from the default pool with callback function(err)', function(done) {
oracledb.createPool({ // this becomes the default pool
it('67.2.7 gets a connection from the default pool', async function() {
const config = {
user : dbConfig.user,
password : dbConfig.password,
connectString : dbConfig.connectString,
@ -529,138 +231,81 @@ describe('67. poolCache.js', function() {
poolMin : 1,
poolIncrement: 1,
poolTimeout: 0 // never terminate unused connections
}, function(err) {
should.not.exist(err);
var defaultPool = oracledb.getPool();
should.exist(defaultPool);
oracledb.getConnection(function(err, conn) {
should.not.exist(err);
conn.close(function(err) {
should.not.exist(err);
defaultPool.close(function(err) {
should.not.exist(err);
done();
});
});
});
});
};
const pool = await oracledb.createPool(config);
const conn = await pool.getConnection();
await conn.close();
await pool.close();
});
}); // 67.2
// This suite extends 67.1.6 case with various types
describe('67.3 poolAlias attribute', function() {
it('67.3.1 throws an error if poolAttrs.poolAlias is an object', function(done) {
dbConfig.poolAlias = {'foo': 'bar'};
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.1 throws an error if poolAttrs.poolAlias is an object', async function() {
const config = {...dbConfig, poolAlias: {'foo': 'bar'}};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.2 throws an error if poolAttrs.poolAlias is an array', function(done) {
dbConfig.poolAlias = [];
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.2 throws an error if poolAttrs.poolAlias is an array', async function() {
const config = {...dbConfig, poolAlias: []};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.3 throws an error if poolAttrs.poolAlias is a number', function(done) {
dbConfig.poolAlias = 123;
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.3 throws an error if poolAttrs.poolAlias is a number', async function() {
const config = {...dbConfig, poolAlias: 123};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.4 throws an error if poolAttrs.poolAlias is a boolean', function(done) {
dbConfig.poolAlias = false;
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.4 throws an error if poolAttrs.poolAlias is a boolean', async function() {
const config = {...dbConfig, poolAlias: false};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.5 throws an error if poolAttrs.poolAlias is null', function(done) {
dbConfig.poolAlias = null;
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.5 throws an error if poolAttrs.poolAlias is null', async function() {
const config = {...dbConfig, poolAlias: null};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.6 throws an error if poolAttrs.poolAlias is an empty string', function(done) {
dbConfig.poolAlias = '';
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.6 throws an error if poolAttrs.poolAlias is an empty string', async function() {
const config = {...dbConfig, poolAlias: null};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.7 throws an error if poolAttrs.poolAlias is NaN', function(done) {
dbConfig.poolAlias = NaN;
oracledb.createPool(dbConfig, function(err) {
should.exist(err);
(err.message).should.startWith('NJS-007:');
done();
});
it('67.3.7 throws an error if poolAttrs.poolAlias is NaN', async function() {
const config = {...dbConfig, poolAlias: NaN};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it('67.3.8 works if poolAttrs.poolAlias is undefined', function(done) {
dbConfig.poolAlias = undefined;
oracledb.createPool(dbConfig, function(err, pool) {
pool.should.be.ok();
(pool.poolAlias).should.equal('default');
pool.close(function(err) {
should.not.exist(err);
done();
});
});
it('67.3.8 works if poolAttrs.poolAlias is undefined', async function() {
const config = {...dbConfig, poolAlias: undefined};
const pool = await oracledb.createPool(config);
assert.strictEqual(pool.poolAlias, "default");
await pool.close();
});
}); // 67.3
});

340
test/poolClose.js
View File

@ -31,270 +31,120 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var should = require('should');
var async = require('async');
var dbConfig = require('./dbconfig.js');
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
describe('51. poolClose.js', function() {
it('51.1 can not get connections from the terminated pool', function(done) {
oracledb.createPool(
dbConfig,
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
pool.terminate(function(err) {
should.not.exist(err);
pool.getConnection(function(err) {
should.exist(err);
should.strictEqual(err.message, "NJS-065: connection pool was closed");
});
done();
}); // terminate()
}
); // createPool()
it('51.1 can not get connections from the terminated pool', async function() {
const pool = await oracledb.createPool(dbConfig);
await pool.close();
await testsUtil.assertThrowsAsync(
async () => await pool.getConnection(),
/NJS-065:/
);
}); // 51.1
it('51.2 can not terminate the same pool multiple times', function(done) {
oracledb.createPool(
dbConfig,
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
pool.terminate(function(err) {
should.not.exist(err);
pool.terminate(function(err) {
should.exist(err);
should.strictEqual(err.message, "NJS-065: connection pool was closed");
});
done();
}); // terminate()
}
); // createPool()
it('51.2 can not terminate the same pool multiple times', async function() {
const pool = await oracledb.createPool(dbConfig);
await pool.terminate();
await testsUtil.assertThrowsAsync(
async () => await pool.terminate(),
/NJS-065:/
);
}); // 51.2
it('51.3 can not close the same pool multiple times', function(done) {
oracledb.createPool(
dbConfig,
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
pool.close(function(err) {
should.not.exist(err);
pool.close(function(err) {
should.exist(err);
should.strictEqual(err.message, "NJS-065: connection pool was closed");
});
done();
}); // terminate()
}
); // createPool()
it('51.3 can not close the same pool multiple times', async function() {
const pool = await oracledb.createPool(dbConfig);
await pool.close();
await testsUtil.assertThrowsAsync(
async () => await pool.close(),
/NJS-065:/
);
}); // 51.3
it('51.4 pool is still available after the failing close', function(done) {
oracledb.createPool(
dbConfig,
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
pool.getConnection(function(err, connection) {
should.not.exist(err);
pool.terminate(function(err) {
should.exist(err);
(err.message).should.startWith('ORA-24422: ');
// ORA-24422: error occurred while trying to destroy the Session Pool
connection.release(function(err) {
should.not.exist(err);
pool.terminate(function(err) {
should.not.exist(err);
done();
}); // terminate #2
}); // release()
}); // terminate() #1
}); // getConnection()
}
); // createPool()
it('51.4 pool is still available after the failing close', async function() {
const pool = await oracledb.createPool(dbConfig);
const conn = await pool.getConnection();
await testsUtil.assertThrowsAsync(
async () => await pool.close(),
/ORA-24422:/
);
await conn.close();
await pool.close();
}); // 51.4
it('51.5 can not close the same connection multiple times', function(done) {
var pool = null;
var conn = null;
async.series([
function(cb) {
oracledb.createPool(
dbConfig,
function(err, pooling) {
should.not.exist(err);
pool = pooling;
pool.should.be.ok();
cb();
}
);
},
function(cb) {
pool.getConnection(function(err, connection) {
should.not.exist(err);
conn = connection;
conn.should.be.ok();
cb();
});
},
function close1(cb) {
conn.close(function(err) {
should.not.exist(err);
cb();
});
},
function close2(cb) {
conn.close(function(err) {
should.exist(err);
should.strictEqual(err.message, 'NJS-003: invalid connection');
cb();
});
},
function(cb) {
pool.terminate(function(err) {
should.not.exist(err);
cb();
});
}
], done);
it('51.5 can not close the same connection multiple times', async function() {
const pool = await oracledb.createPool(dbConfig);
const conn = await pool.getConnection();
await conn.close();
await testsUtil.assertThrowsAsync(
async () => await conn.close(),
/NJS-003:/
);
await pool.close();
}); // 51.5
it('51.6 can not get connection in promise version from the terminated pool', function(done) {
oracledb.createPool(
dbConfig,
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
pool.terminate(function(err) {
should.not.exist(err);
var promise = pool.getConnection();
promise
.then(function(conn) {
should.not.exist(conn);
})
.catch(function(err) {
should.exist(err);
should.strictEqual(err.message, "NJS-065: connection pool was closed");
})
.then(function() {
done();
});
}); // terminate()
}
); // createPool()
it('51.6 can not get connection from a terminated pool', async function() {
const pool = await oracledb.createPool(dbConfig);
await pool.close();
await testsUtil.assertThrowsAsync(
async () => await pool.getConnection(),
/NJS-065:/
);
}); // 51.6
it('51.7 can not set the attributes after pool created', function(done) {
var pMin = 2;
var pMax = 10;
oracledb.createPool(
{
user : dbConfig.user,
password : dbConfig.password,
connectString : dbConfig.connectString,
poolMin : pMin,
poolMax : pMax
},
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
// setter
should.throws(
function() {
pool.poolMin = 20;
},
"TypeError: Cannot assign to read only property 'poolMin' of object '#<Pool>'"
);
pool.terminate(function(err) {
should.not.exist(err);
// setter
should.throws(
function() {
pool.poolMin = 20;
},
"TypeError: Cannot assign to read only property 'poolMin' of object '#<Pool>'"
);
pool.terminate(function(err) {
should.exist(err);
should.strictEqual(err.message, "NJS-065: connection pool was closed");
});
done();
}); // terminate()
}
); // createPool()
it('51.7 can not set the attributes after pool created', async function() {
const config = {
user : dbConfig.user,
password : dbConfig.password,
connectString : dbConfig.connectString,
poolMin : 2,
poolMax : 10
};
const pool = await oracledb.createPool(config);
assert.throws(
() => pool.poolMin = 20,
/TypeError: Cannot set/
);
await pool.close();
assert.throws(
() => pool.poolMin = 20,
/TypeError: Cannot set/
);
await testsUtil.assertThrowsAsync(
async () => await pool.close(),
/NJS-065:/
);
}); // 51.7
it('51.8 can access the attributes of closed pool without error', function(done) {
var pMin = 2;
var pMax = 10;
var pAlias = "foobar";
var pIncr = 2;
it('51.8 can access the attributes of closed pool without error', async function() {
const config = {
user : dbConfig.user,
password : dbConfig.password,
connectString : dbConfig.connectString,
poolMin : 2,
poolMax : 10,
poolAlias : "foobar",
poolIncrement : 2
};
const pool = await oracledb.createPool(config);
await pool.close();
oracledb.createPool(
{
user : dbConfig.user,
password : dbConfig.password,
connectString : dbConfig.connectString,
poolMin : pMin,
poolMax : pMax,
poolAlias : pAlias,
poolIncrement : pIncr
},
function(err, pool) {
should.not.exist(err);
pool.should.be.ok();
// configured values
assert.strictEqual(pool.poolMin, config.poolMin);
assert.strictEqual(pool.poolMax, config.poolMax);
assert.strictEqual(pool.poolAlias, config.poolAlias);
assert.strictEqual(pool.poolIncrement, config.poolIncrement);
pool.terminate(function(err) {
should.not.exist(err);
// getter
should.strictEqual(pool.poolMin, pMin);
should.strictEqual(pool.poolMax, pMax);
// values vary with different databases
// (pool.connectionsInUse).should.be.a.Number();
// (pool.connectionsOpen).should.be.a.Number();
should.strictEqual(pool.poolAlias, pAlias);
should.strictEqual(pool.poolIncrement, pIncr);
// Default values
should.strictEqual(pool.poolPingInterval, 60);
should.strictEqual(pool.poolTimeout, 60);
should.strictEqual(pool.queueMax, 500);
should.strictEqual(pool.queueTimeout, 60000);
should.strictEqual(pool.stmtCacheSize, 30);
done();
}); // terminate()
}
); // createPool()
// default values
assert.strictEqual(pool.poolPingInterval, oracledb.poolPingInterval);
assert.strictEqual(pool.poolTimeout, oracledb.poolTimeout);
assert.strictEqual(pool.queueMax, 500);
assert.strictEqual(pool.queueTimeout, 60000);
assert.strictEqual(pool.stmtCacheSize, oracledb.stmtCacheSize);
}); // 51.8
});

599
test/poolPing.js
View File

@ -31,522 +31,205 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var async = require('async');
var should = require('should');
var dbConfig = require('./dbconfig.js');
const oracledb = require('oracledb');
const assert = require('should');
const dbConfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
describe("73. poolPing.js", function() {
var defaultInterval = oracledb.poolPingInterval;
const defaultInterval = oracledb.poolPingInterval;
afterEach("reset poolPingInterval to default", function() {
oracledb.poolPingInterval = defaultInterval;
should.strictEqual(oracledb.poolPingInterval, 60);
});
it("73.1 the default value of poolPingInterval is 60", function(done) {
var defaultValue = 60;
should.strictEqual(oracledb.poolPingInterval, defaultValue);
var pool;
async.series([
function(cb) {
oracledb.createPool(
dbConfig,
function(err, pooling) {
should.not.exist(err);
pool = pooling;
should.strictEqual(pool.poolPingInterval, defaultValue);
cb();
}
);
},
function(cb) {
pool.close(function(err) {
should.not.exist(err);
cb();
});
}
], done);
it("73.1 the default value of poolPingInterval is 60", async function() {
const defaultValue = 60;
assert.strictEqual(oracledb.poolPingInterval, defaultValue);
const pool = await oracledb.createPool(dbConfig);
assert.strictEqual(pool.poolPingInterval, defaultValue);
await pool.close();
}); // 73.1
it("73.2 does not change after the pool has been created", function(done) {
var userSetInterval = 20;
it("73.2 does not change after the pool has been created", async function() {
const userSetInterval = 20;
oracledb.poolPingInterval = userSetInterval;
var pool;
async.series([
function(cb) {
oracledb.createPool(
dbConfig,
function(err, pooling) {
should.not.exist(err);
pool = pooling;
should.strictEqual(pool.poolPingInterval, userSetInterval);
cb();
}
);
},
function(cb) {
var newInterval = userSetInterval * 2;
oracledb.poolPingInterval = newInterval;
// sleep a while
setTimeout(function() {
cb();
}, 100);
},
function dotest(cb) {
should.strictEqual(pool.poolPingInterval, userSetInterval);
cb();
},
function(cb) {
pool.close(function(err) {
should.not.exist(err);
cb();
});
}
], done);
const pool = await oracledb.createPool(dbConfig);
assert.strictEqual(pool.poolPingInterval, userSetInterval);
const newInterval = userSetInterval * 2;
oracledb.poolPingInterval = newInterval;
await new Promise((resolve) => setTimeout(resolve, 100));
assert.strictEqual(pool.poolPingInterval, userSetInterval);
await pool.close();
}); // 73.2
it("73.3 can not be changed on pool object", function(done) {
var userSetInterval = 30;
it("73.3 can not be changed on pool object", async function() {
const userSetInterval = 30;
oracledb.poolPingInterval = userSetInterval;
var pool;
async.series([
function(cb) {
oracledb.createPool(
dbConfig,
function(err, pooling) {
should.not.exist(err);
pool = pooling;
should.strictEqual(pool.poolPingInterval, userSetInterval);
cb();
}
);
},
function dotest(cb) {
var newInterval = userSetInterval * 2;
try {
pool.poolPingInterval = newInterval;
} catch (err) {
should.strictEqual(err.name, "TypeError");
}
cb();
},
function(cb) {
pool.close(function(err) {
should.not.exist(err);
cb();
});
}
], done);
const pool = await oracledb.createPool(dbConfig);
assert.strictEqual(pool.poolPingInterval, userSetInterval);
const newInterval = userSetInterval * 2;
assert.throws(
() => pool.poolPingInterval = newInterval,
/TypeError/
);
await pool.close();
}); // 73.3
it("73.4 can not be accessed on connection object", function(done) {
var pool, connection;
async.series([
function(cb) {
oracledb.createPool(
dbConfig,
function(err, pooling) {
should.not.exist(err);
pool = pooling;
cb();
}
);
},
function dotest(cb) {
pool.getConnection(function(err, conn) {
should.not.exist(err);
connection = conn;
should.not.exist(connection.poolPingInterval);
cb();
});
},
function(cb) {
connection.close(function(err) {
should.not.exist(err);
cb();
});
},
function(cb) {
pool.close(function(err) {
should.not.exist(err);
cb();
});
}
], done);
it("73.4 can not be accessed on connection object", async function() {
const pool = await oracledb.createPool(dbConfig);
const conn = await pool.getConnection();
assert.strictEqual(conn.poolPingInterval, undefined);
await conn.close();
await pool.close();
}); // 73.4
// helper function for below test cases
var testDefine = function(userSetInterval, callback) {
const testDefine = async function(userSetInterval) {
oracledb.poolPingInterval = userSetInterval;
var pool;
async.series([
function(cb) {
oracledb.createPool(
dbConfig,
function(err, pooling) {
should.not.exist(err);
pool = pooling;
should.strictEqual(pool.poolPingInterval, userSetInterval);
cb();
}
);
},
function(cb) {
pool.close(function(err) {
should.not.exist(err);
cb();
});
}
], callback);
const pool = await oracledb.createPool(dbConfig);
assert.strictEqual(pool.poolPingInterval, userSetInterval);
await pool.close();
}; // testDefine()
it("73.5 can be set to 0, means always ping", function(done) {
var userSetValue = 0;
testDefine(userSetValue, done);
it("73.5 can be set to 0, means always ping", async function() {
await testDefine(0);
}); // 73.5
it("73.6 can be set to negative values, means never ping", function(done) {
var userSetValue = -80;
testDefine(userSetValue, done);
it("73.6 can be set to negative values, means never ping", async function() {
await testDefine(-80);
}); // 73.6
it("73.7 Negative: Number.MAX_SAFE_INTEGER", function(done) {
/*
Number.MAX_SAFE_INTEGER // 9007199254740991
Math.pow(2, 53) - 1 // 9007199254740991
*/
try {
oracledb.poolPingInterval = Number.MAX_SAFE_INTEGER;
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
// NJS-004: invalid value for property pingPoolInterval
done();
}
it("73.7 Negative: Number.MAX_SAFE_INTEGER", function() {
assert.throws(
() => oracledb.poolPingInterval = Number.MAX_SAFE_INTEGER,
/NJS-004:/
);
}); // 73.7
it("73.8 cannot surpass the upper limit", function(done) {
var upperLimit = 2147483647; // 2GB
async.series([
function testMax(cb) {
testDefine(upperLimit, cb);
},
function(cb) {
var upperLimitPlus = upperLimit + 1;
try {
oracledb.poolPingInterval = upperLimitPlus;
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
cb();
}
}
], done);
it("73.8 cannot surpass the upper limit", async function() {
const upperLimit = 2147483647; // 2GB
await testDefine(upperLimit);
assert.throws(
() => oracledb.poolPingInterval = upperLimit + 1,
/NJS-004:/
);
}); // 73.8
it("73.9 cannot surpass the lower Limit", function(done) {
var lowerLimit = -2147483648;
async.series([
function texstMin(cb) {
testDefine(lowerLimit, cb);
},
function(cb) {
var lowerLimitPlus = lowerLimit - 1;
try {
oracledb.poolPingInterval = lowerLimitPlus;
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
cb();
}
}
], done);
it("73.9 cannot surpass the lower Limit", async function() {
const lowerLimit = -2147483648;
await testDefine(lowerLimit);
assert.throws(
() => oracledb.poolPingInterval = lowerLimit - 1,
/NJS-004:/
);
}); // 73.9
it("73.10 Negative: null", function(done) {
try {
oracledb.poolPingInterval = null;
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
done();
}
it("73.10 Negative: null", function() {
assert.throws(
() => oracledb.poolPingInterval = null,
/NJS-004:/
);
}); // 73.10
it("73.11 Negative: NaN", function(done) {
try {
oracledb.poolPingInterval = NaN;
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
done();
}
it("73.11 Negative: NaN", function() {
assert.throws(
() => oracledb.poolPingInterval = NaN,
/NJS-004:/
);
}); // 73.11
it("73.12 Negative: undefined", function(done) {
try {
oracledb.poolPingInterval = undefined;
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
done();
}
it("73.12 Negative: undefined", function() {
assert.throws(
() => oracledb.poolPingInterval = undefined,
/NJS-004:/
);
}); // 73.12
it("73.13 Negative: 'random-string'", function(done) {
try {
oracledb.poolPingInterval = 'random-string';
} catch (err) {
should.exist(err);
(err.message).should.startWith("NJS-004:");
done();
}
it("73.13 Negative: 'random-string'", function() {
assert.throws(
() => oracledb.poolPingInterval = "random-string",
/NJS-004:/
);
}); // 73.13
var testPoolDefine = function(userSetInterval, expectedValue, callback) {
var pool;
async.series([
function(cb) {
oracledb.createPool(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString,
poolPingInterval: userSetInterval
},
function(err, pooling) {
if (userSetInterval === null) {
should.not.exist(pooling);
should.exist(err);
should.strictEqual(err.message, "NJS-007: invalid value for \"poolPingInterval\" in parameter 1");
} else {
should.not.exist(err);
pool = pooling;
should.strictEqual(pool.poolPingInterval, expectedValue);
}
cb();
}
);
},
function(cb) {
if (userSetInterval !== null) {
pool.close(function(err) {
should.not.exist(err);
});
}
cb();
}
], callback);
const testPoolDefine = async function(userSetInterval, expectedValue) {
const config = {
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString,
poolPingInterval: userSetInterval
};
const pool = await oracledb.createPool(config);
assert.strictEqual(pool.poolPingInterval, expectedValue);
await pool.close();
}; // testPoolDefine
it("73.14 can be set at pool creation, e.g. positive value 1234", function(done) {
var userSetValue = 1234;
testPoolDefine(userSetValue, userSetValue, done);
it("73.14 can be set at pool creation, e.g. positive value 1234", async function() {
const userSetValue = 1234;
await testPoolDefine(userSetValue, userSetValue);
});
it("73.15 can be set at pool creation, e.g. negative value -4321", function(done) {
var userSetValue = -4321;
testPoolDefine(userSetValue, userSetValue, done);
it("73.15 can be set at pool creation, e.g. negative value -4321", async function() {
const userSetValue = -4321;
await testPoolDefine(userSetValue, userSetValue);
});
it("73.16 can be set at pool creation, e.g. 0 means always ping", function(done) {
var userSetValue = 0;
testPoolDefine(userSetValue, userSetValue, done);
it("73.16 can be set at pool creation, e.g. 0 means always ping", async function() {
const userSetValue = 0;
await testPoolDefine(userSetValue, userSetValue);
});
it("73.17 Negative: null", function(done) {
it("73.17 Negative: null", async function() {
oracledb.poolPingInterval = 789;
var userSetValue = null;
testPoolDefine(userSetValue, 789, done);
});
it("73.18 Setting to 'undefined' will use current value from oracledb", function(done) {
oracledb.poolPingInterval = 9876;
var userSetValue = undefined;
testPoolDefine(userSetValue, 9876, done);
});
it("73.19 can be set at pool creation. Negative: NaN", function(done) {
/*var userSetValue = 'random-string';*/
var userSetValue = NaN;
oracledb.createPool(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString,
poolPingInterval: userSetValue
},
function(err, pool) {
should.exist(err);
(err.message).should.startWith("NJS-007:");
// NJS-007: invalid value for "poolPingInterval" in parameter 1
should.not.exist(pool);
done();
}
const config = {...dbConfig, poolPingInterval: null};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
});
it("73.18 Setting to 'undefined' will use current value from oracledb", async function() {
oracledb.poolPingInterval = 9876;
const userSetValue = undefined;
await testPoolDefine(userSetValue, oracledb.poolPingInterval);
});
it("73.19 can be set at pool creation. Negative: NaN", async function() {
const config = {...dbConfig, poolPingInterval: NaN};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
}); // 73.19
it("73.20 can be set at pool creation. Negative: 'random-string'", function(done) {
var userSetValue = 'random-string';
oracledb.createPool(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString,
poolPingInterval: userSetValue
},
function(err, pool) {
should.exist(err);
(err.message).should.startWith("NJS-007:");
// NJS-007: invalid value for "poolPingInterval" in parameter 1
should.not.exist(pool);
done();
}
it("73.20 can be set at pool creation. Negative: 'random-string'", async function() {
const config = {...dbConfig, poolPingInterval: "random-string"};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
}); // 73.20
it("73.21 cannot surpass the upper limit at pool creation", function(done) {
var upperLimit = 2147483647; // 2GB
async.series([
function testMax(cb) {
testPoolDefine(upperLimit, upperLimit, cb);
},
function(cb) {
var userSetValue = upperLimit + 1;
oracledb.createPool(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString,
poolPingInterval: userSetValue
},
function(err, pool) {
should.exist(err);
(err.message).should.startWith("NJS-007:");
should.not.exist(pool);
cb();
}
);
}
], done);
it("73.21 cannot surpass the upper limit at pool creation", async function() {
const upperLimit = 2147483647; // 2GB
await testPoolDefine(upperLimit, upperLimit);
const config = {...dbConfig, poolPingInterval: upperLimit + 1};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
}); // 73.21
it("73.22 cannot surpass the lower limit at pool creation", function(done) {
var lowerLimit = -2147483648;
async.series([
function testMax(cb) {
testPoolDefine(lowerLimit, lowerLimit, cb);
},
function(cb) {
var userSetValue = lowerLimit - 1;
oracledb.createPool(
{
user: dbConfig.user,
password: dbConfig.password,
connectString: dbConfig.connectString,
poolPingInterval: userSetValue
},
function(err, pool) {
should.exist(err);
(err.message).should.startWith("NJS-007:");
should.not.exist(pool);
cb();
}
);
}
], done);
it("73.22 cannot surpass the lower limit at pool creation", async function() {
const lowerLimit = -2147483648;
await testPoolDefine(lowerLimit, lowerLimit);
const config = {...dbConfig, poolPingInterval: lowerLimit - 1};
await testsUtil.assertThrowsAsync(
async () => await oracledb.createPool(config),
/NJS-007:/
);
}); // 73.22
});

613
test/rowidDMLBindAsString.js
View File

@ -31,18 +31,17 @@
*****************************************************************************/
'use strict';
var oracledb = require('oracledb');
var should = require('should');
var async = require('async');
var dbConfig = require('./dbconfig.js');
var sql = require('./sql.js');
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
describe('107. rowidDMLBindAsString.js', function() {
var connection = null;
var tableName = "nodb_bind_rowid";
var insertID = 1;
let connection;
const tableName = "nodb_bind_rowid";
let insertID = 1;
var proc_create_table = "BEGIN \n" +
const proc_create_table = "BEGIN \n" +
" DECLARE \n" +
" e_table_missing EXCEPTION; \n" +
" PRAGMA EXCEPTION_INIT(e_table_missing, -00942);\n" +
@ -59,187 +58,157 @@ describe('107. rowidDMLBindAsString.js', function() {
" ) \n" +
" '); \n" +
"END; ";
var drop_table = "DROP TABLE " + tableName + " PURGE";
const drop_table = "DROP TABLE " + tableName + " PURGE";
before('get connection and create table', function(done) {
async.series([
function(cb) {
oracledb.getConnection(dbConfig, function(err, conn) {
should.not.exist(err);
connection = conn;
cb();
});
},
function(cb) {
sql.executeSql(connection, proc_create_table, {}, {}, cb);
}
], done);
before('get connection and create table', async function() {
connection = await oracledb.getConnection(dbConfig);
await connection.execute(proc_create_table);
});
after('release connection', function(done) {
async.series([
function(cb) {
sql.executeSql(connection, drop_table, {}, {}, cb);
},
function(cb) {
connection.release(function(err) {
should.not.exist(err);
cb();
});
}
], done);
after('release connection', async function() {
await connection.execute(drop_table);
await connection.close();
});
beforeEach(function(done) {
beforeEach(function() {
insertID++;
done();
});
describe('107.1 INSERT & SELECT', function() {
it('107.1.1 works with null', function(done) {
var content = null;
var bindVar = {
it('107.1.1 works with null', async function() {
const content = null;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, content, done);
await dmlInsert(bindVar, content);
});
it('107.1.2 works with empty string', function(done) {
var content = "";
var expected = null;
var bindVar = {
it('107.1.2 works with empty string', async function() {
const content = "";
const expected = null;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, expected, done);
await dmlInsert(bindVar, expected);
});
it('107.1.3 works with extended rowid', function(done) {
it('107.1.3 works with extended rowid', async function() {
// Extended rowids use a base 64 encoding of the physical address for each row selected.
// The encoding characters are A-Z, a-z, 0-9, +, and /
var content = "AAABoqAADAAAAwPAAA";
var bindVar = {
const content = "AAABoqAADAAAAwPAAA";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, content, done);
await dmlInsert(bindVar, content);
});
it('107.1.4 works with restricted rowid', function(done) {
var content = "00000DD5.0000.0001";
var bindVar = {
it('107.1.4 works with restricted rowid', async function() {
const content = "00000DD5.0000.0001";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, content, done);
await dmlInsert(bindVar, content);
});
it('107.1.5 throws error with number 0', function(done) {
var content = 0;
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var bindVar = {
it('107.1.5 throws error with number 0', async function() {
const content = 0;
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
connection.execute(
sql_insert,
bindVar,
function(err) {
should.exist(err);
(err.message).should.equal("NJS-011: encountered bind value and type mismatch");
done();
}
await testsUtil.assertThrowsAsync(
async () => await connection.execute(sql_insert, bindVar),
/NJS-011:/
);
});
it('107.1.6 works with string 0', function(done) {
var content = "0";
var expected = "00000000.0000.0000";
var bindVar = {
it('107.1.6 works with string 0', async function() {
const content = "0";
const expected = "00000000.0000.0000";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, expected, done);
await dmlInsert(bindVar, expected);
});
it('107.1.7 works with substr', function(done) {
var content = "AAAA8+AALAAAAQ/AAA";
dmlInsert_substr(content, done);
it('107.1.7 works with substr', async function() {
const content = "AAAA8+AALAAAAQ/AAA";
await dmlInsert_substr(content);
});
it('107.1.8 bind null with default type/dir - named bind', function(done) {
var content = null;
var bindVar_1 = {
it('107.1.8 bind null with default type/dir - named bind', async function() {
const content = null;
const bindVar_1 = {
i: insertID,
c: content
};
dmlInsert(bindVar_1, content, done);
await dmlInsert(bindVar_1, content);
});
it('107.1.9 bind null with default type/dir - positional bind', function(done) {
var content = null;
var bindVar_1 = [ insertID, content ];
dmlInsert(bindVar_1, content, done);
it('107.1.9 bind null with default type/dir - positional bind', async function() {
const content = null;
const bindVar_1 = [ insertID, content ];
await dmlInsert(bindVar_1, content);
});
it('107.1.10 bind extented rowid with default type/dir - named bind', function(done) {
var content = "AAAA8+AALAAAAQ/AAA";
var bindVar_1 = {
it('107.1.10 bind extented rowid with default type/dir - named bind', async function() {
const content = "AAAA8+AALAAAAQ/AAA";
const bindVar_1 = {
i: insertID,
c: content
};
dmlInsert(bindVar_1, content, done);
await dmlInsert(bindVar_1, content);
});
it('107.1.11 bind extented rowid with default type/dir - positional bind', function(done) {
var content = "AAAA8+AALAAAAQ/AAA";
var bindVar_1 = [ insertID, content ];
dmlInsert(bindVar_1, content, done);
it('107.1.11 bind extented rowid with default type/dir - positional bind', async function() {
const content = "AAAA8+AALAAAAQ/AAA";
const bindVar_1 = [ insertID, content ];
await dmlInsert(bindVar_1, content);
});
it('107.1.12 works with undefined', function(done) {
var content = undefined;
var bindVar = {
it('107.1.12 works with undefined', async function() {
const content = undefined;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, null, done);
await dmlInsert(bindVar, null);
});
it('107.1.13 bind undefined with default type/dir - named bind', function(done) {
var content = undefined;
var bindVar_1 = {
it('107.1.13 bind undefined with default type/dir - named bind', async function() {
const content = undefined;
const bindVar_1 = {
i: insertID,
c: content
};
dmlInsert(bindVar_1, null, done);
await dmlInsert(bindVar_1, null);
});
it('107.1.14 bind undefined with default type/dir - positional bind', function(done) {
var content = undefined;
var bindVar_1 = [ insertID, content ];
dmlInsert(bindVar_1, null, done);
it('107.1.14 bind undefined with default type/dir - positional bind', async function() {
const content = undefined;
const bindVar_1 = [ insertID, content ];
await dmlInsert(bindVar_1, null);
});
it('107.1.15 works with NaN', function(done) {
var content = NaN;
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var bindVar = {
it('107.1.15 works with NaN', async function() {
const content = NaN;
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
connection.execute(
sql_insert,
bindVar,
function(err) {
should.exist(err);
(err.message).should.equal("NJS-011: encountered bind value and type mismatch");
done();
}
await testsUtil.assertThrowsAsync(
async () => await connection.execute(sql_insert, bindVar),
/NJS-011:/
);
});
@ -247,364 +216,244 @@ describe('107. rowidDMLBindAsString.js', function() {
describe('107.2 UPDATE', function() {
it('107.2.1 UPDATE null column', function(done) {
var content_insert = null;
var content_update = "AAABiqAADAAAAwPAAA";
dmlUpdate(content_insert, content_update, content_update, done);
it('107.2.1 UPDATE null column', async function() {
const content_insert = null;
const content_update = "AAABiqAADAAAAwPAAA";
await dmlUpdate(content_insert, content_update, content_update);
});
it('107.2.1 UPDATE extented rowid with restricted rowid', function(done) {
var content_insert = "AAABioAADAAAAwPAAA";
var content_update = "00000DD5.0010.0001";
dmlUpdate(content_insert, content_update, content_update, done);
it('107.2.1 UPDATE extented rowid with restricted rowid', async function() {
const content_insert = "AAABioAADAAAAwPAAA";
const content_update = "00000DD5.0010.0001";
await dmlUpdate(content_insert, content_update, content_update);
});
it('107.2.3 UPDATE restricted rowid with null', function(done) {
var content_insert = "00000DD5.0010.0002";
var content_update = null;
dmlUpdate(content_insert, content_update, content_update, done);
it('107.2.3 UPDATE restricted rowid with null', async function() {
const content_insert = "00000DD5.0010.0002";
const content_update = null;
await dmlUpdate(content_insert, content_update, content_update);
});
});
describe('107.3 RETURNING INTO', function() {
it('107.3.1 INSERT null', function(done) {
var content = null;
var bindVar = {
it('107.3.1 INSERT null', async function() {
const content = null;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('107.3.2 INSERT extented rowid', function(done) {
var content = "AAAA++AALAAAAQ/AAA";
var bindVar = {
it('107.3.2 INSERT extented rowid', async function() {
const content = "AAAA++AALAAAAQ/AAA";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('107.3.3 INSERT restricted rowid', function(done) {
var content = "00000000.0100.0100";
var bindVar = {
it('107.3.3 INSERT restricted rowid', async function() {
const content = "00000000.0100.0100";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('107.3.7 UPDATE null with extented rowid', function(done) {
var content_insert = null;
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = {
it('107.3.7 UPDATE null with extented rowid', async function() {
const content_insert = null;
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('107.3.8 UPDATE extented rowid with null', function(done) {
var content_insert = "AAABiqAADAAAAwPAAA";
var content_update = null;
var bindVar_update = {
it('107.3.8 UPDATE extented rowid with null', async function() {
const content_insert = "AAABiqAADAAAAwPAAA";
const content_update = null;
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('107.3.9 UPDATE restricted rowid with empty string', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "";
var bindVar_update = {
it('107.3.9 UPDATE restricted rowid with empty string', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "";
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, null, done);
await update_returning(content_insert, bindVar_update, null);
});
it('107.3.10 UPDATE restricted rowid with extented rowid', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = {
it('107.3.10 UPDATE restricted rowid with extented rowid', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('107.3.11 INSERT with default type/dir - named bind', function(done) {
var content = "00000000.0100.0100";
var bindVar = {
it('107.3.11 INSERT with default type/dir - named bind', async function() {
const content = "00000000.0100.0100";
const bindVar = {
i: insertID,
c: content,
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('107.3.12 INSERT with default type/dir - positional bind', function(done) {
var content = "00000000.0100.0100";
var bindVar = [ insertID, content, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
insert_returning(bindVar, content, done);
it('107.3.12 INSERT with default type/dir - positional bind', async function() {
const content = "00000000.0100.0100";
const bindVar = [ insertID, content, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
await insert_returning(bindVar, content);
});
it('107.3.13 UPDATE with default type/dir - named bind', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = {
it('107.3.13 UPDATE with default type/dir - named bind', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = {
i: insertID,
c: content_update,
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('107.3.14 UPDATE with default type/dir - positional bind', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = [ content_update, insertID, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
update_returning(content_insert, bindVar_update, content_update, done);
it('107.3.14 UPDATE with default type/dir - positional bind', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = [ content_update, insertID, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
await update_returning(content_insert, bindVar_update, content_update);
});
});
describe('107.4 WHERE', function() {
it('107.4.1 can bind in WHERE clause', function(done) {
where_select(done);
it('107.4.1 can bind in WHERE clause', async function() {
await where_select();
});
});
var dmlInsert = function(bindVar, expected, callback) {
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var sql_select = "select * from " + tableName + " where id = :i";
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_select,
{ i: insertID },
function(err, result) {
should.not.exist(err);
var resultVal = result.rows[0][1];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
cb();
}
);
}
], callback);
const dmlInsert = async function(bindVar, expected) {
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const sql_select = "select * from " + tableName + " where id = :i";
let result = await connection.execute(sql_insert, bindVar);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_select, { i: insertID });
const resultVal = result.rows[0][1];
assert.strictEqual(resultVal, expected);
};
var dmlInsert_substr = function(content, callback) {
var id = insertID++;
var sql_insert = "insert into " + tableName + "(id, content) values (" + id + ", CHARTOROWID(:c))";
var sql_select = "select content, SUBSTR(content,1,6) , SUBSTR(content,7,3), SUBSTR(content,10,6), SUBSTR(content,16,3) from " + tableName + " where id = " + id;
var bindVar = { c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }};
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_select,
function(err, result) {
should.not.exist(err);
var resultVal_rowid = result.rows[0][0];
var resultVal_object = result.rows[0][1];
var resultVal_file = result.rows[0][2];
var resultVal_block = result.rows[0][3];
var resultVal_row = result.rows[0][4];
should.strictEqual(typeof resultVal_rowid, "string");
should.strictEqual(typeof resultVal_block, "string");
should.strictEqual(typeof resultVal_row, "string");
should.strictEqual(typeof resultVal_file, "string");
should.strictEqual(typeof resultVal_object, "string");
should.strictEqual(resultVal_rowid, content);
should.strictEqual(resultVal_object, content.substring(0, 6));
should.strictEqual(resultVal_file, content.substring(6, 9));
should.strictEqual(resultVal_block, content.substring(9, 15));
should.strictEqual(resultVal_row, content.substring(15, 18));
cb();
}
);
}
], callback);
const dmlInsert_substr = async function(content) {
const id = insertID++;
const sql_insert = "insert into " + tableName + "(id, content) values (" + id + ", CHARTOROWID(:c))";
const sql_select = "select content, SUBSTR(content,1,6) , SUBSTR(content,7,3), SUBSTR(content,10,6), SUBSTR(content,16,3) from " + tableName + " where id = " + id;
const bindVar = { c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }};
let result = await connection.execute(sql_insert, bindVar);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_select);
const resultVal_rowid = result.rows[0][0];
const resultVal_object = result.rows[0][1];
const resultVal_file = result.rows[0][2];
const resultVal_block = result.rows[0][3];
const resultVal_row = result.rows[0][4];
assert.strictEqual(typeof resultVal_rowid, "string");
assert.strictEqual(typeof resultVal_block, "string");
assert.strictEqual(typeof resultVal_row, "string");
assert.strictEqual(typeof resultVal_file, "string");
assert.strictEqual(typeof resultVal_object, "string");
assert.strictEqual(resultVal_rowid, content);
assert.strictEqual(resultVal_object, content.substring(0, 6));
assert.strictEqual(resultVal_file, content.substring(6, 9));
assert.strictEqual(resultVal_block, content.substring(9, 15));
assert.strictEqual(resultVal_row, content.substring(15, 18));
};
var dmlUpdate = function(content_insert, content_update, expected, callback) {
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var sql_update = "update " + tableName + " set content = :c where id = :i";
var sql_select = "select * from " + tableName + " where id = :i";
var bindVar_insert = {
const dmlUpdate = async function(content_insert, content_update, expected) {
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const sql_update = "update " + tableName + " set content = :c where id = :i";
const sql_select = "select * from " + tableName + " where id = :i";
const bindVar_insert = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_insert, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
var bindVar_update = {
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar_insert,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_update,
bindVar_update,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_select,
{ i: insertID },
function(err, result) {
should.not.exist(err);
var resultVal = result.rows[0][1];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
cb();
}
);
}
], callback);
let result = await connection.execute(sql_insert, bindVar_insert);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_update, bindVar_update);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_select, { i: insertID });
const resultVal = result.rows[0][1];
assert.strictEqual(resultVal, expected);
};
var insert_returning = function(bindVar, expected, callback) {
var sql_returning = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c)) returning content into :o";
connection.execute(
sql_returning,
bindVar,
function(err, result) {
should.not.exist(err);
var resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
callback();
}
);
const insert_returning = async function(bindVar, expected) {
const sql_returning = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c)) returning content into :o";
const result = await connection.execute(sql_returning, bindVar);
let resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
assert.strictEqual(resultVal, expected);
};
var update_returning = function(content_insert, bindVar_update, expected, callback) {
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var sql_update = "update " + tableName + " set content = :c where id = :i returning content into :o";
var bindVar_insert = {
const update_returning = async function(content_insert, bindVar_update, expected) {
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const sql_update = "update " + tableName + " set content = :c where id = :i returning content into :o";
const bindVar_insert = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_insert, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar_insert,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_update,
bindVar_update,
function(err, result) {
should.not.exist(err);
var resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
cb();
}
);
}
], callback);
let result = await connection.execute(sql_insert, bindVar_insert);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_update, bindVar_update);
let resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
assert.strictEqual(resultVal, expected);
};
var where_select = function(callback) {
async.series([
function(cb) {
connection.execute(
"insert into " + tableName + " T (ID) values (" + insertID + ")",
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
"UPDATE " + tableName + " T SET content = T.ROWID where ID = " + insertID,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
"select content from " + tableName + " where ID = " + insertID,
function(err, result) {
should.not.exist(err);
var resultVal = result.rows[0][0];
connection.execute(
"select * from " + tableName + " where ROWID = CHARTOROWID(:c)",
{ c: { val: resultVal, dir : oracledb.BIND_IN, type : oracledb.STRING } },
function(err_1, result_1) {
should.not.exist(err_1);
var resultVal_1 = result_1.rows[0][0];
var resultVal_2 = result_1.rows[0][1];
should.strictEqual(resultVal_1, insertID);
should.strictEqual(resultVal_2, resultVal);
cb();
}
);
}
);
const where_select = async function() {
let sql = "insert into " + tableName + " T (ID) values (" + insertID + ")";
let result = await connection.execute(sql);
assert.strictEqual(result.rowsAffected, 1);
sql = "UPDATE " + tableName + " T SET content = T.ROWID where ID = " + insertID;
result = await connection.execute(sql);
assert.strictEqual(result.rowsAffected, 1);
sql = "select content from " + tableName + " where ID = " + insertID;
result = await connection.execute(sql);
const resultVal = result.rows[0][0];
sql = "select * from " + tableName + " where ROWID = CHARTOROWID(:c)";
const binds = {
c: {
val: resultVal, dir : oracledb.BIND_IN, type : oracledb.STRING
}
], callback);
};
result = await connection.execute(sql, binds);
const resultVal_1 = result.rows[0][0];
const resultVal_2 = result.rows[0][1];
assert.strictEqual(resultVal_1, insertID);
assert.strictEqual(resultVal_2, resultVal);
};
});

12
test/tpcResume.js
View File

@ -34,10 +34,9 @@
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
const testsUtil = require('./testsUtil.js');
describe('260. tpcResume.js', function() {
let connection;
const xid = {
"formatId": 101,
"globalTransactionId": "testtxt1",
@ -63,7 +62,7 @@ describe('260. tpcResume.js', function() {
END;`;
before (async function() {
connection = await oracledb.getConnection(dbConfig);
const connection = await oracledb.getConnection(dbConfig);
await connection.execute(createTableSQL);
await connection.executeMany(
`INSERT INTO nodb_tpc_resume values (:1, :2)`,
@ -74,10 +73,7 @@ describe('260. tpcResume.js', function() {
});
after(async function() {
connection = await oracledb.getConnection(dbConfig);
await connection.execute(`DROP TABLE nodb_tpc_resume`);
await connection.close();
connection = undefined;
await testsUtil.dropTable("nodb_tpc_resume");
});
@ -85,7 +81,7 @@ describe('260. tpcResume.js', function() {
let result;
// connection 1
connection = await oracledb.getConnection(dbConfig);
let connection = await oracledb.getConnection(dbConfig);
await connection.tpcBegin(xid);
await connection.execute(
`UPDATE nodb_tpc_resume SET salary = salary * 1.1 WHERE id = :1`, [1]);

608
test/urowidDMLBindAsString1.js
View File

@ -34,17 +34,16 @@
'use strict';
var oracledb = require('oracledb');
var should = require('should');
var async = require('async');
var assert = require('assert');
var dbConfig = require('./dbconfig.js');
var sql = require('./sql.js');
var testsUtil = require('./testsUtil.js');
describe('114. urowidDMLBindAsString1.js', function() {
var connection = null;
var tableName = "nodb_bind_urowid";
var insertID = 1;
let connection;
const tableName = "nodb_bind_urowid";
let insertID = 1;
var proc_create_table = "BEGIN \n" +
const proc_create_table = "BEGIN \n" +
" DECLARE \n" +
" e_table_missing EXCEPTION; \n" +
" PRAGMA EXCEPTION_INIT(e_table_missing, -00942);\n" +
@ -61,185 +60,155 @@ describe('114. urowidDMLBindAsString1.js', function() {
" ) \n" +
" '); \n" +
"END; ";
var drop_table = "DROP TABLE " + tableName + " PURGE";
const drop_table = "DROP TABLE " + tableName + " PURGE";
before('get connection and create table', function(done) {
async.series([
function(cb) {
oracledb.getConnection(dbConfig, function(err, conn) {
should.not.exist(err);
connection = conn;
cb();
});
},
function(cb) {
sql.executeSql(connection, proc_create_table, {}, {}, cb);
}
], done);
before('get connection and create table', async function() {
connection = await oracledb.getConnection(dbConfig);
await connection.execute(proc_create_table);
});
after('release connection', function(done) {
async.series([
function(cb) {
sql.executeSql(connection, drop_table, {}, {}, cb);
},
function(cb) {
connection.release(function(err) {
should.not.exist(err);
cb();
});
}
], done);
after('release connection', async function() {
await connection.execute(drop_table);
await connection.close();
});
beforeEach(function(done) {
beforeEach(function() {
insertID++;
done();
});
describe('114.1 INSERT & SELECT', function() {
it('114.1.1 works with null', function(done) {
var content = null;
var bindVar = {
it('114.1.1 works with null', async function() {
const content = null;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, content, done);
await dmlInsert(bindVar, content);
});
it('114.1.2 works with empty string', function(done) {
var content = "";
var expected = null;
var bindVar = {
it('114.1.2 works with empty string', async function() {
const content = "";
const expected = null;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, expected, done);
await dmlInsert(bindVar, expected);
});
it('114.1.3 works with extended rowid', function(done) {
var content = "AAABoqAADAAAAwPAAA";
var bindVar = {
it('114.1.3 works with extended rowid', async function() {
const content = "AAABoqAADAAAAwPAAA";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, content, done);
await dmlInsert(bindVar, content);
});
it('114.1.4 works with restricted rowid', function(done) {
var content = "00000DD5.0000.0001";
var bindVar = {
it('114.1.4 works with restricted rowid', async function() {
const content = "00000DD5.0000.0001";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, content, done);
await dmlInsert(bindVar, content);
});
it('114.1.5 throws error with number 0', function(done) {
var content = 0;
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var bindVar = {
it('114.1.5 throws error with number 0', async function() {
const content = 0;
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
connection.execute(
sql_insert,
bindVar,
function(err) {
should.exist(err);
(err.message).should.equal("NJS-011: encountered bind value and type mismatch");
done();
}
await testsUtil.assertThrowsAsync(
async () => await connection.execute(sql_insert, bindVar),
/NJS-011:/
);
});
it('114.1.6 works with string 0', function(done) {
var content = "0";
var expected = "00000000.0000.0000";
var bindVar = {
it('114.1.6 works with string 0', async function() {
const content = "0";
const expected = "00000000.0000.0000";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, expected, done);
await dmlInsert(bindVar, expected);
});
it('114.1.7 works with substr', function(done) {
var content = "AAAA8+AALAAAAQ/AAA";
dmlInsert_substr(content, done);
it('114.1.7 works with substr', async function() {
const content = "AAAA8+AALAAAAQ/AAA";
await dmlInsert_substr(content);
});
it('114.1.8 bind null with default type/dir - named bind', function(done) {
var content = null;
var bindVar_1 = {
it('114.1.8 bind null with default type/dir - named bind', async function() {
const content = null;
const bindVar_1 = {
i: insertID,
c: content
};
dmlInsert(bindVar_1, content, done);
await dmlInsert(bindVar_1, content);
});
it('114.1.9 bind null with default type/dir - positional bind', function(done) {
var content = null;
var bindVar_1 = [ insertID, content ];
dmlInsert(bindVar_1, content, done);
it('114.1.9 bind null with default type/dir - positional bind', async function() {
const content = null;
const bindVar_1 = [ insertID, content ];
await dmlInsert(bindVar_1, content);
});
it('114.1.10 bind extented rowid with default type/dir - named bind', function(done) {
var content = "AAAA8+AALAAAAQ/AAA";
var bindVar_1 = {
it('114.1.10 bind extented rowid with default type/dir - named bind', async function() {
const content = "AAAA8+AALAAAAQ/AAA";
const bindVar_1 = {
i: insertID,
c: content
};
dmlInsert(bindVar_1, content, done);
await dmlInsert(bindVar_1, content);
});
it('114.1.11 bind extented rowid with default type/dir - positional bind', function(done) {
var content = "AAAA8+AALAAAAQ/AAA";
var bindVar_1 = [ insertID, content ];
dmlInsert(bindVar_1, content, done);
it('114.1.11 bind extented rowid with default type/dir - positional bind', async function() {
const content = "AAAA8+AALAAAAQ/AAA";
const bindVar_1 = [ insertID, content ];
await dmlInsert(bindVar_1, content);
});
it('114.1.12 works with undefined', function(done) {
var content = undefined;
var bindVar = {
it('114.1.12 works with undefined', async function() {
const content = undefined;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
dmlInsert(bindVar, null, done);
await dmlInsert(bindVar, null);
});
it('114.1.13 bind undefined with default type/dir - named bind', function(done) {
var content = undefined;
var bindVar_1 = {
it('114.1.13 bind undefined with default type/dir - named bind', async function() {
const content = undefined;
const bindVar_1 = {
i: insertID,
c: content
};
dmlInsert(bindVar_1, null, done);
await dmlInsert(bindVar_1, null);
});
it('114.1.14 bind undefined with default type/dir - positional bind', function(done) {
var content = undefined;
var bindVar_1 = [ insertID, content ];
dmlInsert(bindVar_1, null, done);
it('114.1.14 bind undefined with default type/dir - positional bind', async function() {
const content = undefined;
const bindVar_1 = [ insertID, content ];
await dmlInsert(bindVar_1, null);
});
it('114.1.15 works with NaN', function(done) {
var content = NaN;
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var bindVar = {
it('114.1.15 works with NaN', async function() {
const content = NaN;
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
connection.execute(
sql_insert,
bindVar,
function(err) {
should.exist(err);
(err.message).should.equal("NJS-011: encountered bind value and type mismatch");
done();
}
await testsUtil.assertThrowsAsync(
async () => await connection.execute(sql_insert, bindVar),
/NJS-011:/
);
});
@ -247,365 +216,244 @@ describe('114. urowidDMLBindAsString1.js', function() {
describe('114.2 UPDATE', function() {
it('114.2.1 UPDATE null column', function(done) {
var content_insert = null;
var content_update = "AAABiqAADAAAAwPAAA";
dmlUpdate(content_insert, content_update, content_update, done);
it('114.2.1 UPDATE null column', async function() {
const content_insert = null;
const content_update = "AAABiqAADAAAAwPAAA";
await dmlUpdate(content_insert, content_update, content_update);
});
it('114.2.1 UPDATE extented rowid with restricted rowid', function(done) {
var content_insert = "AAABioAADAAAAwPAAA";
var content_update = "00000DD5.0010.0001";
dmlUpdate(content_insert, content_update, content_update, done);
it('114.2.1 UPDATE extented rowid with restricted rowid', async function() {
const content_insert = "AAABioAADAAAAwPAAA";
const content_update = "00000DD5.0010.0001";
await dmlUpdate(content_insert, content_update, content_update);
});
it('114.2.3 UPDATE restricted rowid with null', function(done) {
var content_insert = "00000DD5.0010.0002";
var content_update = null;
dmlUpdate(content_insert, content_update, content_update, done);
it('114.2.3 UPDATE restricted rowid with null', async function() {
const content_insert = "00000DD5.0010.0002";
const content_update = null;
await dmlUpdate(content_insert, content_update, content_update);
});
});
describe('114.3 RETURNING INTO', function() {
it('114.3.1 INSERT null', function(done) {
var content = null;
var bindVar = {
it('114.3.1 INSERT null', async function() {
const content = null;
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('114.3.2 INSERT extented rowid', function(done) {
var content = "AAAA++AALAAAAQ/AAA";
var bindVar = {
it('114.3.2 INSERT extented rowid', async function() {
const content = "AAAA++AALAAAAQ/AAA";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('114.3.3 INSERT restricted rowid', function(done) {
var content = "00000000.0100.0100";
var bindVar = {
it('114.3.3 INSERT restricted rowid', async function() {
const content = "00000000.0100.0100";
const bindVar = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('114.3.7 UPDATE null with extented rowid', function(done) {
var content_insert = null;
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = {
it('114.3.7 UPDATE null with extented rowid', async function() {
const content_insert = null;
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('114.3.8 UPDATE extented rowid with null', function(done) {
var content_insert = "AAABiqAADAAAAwPAAA";
var content_update = null;
var bindVar_update = {
it('114.3.8 UPDATE extented rowid with null', async function() {
const content_insert = "AAABiqAADAAAAwPAAA";
const content_update = null;
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('114.3.9 UPDATE restricted rowid with empty string', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "";
var bindVar_update = {
it('114.3.9 UPDATE restricted rowid with empty string', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "";
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, null, done);
await update_returning(content_insert, bindVar_update, null);
});
it('114.3.10 UPDATE restricted rowid with extented rowid', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = {
it('114.3.10 UPDATE restricted rowid with extented rowid', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING },
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('114.3.11 INSERT with default type/dir - named bind', function(done) {
var content = "00000000.0100.0100";
var bindVar = {
it('114.3.11 INSERT with default type/dir - named bind', async function() {
const content = "00000000.0100.0100";
const bindVar = {
i: insertID,
c: content,
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
insert_returning(bindVar, content, done);
await insert_returning(bindVar, content);
});
it('114.3.12 INSERT with default type/dir - positional bind', function(done) {
var content = "00000000.0100.0100";
var bindVar = [ insertID, content, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
insert_returning(bindVar, content, done);
it('114.3.12 INSERT with default type/dir - positional bind', async function() {
const content = "00000000.0100.0100";
const bindVar = [ insertID, content, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
await insert_returning(bindVar, content);
});
it('114.3.13 UPDATE with default type/dir - named bind', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = {
it('114.3.13 UPDATE with default type/dir - named bind', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = {
i: insertID,
c: content_update,
o: { dir : oracledb.BIND_OUT, type : oracledb.STRING }
};
update_returning(content_insert, bindVar_update, content_update, done);
await update_returning(content_insert, bindVar_update, content_update);
});
it('114.3.14 UPDATE with default type/dir - positional bind', function(done) {
var content_insert = "00000000.0100.0100";
var content_update = "AAABiqAADAAAAwPAAA";
var bindVar_update = [ content_update, insertID, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
update_returning(content_insert, bindVar_update, content_update, done);
it('114.3.14 UPDATE with default type/dir - positional bind', async function() {
const content_insert = "00000000.0100.0100";
const content_update = "AAABiqAADAAAAwPAAA";
const bindVar_update = [ content_update, insertID, { dir : oracledb.BIND_OUT, type : oracledb.STRING } ];
await update_returning(content_insert, bindVar_update, content_update);
});
});
describe('107.4 WHERE', function() {
it('107.4.1 can bind in WHERE clause', function(done) {
where_select(done);
it('107.4.1 can bind in WHERE clause', async function() {
await where_select();
});
});
var dmlInsert = function(bindVar, expected, callback) {
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var sql_select = "select * from " + tableName + " where id = :i";
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_select,
{ i: insertID },
function(err, result) {
should.not.exist(err);
var resultVal = result.rows[0][1];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
cb();
}
);
}
], callback);
const dmlInsert = async function(bindVar, expected) {
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const sql_select = "select * from " + tableName + " where id = :i";
let result = await connection.execute(sql_insert, bindVar);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_select, { i: insertID });
const resultVal = result.rows[0][1];
assert.strictEqual(resultVal, expected);
};
var dmlInsert_substr = function(content, callback) {
var id = insertID++;
var sql_insert = "insert into " + tableName + "(id, content) values (" + id + ", CHARTOROWID(:c))";
var sql_select = "select content, SUBSTR(content,1,6) , SUBSTR(content,7,3), SUBSTR(content,10,6), SUBSTR(content,16,3) from " + tableName + " where id = " + id;
var bindVar = { c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }};
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_select,
function(err, result) {
should.not.exist(err);
var resultVal_rowid = result.rows[0][0];
var resultVal_object = result.rows[0][1];
var resultVal_file = result.rows[0][2];
var resultVal_block = result.rows[0][3];
var resultVal_row = result.rows[0][4];
should.strictEqual(typeof resultVal_rowid, "string");
should.strictEqual(typeof resultVal_block, "string");
should.strictEqual(typeof resultVal_row, "string");
should.strictEqual(typeof resultVal_file, "string");
should.strictEqual(typeof resultVal_object, "string");
should.strictEqual(resultVal_rowid, content);
should.strictEqual(resultVal_object, content.substring(0, 6));
should.strictEqual(resultVal_file, content.substring(6, 9));
should.strictEqual(resultVal_block, content.substring(9, 15));
should.strictEqual(resultVal_row, content.substring(15, 18));
cb();
}
);
}
], callback);
const dmlInsert_substr = async function(content) {
const id = insertID++;
const sql_insert = "insert into " + tableName + "(id, content) values (" + id + ", CHARTOROWID(:c))";
const sql_select = "select content, SUBSTR(content,1,6) , SUBSTR(content,7,3), SUBSTR(content,10,6), SUBSTR(content,16,3) from " + tableName + " where id = " + id;
const bindVar = { c: { val : content, dir : oracledb.BIND_IN, type : oracledb.STRING }};
let result = await connection.execute(sql_insert, bindVar);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_select);
const resultVal_rowid = result.rows[0][0];
const resultVal_object = result.rows[0][1];
const resultVal_file = result.rows[0][2];
const resultVal_block = result.rows[0][3];
const resultVal_row = result.rows[0][4];
assert.strictEqual(typeof resultVal_rowid, "string");
assert.strictEqual(typeof resultVal_block, "string");
assert.strictEqual(typeof resultVal_row, "string");
assert.strictEqual(typeof resultVal_file, "string");
assert.strictEqual(typeof resultVal_object, "string");
assert.strictEqual(resultVal_rowid, content);
assert.strictEqual(resultVal_object, content.substring(0, 6));
assert.strictEqual(resultVal_file, content.substring(6, 9));
assert.strictEqual(resultVal_block, content.substring(9, 15));
assert.strictEqual(resultVal_row, content.substring(15, 18));
};
var dmlUpdate = function(content_insert, content_update, expected, callback) {
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var sql_update = "update " + tableName + " set content = :c where id = :i";
var sql_select = "select * from " + tableName + " where id = :i";
var bindVar_insert = {
const dmlUpdate = async function(content_insert, content_update, expected) {
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const sql_update = "update " + tableName + " set content = :c where id = :i";
const sql_select = "select * from " + tableName + " where id = :i";
const bindVar_insert = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_insert, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
var bindVar_update = {
const bindVar_update = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_update, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar_insert,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_update,
bindVar_update,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_select,
{ i: insertID },
function(err, result) {
should.not.exist(err);
var resultVal = result.rows[0][1];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
cb();
}
);
}
], callback);
let result = await connection.execute(sql_insert, bindVar_insert);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_update, bindVar_update);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_select, { i: insertID });
const resultVal = result.rows[0][1];
assert.strictEqual(resultVal, expected);
};
var insert_returning = function(bindVar, expected, callback) {
var sql_returning = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c)) returning content into :o";
connection.execute(
sql_returning,
bindVar,
function(err, result) {
should.not.exist(err);
var resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
callback();
}
);
const insert_returning = async function(bindVar, expected) {
const sql_returning = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c)) returning content into :o";
const result = await connection.execute(sql_returning, bindVar);
let resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
assert.strictEqual(resultVal, expected);
};
var update_returning = function(content_insert, bindVar_update, expected, callback) {
var sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
var sql_update = "update " + tableName + " set content = :c where id = :i returning content into :o";
var bindVar_insert = {
const update_returning = async function(content_insert, bindVar_update, expected) {
const sql_insert = "insert into " + tableName + "(id, content) values (:i, CHARTOROWID(:c))";
const sql_update = "update " + tableName + " set content = :c where id = :i returning content into :o";
const bindVar_insert = {
i: { val : insertID, dir : oracledb.BIND_IN, type : oracledb.NUMBER },
c: { val : content_insert, dir : oracledb.BIND_IN, type : oracledb.STRING }
};
async.series([
function(cb) {
connection.execute(
sql_insert,
bindVar_insert,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
sql_update,
bindVar_update,
function(err, result) {
should.not.exist(err);
var resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
should.strictEqual(resultVal, expected);
// should.strictEqual(typeof resultVal, "string");
cb();
}
);
}
], callback);
let result = await connection.execute(sql_insert, bindVar_insert);
assert.strictEqual(result.rowsAffected, 1);
result = await connection.execute(sql_update, bindVar_update);
let resultVal;
if (typeof (result.outBinds.o) === 'undefined') resultVal = result.outBinds[0][0];
else resultVal = result.outBinds.o[0];
assert.strictEqual(resultVal, expected);
};
var where_select = function(callback) {
async.series([
function(cb) {
connection.execute(
"insert into " + tableName + " T (ID) values (" + insertID + ")",
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
"UPDATE " + tableName + " T SET content = T.ROWID where ID = " + insertID,
function(err, result) {
should.not.exist(err);
(result.rowsAffected).should.be.exactly(1);
cb();
}
);
},
function(cb) {
connection.execute(
"select content from " + tableName + " where ID = " + insertID,
function(err, result) {
should.not.exist(err);
var resultVal = result.rows[0][0];
connection.execute(
"select * from " + tableName + " where ROWID = CHARTOROWID(:c)",
{ c: { val: resultVal, dir : oracledb.BIND_IN, type : oracledb.STRING } },
function(err_1, result_1) {
should.not.exist(err_1);
var resultVal_1 = result_1.rows[0][0];
var resultVal_2 = result_1.rows[0][1];
should.strictEqual(resultVal_1, insertID);
should.strictEqual(resultVal_2, resultVal);
cb();
}
);
}
);
const where_select = async function() {
let sql = `insert into ${tableName} T (ID) values (${insertID})`;
let result = await connection.execute(sql);
assert.strictEqual(result.rowsAffected, 1);
sql = `UPDATE ${tableName} T SET content = T.ROWID where ID = ${insertID}`;
result = await connection.execute(sql);
assert.strictEqual(result.rowsAffected, 1);
sql = `select content from ${tableName} where ID = ${insertID}`;
result = await connection.execute(sql);
const resultVal = result.rows[0][0];
sql = `select * from ${tableName} where ROWID = CHARTOROWID(:c)`;
const binds = {
c: {
val: resultVal, dir : oracledb.BIND_IN, type : oracledb.STRING
}
], callback);
};
result = await connection.execute(sql, binds);
const resultVal_1 = result.rows[0][0];
const resultVal_2 = result.rows[0][1];
assert.strictEqual(resultVal_1, insertID);
assert.strictEqual(resultVal_2, resultVal);
};
});

143
test/writableProperties1.js
View File

@ -32,133 +32,68 @@
'use strict';
const oracledb = require('oracledb');
const assert = require('assert');
const dbConfig = require('./dbconfig.js');
describe('66. writableProperties1.js', function() {
it('66.1 allows overwriting of public methods on pool instances', async function() {
var pool = await oracledb.createPool(dbConfig);
assert(pool);
var keys;
var keysIdx;
var originalFunction;
keys = Object.keys(pool);
for (keysIdx = 0; keysIdx < keys.length; keysIdx += 1) {
if (typeof pool[keys[keysIdx]] === 'function') {
originalFunction = pool[keys[keysIdx]];
pool[keys[keysIdx]] = function() {};
pool[keys[keysIdx]] = originalFunction;
const checkOverwrite = function(obj, excludeKeys) {
if (excludeKeys === undefined)
excludeKeys = [];
const keys = Object.keys(obj);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
if (excludeKeys.includes(key))
continue;
const value = obj[key];
if (typeof value === 'function') {
obj[key] = function() {};
obj[key] = value;
}
}
};
await pool.terminate();
it('66.1 allows overwriting of public methods on pool instances', async function() {
const pool = await oracledb.createPool(dbConfig);
checkOverwrite(pool);
await pool.close();
});
it('66.2 allows overwriting of public methods on connection instances', async function() {
var conn = await oracledb.getConnection(dbConfig);
var keys;
var keysIdx;
var originalFunction;
keys = Object.keys(conn);
for (keysIdx = 0; keysIdx < keys.length; keysIdx += 1) {
if (typeof conn[keys[keysIdx]] === 'function') {
originalFunction = conn[keys[keysIdx]];
conn[keys[keysIdx]] = function() {};
conn[keys[keysIdx]] = originalFunction;
}
}
await conn.release();
const conn = await oracledb.getConnection(dbConfig);
checkOverwrite(conn);
await conn.close();
});
it('66.3 allows overwriting of public methods on resultset instances', async function() {
var conn = await oracledb.getConnection(dbConfig);
var result = await conn.execute(
const conn = await oracledb.getConnection(dbConfig);
const result = await conn.execute(
'select 1 from dual union select 2 from dual',
[], // no binds
{
resultSet: true
});
var keys;
var keysIdx;
var originalFunction;
keys = Object.keys(result.resultSet);
for (keysIdx = 0; keysIdx < keys.length; keysIdx += 1) {
if (typeof result.resultSet[keys[keysIdx]] === 'function') {
originalFunction = result.resultSet[keys[keysIdx]];
result.resultSet[keys[keysIdx]] = function() {};
result.resultSet[keys[keysIdx]] = originalFunction;
}
}
await result.resultSet.close();
await conn.release();
const rs = result.resultSet;
checkOverwrite(rs);
await rs.close();
await conn.close();
});
it('66.4 allows overwriting of public methods on lob instances', async function() {
var conn = await oracledb.getConnection(dbConfig);
assert(conn);
var result = await conn.execute('select to_clob(dummy) from dual');
var keys;
var keysIdx;
var originalFunction;
var lob;
lob = result.rows[0][0];
keys = Object.keys(lob);
for (keysIdx = 0; keysIdx < keys.length; keysIdx += 1) {
if (typeof lob[keys[keysIdx]] === 'function') {
originalFunction = lob[keys[keysIdx]];
lob[keys[keysIdx]] = function() {};
lob[keys[keysIdx]] = originalFunction;
}
}
lob.on("finish", function(err) {
assert.fail(err);
});
lob.on("error", function(err) {
assert.fail(err, "lob.on 'error' event.");
});
lob.destroy();
const conn = await oracledb.getConnection(dbConfig);
const result = await conn.execute('select to_clob(dummy) from dual');
const lob = result.rows[0][0];
checkOverwrite(lob);
await lob.close();
await conn.close();
}); // 66.4
it('66.5 allows overwriting of public methods on oracledb instances', function(done) {
var keys = Object.keys(oracledb);
for (var keysIdx = 0; keysIdx < keys.length; keysIdx += 1) {
if (typeof oracledb[keys[keysIdx]] === 'function') {
var originalFunction = oracledb[keys[keysIdx]];
oracledb[keys[keysIdx]] = function() {};
oracledb[keys[keysIdx]] = originalFunction;
}
}
done();
it('66.5 allows overwriting of public methods on oracledb instances', function() {
const excludeNames = [
"initOracleClient",
"oracleClientVersion",
"oracleClientVersionString"
];
checkOverwrite(oracledb, excludeNames);
}); // 66.5
});