Skip to content

N
node-sqlite3
Commit 2672f403 by Konstantin Käfer
Options

move test suite to mocha

parent cbd74f7c
Showing with 730 additions and 756 deletions
package.json
...@@ -30,7 +30,7 @@ ...@@ -30,7 +30,7 @@
}, },
"devDependencies": { "devDependencies": {
"step": "0.0.4", "step": "0.0.4",
"expresso": "*" "mocha": "~1.7"
}, },
"engines": { "engines": {
"node": ">= 0.6.13 && < 0.11.0" "node": ">= 0.6.13 && < 0.11.0"
......
test/affected.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('query properties', function() {
var db;
exports['test row changes and lastID'] = function(beforeExit) { before(function(done) {
var db = new sqlite3.Database(':memory:'); db = new sqlite3.Database(':memory:');
db.run("CREATE TABLE foo (id INT, txt TEXT)", done);
var finished = false; });
db.serialize(function() { it('should return the correct lastID', function(done) {
db.run("CREATE TABLE foo (id INT, txt TEXT)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
var j = 1; var j = 1;
for (var i = 0; i < 1000; i++) { for (var i = 0; i < 1000; i++) {
...@@ -20,15 +19,14 @@ exports['test row changes and lastID'] = function(beforeExit) { ...@@ -20,15 +19,14 @@ exports['test row changes and lastID'] = function(beforeExit) {
assert.equal(j++, this.lastID); assert.equal(j++, this.lastID);
}); });
} }
db.wait(done);
});
it('should return the correct changes count', function(done) {
db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err) { db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err) {
if (err) throw err; if (err) throw err;
assert.equal(500, this.changes); assert.equal(500, this.changes);
finished = true; done();
}); });
}); });
});
beforeExit(function() {
assert.ok(finished);
})
}
test/blob.test.js
var sqlite3 = require('sqlite3'), var sqlite3 = require('..'),
Step = require('step'),
fs = require('fs'), fs = require('fs'),
assert = require('assert') assert = require('assert'),
Buffer = require('buffer').Buffer; Buffer = require('buffer').Buffer;
if (process.setMaxListeners) process.setMaxListeners(0);
// lots of elmo // lots of elmo
var elmo = fs.readFileSync(__dirname + '/support/elmo.png'); var elmo = fs.readFileSync(__dirname + '/support/elmo.png');
exports['blob test'] = function(beforeExit) { describe('blob', function() {
var db = new sqlite3.Database(':memory:'); var db;
before(function(done) {
db = new sqlite3.Database(':memory:');
db.run("CREATE TABLE elmos (id INT, image BLOB)", done);
});
var total = 10; var total = 10;
var inserted = 0; var inserted = 0;
var retrieved = 0; var retrieved = 0;
db.serialize(function() {
db.run('CREATE TABLE elmos (id INT, image BLOB)');
it('should insert blobs', function(done) {
for (var i = 0; i < total; i++) { for (var i = 0; i < total; i++) {
db.run('INSERT INTO elmos (id, image) VALUES (?, ?)', i, elmo, function(err) { db.run('INSERT INTO elmos (id, image) VALUES (?, ?)', i, elmo, function(err) {
if (err) throw err; if (err) throw err;
inserted++; inserted++;
}); });
} }
db.wait(function() {
assert.equal(inserted, total);
done();
});
});
it('should retrieve the blobs', function(done) {
db.all('SELECT id, image FROM elmos ORDER BY id', function(err, rows) { db.all('SELECT id, image FROM elmos ORDER BY id', function(err, rows) {
if (err) throw err; if (err) throw err;
for (var i = 0; i < rows.length; i++) { for (var i = 0; i < rows.length; i++) {
...@@ -39,12 +46,9 @@ exports['blob test'] = function(beforeExit) { ...@@ -39,12 +46,9 @@ exports['blob test'] = function(beforeExit) {
retrieved++; retrieved++;
} }
});
assert.equal(retrieved, total);
done();
});
}); });
});
beforeExit(function() {
assert.equal(inserted, total);
assert.equal(retrieved, total);
})
}
test/cache.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var helper = require('./support/helper'); var helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0); describe('cache', function() {
it('should cache Database objects while opening', function(done) {
exports['test caching Database objects while opening'] = function(beforeExit) { var filename = 'test/tmp/test_cache.db';
var filename = 'test/tmp/test_cache.db'; helper.deleteFile(filename);
helper.deleteFile(filename); var opened1 = false, opened2 = false;
var opened1 = false, opened2 = false var db1 = new sqlite3.cached.Database(filename, function(err) {
var db1 = new sqlite3.cached.Database(filename, function(err) { if (err) throw err;
if (err) throw err; opened1 = true;
opened1 = true; if (opened1 && opened2) done();
}); });
var db2 = new sqlite3.cached.Database(filename, function(err) { var db2 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err; if (err) throw err;
opened2 = true; opened2 = true;
if (opened1 && opened2) done();
});
assert.equal(db1, db2);
}); });
assert.equal(db1, db2);
beforeExit(function() { it('should cache Database objects after they are open', function(done) {
assert.ok(opened1); var filename = 'test/tmp/test_cache2.db';
assert.ok(opened2); helper.deleteFile(filename);
}); var db1, db2;
}; db1 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err;
process.nextTick(function() {
db2 = new sqlite3.cached.Database(filename, function(err) {
done();
exports['test caching Database objects after it is open'] = function(beforeExit) { });
var filename = 'test/tmp/test_cache2.db'; assert.equal(db1, db2);
helper.deleteFile(filename);
var opened1 = false, opened2 = false
var db1, db2;
db1 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err;
opened1 = true;
setTimeout(function() {
db2 = new sqlite3.cached.Database(filename, function(err) {
opened2 = true;
}); });
}, 100); });
});
beforeExit(function() {
assert.equal(db1, db2);
assert.ok(opened1);
assert.ok(opened2);
}); });
}; });
test/constants.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('constants', function() {
it('should have the right OPEN_* flags', function() {
assert.ok(sqlite3.OPEN_READONLY === 1);
assert.ok(sqlite3.OPEN_READWRITE === 2);
assert.ok(sqlite3.OPEN_CREATE === 4);
});
exports['test constants'] = function() { it('should have the right error flags', function() {
assert.ok(sqlite3.OPEN_READONLY === 1); assert.ok(sqlite3.OK === 0);
assert.ok(sqlite3.OPEN_READWRITE === 2); assert.ok(sqlite3.ERROR === 1);
assert.ok(sqlite3.OPEN_CREATE === 4); assert.ok(sqlite3.INTERNAL === 2);
assert.ok(sqlite3.PERM === 3);
assert.ok(sqlite3.OK === 0); assert.ok(sqlite3.ABORT === 4);
assert.ok(sqlite3.ERROR === 1); assert.ok(sqlite3.BUSY === 5);
assert.ok(sqlite3.INTERNAL === 2); assert.ok(sqlite3.LOCKED === 6);
assert.ok(sqlite3.PERM === 3); assert.ok(sqlite3.NOMEM === 7);
assert.ok(sqlite3.ABORT === 4); assert.ok(sqlite3.READONLY === 8);
assert.ok(sqlite3.BUSY === 5); assert.ok(sqlite3.INTERRUPT === 9);
assert.ok(sqlite3.LOCKED === 6); assert.ok(sqlite3.IOERR === 10);
assert.ok(sqlite3.NOMEM === 7); assert.ok(sqlite3.CORRUPT === 11);
assert.ok(sqlite3.READONLY === 8); assert.ok(sqlite3.NOTFOUND === 12);
assert.ok(sqlite3.INTERRUPT === 9); assert.ok(sqlite3.FULL === 13);
assert.ok(sqlite3.IOERR === 10); assert.ok(sqlite3.CANTOPEN === 14);
assert.ok(sqlite3.CORRUPT === 11); assert.ok(sqlite3.PROTOCOL === 15);
assert.ok(sqlite3.NOTFOUND === 12); assert.ok(sqlite3.EMPTY === 16);
assert.ok(sqlite3.FULL === 13); assert.ok(sqlite3.SCHEMA === 17);
assert.ok(sqlite3.CANTOPEN === 14); assert.ok(sqlite3.TOOBIG === 18);
assert.ok(sqlite3.PROTOCOL === 15); assert.ok(sqlite3.CONSTRAINT === 19);
assert.ok(sqlite3.EMPTY === 16); assert.ok(sqlite3.MISMATCH === 20);
assert.ok(sqlite3.SCHEMA === 17); assert.ok(sqlite3.MISUSE === 21);
assert.ok(sqlite3.TOOBIG === 18); assert.ok(sqlite3.NOLFS === 22);
assert.ok(sqlite3.CONSTRAINT === 19); assert.ok(sqlite3.AUTH === 23);
assert.ok(sqlite3.MISMATCH === 20); assert.ok(sqlite3.FORMAT === 24);
assert.ok(sqlite3.MISUSE === 21); assert.ok(sqlite3.RANGE === 25);
assert.ok(sqlite3.NOLFS === 22); assert.ok(sqlite3.NOTADB === 26);
assert.ok(sqlite3.AUTH === 23); });
assert.ok(sqlite3.FORMAT === 24); });
assert.ok(sqlite3.RANGE === 25);
assert.ok(sqlite3.NOTADB === 26);
};
\ No newline at end of file
test/each.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var util = require('util');
if (process.setMaxListeners) process.setMaxListeners(0); describe('each', function() {
var db;
exports['test Statement#each'] = function(beforeExit) { before(function(done) {
var db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY); db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY, done);
var total = 100000;
var retrieved = 0;
db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
if (err) throw err;
retrieved++;
});
beforeExit(function() {
assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
}); });
};
exports['test Statement#each with complete callback'] = function(beforeExit) { it('retrieve 100,000 rows with Statement#each', function(done) {
var db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY); var total = 100000;
var retrieved = 0;
var total = 10000; db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
var retrieved = 0; if (err) throw err;
var completed = false; retrieved++;
});
db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) { db.wait(function() {
if (err) throw err; assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
retrieved++; done();
}, function(err, num) { });
assert.equal(retrieved, num);
completed = true;
}); });
beforeExit(function() { it('Statement#each with complete callback', function(done) {
assert.ok(completed); var total = 10000;
assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows."); var retrieved = 0;
db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
if (err) throw err;
retrieved++;
}, function(err, num) {
assert.equal(retrieved, num);
assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
done();
});
}); });
}; });
test/exec.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var fs = require('fs'); var fs = require('fs');
if (process.setMaxListeners) process.setMaxListeners(0); describe('exec', function() {
var db;
exports['test Database#exec'] = function(beforeExit) { before(function(done) {
var db = new sqlite3.Database(':memory:'); db = new sqlite3.Database(':memory:', done);
var finished = false; });
var sql = fs.readFileSync('test/support/script.sql', 'utf8');
db.exec(sql, function(err) { it('Database#exec', function(done) {
if (err) throw err; var sql = fs.readFileSync('test/support/script.sql', 'utf8');
db.exec(sql, done);
});
it('retrieve database structure', function(done) {
db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err, rows) { db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err, rows) {
if (err) throw err; if (err) throw err;
assert.deepEqual(rows, [ assert.deepEqual(rows, [
{ type: 'index', name: 'grid_key_lookup' }, { type: 'index', name: 'grid_key_lookup' },
{ type: 'index', name: 'grid_utfgrid_lookup' }, { type: 'index', name: 'grid_utfgrid_lookup' },
...@@ -32,12 +33,7 @@ exports['test Database#exec'] = function(beforeExit) { ...@@ -32,12 +33,7 @@ exports['test Database#exec'] = function(beforeExit) {
{ type: 'view', name: 'grids' }, { type: 'view', name: 'grids' },
{ type: 'view', name: 'tiles' } { type: 'view', name: 'tiles' }
]); ]);
done();
finished = true;
}); });
}); });
});
beforeExit(function() {
assert.ok(finished);
});
};
test/extension.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var exists = require('fs').existsSync || require('path').existsSync var exists = require('fs').existsSync || require('path').existsSync;
if (process.setMaxListeners) process.setMaxListeners(0);
var spatialite_ext = '/usr/local/lib/libspatialite.dylib'; var spatialite_ext = '/usr/local/lib/libspatialite.dylib';
exports['test loadExtension'] = function(beforeExit) { describe('loadExtension', function(done) {
var db = new sqlite3.Database(':memory:'); var db;
var completed = false; before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
if (exists(spatialite_ext)) { if (exists(spatialite_ext)) {
db.loadExtension(spatialite_ext, function(err) { it('libspatialite', function(done) {
if (err) throw err; db.loadExtension(spatialite_ext, done);
completed = true;
}); });
} else { } else {
completed = true; it('libspatialite');
} }
});
beforeExit(function() {
assert.ok(completed);
});
}
test/fts-content.test.js
/*jshint strict:true node:true es5:true onevar:true laxcomma:true laxbreak:true eqeqeq:true immed:true latedef:true*/ var sqlite3 = require('..');
(function () { var assert = require('assert');
"use strict";
var sqlite = require('sqlite3') describe('fts', function() {
, assert = require('assert') var db;
, db before(function(done) {
; db = new sqlite3.Database(':memory:', done);
function readyForQuery() {
db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);', function (err) {
assert.ok(!err);
}); });
}
db = new sqlite.Database(":memory:", readyForQuery); it('should create a new fts4 table', function(done) {
}()); db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);', done);
});
});
test/map.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('map', function() {
it('test Database#map() with two columns', function(done) {
exports['test Database#map() with two columns'] = function(beforeExit) { var count = 10;
var db = new sqlite3.Database(':memory:'); var inserted = 0;
var count = 10; var db = new sqlite3.Database(':memory:');
var inserted = 0; db.serialize(function() {
var retrieved = false; db.run("CREATE TABLE foo (id INT, value TEXT)");
db.serialize(function() { var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
db.run("CREATE TABLE foo (id INT, value TEXT)"); for (var i = 5; i < count; i++) {
stmt.run(i, 'Value for ' + i, function(err) {
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); if (err) throw err;
for (var i = 5; i < count; i++) { inserted++;
stmt.run(i, 'Value for ' + i, function(err) { });
if (err) throw err; }
inserted++; stmt.finalize();
});
} db.map("SELECT * FROM foo", function(err, map) {
stmt.finalize(); if (err) throw err;
assert.deepEqual(map, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' });
db.map("SELECT * FROM foo", function(err, map) { assert.equal(inserted, 5);
retrieved = true; done();
assert.deepEqual(map, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' }); });
}); });
});
beforeExit(function() {
assert.equal(inserted, 5);
assert.ok(retrieved);
});
};
exports['test Database#map() with three columns'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var count = 10;
var inserted = 0;
var retrieved = false;
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?)");
for (var i = 5; i < count; i++) {
stmt.run(i, 'Value for ' + i, null, function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize();
db.map("SELECT * FROM foo", function(err, map) {
retrieved = true;
assert.deepEqual(map, {
5: { id: 5, value: 'Value for 5', other: null },
6: { id: 6, value: 'Value for 6', other: null },
7: { id: 7, value: 'Value for 7', other: null },
8: { id: 8, value: 'Value for 8', other: null },
9: { id: 9, value: 'Value for 9', other: null }
});
});
}); });
beforeExit(function() { it('test Database#map() with three columns', function(done) {
assert.equal(inserted, 5); var db = new sqlite3.Database(':memory:');
assert.ok(retrieved);
var count = 10;
var inserted = 0;
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?)");
for (var i = 5; i < count; i++) {
stmt.run(i, 'Value for ' + i, null, function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize();
db.map("SELECT * FROM foo", function(err, map) {
if (err) throw err;
assert.deepEqual(map, {
5: { id: 5, value: 'Value for 5', other: null },
6: { id: 6, value: 'Value for 6', other: null },
7: { id: 7, value: 'Value for 7', other: null },
8: { id: 8, value: 'Value for 8', other: null },
9: { id: 9, value: 'Value for 9', other: null }
});
assert.equal(inserted, 5);
done();
});
});
}); });
}; });
test/named_columns.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('named columns', function() {
var db;
exports['test named columns'] = function(beforeExit) { before(function(done) {
var db = new sqlite3.Database(':memory:'); db = new sqlite3.Database(':memory:', done);
});
var finished = false;
db.serialize(function() { it('should create the table', function(done) {
db.run("CREATE TABLE foo (txt TEXT, num INT)"); db.run("CREATE TABLE foo (txt TEXT, num INT)", done);
});
it('should insert a value', function(done) {
db.run("INSERT INTO foo VALUES($text, $id)", { db.run("INSERT INTO foo VALUES($text, $id)", {
$id: 1, $id: 1,
$text: "Lorem Ipsum" $text: "Lorem Ipsum"
}); }, done);
});
it('should retrieve the values', function(done) {
db.get("SELECT txt, num FROM foo ORDER BY num", function(err, row) { db.get("SELECT txt, num FROM foo ORDER BY num", function(err, row) {
if (err) throw err; if (err) throw err;
assert.equal(row.txt, "Lorem Ipsum"); assert.equal(row.txt, "Lorem Ipsum");
assert.equal(row.num, 1); assert.equal(row.num, 1);
done();
finished = true;
}); });
});
beforeExit(function() {
assert.ok(finished);
}); });
}; });
\ No newline at end of file
test/named_params.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('named parameters', function() {
var db;
exports['test named parameters'] = function(beforeExit) { before(function(done) {
var db = new sqlite3.Database(':memory:'); db = new sqlite3.Database(':memory:', done);
});
var finished = false;
db.serialize(function() { it('should create the table', function(done) {
db.run("CREATE TABLE foo (txt TEXT, num INT)"); db.run("CREATE TABLE foo (txt TEXT, num INT)", done);
});
it('should insert a value with $ placeholders', function(done) {
db.run("INSERT INTO foo VALUES($text, $id)", { db.run("INSERT INTO foo VALUES($text, $id)", {
$id: 1, $id: 1,
$text: "Lorem Ipsum" $text: "Lorem Ipsum"
}); }, done);
});
it('should insert a value with : placeholders', function(done) {
db.run("INSERT INTO foo VALUES(:text, :id)", { db.run("INSERT INTO foo VALUES(:text, :id)", {
":id": 2, ':id': 2,
":text": "Dolor Sit Amet" ':text': "Dolor Sit Amet"
}); }, done);
});
it('should insert a value with @ placeholders', function(done) {
db.run("INSERT INTO foo VALUES(@txt, @id)", { db.run("INSERT INTO foo VALUES(@txt, @id)", {
"@id": 3, "@id": 3,
"@txt": "Consectetur Adipiscing Elit" "@txt": "Consectetur Adipiscing Elit"
}); }, done);
});
db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ]); it('should insert a value with @ placeholders using an array', function(done) {
db.run("INSERT INTO foo VALUES(?2, ?4)", [ null, 'Tempor Incididunt', null, 5 ]); db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ], done);
});
it('should insert a value with indexed placeholders', function(done) {
db.run("INSERT INTO foo VALUES(?2, ?4)",
[ null, 'Tempor Incididunt', null, 5 ], done);
});
it('should insert a value with autoindexed placeholders', function(done) {
db.run("INSERT INTO foo VALUES(?, ?)", { db.run("INSERT INTO foo VALUES(?, ?)", {
2: 6, 2: 6,
1: "Ut Labore Et Dolore" 1: "Ut Labore Et Dolore"
}); }, done);
});
it('should retrieve all inserted values', function(done) {
db.all("SELECT txt, num FROM foo ORDER BY num", function(err, rows) { db.all("SELECT txt, num FROM foo ORDER BY num", function(err, rows) {
if (err) throw err; if (err) throw err;
assert.equal(rows[0].txt, "Lorem Ipsum"); assert.equal(rows[0].txt, "Lorem Ipsum");
assert.equal(rows[0].num, 1); assert.equal(rows[0].num, 1);
assert.equal(rows[1].txt, "Dolor Sit Amet"); assert.equal(rows[1].txt, "Dolor Sit Amet");
...@@ -49,12 +63,7 @@ exports['test named parameters'] = function(beforeExit) { ...@@ -49,12 +63,7 @@ exports['test named parameters'] = function(beforeExit) {
assert.equal(rows[4].num, 5); assert.equal(rows[4].num, 5);
assert.equal(rows[5].txt, "Ut Labore Et Dolore"); assert.equal(rows[5].txt, "Ut Labore Et Dolore");
assert.equal(rows[5].num, 6); assert.equal(rows[5].num, 6);
done();
finished = true;
}); });
}); });
});
beforeExit(function() {
assert.ok(finished);
});
};
\ No newline at end of file
test/null_error.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var helper = require('./support/helper'); var helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0); describe('null error', function() {
exports['test SQLITE_OK error'] = function(beforeExit) {
var completed = false;
var filename = 'test/tmp/test_sqlite_ok_error.db'; var filename = 'test/tmp/test_sqlite_ok_error.db';
helper.deleteFile(filename); var db;
var db = new sqlite3.Database(filename);
db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)", function(err) { before(function(done) {
if (err) throw err; helper.deleteFile(filename);
db = new sqlite3.Database(filename, done);
});
it('should create a table', function(done) {
db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)", done);
});
it('should insert rows with lots of null values', function(done) {
var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) { var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) {
if (err) throw err; if (err) throw err;
...@@ -21,15 +25,16 @@ exports['test SQLITE_OK error'] = function(beforeExit) { ...@@ -21,15 +25,16 @@ exports['test SQLITE_OK error'] = function(beforeExit) {
stmt.finalize(function(err) { stmt.finalize(function(err) {
if (err) throw err; if (err) throw err;
completed = true; done();
}); });
}); });
}); });
beforeExit(function() { it('should have created the database', function() {
assert.ok(completed);
assert.fileExists(filename); assert.fileExists(filename);
});
after(function() {
helper.deleteFile(filename); helper.deleteFile(filename);
}); });
}; });
\ No newline at end of file
test/open_close.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var fs = require('fs'); var fs = require('fs');
var helper = require('./support/helper'); var helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0); describe('open/close', function() {
describe('open and close non-existant database', function() {
before(function() {
helper.deleteFile('test/tmp/test_create.db');
});
exports['open and close non-existent database'] = function(beforeExit) { var db;
var opened, closed; it('should open the database', function(done) {
db = new sqlite3.Database('test/tmp/test_create.db', done);
});
helper.deleteFile('test/tmp/test_create.db'); it('should close the database', function(done) {
var db = new sqlite3.Database('test/tmp/test_create.db', function(err) { db.close(done);
if (err) throw err; });
assert.ok(!opened);
assert.ok(!closed);
opened = true;
});
db.close(function(err) { it('should have created the file', function() {
if (err) throw err; assert.fileExists('test/tmp/test_create.db');
assert.ok(opened); });
assert.ok(!closed);
closed = true;
});
beforeExit(function() { after(function() {
assert.ok(opened, 'Database not opened'); helper.deleteFile('test/tmp/test_create.db');
assert.ok(closed, 'Database not closed'); });
assert.fileExists('test/tmp/test_create.db');
helper.deleteFile('test/tmp/test_create.db');
}); });
};
exports['open inaccessible database'] = function(beforeExit) {
var notOpened;
var db = new sqlite3.Database('/usr/bin/test.db', function(err) { it('should be unable to open an inaccessible database', function(done) {
if (err && err.errno === sqlite3.CANTOPEN) { // NOTE: test assumes that the user is not allowed to create new files
notOpened = true; // in /usr/bin.
} var db = new sqlite3.Database('/usr/bin/test.db', function(err) {
else if (err) throw err; if (err && err.errno === sqlite3.CANTOPEN) {
done();
} else if (err) {
done(err);
} else {
done('Opened database that should be inaccessible');
}
});
}); });
beforeExit(function() {
assert.ok(notOpened, 'Database could be opened');
});
};
describe('creating database without create flag', function() {
before(function() {
helper.deleteFile('test/tmp/test_readonly.db');
});
exports['open non-existent database without create'] = function(beforeExit) { it('should fail to open the database', function(done) {
var notOpened; new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY, function(err) {
if (err && err.errno === sqlite3.CANTOPEN) {
done();
} else if (err) {
done(err);
} else {
done('Created database without create flag');
}
});
});
helper.deleteFile('tmp/test_readonly.db'); it('should not have created the file', function() {
var db = new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY, assert.fileDoesNotExist('test/tmp/test_readonly.db');
function(err) {
if (err && err.errno === sqlite3.CANTOPEN) {
notOpened = true;
}
else if (err) throw err;
}); });
beforeExit(function() { after(function() {
assert.ok(notOpened, 'Database could be opened'); helper.deleteFile('test/tmp/test_readonly.db');
assert.fileDoesNotExist('tmp/test_readonly.db'); });
}); });
};
exports['open and close memory database queuing'] = function(beforeExit) { describe('open and close memory database queuing', function() {
var opened = 0, closed = 0, closeFailed = 0; var db;
it('should open the database', function(done) {
db = new sqlite3.Database(':memory:', done);
});
var db = new sqlite3.Database(':memory:', function openedCallback(err) { it('should close the database', function(done) {
if (err) throw err; db.close(done);
opened++; });
});
function closedCallback(err) { it('shouldn\'t close the database again', function(done) {
if (closed > 0) { db.close(function(err) {
assert.ok(err, 'No error object received on second close'); assert.ok(err, 'No error object received on second close');
assert.ok(err.errno === sqlite3.MISUSE); assert.ok(err.errno === sqlite3.MISUSE);
closeFailed++; done();
} });
else if (err) throw err; });
else closed++;
}
db.close(closedCallback);
db.close(closedCallback);
beforeExit(function() {
assert.equal(opened, 1, 'Database not opened');
assert.equal(closed, 1, 'Database not closed');
assert.equal(closeFailed, 1, 'Database could be closed again');
}); });
};
exports['test closing with open statements'] = function(beforeExit) { describe('closing with unfinalized statements', function(done) {
var completed = false; var completed = false;
var completedSecond = false; var completedSecond = false;
var closed = false; var closed = false;
var db = new sqlite3.Database(':memory:'); var db;
before(function() {
db = new sqlite3.Database(':memory:', done);
});
db.serialize(function() { it('should create a table', function(done) {
db.run("CREATE TABLE foo (id INT, num INT)"); db.run("CREATE TABLE foo (id INT, num INT)", done);
});
var stmt = db.prepare('INSERT INTO foo VALUES (?, ?)') var stmt;
stmt.run(1, 2); it('should prepare/run a statement', function(done) {
stmt = db.prepare('INSERT INTO foo VALUES (?, ?)');
stmt.run(1, 2, done);
});
db.close(function(err) { it('should fail to close the database', function(done) {
assert.ok(err.message, db.close(function(err) {
"SQLITE_BUSY: unable to close due to unfinalised statements"); assert.ok(err.message,
completed = true; "SQLITE_BUSY: unable to close due to unfinalised statements");
done();
});
});
it('should succeed to close the database after finalizing', function(done) {
stmt.run(3, 4, function() { stmt.run(3, 4, function() {
completedSecond = true;
stmt.finalize(); stmt.finalize();
db.close(function(err) { db.close(done);
if (err) throw err;
closed = true;
});
}); });
}); });
}); });
});
beforeExit(function() {
assert.ok(completed);
assert.ok(completedSecond);
assert.ok(closed);
});
};
test/other_objects.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('data types', function() {
var db;
exports['test Date() and RegExp() serialization'] = function(beforeExit) { before(function(done) {
var db = new sqlite3.Database(':memory:'); db = new sqlite3.Database(':memory:');
db.run("CREATE TABLE txt_table (txt TEXT)");
db.run("CREATE TABLE int_table (int INTEGER)");
db.run("CREATE TABLE flt_table (flt FLOAT)");
db.wait(done);
});
var retrieved = false; beforeEach(function(done) {
var date = new Date(); db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;', done);
});
db.serialize(function() { it('should serialize Date()', function(done) {
db.run("CREATE TABLE foo (txt TEXT, num FLOAT)"); var date = new Date();
db.run("INSERT INTO foo VALUES(?, ?)", (/^f\noo/), date); db.run("INSERT INTO int_table VALUES(?)", date);
db.get("SELECT txt, num FROM foo", function(err, row) { db.get("SELECT int FROM int_table", function(err, row) {
if (err) throw err; if (err) throw err;
assert.equal(row.txt, '/^f\\noo/'); assert.equal(row.int, +date);
assert.equal(row.num, +date); done();
retrieved = true; });
})
}); });
beforeExit(function() { it('should serialize RegExp()', function(done) {
assert.ok(retrieved); var regexp = /^f\noo/;
db.run("INSERT INTO txt_table VALUES(?)", regexp);
db.get("SELECT txt FROM txt_table", function(err, row) {
if (err) throw err;
assert.equal(row.txt, String(regexp));
done();
});
}); });
};
exports['test large floats'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var retrieved = false;
var numbers = [ [
4294967296.249, 4294967296.249,
Math.PI, Math.PI,
3924729304762836.5, 3924729304762836.5,
...@@ -42,39 +47,18 @@ exports['test large floats'] = function(beforeExit) { ...@@ -42,39 +47,18 @@ exports['test large floats'] = function(beforeExit) {
-9.293476892934982e+300, -9.293476892934982e+300,
-2.3948728634826374e+83, -2.3948728634826374e+83,
-Infinity -Infinity
]; ].forEach(function(flt) {
it('should serialize float ' + flt, function(done) {
db.serialize(function() { db.run("INSERT INTO flt_table VALUES(?)", flt);
db.run("CREATE TABLE foo (id INT, num FLOAT)"); db.get("SELECT flt FROM flt_table", function(err, row) {
if (err) throw err;
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); assert.equal(row.flt, flt);
for (var i = 0; i < numbers.length; i++) { done();
stmt.run(i, numbers[i]); });
} });
stmt.finalize();
db.all("SELECT num FROM foo ORDER BY id", function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(numbers[i], rows[i].num);
}
retrieved = true;
})
}); });
beforeExit(function() { [
assert.ok(retrieved);
});
};
exports['test large integers'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var retrieved = false;
var numbers = [
4294967299, 4294967299,
3924729304762836, 3924729304762836,
new Date().valueOf(), new Date().valueOf(),
...@@ -84,29 +68,14 @@ exports['test large integers'] = function(beforeExit) { ...@@ -84,29 +68,14 @@ exports['test large integers'] = function(beforeExit) {
-9.293476892934982e+300, -9.293476892934982e+300,
-2.3948728634826374e+83, -2.3948728634826374e+83,
-Infinity -Infinity
]; ].forEach(function(integer) {
it('should serialize integer ' + integer, function(done) {
db.serialize(function() { db.run("INSERT INTO int_table VALUES(?)", integer);
db.run("CREATE TABLE foo (id INT, num INTEGER)"); db.get("SELECT int AS integer FROM int_table", function(err, row) {
if (err) throw err;
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)"); assert.equal(row.integer, integer);
for (var i = 0; i < numbers.length; i++) { done();
stmt.run(i, numbers[i]); });
} });
stmt.finalize();
db.all("SELECT num FROM foo ORDER BY id", function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(numbers[i], rows[i].num);
}
retrieved = true;
})
});
beforeExit(function() {
assert.ok(retrieved);
}); });
}; });
test/parallel_insert.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var util = require('util');
var helper = require('./support/helper'); var helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0); describe('parallel', function() {
var db;
exports['test parallel inserts'] = function(beforeExit) { before(function(done) {
var completed = false; helper.deleteFile('test/tmp/test_parallel_inserts.db');
helper.deleteFile('test/tmp/test_parallel_inserts.db'); db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done);
var db = new sqlite3.Database('test/tmp/test_parallel_inserts.db'); });
var columns = []; var columns = [];
for (var i = 0; i < 128; i++) { for (var i = 0; i < 128; i++) {
columns.push('id' + i); columns.push('id' + i);
} }
db.serialize(function() { it('should create the table', function(done) {
db.run("CREATE TABLE foo (" + columns + ")"); db.run("CREATE TABLE foo (" + columns + ")", done);
}); });
for (var i = 0; i < 1000; i++) { it('should insert in parallel', function(done) {
for (var values = [], j = 0; j < columns.length; j++) { for (var i = 0; i < 1000; i++) {
values.push(i * j); for (var values = [], j = 0; j < columns.length; j++) {
values.push(i * j);
}
db.run("INSERT INTO foo VALUES (" + values + ")");
} }
db.run("INSERT INTO foo VALUES (" + values + ")");
}
db.close(function() { db.wait(done);
completed = true;
}); });
beforeExit(function() { it('should close the database', function(done) {
assert.ok(completed); db.close(done);
});
it('should verify that the database exists', function() {
assert.fileExists('test/tmp/test_parallel_inserts.db'); assert.fileExists('test/tmp/test_parallel_inserts.db');
});
after(function() {
helper.deleteFile('test/tmp/test_parallel_inserts.db'); helper.deleteFile('test/tmp/test_parallel_inserts.db');
}); });
}; });
test/profile.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var util = require('util');
if (process.setMaxListeners) process.setMaxListeners(0); describe('profiling', function() {
exports['test Database profiling'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var create = false; var create = false;
var select = false; var select = false;
db.on('profile', function(sql, nsecs) { var db;
assert.ok(typeof nsecs === "number"); before(function(done) {
if (sql.match(/^SELECT/)) { db = new sqlite3.Database(':memory:', done);
assert.ok(!select);
assert.equal(sql, "SELECT * FROM foo"); db.on('profile', function(sql, nsecs) {
select = true; assert.ok(typeof nsecs === "number");
} if (sql.match(/^SELECT/)) {
else if (sql.match(/^CREATE/)) { assert.ok(!select);
assert.ok(!create); assert.equal(sql, "SELECT * FROM foo");
assert.equal(sql, "CREATE TABLE foo (id int)"); select = true;
create = true; }
} else if (sql.match(/^CREATE/)) {
else { assert.ok(!create);
assert.ok(false); assert.equal(sql, "CREATE TABLE foo (id int)");
} create = true;
}
else {
assert.ok(false);
}
});
}); });
db.serialize(function() { it('should profile a create table', function(done) {
db.run("CREATE TABLE foo (id int)"); assert.ok(!create);
db.run("SELECT * FROM foo"); db.run("CREATE TABLE foo (id int)", function(err) {
if (err) throw err;
process.nextTick(function() {
assert.ok(create);
done();
});
});
}); });
db.close();
beforeExit(function() { it('should profile a select', function(done) {
assert.ok(create); assert.ok(!select);
assert.ok(select); db.run("SELECT * FROM foo", function(err) {
if (err) throw err;
process.nextTick(function() {
assert.ok(select);
done();
});
});
});
after(function(done) {
db.close(done);
}); });
}; });
test/rerun.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('rerunning statements', function() {
var db;
exports['test running the same statement multiple times'] = function(beforeExit) { before(function(done) { db = new sqlite3.Database(':memory:', done); });
var db = new sqlite3.Database(':memory:');
var count = 10; var count = 10;
var inserted = 0; var inserted = 0;
var retrieved = 0; var retrieved = 0;
db.serialize(function() { it('should create the table', function(done) {
db.run("CREATE TABLE foo (id int)"); db.run("CREATE TABLE foo (id int)", done);
});
var stmt = db.prepare("INSERT INTO foo VALUES(?)"); it('should insert repeatedly, reusing the same statement', function(done) {
for (var i = 5; i < count; i++) { var stmt = db.prepare("INSERT INTO foo VALUES(?)");
stmt.run(i, function(err) { for (var i = 5; i < count; i++) {
if (err) throw err; stmt.run(i, function(err) {
inserted++; if (err) throw err;
}); inserted++;
} });
stmt.finalize(); }
stmt.finalize(done);
});
var collected = []; it('should retrieve repeatedly, resuing the same statement', function(done) {
var stmt = db.prepare("SELECT id FROM foo WHERE id = ?"); var collected = [];
for (var i = 0; i < count; i++) { var stmt = db.prepare("SELECT id FROM foo WHERE id = ?");
stmt.get(i, function(err, row) { for (var i = 0; i < count; i++) {
if (err) throw err; stmt.get(i, function(err, row) {
if (row) collected.push(row); if (err) throw err;
}); if (row) collected.push(row);
} });
stmt.finalize(function() { }
retrieved += collected.length; stmt.finalize(function(err) {
assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]); if (err) throw err;
}); retrieved += collected.length;
assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]);
done();
});
}); });
beforeExit(function() { it('should have inserted and retrieved the right amount', function() {
assert.equal(inserted, 5); assert.equal(inserted, 5);
assert.equal(retrieved, 5); assert.equal(retrieved, 5);
}); });
};
after(function(done) { db.close(done); });
});
test/scheduling.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0); describe('scheduling', function() {
it('scheduling after the database was closed', function(done) {
var db = new sqlite3.Database(':memory:');
db.on('error', function(err) {
assert.equal(err.message, "SQLITE_MISUSE: Database handle is closed");
done();
});
exports['test scheduling a query after the database was closed'] = function(beforeExit) { db.close();
var error = false; db.run("CREATE TABLE foo (id int)");
var db = new sqlite3.Database(':memory:');
db.on('error', function(err) {
error = true;
assert.equal(err.message, "SQLITE_MISUSE: Database handle is closed");
}); });
db.close();
db.run("CREATE TABLE foo (id int)");
beforeExit(function() {
assert.ok(error);
});
};
it('scheduling a query with callback after the database was closed', function(done) {
var db = new sqlite3.Database(':memory:');
db.on('error', function(err) {
assert.ok(false, 'Event was accidentally triggered');
});
exports['test scheduling a query with callback after the database was closed'] = function(beforeExit) { db.close();
var error = false; db.run("CREATE TABLE foo (id int)", function(err) {
var errorEvent = false; assert.ok(err.message, "SQLITE_MISUSE: Database handle is closed");
var db = new sqlite3.Database(':memory:'); done();
db.on('error', function(err) { });
errorEvent = true;
}); });
db.close(); it('running a query after the database was closed', function(done) {
db.run("CREATE TABLE foo (id int)", function(err) { var db = new sqlite3.Database(':memory:');
assert.ok(err.message, "SQLITE_MISUSE: Database handle is closed");
error = true;
});
beforeExit(function() { var stmt = db.prepare("SELECT * FROM sqlite_master", function(err) {
assert.ok(error); if (err) throw err;
assert.ok(!errorEvent); db.close(function(err) {
}); assert.ok(err);
}; assert.equal(err.message, "SQLITE_BUSY: unable to close due to unfinalised statements");
exports['test running a query after the database was closed'] = function(beforeExit) {
var error = false;
var db = new sqlite3.Database(':memory:');
var stmt = db.prepare("SELECT * FROM sqlite_master", function(err) {
if (err) throw err;
db.close(function(err) {
assert.ok(err);
error = true;
assert.equal(err.message, "SQLITE_BUSY: unable to close due to unfinalised statements");
stmt.run();
});
});
beforeExit(function() { // Running a statement now should not fail.
assert.ok(error); stmt.run(done);
});
});
}); });
}; });
test/serialization.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test serialize() and parallelize()'] = function(beforeExit) { describe('serialize() and parallelize()', function() {
var db = new sqlite3.Database(':memory:'); var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
var inserted1 = 0; var inserted1 = 0;
var inserted2 = 0; var inserted2 = 0;
...@@ -12,62 +12,33 @@ exports['test serialize() and parallelize()'] = function(beforeExit) { ...@@ -12,62 +12,33 @@ exports['test serialize() and parallelize()'] = function(beforeExit) {
var count = 1000; var count = 1000;
db.serialize(); it('should toggle', function(done) {
db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); db.serialize();
db.parallelize();
var stmt1 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
var stmt2 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
for (var i = 0; i < count; i++) {
stmt1.run('String ' + i, i, i * Math.PI, function(err) {
if (err) throw err;
inserted1++;
// Might sometimes fail, but should work fine most of the time.
assert.ok(inserted2 >= Math.floor(0.75 * inserted1));
});
i++;
stmt2.run('String ' + i, i, i * Math.PI, function(err) {
if (err) throw err;
inserted2++;
assert.ok(inserted1 >= Math.floor(0.75 * inserted2));
});
}
db.serialize();
db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(rows[i].txt, 'String ' + i);
assert.equal(rows[i].num, i);
assert.equal(rows[i].flt, i * Math.PI);
assert.equal(rows[i].blb, null);
retrieved++;
}
});
beforeExit(function() {
assert.equal(count, inserted1 + inserted2, "Didn't insert all rows");
assert.equal(count, retrieved, "Didn't retrieve all rows");
});
}
exports['test serialize(fn)'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var inserted = 0;
var retrieved = 0;
var count = 1000;
db.serialize(function() {
db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)"); db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
db.parallelize(done);
});
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)"); it('should insert rows', function() {
var stmt1 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
var stmt2 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
for (var i = 0; i < count; i++) { for (var i = 0; i < count; i++) {
stmt.run('String ' + i, i, i * Math.PI, function(err) { // Interleaved inserts with two statements.
stmt1.run('String ' + i, i, i * Math.PI, function(err) {
if (err) throw err;
inserted1++;
});
i++;
stmt2.run('String ' + i, i, i * Math.PI, function(err) {
if (err) throw err; if (err) throw err;
inserted++; inserted2++;
}); });
} }
stmt1.finalize();
stmt2.finalize();
});
it('should have inserted all the rows after synchronizing with serialize()', function(done) {
db.serialize();
db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) { db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
if (err) throw err; if (err) throw err;
for (var i = 0; i < rows.length; i++) { for (var i = 0; i < rows.length; i++) {
...@@ -77,11 +48,57 @@ exports['test serialize(fn)'] = function(beforeExit) { ...@@ -77,11 +48,57 @@ exports['test serialize(fn)'] = function(beforeExit) {
assert.equal(rows[i].blb, null); assert.equal(rows[i].blb, null);
retrieved++; retrieved++;
} }
assert.equal(count, inserted1 + inserted2, "Didn't insert all rows");
assert.equal(count, retrieved, "Didn't retrieve all rows");
done();
}); });
}); });
beforeExit(function() { after(function(done) { db.close(done); });
});
describe('serialize(fn)', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
var inserted = 0;
var retrieved = 0;
var count = 1000;
it('should call the callback', function(done) {
db.serialize(function() {
db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
for (var i = 0; i < count; i++) {
stmt.run('String ' + i, i, i * Math.PI, function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize();
db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(rows[i].txt, 'String ' + i);
assert.equal(rows[i].num, i);
assert.equal(rows[i].flt, i * Math.PI);
assert.equal(rows[i].blb, null);
retrieved++;
}
done();
});
});
});
it('should have inserted and retrieved all rows', function() {
assert.equal(count, inserted, "Didn't insert all rows"); assert.equal(count, inserted, "Didn't insert all rows");
assert.equal(count, retrieved, "Didn't retrieve all rows"); assert.equal(count, retrieved, "Didn't retrieve all rows");
}); });
}
after(function(done) { db.close(done); });
});
test/trace.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
var util = require('util');
if (process.setMaxListeners) process.setMaxListeners(0); describe('tracing', function() {
it('Database tracing', function(done) {
var db = new sqlite3.Database(':memory:');
var create = false;
var select = false;
exports['test Database tracing'] = function(beforeExit) { db.on('trace', function(sql) {
var db = new sqlite3.Database(':memory:'); if (sql.match(/^SELECT/)) {
var create = false; assert.ok(!select);
var select = false; assert.equal(sql, "SELECT * FROM foo");
select = true;
}
else if (sql.match(/^CREATE/)) {
assert.ok(!create);
assert.equal(sql, "CREATE TABLE foo (id int)");
create = true;
}
else {
assert.ok(false);
}
});
db.on('trace', function(sql) { db.serialize(function() {
if (sql.match(/^SELECT/)) { db.run("CREATE TABLE foo (id int)");
assert.ok(!select); db.run("SELECT * FROM foo");
assert.equal(sql, "SELECT * FROM foo"); });
select = true;
}
else if (sql.match(/^CREATE/)) {
assert.ok(!create);
assert.equal(sql, "CREATE TABLE foo (id int)");
create = true;
}
else {
assert.ok(false);
}
});
db.serialize(function() { db.close(function(err) {
db.run("CREATE TABLE foo (id int)"); if (err) throw err;
db.run("SELECT * FROM foo"); assert.ok(create);
assert.ok(select);
done();
});
}); });
db.close();
beforeExit(function() { it('test disabling tracing #1', function(done) {
assert.ok(create); var db = new sqlite3.Database(':memory:');
assert.ok(select);
});
};
exports['test disabling tracing #1'] = function(beforeExit) { db.on('trace', function(sql) {});
var db = new sqlite3.Database(':memory:'); db.removeAllListeners('trace');
db._events['trace'] = function(sql) {
assert.ok(false);
};
db.on('trace', function(sql) {}); db.run("CREATE TABLE foo (id int)");
db.removeAllListeners('trace'); db.close(done);
db._events['trace'] = function(sql) { });
assert.ok(false);
};
db.run("CREATE TABLE foo (id int)");
db.close();
};
exports['test disabling tracing #2'] = function(beforeExit) { it('test disabling tracing #2', function(done) {
var db = new sqlite3.Database(':memory:'); var db = new sqlite3.Database(':memory:');
var trace = function(sql) {}; var trace = function(sql) {};
db.on('trace', trace); db.on('trace', trace);
db.removeListener('trace', trace); db.removeListener('trace', trace);
db._events['trace'] = function(sql) { db._events['trace'] = function(sql) {
assert.ok(false); assert.ok(false);
}; };
db.run("CREATE TABLE foo (id int)"); db.run("CREATE TABLE foo (id int)");
db.close(); db.close(done);
}; });
});
test/unicode.test.js
var sqlite3 = require('sqlite3'); var sqlite3 = require('..');
var assert = require('assert'); var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0);
function randomString() { function randomString() {
var str = ''; var str = '';
for (var i = Math.random() * 300; i > 0; i--) { for (var i = Math.random() * 300; i > 0; i--) {
str += String.fromCharCode(Math.floor(Math.random() * 65536)); str += String.fromCharCode(Math.floor(Math.random() * 65536));
} }
return str; return str;
}; }
exports['test unicode characters'] = function(beforeExit) { describe('unicode', function() {
var db = new sqlite3.Database(':memory:'); var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
// Generate random data. // Generate random data.
var data = []; var data = [];
var length = Math.floor(Math.random() * 1000) + 200; var length = Math.floor(Math.random() * 1000) + 200;
for (var i = 0; i < length; i++) { for (var i = 0; i < length; i++) {
...@@ -24,30 +23,37 @@ exports['test unicode characters'] = function(beforeExit) { ...@@ -24,30 +23,37 @@ exports['test unicode characters'] = function(beforeExit) {
var inserted = 0; var inserted = 0;
var retrieved = 0; var retrieved = 0;
db.serialize(function() { it('should create the table', function(done) {
db.run("CREATE TABLE foo (id int, txt text)"); db.run("CREATE TABLE foo (id int, txt text)", done);
});
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 0; i < data.length; i++) { it('should insert all values', function(done) {
stmt.run(i, data[i], function(err) { var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
if (err) throw err; for (var i = 0; i < data.length; i++) {
inserted++; stmt.run(i, data[i], function(err) {
}); if (err) throw err;
} inserted++;
stmt.finalize(); });
}
db.all("SELECT txt FROM foo ORDER BY id", function(err, rows) { stmt.finalize(done);
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(rows[i].txt, data[i]);
retrieved++;
}
});
}); });
beforeExit(function() { it('should retrieve all values', function(done) {
db.all("SELECT txt FROM foo ORDER BY id", function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(rows[i].txt, data[i]);
retrieved++;
}
done();
});
});
it('should have inserted and retrieved the correct amount', function() {
assert.equal(inserted, length); assert.equal(inserted, length);
assert.equal(retrieved, length); assert.equal(retrieved, length);
}); });
};
after(function(done) { db.close(done); });
});
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