From b15e0567bc05b222a5daf30206fa65c4dfc097ab Mon Sep 17 00:00:00 2001 From: Christopher Jones Date: Sat, 23 Mar 2019 07:58:36 +1100 Subject: [PATCH] Revise test/fetchRowidAsString.js by removing oversized raw column test --- test/fetchRawAsString.js | 377 +++++++++++++++++---------------------- test/list.txt | 33 ++-- 2 files changed, 186 insertions(+), 224 deletions(-) diff --git a/test/fetchRawAsString.js b/test/fetchRawAsString.js index 16839db4..8a8c3133 100644 --- a/test/fetchRawAsString.js +++ b/test/fetchRawAsString.js @@ -76,6 +76,38 @@ describe('188. fetchRowidAsString.js', function() { before(async function() { try { conn = await oracledb.getConnection(dbConfig); + const sqlCreateTable = `BEGIN \n` + + ` DECLARE \n` + + ` e_table_missing EXCEPTION; \n` + + ` PRAGMA EXCEPTION_INIT(e_table_missing, -00942);\n` + + ` BEGIN \n` + + ` EXECUTE IMMEDIATE ('DROP TABLE ${tableName} PURGE' ); \n` + + ` EXCEPTION \n` + + ` WHEN e_table_missing \n` + + ` THEN NULL; \n` + + ` END; \n` + + ` EXECUTE IMMEDIATE ( ' \n` + + ` CREATE TABLE ${tableName} ( \n` + + ` raw_content RAW(${rawMaxLength}) NULL, \n` + + ` content_type VARCHAR(20) \n` + + ` ) \n` + + ` '); \n` + + `END; `; + await conn.execute(sqlCreateTable); + + let sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_to_raw('${rawContentString}'), 'string')`; + await conn.execute(sql); + sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_number(${rawContentNumber}), 'number')`; + await conn.execute(sql); + sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_binary_double(${rawContentFloat}), 'binary_double')`; + await conn.execute(sql); + sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_binary_float(${rawContentFloat}), 'binary_float')`; + await conn.execute(sql); + sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_binary_integer(${rawContentNumber}), 'binary_integer')`; + await conn.execute(sql); + sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_to_raw('${rawMaxLengthString}'), 'max_length_string')`; + await conn.execute(sql); + await conn.commit(); } catch (err) { should.not.exist(err); } @@ -105,219 +137,146 @@ describe('188. fetchRowidAsString.js', function() { oracledb.fetchAsString = []; }); - describe("188.1 Normal Use Cases", function() { - - before(async function() { - try { - const sqlCreateTable = `BEGIN \n` + - ` DECLARE \n` + - ` e_table_missing EXCEPTION; \n` + - ` PRAGMA EXCEPTION_INIT(e_table_missing, -00942);\n` + - ` BEGIN \n` + - ` EXECUTE IMMEDIATE ('DROP TABLE ${tableName} PURGE' ); \n` + - ` EXCEPTION \n` + - ` WHEN e_table_missing \n` + - ` THEN NULL; \n` + - ` END; \n` + - ` EXECUTE IMMEDIATE ( ' \n` + - ` CREATE TABLE ${tableName} ( \n` + - ` raw_content RAW(${rawMaxLength}) NULL, \n` + - ` content_type VARCHAR(20) \n` + - ` ) \n` + - ` '); \n` + - `END; `; - await conn.execute(sqlCreateTable); - - let sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_to_raw('${rawContentString}'), 'string')`; - await conn.execute(sql); - sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_number(${rawContentNumber}), 'number')`; - await conn.execute(sql); - sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_binary_double(${rawContentFloat}), 'binary_double')`; - await conn.execute(sql); - sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_binary_float(${rawContentFloat}), 'binary_float')`; - await conn.execute(sql); - sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_from_binary_integer(${rawContentNumber}), 'binary_integer')`; - await conn.execute(sql); - sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_to_raw('${rawMaxLengthString}'), 'max_length_string')`; - await conn.execute(sql); - await conn.commit(); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.1 Fetch RAW by default should be oracledb.BUFFER type", async function() { - try { - let res = await conn.execute(`select raw_content from ${tableName} where content_type='string'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("object"); - should.strictEqual(fetchedContent.toString("hex"), Buffer.from(rawContentString).toString("hex")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.2 Fetch RAW as string by defining fetchAsString", async function() { - try { - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='string'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), Buffer.from(rawContentString).toString("hex")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.3 Fetch RAW as string by defining fetchInfo", async function() { - try { - oracledb.fetchAsString = []; - let res = await conn.execute( - `select raw_content from ${tableName} where content_type='string'`, [], - { fetchInfo: {"RAW_CONTENT": {type: oracledb.STRING}} } - ); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), Buffer.from(rawContentString).toString("hex")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.4 Fetch number converted RAW as string", async function() { - try { - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='number'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentNumber, "number")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.5 Fetch binary double converted RAW as string", async function() { - try { - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='binary_double'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentFloat, "double")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.6 Fetch binary float converted RAW as string", async function() { - try { - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='binary_float'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentFloat, "float")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.7 Fetch binary integer converted RAW as string", async function() { - try { - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='binary_integer'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentNumber, "integer")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.8 Insert a string of maximum lenght of RAW then fetch it as string", async function() { - try { - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='max_length_string'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - let fetchedContent = res.rows[0][0]; - fetchedContent.should.be.type("string"); - should.strictEqual(fetchedContent.toLowerCase(), Buffer.from(rawMaxLengthString).toString("hex")); - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.9 Insert a string exceeds maximum lenght of RAW", async function() { - try { - let contentString = random.getRandomLengthString(rawMaxLength+1); - const sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_to_raw('${contentString}'), 'string')`; - await testUtil.assertThrowsAsync(async () => { - await conn.execute(sql); - await conn.commit(); - }, /ORA-12899:/); // ORA-12899: value too large for column "HR"."NODB_RAWTOSTRING"."RAW_CONTENT" (actual: 21, maximum: 20) - } catch (err) { - should.not.exist(err); - } - }); - - it("188.1.10 Insert null to RAW column then fetch it as string", async function() { - try { - const sql = `INSERT INTO ${tableName} VALUES(null, 'null')`; - await conn.execute(sql); - await conn.commit(); - oracledb.fetchAsString = [oracledb.BUFFER]; - let res = await conn.execute(`select raw_content from ${tableName} where content_type='null'`); - should.exist(res.rows); - should.strictEqual(res.rows.length, 1); - should.strictEqual(res.rows[0][0], null); - } catch (err) { - should.not.exist(err); - } - }); + it("188.1 Fetch RAW by default should be oracledb.BUFFER type", async function() { + try { + let res = await conn.execute(`select raw_content from ${tableName} where content_type='string'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("object"); + should.strictEqual(fetchedContent.toString("hex"), Buffer.from(rawContentString).toString("hex")); + } catch (err) { + should.not.exist(err); + } }); - describe("188.2 Boundary Cases", function() { + it("188.2 Fetch RAW as string by defining fetchAsString", async function() { + try { + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='string'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), Buffer.from(rawContentString).toString("hex")); + } catch (err) { + should.not.exist(err); + } + }); - it("188.2.1 Creating table specifing length greater than RAW max limit", async function() { - try { - const sql_create_table = `BEGIN \n` + - ` DECLARE \n` + - ` e_table_missing EXCEPTION; \n` + - ` PRAGMA EXCEPTION_INIT(e_table_missing, -00942);\n` + - ` BEGIN \n` + - ` EXECUTE IMMEDIATE ('DROP TABLE ${tableName} PURGE' ); \n` + - ` EXCEPTION \n` + - ` WHEN e_table_missing \n` + - ` THEN NULL; \n` + - ` END; \n` + - ` EXECUTE IMMEDIATE ( ' \n` + - ` CREATE TABLE ${tableName} ( \n` + - ` raw_content RAW(2001), \n` + - ` content_type VARCHAR(20) \n` + - ` ) \n` + - ` '); \n` + - `END; `; - await testUtil.assertThrowsAsync(async () => { - await conn.execute(sql_create_table); - }, /ORA-00910:/); // ORA-00910: specified length too long for its datatype - } catch (err) { - should.not.exist(err); - } - }); + it("188.3 Fetch RAW as string by defining fetchInfo", async function() { + try { + oracledb.fetchAsString = []; + let res = await conn.execute( + `select raw_content from ${tableName} where content_type='string'`, [], + { fetchInfo: {"RAW_CONTENT": {type: oracledb.STRING}} } + ); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), Buffer.from(rawContentString).toString("hex")); + } catch (err) { + should.not.exist(err); + } + }); + it("188.4 Fetch number converted RAW as string", async function() { + try { + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='number'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentNumber, "number")); + } catch (err) { + should.not.exist(err); + } + }); + + it("188.5 Fetch binary double converted RAW as string", async function() { + try { + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='binary_double'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentFloat, "double")); + } catch (err) { + should.not.exist(err); + } + }); + + it("188.6 Fetch binary float converted RAW as string", async function() { + try { + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='binary_float'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentFloat, "float")); + } catch (err) { + should.not.exist(err); + } + }); + + it("188.7 Fetch binary integer converted RAW as string", async function() { + try { + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='binary_integer'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), getHex(rawContentNumber, "integer")); + } catch (err) { + should.not.exist(err); + } + }); + + it("188.8 Insert a string of maximum lenght of RAW then fetch it as string", async function() { + try { + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='max_length_string'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + let fetchedContent = res.rows[0][0]; + fetchedContent.should.be.type("string"); + should.strictEqual(fetchedContent.toLowerCase(), Buffer.from(rawMaxLengthString).toString("hex")); + } catch (err) { + should.not.exist(err); + } + }); + + it("188.9 Insert a string exceeds maximum lenght of RAW", async function() { + try { + let contentString = random.getRandomLengthString(rawMaxLength+1); + const sql = `INSERT INTO ${tableName} VALUES(utl_raw.cast_to_raw('${contentString}'), 'string')`; + await testUtil.assertThrowsAsync(async () => { + await conn.execute(sql); + await conn.commit(); + }, /ORA-12899:/); // ORA-12899: value too large for column "HR"."NODB_RAWTOSTRING"."RAW_CONTENT" (actual: 21, maximum: 20) + } catch (err) { + should.not.exist(err); + } + }); + + it("188.10 Insert null to RAW column then fetch it as string", async function() { + try { + const sql = `INSERT INTO ${tableName} VALUES(null, 'null')`; + await conn.execute(sql); + await conn.commit(); + oracledb.fetchAsString = [oracledb.BUFFER]; + let res = await conn.execute(`select raw_content from ${tableName} where content_type='null'`); + should.exist(res.rows); + should.strictEqual(res.rows.length, 1); + should.strictEqual(res.rows[0][0], null); + } catch (err) { + should.not.exist(err); + } }); }); diff --git a/test/list.txt b/test/list.txt index edf7c64e..3fd4dc88 100755 --- a/test/list.txt +++ b/test/list.txt @@ -265,7 +265,7 @@ Overview of node-oracledb functional tests 12.3.11 Negative - set the 1st parameter of getRows() to be -5 12.3.12 Negative - set the 1st parameter of getRows() to be null 12.4 Testing function getRow() - 12.4.1 works well with all correct setting (39ms) + 12.4.1 works well with all correct setting 12.4.2 data in resultSet is array when setting outFormat ARRAY 12.4.3 data in resultSet is object when setting outFormat OBJECT 12.4.4 query 0 row @@ -2027,7 +2027,7 @@ Overview of node-oracledb functional tests 88.1.3 works with small value 88.1.4 works with (64K - 1) value 88.1.5 works with (64K + 1) value - 88.1.6 works with (1MB + 1) value (121ms) + 88.1.6 works with (1MB + 1) value 88.1.7 works with dbms_lob.substr() 88.1.8 works with EMPTY_BLOB() 88.1.9 fetch multiple BLOB rows as Buffer @@ -4398,6 +4398,7 @@ Overview of node-oracledb functional tests 184.4.9 Close connection from pool with {drop: 0} 184.4.10 Close connection from pool with empty dict 184.4.11 Close connection from pool with {drop: random string} + 185. cqn.js 185.1 Positive Cases 185.1.1 Register simple callback and unsubscribe @@ -4418,8 +4419,10 @@ Overview of node-oracledb functional tests 185.2 Negative Cases 185.2.1 Does not throw error when trying to unsubscribe twice 185.2.2 Throw error ORA-29972 if CHANGE NOTIFICATION is revoked from the user + 186. instanceof2.js 186.1 instanceof checks for SODA classes + 187. plsqlBindList.js 187.1 Positive Cases 187.1.1 Bind Object of List by position with type specified @@ -4439,26 +4442,26 @@ Overview of node-oracledb functional tests 187.2.8 Bind STRING List by position while required type is NUMBER 187.2.9 Bind NUMBER List by name while required type is STRING 187.2.10 Bind NUMBER List by position while required type is STRING + 188. fetchRowidAsString.js - 188.1 Normal Use Cases - 188.1.1 Fetch RAW by default should be oracledb.BUFFER type - 188.1.2 Fetch RAW as string by defining fetchAsString - 188.1.3 Fetch RAW as string by defining fetchInfo - 188.1.4 Fetch number converted RAW as string - 188.1.5 Fetch binary double converted RAW as string - 188.1.6 Fetch binary float converted RAW as string - 188.1.7 Fetch binary integer converted RAW as string - 188.1.8 Insert a string of maximum lenght of RAW then fetch it as string - 188.1.9 Insert a string exceeds maximum lenght of RAW - 188.1.10 Insert null to RAW column then fetch it as string - 188.2 Boundary Cases - 188.2.1 Creating table specifing length greater than RAW max limit + 188.1 Fetch RAW by default should be oracledb.BUFFER type + 188.2 Fetch RAW as string by defining fetchAsString + 188.3 Fetch RAW as string by defining fetchInfo + 188.4 Fetch number converted RAW as string + 188.5 Fetch binary double converted RAW as string + 188.6 Fetch binary float converted RAW as string + 188.7 Fetch binary integer converted RAW as string + 188.8 Insert a string of maximum lenght of RAW then fetch it as string + 188.9 Insert a string exceeds maximum lenght of RAW + 188.10 Insert null to RAW column then fetch it as string + 189. writableProperties2.js 189.1 Allows overwriting of public methods on SodaDatabase instance 189.2 Allows overwriting of public methods on SodaDocument instance 189.3 Allows overwriting of public methods on SodaCollection instance 189.4 Allows overwriting of public methods on SodaOperation instance 189.5 Allows overwriting of public methods on SodaDocCursor instance + 190. fetchBinaryTypesAsString.js 190.1 Fetch binary double 190.1.1 Fetch binary double should return JS number