Skip to content

N
node-sqlite3
Commit dd8f13ef by Konstantin Käfer
Options

remove tests

parent 947fcf7d
Showing with 0 additions and 1094 deletions
tests/lib/common.js deleted 100644 → 0
exports.insertMany = function (db, table, fields, rows, callback) {
var columns_fragment = fields.join(",");
var placeholders_fragment = [];
var i = fields.length;
while (i--) {
placeholders_fragment.push('?');
}
placeholders_fragment = placeholders_fragment.join(", ");
var sql = 'INSERT INTO ' + table
+ ' (' + columns_fragment + ')'
+ ' VALUES (' + placeholders_fragment + ')';
var i = rows.length;
var statement;
function doStep(i) {
statement.bindArray(rows[i], function () {
statement.step(function (error, row) {
if (error) throw error;
statement.reset();
if (i) {
doStep(--i);
}
else {
statement.finalize(function () {
callback();
});
}
});
});
}
db.prepare(sql, function (error, stmt) {
if (error) return callback(error);
statement = stmt;
doStep(--i);
});
}
exports.getResultsStep = function (db, callback) {
var results = [];
db.prepare('SELECT * FROM table1', function (error, statement) {
function doStep() {
statement.step(function (error, row) {
if (row) {
results.push(row);
doStep();
}
else {
statement.finalize(function () {
callback && callback(results);
});
}
});
}
doStep();
});
}
exports.createTable = function (db, name, columns, callback) {
var columnFragment
= '(' +
columns.map(function (i) {
return i.name + " " + i.type
}).join(', ') +
')';
db.prepare('CREATE TABLE ' + name + ' ' + columnFragment,
function (error, createStatement) {
if (error) throw error;
createStatement.step(function (error, row) {
if (error) throw error;
callback();
});
});
}
tests/test-affected-rows.js deleted 100644 → 0
path = require('path');
require.paths.unshift(path.join(__dirname, 'lib'));
sys = require('sys');
fs = require('fs');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite');
common = require('common');
puts = sys.puts;
inspect = sys.inspect;
var name = "Caching of affectedRows";
var suite = exports[name] = new TestSuite(name);
var tests = [
{ 'insert a row with lastinsertedid':
function (assert, finished) {
var self = this;
var data = [ ['foo 0']
, ['foo 1']
, ['foo 2']
, ['foo 3']
, ['foo 4']
, ['foo 5']
, ['foo 6']
, ['foo 7']
, ['foo 8']
, ['foo 9']
];
common.createTable
( self.db
, 'table1'
, [ { name: 'id', type: 'INT' }
, { name: 'name', type: 'TEXT' }
]
, function (error) {
if (error) throw error;
var updateSQL
= 'UPDATE table1 SET name="o hai"';
common.insertMany
( self.db
, 'table1'
, ['name']
, data
, function () {
self.db.prepare
( updateSQL
, { affectedRows: true }
, onUpdateStatementCreated
);
});
}
);
function onUpdateStatementCreated(error, statement) {
if (error) throw error;
statement.step(function (error, row) {
if (error) throw error;
assert.equal
( this.affectedRows
, data.length
, "Last inserted id should be 10"
);
finished();
});
}
}
}
];
// order matters in our tests
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
this.db.open(':memory:', function (error) {
finished();
});
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-bind-placeholders.js deleted 100644 → 0
require.paths.push(__dirname + '/..');
sys = require('sys');
fs = require('fs');
path = require('path');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite3_bindings');
puts = sys.puts;
inspect = sys.inspect;
var name = "Binding statement place holders";
var suite = exports[name] = new TestSuite(name);
var tests = [
{ "Bind placeholders by position":
function (assert, finished) {
var self = this;
self.db.open(":memory:", function () {
self.db.prepare("SELECT ? AS foo, ? AS bar, ? AS baz"
, function (error, statement) {
if (error) throw error;
statement.bind(1, "hi", function (error) {
if (error) throw error;
statement.bind(2, "there", function (error) {
if (error) throw error;
statement.bind(3, "world", function (error) {
if (error) throw error;
statement.step(function (error, row) {
if (error) throw error;
assert.deepEqual(row
, { foo: 'hi'
, bar: 'there'
, baz: 'world'
});
finished();
});
});
});
});
});
});
}
}
, { "Bind placeholders using an array":
function (assert, finished) {
var self = this;
self.db.open(":memory:", function () {
self.db.prepare("SELECT ? AS foo, ? AS bar, ? AS baz"
, function (error, statement) {
if (error) throw error;
statement.bindArray(['hi', 'there', 'world'], function (error) {
if (error) throw error;
statement.step(function (error, row) {
if (error) throw error;
assert.deepEqual(row
, { foo: 'hi'
, bar: 'there'
, baz: 'world'
});
statement.reset();
statement.bindArray([1, 2, null], function (error) {
statement.step(function (error, row) {
if (error) throw error;
assert.deepEqual(row, { foo: 1, bar: 2, baz: null });
finished();
});
});
});
});
});
});
}
}
, { "Bind placeholders using an object":
function (assert, finished) {
var self = this;
self.db.open(":memory:", function () {
self.db.prepare("SELECT $x AS foo, $y AS bar, $z AS baz"
, function (error, statement) {
if (error) throw error;
statement.bindObject({ $x: 'hi', $y: null, $z: 'world' }, function (error) {
if (error) throw error;
statement.step(function (error, row) {
if (error) throw error;
assert.deepEqual(row, { foo: 'hi', bar: null, baz: 'world' });
statement.reset();
statement.bindArray([1, 2, null], function (error) {
statement.step(function (error, row) {
if (error) throw error;
assert.deepEqual(row, { foo: 1, bar: 2, baz: null });
finished();
});
});
});
});
});
});
}
}
];
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
finished();
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-bind-strings.js deleted 100644 → 0
require.paths.push(__dirname + '/..');
sys = require('sys');
fs = require('fs');
path = require('path');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite');
// puts = sys.puts;
puts = function () {};
inspect = sys.inspect;
var name = "Test binding strings to placeholders";
var suite = exports[name] = new TestSuite(name);
function checkTable(db, assert, callback) {
db.prepare('SELECT * FROM tbl WHERE foo="hello"', function (error, stmt) {
puts("prepared2 ok", inspect(arguments));
assert.ok(!error);
stmt.step(function (error, row) {
puts("step2 ok", inspect(arguments));
assert.ok(!error);
assert.ok(row, "We should get a row back");
callback();
});
});
}
function setupTableWithBindArray(db, assert, callback) {
db.prepareAndStep("CREATE TABLE tbl (foo TEXT)", function (error, stmt) {
puts("created ok", inspect(arguments));
assert.ok(!error);
db.prepare("INSERT INTO tbl (foo) VALUES (?)", function (error, stmt) {
assert.ok(!error);
puts("prepared ok", inspect(arguments));
stmt.bindArray(["hello"], function (error) {
assert.ok(!error);
checkTableCreated(stmt, assert, callback);
});
});
});
}
function setupTableWithBindByKey(db, assert, callback) {
db.prepareAndStep("CREATE TABLE tbl (foo TEXT)", function (error, stmt) {
puts("created ok", inspect(arguments));
assert.ok(!error);
db.prepare("INSERT INTO tbl (foo) VALUES ($x)", function (error, stmt) {
assert.ok(!error);
puts("prepared ok", inspect(arguments));
stmt.bind('$x', "hello", function (error) {
assert.ok(!error);
checkTableCreated(stmt, assert, callback);
});
});
});
}
function setupTableWithBindByPosition(db, assert, callback) {
db.prepareAndStep("CREATE TABLE tbl (foo TEXT)", function (error, stmt) {
puts("created ok", inspect(arguments));
assert.ok(!error);
db.prepare("INSERT INTO tbl (foo) VALUES (?)", function (error, stmt) {
assert.ok(!error);
puts("prepared ok", inspect(arguments));
stmt.bind(1, "hello", function (error) {
assert.ok(!error);
checkTableCreated(stmt, assert, callback);
});
});
});
}
function checkTableCreated(stmt, assert, callback) {
puts("bound", inspect(arguments));
stmt.step(function (error, row) {
assert.ok(!error);
assert.ok(!row);
puts("stepped", inspect(arguments));
stmt.finalize(function () {
callback();
});
});
}
var tests = [
{ "Check strings are bound ok using an array":
function (assert, finished) {
var self = this;
self.db.open(":memory:", function () {
setupTableWithBindArray(self.db, assert, function () {
checkTable(self.db, assert, function () {
finished();
});
});
});
}
}
, { "Check strings are bound ok using keys":
function (assert, finished) {
var self = this;
self.db.open(":memory:", function () {
setupTableWithBindByKey(self.db, assert, function () {
checkTable(self.db, assert, function () {
finished();
});
});
});
}
}
, { "Check strings are bound ok using placeholder position":
function (assert, finished) {
var self = this;
self.db.open(":memory:", function () {
setupTableWithBindByPosition(self.db, assert, function () {
checkTable(self.db, assert, function () {
finished();
});
});
});
}
}
];
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
finished();
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-blob.js deleted 100644 → 0
require.paths.push(__dirname + '/..');
sys = require('sys');
fs = require('fs');
path = require('path');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite');
var db = new sqlite.Database();
var name = "Reading and writing blobs";
var suite = exports[name] = new TestSuite(name);
var fixture_path = path.join(__dirname, 'fixtures/principia_mathematica.jpg');
function createTestTable(db, callback) {
db.prepare('CREATE TABLE [images] (name text,image blob);',
function (error, createStatement) {
if (error) throw error;
createStatement.step(function (error, row) {
if (error) throw error;
callback();
});
});
}
var tests = [
{ "Blob read/write":
function(assert, finished) {
var that = this;
this.db.open(':memory:', function() {
createTestTable(that.db, function() {
that.db.prepare(
'INSERT INTO images (name, image) VALUES ("principia_mathematica", ?);',
function(err, statement) {
if (err) throw err;
fs.readFile(fixture_path, function(err, data) {
if (err) throw err;
assert.equal(data.length, 48538);
statement.bind(1, data, function(err) {
if (err) throw err;
statement.step(function(err, row) {
if (err) throw err;
that.db.prepare(
'SELECT image FROM images WHERE name = "principia_mathematica";',
function(err, statement) {
if (err) throw err;
statement.step(function(err, row) {
if (err) throw err;
assert.equal(row.image.length, 48538);
finished();
});
}
);
});
});
});
}
);
});
});
}
},
{ "Close database after blob query":
function(assert, finished) {
this.db.close(function (err) {
if (err) throw err;
finished();
});
}
}
];
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.db = new sqlite.Database();
suite.setup(function(finished, test) {
this.db = suite.db;
finished();
});
suite.teardown(function(finished) {
finished();
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-last-inserted-id.js deleted 100644 → 0
sys = require('sys');
fs = require('fs');
path = require('path');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite3_bindings');
common = require('./lib/common');
puts = sys.puts;
inspect = sys.inspect;
var name = "Caching of lastInsertedRowID";
var suite = exports[name] = new TestSuite(name);
function createTestTable(db, callback) {
db.prepare('CREATE TABLE table1 (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)',
function (error, createStatement) {
if (error) throw error;
createStatement.step(function (error, row) {
if (error) throw error;
callback();
});
});
}
var tests = [
{ 'insert a row with lastinsertedid':
function (assert, finished) {
var self = this;
self.db.open(':memory:', function (error) {
function createStatement(error, statement) {
if (error) throw error;
statement.step(function (error, row) {
assert.equal(this.lastInsertRowID, 101, "Last inserted id should be 1");
assert.equal(this.affectedRows, 1, "Last inserted id should be 1");
statement.reset();
statement.step(function (error, row) {
assert.equal(this.lastInsertRowID, 102, "Last inserted id should be 1");
assert.equal(this.affectedRows, 1, "Last inserted id should be 1");
finished();
});
});
}
createTestTable(self.db,
function () {
common.insertMany(self.db , 'table1'
, ['id', 'name']
, [ [100, "first post!"] ]
, function () {
self.db.prepare('INSERT INTO table1 (name) VALUES ("orlando")'
, { affectedRows: true, lastInsertRowID: true }
, createStatement);
});
});
});
}
}
];
// order matters in our tests
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
finished();
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-prepare.js deleted 100644 → 0
sys = require('sys');
fs = require('fs');
path = require('path');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite3_bindings');
puts = sys.puts;
inspect = sys.inspect;
var name = "SQLite bindings";
var suite = exports[name] = new TestSuite(name);
function createTestTable(db, callback) {
db.prepare('CREATE TABLE test1 (column1 TEXT)',
function (error, createStatement) {
if (error) throw error;
createStatement.step(function (error, row) {
if (error) throw error;
callback();
});
});
}
function fetchAll(db, sql, callback) {
db.prepare(
sql,
function (error, statement) {
if (error) throw error;
var rows = [];
function doStep() {
statement.step(function (error, row) {
if (error) throw error;
if (row) {
rows.push(row);
doStep();
}
else {
callback(rows);
}
});
}
doStep();
});
}
var tests = [
{ 'create in memory database object':
function (assert, finished) {
this.db.open(':memory:', function (error) {
assert.ok(!error)
finished();
});
}
}
, { 'prepareAndStep() a statement that returns no rows':
function (assert, finished) {
var self = this;
this.db.open(':memory:', function (error) {
if (error) throw error;
// use a query that will never return rows
self.db.prepareAndStep('SELECT * FROM (SELECT 1) WHERE 1=0',
function (error, statement) {
if (error) throw error;
assert.equal(error, undefined)
// no statement will be returned here
assert.ok(!statement)
finished();
});
});
}
}
, { 'prepareAndStep (and step over) a statement that returns a row':
function (assert, finished) {
var self = this;
this.db.open(':memory:', function (error) {
if (error) throw error;
// use a query that will never return rows
self.db.prepareAndStep('SELECT 1 AS handbanana',
function (error, statement) {
if (error) throw error;
assert.equal(error, undefined)
assert.ok(statement)
var rows = [];
// iterate over rows
function doStep() {
statement.step(function (error, row) {
if (error) throw error;
if (row) {
rows.push(row);
doStep();
}
else {
assert.deepEqual(rows, [{ handbanana: '1' }]);
finished();
}
});
}
doStep();
});
});
}
}
, { 'prepare (and step over) a statement that returns a row':
function (assert, finished) {
var self = this;
this.db.open(':memory:', function (error) {
if (error) throw error;
// use a query that will never return rows
self.db.prepare('select 1 AS handbanana',
function (error, statement) {
if (error) throw error;
assert.equal(error, undefined)
assert.ok(statement)
var rows = [];
// iterate over rows
function doStep() {
statement.step(function (error, row) {
if (error) throw error;
if (row) {
rows.push(row);
doStep();
}
else {
assert.deepEqual(rows, [{ handbanana: '1' }]);
finished();
}
});
}
doStep();
});
});
}
}
, { 'prepare a statement that returns no result with prepare()':
function (assert, finished) {
var self = this;
this.db.open(':memory:', function (error) {
if (error) throw error;
self.db.prepare('select * from (select 1) where 1=0;',
function (error, statement) {
if (error) throw error;
assert.equal(error, undefined)
// we'll get a prepared statement here
assert.ok(statement)
finished();
});
});
}
}
, { 'insert a few times using step and reset':
function (assert, finished) {
var self = this;
self.db.open(':memory:', function (error) {
createTestTable(self.db,
function () {
self.db.prepare('INSERT INTO test1 (column1) VALUES (1)',
function (error, insertStatement) {
if (error) throw error;
var i = 0;
function doStep() {
insertStatement.step(function (error, row) {
if (error) throw error;
if (row) {
doStep();
}
else {
if (++i < 5) {
insertStatement.reset();
doStep();
}
else {
fetchAll(self.db, "SELECT * FROM test1",
function (rows) {
assert.deepEqual(rows, [
{ column1: '1' }
, { column1: '1' }
, { column1: '1' }
, { column1: '1' }
, { column1: '1' }
]);
finished();
});
}
}
});
}
doStep();
});
});
});
}
}
];
// order matters in our tests
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
finished();
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-statement-fetchall.js deleted 100644 → 0
sys = require('sys');
fs = require('fs');
path = require('path');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite3_bindings');
puts = sys.puts;
inspect = sys.inspect;
var name = "Fetching all results";
var suite = exports[name] = new TestSuite(name);
function createTestTable(db, callback) {
db.prepare('CREATE TABLE table1 (id INTEGER, name TEXT, age FLOAT)',
function (error, createStatement) {
if (error) throw error;
createStatement.step(function (error, row) {
if (error) throw error;
callback();
});
});
}
var testRows = [ [ 1, "foo", 9 ]
, [ 2, "bar", 8 ]
, [ 3, "baz", 7 ]
, [ 4, "quux", 6 ]
, [ 5, "juju", 5 ]
];
var testRowsExpected = [ { id: 5, name: 'juju', age: 5 }
, { id: 4, name: 'quux', age: 6 }
, { id: 3, name: 'baz', age: 7 }
, { id: 2, name: 'bar', age: 8 }
, { id: 1, name: 'foo', age: 9 }
];
var tests = [
{ 'insert a row with lastinsertedid':
function (assert, finished) {
var self = this;
self.db.open(':memory:', function (error) {
function selectStatementPrepared(error, statement) {
if (error) throw error;
statement.fetchAll(function (error, rows) {
if (error) throw error;
assert.deepEqual(testRowsExpected, rows);
self.db.close(function () {
finished();
});
});
}
createTestTable(self.db,
function () {
function insertRows(db, rows, callback) {
var i = rows.length;
db.prepare('INSERT INTO table1 (id, name, age) VALUES (?, ?, ?)',
function (error, statement) {
function doStep(i) {
statement.bindArray(rows[i], function () {
statement.step(function (error, row) {
if (error) throw error;
assert.ok(!row, "Row should be unset");
statement.reset();
if (i) {
doStep(--i);
}
else {
statement.finalize(function () {
callback();
});
}
});
});
}
doStep(--i);
});
}
var selectSQL
= 'SELECT * from table1';
insertRows(self.db, testRows, function () {
self.db.prepare(selectSQL
, selectStatementPrepared);
});
});
});
},
'check errors are generated correctly':
function (assert, finished) {
var self = this;
self.db.open(':memory:', function (error) {
if (error) throw error;
execSQL("CREATE TABLE table2 (value INTEGER, CHECK (value BETWEEN 0 AND 11))", function (error) {
if (error) throw error;
execSQL("INSERT INTO table2 (value) VALUES (12)", function (error) {
assert.equal(error.message, "constraint failed");
finished();
});
});
});
function execSQL(sql, cb) {
self.db.prepare(sql, function (err, stmt) {
if (err) throw err;
stmt.fetchAll(function (err, rows) {
stmt.finalize(function () {
cb(err, rows);
});
});
});
}
}
}
];
// order matters in our tests
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
finished();
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
tests/test-statement-step.js deleted 100644 → 0
sys = require('sys');
fs = require('fs');
path = require('path');
common = require('./lib/common');
TestSuite = require('async-testing/async_testing').TestSuite;
sqlite = require('sqlite3_bindings');
puts = sys.puts;
inspect = sys.inspect;
var name = "Fetching all results";
var suite = exports[name] = new TestSuite(name);
function createTestTable(db, callback) {
db.prepare('CREATE TABLE table1 (id INTEGER, name TEXT, age FLOAT)',
function (error, createStatement) {
if (error) throw error;
createStatement.step(function (error, row) {
if (error) throw error;
callback();
});
});
}
var testRows = [ [ 1, "foo", 9 ]
, [ 2, "bar", 8 ]
, [ 3, null, 7 ]
, [ 4, "quux", 6 ]
, [ 5, "juju", null ]
];
var testRowsExpected = [ { id: 5, name: 'juju', age: null }
, { id: 4, name: 'quux', age: 6 }
, { id: 3, name: null, age: 7 }
, { id: 2, name: 'bar', age: 8 }
, { id: 1, name: 'foo', age: 9 }
];
var tests = [
{ 'insert a row with lastinsertedid':
function (assert, finished) {
var self = this;
self.db.open(':memory:', function (error) {
createTestTable(self.db,
function () {
common.insertMany(self.db
, 'table1'
, ['id', 'name', 'age']
, testRows
, function () {
common.getResultsStep(self.db, function (rows) {
assert.deepEqual(rows, testRowsExpected);
finished();
});
});
});
});
}
}
];
// order matters in our tests
for (var i=0,il=tests.length; i < il; i++) {
suite.addTests(tests[i]);
}
var currentTest = 0;
var testCount = tests.length;
suite.setup(function(finished, test) {
this.db = new sqlite.Database();
finished();
});
suite.teardown(function(finished) {
if (this.db) this.db.close(function (error) {
finished();
});
++currentTest == testCount;
});
if (module == require.main) {
suite.runTests();
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment