Skip to content

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

move test suite to mocha

parent cbd74f7c
Showing with 1177 additions and 1292 deletions
package.json
......@@ -30,7 +30,7 @@
},
"devDependencies": {
"step": "0.0.4",
"expresso": "*"
"mocha": "~1.7"
},
"engines": {
"node": ">= 0.6.13 && < 0.11.0"
......
test/affected.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test row changes and lastID'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var finished = false;
describe('query properties', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:');
db.run("CREATE TABLE foo (id INT, txt TEXT)", done);
});
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, txt TEXT)");
it('should return the correct lastID', function(done) {
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
var j = 1;
for (var i = 0; i < 1000; i++) {
......@@ -20,15 +19,14 @@ exports['test row changes and lastID'] = function(beforeExit) {
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) {
if (err) throw err;
assert.equal(500, this.changes);
finished = true;
done();
});
});
beforeExit(function() {
assert.ok(finished);
})
}
});
test/blob.test.js
var sqlite3 = require('sqlite3'),
Step = require('step'),
var sqlite3 = require('..'),
fs = require('fs'),
assert = require('assert')
assert = require('assert'),
Buffer = require('buffer').Buffer;
if (process.setMaxListeners) process.setMaxListeners(0);
// lots of elmo
var elmo = fs.readFileSync(__dirname + '/support/elmo.png');
exports['blob test'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('blob', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:');
db.run("CREATE TABLE elmos (id INT, image BLOB)", done);
});
var total = 10;
var inserted = 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++) {
db.run('INSERT INTO elmos (id, image) VALUES (?, ?)', i, elmo, function(err) {
if (err) throw err;
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) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
......@@ -39,12 +46,9 @@ exports['blob test'] = function(beforeExit) {
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 helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test caching Database objects while opening'] = function(beforeExit) {
var filename = 'test/tmp/test_cache.db';
helper.deleteFile(filename);
var opened1 = false, opened2 = false
var db1 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err;
opened1 = true;
});
var db2 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err;
opened2 = true;
describe('cache', function() {
it('should cache Database objects while opening', function(done) {
var filename = 'test/tmp/test_cache.db';
helper.deleteFile(filename);
var opened1 = false, opened2 = false;
var db1 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err;
opened1 = true;
if (opened1 && opened2) done();
});
var db2 = new sqlite3.cached.Database(filename, function(err) {
if (err) throw err;
opened2 = true;
if (opened1 && opened2) done();
});
assert.equal(db1, db2);
});
assert.equal(db1, db2);
beforeExit(function() {
assert.ok(opened1);
assert.ok(opened2);
});
};
it('should cache Database objects after they are open', function(done) {
var filename = 'test/tmp/test_cache2.db';
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';
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;
});
assert.equal(db1, db2);
});
}, 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');
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() {
assert.ok(sqlite3.OPEN_READONLY === 1);
assert.ok(sqlite3.OPEN_READWRITE === 2);
assert.ok(sqlite3.OPEN_CREATE === 4);
assert.ok(sqlite3.OK === 0);
assert.ok(sqlite3.ERROR === 1);
assert.ok(sqlite3.INTERNAL === 2);
assert.ok(sqlite3.PERM === 3);
assert.ok(sqlite3.ABORT === 4);
assert.ok(sqlite3.BUSY === 5);
assert.ok(sqlite3.LOCKED === 6);
assert.ok(sqlite3.NOMEM === 7);
assert.ok(sqlite3.READONLY === 8);
assert.ok(sqlite3.INTERRUPT === 9);
assert.ok(sqlite3.IOERR === 10);
assert.ok(sqlite3.CORRUPT === 11);
assert.ok(sqlite3.NOTFOUND === 12);
assert.ok(sqlite3.FULL === 13);
assert.ok(sqlite3.CANTOPEN === 14);
assert.ok(sqlite3.PROTOCOL === 15);
assert.ok(sqlite3.EMPTY === 16);
assert.ok(sqlite3.SCHEMA === 17);
assert.ok(sqlite3.TOOBIG === 18);
assert.ok(sqlite3.CONSTRAINT === 19);
assert.ok(sqlite3.MISMATCH === 20);
assert.ok(sqlite3.MISUSE === 21);
assert.ok(sqlite3.NOLFS === 22);
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
it('should have the right error flags', function() {
assert.ok(sqlite3.OK === 0);
assert.ok(sqlite3.ERROR === 1);
assert.ok(sqlite3.INTERNAL === 2);
assert.ok(sqlite3.PERM === 3);
assert.ok(sqlite3.ABORT === 4);
assert.ok(sqlite3.BUSY === 5);
assert.ok(sqlite3.LOCKED === 6);
assert.ok(sqlite3.NOMEM === 7);
assert.ok(sqlite3.READONLY === 8);
assert.ok(sqlite3.INTERRUPT === 9);
assert.ok(sqlite3.IOERR === 10);
assert.ok(sqlite3.CORRUPT === 11);
assert.ok(sqlite3.NOTFOUND === 12);
assert.ok(sqlite3.FULL === 13);
assert.ok(sqlite3.CANTOPEN === 14);
assert.ok(sqlite3.PROTOCOL === 15);
assert.ok(sqlite3.EMPTY === 16);
assert.ok(sqlite3.SCHEMA === 17);
assert.ok(sqlite3.TOOBIG === 18);
assert.ok(sqlite3.CONSTRAINT === 19);
assert.ok(sqlite3.MISMATCH === 20);
assert.ok(sqlite3.MISUSE === 21);
assert.ok(sqlite3.NOLFS === 22);
assert.ok(sqlite3.AUTH === 23);
assert.ok(sqlite3.FORMAT === 24);
assert.ok(sqlite3.RANGE === 25);
assert.ok(sqlite3.NOTADB === 26);
});
});
test/database_fail.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
exports['test Database() without new'] = function(beforeExit) {
assert.throws(function() {
sqlite3.Database(':memory:');
}, (/Use the new operator to create new Database objects/));
assert.throws(function() {
sqlite3.Statement();
}, (/Use the new operator to create new Statement objects/));
};
exports['test Database#get prepare fail'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.get('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#all prepare fail'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.all('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#run prepare fail'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.run('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#each prepare fail'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.each('SELECT id, txt FROM foo', function(err, row) {
assert.ok(false, "this should not be called");
}, function(err, num) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#each prepare fail without completion handler'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.each('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
else {
assert.ok(false, 'this should not be called')
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#get prepare fail with param binding'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#all prepare fail with param binding'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#run prepare fail with param binding'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#each prepare fail with param binding'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
assert.ok(false, "this should not be called");
}, function(err, num) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
});
beforeExit(function() {
assert.ok(completed);
});
};
exports['test Database#each prepare fail with param binding without completion handler'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
completed = true;
}
else {
assert.ok(false, 'this should not be called')
}
});
beforeExit(function() {
assert.ok(completed);
});
};
describe('error handling', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
it('throw when calling Database() without new', function() {
assert.throws(function() {
sqlite3.Database(':memory:');
}, (/Use the new operator to create new Database objects/));
assert.throws(function() {
sqlite3.Statement();
}, (/Use the new operator to create new Statement objects/));
});
it('should error when calling Database#get on a missing table', function(done) {
db.get('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#all prepare fail', function(done) {
db.all('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#run prepare fail', function(done) {
db.run('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#each prepare fail', function(done) {
db.each('SELECT id, txt FROM foo', function(err, row) {
assert.ok(false, "this should not be called");
}, function(err, num) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#each prepare fail without completion handler', function(done) {
db.each('SELECT id, txt FROM foo', function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#get prepare fail with param binding', function(done) {
db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#all prepare fail with param binding', function(done) {
db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#run prepare fail with param binding', function(done) {
db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#each prepare fail with param binding', function(done) {
db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
assert.ok(false, "this should not be called");
}, function(err, num) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
it('Database#each prepare fail with param binding without completion handler', function(done) {
db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
if (err) {
assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
assert.equal(err.errno, sqlite3.ERROR);
assert.equal(err.code, 'SQLITE_ERROR');
done();
} else {
done(new Error('Completed query without error, but expected error'));
}
});
});
});
test/each.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
var util = require('util');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test Statement#each'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY);
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.");
describe('each', function() {
var db;
before(function(done) {
db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY, done);
});
};
exports['test Statement#each with complete callback'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY);
it('retrieve 100,000 rows with Statement#each', function(done) {
var total = 100000;
var retrieved = 0;
var total = 10000;
var retrieved = 0;
var completed = false;
db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
if (err) throw err;
retrieved++;
});
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);
completed = true;
db.wait(function() {
assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
done();
});
});
beforeExit(function() {
assert.ok(completed);
assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
it('Statement#each with complete callback', function(done) {
var total = 10000;
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 fs = require('fs');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test Database#exec'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var finished = false;
var sql = fs.readFileSync('test/support/script.sql', 'utf8');
describe('exec', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
db.exec(sql, function(err) {
if (err) throw err;
it('Database#exec', function(done) {
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) {
if (err) throw err;
assert.deepEqual(rows, [
{ type: 'index', name: 'grid_key_lookup' },
{ type: 'index', name: 'grid_utfgrid_lookup' },
......@@ -32,12 +33,7 @@ exports['test Database#exec'] = function(beforeExit) {
{ type: 'view', name: 'grids' },
{ type: 'view', name: 'tiles' }
]);
finished = true;
done();
});
});
beforeExit(function() {
assert.ok(finished);
});
};
});
test/extension.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
var exists = require('fs').existsSync || require('path').existsSync
if (process.setMaxListeners) process.setMaxListeners(0);
var exists = require('fs').existsSync || require('path').existsSync;
var spatialite_ext = '/usr/local/lib/libspatialite.dylib';
exports['test loadExtension'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var completed = false;
describe('loadExtension', function(done) {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
if (exists(spatialite_ext)) {
db.loadExtension(spatialite_ext, function(err) {
if (err) throw err;
completed = true;
it('libspatialite', function(done) {
db.loadExtension(spatialite_ext, done);
});
} 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*/
(function () {
"use strict";
var sqlite3 = require('..');
var assert = require('assert');
var sqlite = require('sqlite3')
, assert = require('assert')
, db
;
function readyForQuery() {
db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);', function (err) {
assert.ok(!err);
describe('fts', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
}
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');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test Database#map() with two 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)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 5; i < count; i++) {
stmt.run(i, 'Value for ' + i, function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize();
db.map("SELECT * FROM foo", function(err, map) {
retrieved = true;
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 }
});
});
describe('map', function() {
it('test Database#map() with two columns', function(done) {
var count = 10;
var inserted = 0;
var db = new sqlite3.Database(':memory:');
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, value TEXT)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 5; i < count; i++) {
stmt.run(i, 'Value for ' + i, 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: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' });
assert.equal(inserted, 5);
done();
});
});
});
beforeExit(function() {
assert.equal(inserted, 5);
assert.ok(retrieved);
it('test Database#map() with three columns', function(done) {
var db = new sqlite3.Database(':memory:');
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');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test named columns'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var finished = false;
describe('named columns', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
db.serialize(function() {
db.run("CREATE TABLE foo (txt TEXT, num INT)");
it('should create the table', function(done) {
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)", {
$id: 1,
$text: "Lorem Ipsum"
});
}, done);
});
it('should retrieve the values', function(done) {
db.get("SELECT txt, num FROM foo ORDER BY num", function(err, row) {
if (err) throw err;
assert.equal(row.txt, "Lorem Ipsum");
assert.equal(row.num, 1);
finished = true;
done();
});
});
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');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test named parameters'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var finished = false;
describe('named parameters', function() {
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
});
db.serialize(function() {
db.run("CREATE TABLE foo (txt TEXT, num INT)");
it('should create the table', function(done) {
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)", {
$id: 1,
$text: "Lorem Ipsum"
});
}, done);
});
it('should insert a value with : placeholders', function(done) {
db.run("INSERT INTO foo VALUES(:text, :id)", {
":id": 2,
":text": "Dolor Sit Amet"
});
':id': 2,
':text': "Dolor Sit Amet"
}, done);
});
it('should insert a value with @ placeholders', function(done) {
db.run("INSERT INTO foo VALUES(@txt, @id)", {
"@id": 3,
"@txt": "Consectetur Adipiscing Elit"
});
}, done);
});
db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ]);
db.run("INSERT INTO foo VALUES(?2, ?4)", [ null, 'Tempor Incididunt', null, 5 ]);
it('should insert a value with @ placeholders using an array', function(done) {
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(?, ?)", {
2: 6,
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) {
if (err) throw err;
assert.equal(rows[0].txt, "Lorem Ipsum");
assert.equal(rows[0].num, 1);
assert.equal(rows[1].txt, "Dolor Sit Amet");
......@@ -49,12 +63,7 @@ exports['test named parameters'] = function(beforeExit) {
assert.equal(rows[4].num, 5);
assert.equal(rows[5].txt, "Ut Labore Et Dolore");
assert.equal(rows[5].num, 6);
finished = true;
done();
});
});
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 helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test SQLITE_OK error'] = function(beforeExit) {
var completed = false;
describe('null error', function() {
var filename = 'test/tmp/test_sqlite_ok_error.db';
helper.deleteFile(filename);
var db = new sqlite3.Database(filename);
var db;
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) {
if (err) throw err;
before(function(done) {
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) {
if (err) throw err;
......@@ -21,15 +25,16 @@ exports['test SQLITE_OK error'] = function(beforeExit) {
stmt.finalize(function(err) {
if (err) throw err;
completed = true;
done();
});
});
});
beforeExit(function() {
assert.ok(completed);
it('should have created the database', function() {
assert.fileExists(filename);
});
after(function() {
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 fs = require('fs');
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 opened, closed;
var db;
it('should open the database', function(done) {
db = new sqlite3.Database('test/tmp/test_create.db', done);
});
helper.deleteFile('test/tmp/test_create.db');
var db = new sqlite3.Database('test/tmp/test_create.db', function(err) {
if (err) throw err;
assert.ok(!opened);
assert.ok(!closed);
opened = true;
});
it('should close the database', function(done) {
db.close(done);
});
db.close(function(err) {
if (err) throw err;
assert.ok(opened);
assert.ok(!closed);
closed = true;
});
it('should have created the file', function() {
assert.fileExists('test/tmp/test_create.db');
});
beforeExit(function() {
assert.ok(opened, 'Database not opened');
assert.ok(closed, 'Database not closed');
assert.fileExists('test/tmp/test_create.db');
helper.deleteFile('test/tmp/test_create.db');
after(function() {
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) {
if (err && err.errno === sqlite3.CANTOPEN) {
notOpened = true;
}
else if (err) throw err;
it('should be unable to open an inaccessible database', function(done) {
// NOTE: test assumes that the user is not allowed to create new files
// in /usr/bin.
var db = new sqlite3.Database('/usr/bin/test.db', function(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) {
var notOpened;
it('should fail to open the database', function(done) {
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');
var db = new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY,
function(err) {
if (err && err.errno === sqlite3.CANTOPEN) {
notOpened = true;
}
else if (err) throw err;
it('should not have created the file', function() {
assert.fileDoesNotExist('test/tmp/test_readonly.db');
});
beforeExit(function() {
assert.ok(notOpened, 'Database could be opened');
assert.fileDoesNotExist('tmp/test_readonly.db');
after(function() {
helper.deleteFile('test/tmp/test_readonly.db');
});
});
};
exports['open and close memory database queuing'] = function(beforeExit) {
var opened = 0, closed = 0, closeFailed = 0;
describe('open and close memory database queuing', function() {
var db;
it('should open the database', function(done) {
db = new sqlite3.Database(':memory:', done);
});
var db = new sqlite3.Database(':memory:', function openedCallback(err) {
if (err) throw err;
opened++;
});
it('should close the database', function(done) {
db.close(done);
});
function closedCallback(err) {
if (closed > 0) {
assert.ok(err, 'No error object received on second close');
assert.ok(err.errno === sqlite3.MISUSE);
closeFailed++;
}
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');
it('shouldn\'t close the database again', function(done) {
db.close(function(err) {
assert.ok(err, 'No error object received on second close');
assert.ok(err.errno === sqlite3.MISUSE);
done();
});
});
});
};
exports['test closing with open statements'] = function(beforeExit) {
var completed = false;
var completedSecond = false;
var closed = false;
describe('closing with unfinalized statements', function(done) {
var completed = false;
var completedSecond = false;
var closed = false;
var db = new sqlite3.Database(':memory:');
var db;
before(function() {
db = new sqlite3.Database(':memory:', done);
});
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, num INT)");
it('should create a table', function(done) {
db.run("CREATE TABLE foo (id INT, num INT)", done);
});
var stmt = db.prepare('INSERT INTO foo VALUES (?, ?)')
stmt.run(1, 2);
var stmt;
it('should prepare/run a statement', function(done) {
stmt = db.prepare('INSERT INTO foo VALUES (?, ?)');
stmt.run(1, 2, done);
});
db.close(function(err) {
assert.ok(err.message,
"SQLITE_BUSY: unable to close due to unfinalised statements");
completed = true;
it('should fail to close the database', function(done) {
db.close(function(err) {
assert.ok(err.message,
"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() {
completedSecond = true;
stmt.finalize();
db.close(function(err) {
if (err) throw err;
closed = true;
});
db.close(done);
});
});
});
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');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test Date() and RegExp() serialization'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('data types', function() {
var db;
before(function(done) {
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;
var date = new Date();
beforeEach(function(done) {
db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;', done);
});
db.serialize(function() {
db.run("CREATE TABLE foo (txt TEXT, num FLOAT)");
db.run("INSERT INTO foo VALUES(?, ?)", (/^f\noo/), date);
db.get("SELECT txt, num FROM foo", function(err, row) {
it('should serialize Date()', function(done) {
var date = new Date();
db.run("INSERT INTO int_table VALUES(?)", date);
db.get("SELECT int FROM int_table", function(err, row) {
if (err) throw err;
assert.equal(row.txt, '/^f\\noo/');
assert.equal(row.num, +date);
retrieved = true;
})
assert.equal(row.int, +date);
done();
});
});
beforeExit(function() {
assert.ok(retrieved);
it('should serialize RegExp()', function(done) {
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,
Math.PI,
3924729304762836.5,
......@@ -42,39 +47,18 @@ exports['test large floats'] = function(beforeExit) {
-9.293476892934982e+300,
-2.3948728634826374e+83,
-Infinity
];
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, num FLOAT)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 0; i < numbers.length; i++) {
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;
})
].forEach(function(flt) {
it('should serialize float ' + flt, function(done) {
db.run("INSERT INTO flt_table VALUES(?)", flt);
db.get("SELECT flt FROM flt_table", function(err, row) {
if (err) throw err;
assert.equal(row.flt, flt);
done();
});
});
});
beforeExit(function() {
assert.ok(retrieved);
});
};
exports['test large integers'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var retrieved = false;
var numbers = [
[
4294967299,
3924729304762836,
new Date().valueOf(),
......@@ -84,29 +68,14 @@ exports['test large integers'] = function(beforeExit) {
-9.293476892934982e+300,
-2.3948728634826374e+83,
-Infinity
];
db.serialize(function() {
db.run("CREATE TABLE foo (id INT, num INTEGER)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 0; i < numbers.length; i++) {
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);
].forEach(function(integer) {
it('should serialize integer ' + integer, function(done) {
db.run("INSERT INTO int_table VALUES(?)", integer);
db.get("SELECT int AS integer FROM int_table", function(err, row) {
if (err) throw err;
assert.equal(row.integer, integer);
done();
});
});
});
};
});
test/parallel_insert.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
var util = require('util');
var helper = require('./support/helper');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test parallel inserts'] = function(beforeExit) {
var completed = false;
helper.deleteFile('test/tmp/test_parallel_inserts.db');
var db = new sqlite3.Database('test/tmp/test_parallel_inserts.db');
describe('parallel', function() {
var db;
before(function(done) {
helper.deleteFile('test/tmp/test_parallel_inserts.db');
db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done);
});
var columns = [];
for (var i = 0; i < 128; i++) {
columns.push('id' + i);
}
db.serialize(function() {
db.run("CREATE TABLE foo (" + columns + ")");
it('should create the table', function(done) {
db.run("CREATE TABLE foo (" + columns + ")", done);
});
for (var i = 0; i < 1000; i++) {
for (var values = [], j = 0; j < columns.length; j++) {
values.push(i * j);
it('should insert in parallel', function(done) {
for (var i = 0; i < 1000; i++) {
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() {
completed = true;
db.wait(done);
});
beforeExit(function() {
assert.ok(completed);
it('should close the database', function(done) {
db.close(done);
});
it('should verify that the database exists', function() {
assert.fileExists('test/tmp/test_parallel_inserts.db');
});
after(function() {
helper.deleteFile('test/tmp/test_parallel_inserts.db');
});
};
});
test/prepare.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
var Step = require('step');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test simple prepared statement with invalid SQL'] = function(beforeExit) {
var error = false;
var db = new sqlite3.Database(':memory:');
db.prepare('CRATE TALE foo text bar)', function(err, statement) {
if (err && err.errno == sqlite3.ERROR &&
err.message === 'SQLITE_ERROR: near "CRATE": syntax error') {
error = true;
}
else throw err;
}).finalize();
db.close();
describe('prepare', function() {
describe('invalid SQL', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
var stmt;
it('should fail preparing a statement with invalid SQL', function(done) {
stmt = db.prepare('CRATE TALE foo text bar)', function(err, statement) {
if (err && err.errno == sqlite3.ERROR &&
err.message === 'SQLITE_ERROR: near "CRATE": syntax error') {
done();
}
else throw err;
});
});
beforeExit(function() {
assert.ok(error, 'No error thrown for invalid SQL');
after(function(done) { db.close(done); });
});
};
exports['test simple prepared statement'] = function(beforeExit) {
var run = false;
var db = new sqlite3.Database(':memory:');
db.prepare("CREATE TABLE foo (text bar)")
.run(function(err) {
if (err) throw err;
run = true;
})
.finalize()
.close();
beforeExit(function() {
assert.ok(run, 'Database query did not run');
describe('simple prepared statement', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
it('should prepare, run and finalize the statement', function(done) {
db.prepare("CREATE TABLE foo (text bar)")
.run()
.finalize(done);
});
after(function(done) { db.close(done); });
});
};
exports['test inserting and retrieving rows'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('inserting and retrieving rows', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
var inserted = 0;
var retrieved = 0;
var inserted = 0;
var retrieved = 0;
// We insert and retrieve that many rows.
var count = 1000;
// We insert and retrieve that many rows.
var count = 1000;
it('should create the table', function(done) {
db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run().finalize(done);
});
Step(
function() {
db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run(this);
},
function(err) {
if (err) throw err;
var group = this.group();
it('should insert ' + count + ' rows', function(done) {
for (var i = 0; i < count; i++) {
db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)")
.run(
'String ' + i,
i,
i * Math.PI,
// null (SQLite sets this implicitly)
group()
);
db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)").run(
'String ' + i,
i,
i * Math.PI,
// null (SQLite sets this implicitly)
function(err) {
if (err) throw err;
inserted++;
}
).finalize(function(err) {
if (err) throw err;
if (inserted == count) done();
});
}
},
function(err, rows) {
if (err) throw err;
inserted += rows.length;
});
it('should prepare a statement and run it ' + (count + 5) + ' times', function(done) {
var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err) {
if (err) throw err;
assert.equal(stmt.sql, 'SELECT txt, num, flt, blb FROM foo ORDER BY num');
});
var group = this.group();
for (var i = 0; i < count + 5; i++) {
stmt.get(group());
}
},
function(err, rows) {
if (err) throw err;
assert.equal(count + 5, rows.length, "Didn't run all queries");
for (var i = 0; i < count + 5; i++) (function(i) {
stmt.get(function(err, row) {
if (err) throw err;
for (var i = 0; i < count; 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++;
}
if (retrieved >= 1000) {
assert.equal(row, undefined);
} else {
assert.equal(row.txt, 'String ' + i);
assert.equal(row.num, i);
assert.equal(row.flt, i * Math.PI);
assert.equal(row.blb, null);
}
for (var i = rows; i < count + 5; i++) {
assert.ok(!rows[i]);
}
}
);
retrieved++;
});
})(i);
beforeExit(function() {
assert.equal(count, inserted, "Didn't insert all rows");
assert.equal(count, retrieved, "Didn't retrieve all rows");
stmt.finalize(done);
});
it('should have retrieved ' + (count + 5) + ' rows', function() {
assert.equal(count + 5, retrieved, "Didn't retrieve all rows");
});
after(function(done) { db.close(done); });
});
};
exports['test retrieving reset() function'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
describe('retrieving reset() function', function() {
var db;
before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
var retrieved = 0;
var retrieved = 0;
Step(
function() {
it('should retrieve the same row over and over again', function(done) {
var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num");
var group = this.group();
for (var i = 0; i < 10; i++) {
stmt.reset();
stmt.get(group());
stmt.get(function(err, row) {
if (err) throw err;
assert.equal(row.txt, 'String 0');
assert.equal(row.num, 0);
assert.equal(row.flt, 0.0);
assert.equal(row.blb, null);
retrieved++;
});
}
},
function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(rows[i].txt, 'String 0');
assert.equal(rows[i].num, 0);
assert.equal(rows[i].flt, 0.0);
assert.equal(rows[i].blb, null);
retrieved++;
}
}
);
stmt.finalize(done);
});
beforeExit(function() {
assert.equal(10, retrieved, "Didn't retrieve all rows");
it('should have retrieved 10 rows', function() {
assert.equal(10, retrieved, "Didn't retrieve all rows");
});
after(function(done) { db.close(done); });
});
};
exports['test multiple get() parameter binding'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
describe('multiple get() parameter binding', function() {
var db;
before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
var retrieved = 0;
var retrieved = 0;
Step(
function() {
it('should retrieve particular rows', function(done) {
var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ?");
var group = this.group();
for (var i = 0; i < 10; i++) {
stmt.get(i * 10 + 1, group());
}
},
function(err, rows) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
var val = i * 10 + 1;
assert.equal(rows[i].txt, 'String ' + val);
assert.equal(rows[i].num, val);
assert.equal(rows[i].flt, val * Math.PI);
assert.equal(rows[i].blb, null);
retrieved++;
}
}
);
beforeExit(function() {
assert.equal(10, retrieved, "Didn't retrieve all rows");
for (var i = 0; i < 10; i++) (function(i) {
stmt.get(i * 10 + 1, function(err, row) {
if (err) throw err;
var val = i * 10 + 1;
assert.equal(row.txt, 'String ' + val);
assert.equal(row.num, val);
assert.equal(row.flt, val * Math.PI);
assert.equal(row.blb, null);
retrieved++;
});
})(i);
stmt.finalize(done);
});
it('should have retrieved 10 rows', function() {
assert.equal(10, retrieved, "Didn't retrieve all rows");
});
after(function(done) { db.close(done); });
});
};
exports['test prepare() parameter binding'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
var retrieved = 0;
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10')
.get(function(err, row) {
if (err) throw err;
assert.equal(row.txt, 'String 10');
assert.equal(row.num, 10);
assert.equal(row.flt, 10 * Math.PI);
assert.equal(row.blb, null);
retrieved++;
describe('prepare() parameter binding', function() {
var db;
before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
var retrieved = 0;
it('should retrieve particular rows', function(done) {
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10')
.get(function(err, row) {
if (err) throw err;
assert.equal(row.txt, 'String 10');
assert.equal(row.num, 10);
assert.equal(row.flt, 10 * Math.PI);
assert.equal(row.blb, null);
retrieved++;
})
.finalize(done);
});
it('should have retrieved 1 row', function() {
assert.equal(1, retrieved, "Didn't retrieve all rows");
});
after(function(done) { db.close(done); });
});
beforeExit(function() {
assert.equal(1, retrieved, "Didn't retrieve all rows");
describe('all()', function() {
var db;
before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
var retrieved = 0;
var count = 1000;
it('should retrieve particular rows', function(done) {
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num", count)
.all(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++;
}
})
.finalize(done);
});
it('should have retrieved all rows', function() {
assert.equal(count, retrieved, "Didn't retrieve all rows");
});
after(function(done) { db.close(done); });
});
};
describe('all()', function() {
var db;
before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
exports['test get() parameter binding'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
it('should retrieve particular rows', function(done) {
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000")
.all(function(err, rows) {
if (err) throw err;
assert.ok(rows.length === 0);
})
.finalize(done);
});
var retrieved = 0;
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?")
.get(10, 'String 10', function(err, row) {
if (err) throw err;
assert.equal(row.txt, 'String 10');
assert.equal(row.num, 10);
assert.equal(row.flt, 10 * Math.PI);
assert.equal(row.blb, null);
retrieved++;
after(function(done) { db.close(done); });
});
beforeExit(function() {
assert.equal(1, retrieved, "Didn't retrieve all rows");
});
};
exports['test all()'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
var retrieved = 0;
var count = 1000;
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num", count)
.all(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++;
describe('high concurrency', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
function randomString() {
var str = '';
for (var i = Math.random() * 300; i > 0; i--) {
str += String.fromCharCode(Math.floor(Math.random() * 256));
}
return str;
}
});
beforeExit(function() {
assert.equal(count, retrieved, "Didn't retrieve all rows");
});
};
// Generate random data.
var data = [];
var length = Math.floor(Math.random() * 1000) + 200;
for (var i = 0; i < length; i++) {
data.push([ randomString(), i, i * Math.random(), null ]);
}
var inserted = 0;
var retrieved = 0;
it('should create the table', function(done) {
db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run().finalize(done);
});
exports['test all() parameter binding'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
it('should insert all values', function(done) {
for (var i = 0; i < data.length; i++) {
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
stmt.run(data[i][0], data[i][1], data[i][2], data[i][3], function(err) {
if (err) throw err;
inserted++;
}).finalize(function(err) {
if (err) throw err;
if (inserted == data.length) done();
});
}
});
var retrieved = 0;
var count = 1000;
it('should retrieve all values', function(done) {
db.prepare("SELECT txt, num, flt, blb FROM foo")
.all(function(err, rows) {
if (err) throw err;
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num")
.all(count, 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++;
}
});
for (var i = 0; i < rows.length; i++) {
assert.ok(data[rows[i].num] !== true);
beforeExit(function() {
assert.equal(count, retrieved, "Didn't retrieve all rows");
});
};
assert.equal(rows[i].txt, data[rows[i].num][0]);
assert.equal(rows[i].num, data[rows[i].num][1]);
assert.equal(rows[i].flt, data[rows[i].num][2]);
assert.equal(rows[i].blb, data[rows[i].num][3]);
exports['test all() without results'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
// Mark the data row as already retrieved.
data[rows[i].num] = true;
retrieved++;
var empty = false;
}
db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000")
.all(function(err, rows) {
if (err) throw err;
assert.ok(rows.length === 0);
empty = true;
});
assert.equal(retrieved, data.length);
assert.equal(retrieved, inserted);
})
.finalize(done);
});
beforeExit(function() {
assert.ok(empty, "Didn't retrieve an empty result set");
after(function(done) { db.close(done); });
});
};
exports['test high concurrency'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
function randomString() {
var str = '';
for (var i = Math.random() * 300; i > 0; i--) {
str += String.fromCharCode(Math.floor(Math.random() * 256));
}
return str;
};
// Generate random data.
var data = [];
var length = Math.floor(Math.random() * 1000) + 200;
for (var i = 0; i < length; i++) {
data.push([ randomString(), i, i * Math.random(), null ]);
}
var inserted = false;
var retrieved = 0;
Step(
function() {
db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run(this);
},
function(err) {
if (err) throw err;
var group = this.group();
for (var i = 0; i < data.length; i++) {
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
stmt.run(data[i][0], data[i][1], data[i][2], data[i][3], group());
}
},
function(err, result) {
if (err) throw err;
assert.ok(result.length === length, 'Invalid length');
inserted = true;
db.prepare("SELECT txt, num, flt, blb FROM foo")
.all(function(err, rows) {
if (err) throw err;
describe('test Database#get()', function() {
var db;
before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
for (var i = 0; i < rows.length; i++) {
assert.ok(data[rows[i].num] !== true);
var retrieved = 0;
assert.equal(rows[i].txt, data[rows[i].num][0]);
assert.equal(rows[i].num, data[rows[i].num][1]);
assert.equal(rows[i].flt, data[rows[i].num][2]);
assert.equal(rows[i].blb, data[rows[i].num][3]);
// Mark the data row as already retrieved.
data[rows[i].num] = true;
retrieved++;
}
it('should get a row', function(done) {
db.get("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10', function(err, row) {
if (err) throw err;
assert.equal(row.txt, 'String 10');
assert.equal(row.num, 10);
assert.equal(row.flt, 10 * Math.PI);
assert.equal(row.blb, null);
retrieved++;
done();
});
}
);
beforeExit(function() {
assert.ok(inserted);
});
};
});
exports['test Database#get()'] = function(beforeExit) {
var db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY);
it('should have retrieved all rows', function() {
assert.equal(1, retrieved, "Didn't retrieve all rows");
});
var retrieved = 0;
db.get("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10', function(err, row) {
if (err) throw err;
assert.equal(row.txt, 'String 10');
assert.equal(row.num, 10);
assert.equal(row.flt, 10 * Math.PI);
assert.equal(row.blb, null);
retrieved++;
after(function(done) { db.close(done); });
});
beforeExit(function() {
assert.equal(1, retrieved, "Didn't retrieve all rows");
});
};
describe('Database#run() and Database#all()', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
exports['test Database#run() and Database#all()'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
var inserted = 0;
var retrieved = 0;
var inserted = 0;
var retrieved = 0;
// We insert and retrieve that many rows.
var count = 1000;
// We insert and retrieve that many rows.
var count = 1000;
it('should create the table', function(done) {
db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)", done);
});
Step(
function() {
db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)", this);
},
function(err) {
if (err) throw err;
var group = this.group();
it('should insert ' + count + ' rows', function(done) {
for (var i = 0; i < count; i++) {
db.run("INSERT INTO foo VALUES(?, ?, ?, ?)",
'String ' + i,
i,
i * Math.PI,
// null (SQLite sets this implicitly)
group()
);
function(err) {
if (err) throw err;
inserted++;
if (inserted == count) done();
}
);
}
},
function(err, rows) {
if (err) throw err;
inserted += rows.length;
db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", this)
},
function(err, rows) {
if (err) throw err;
assert.equal(count, rows.length, "Couldn't retrieve all rows");
});
for (var i = 0; i < count; 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++;
}
}
);
it('should retrieve all rows', function(done) {
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++;
}
assert.equal(retrieved, count);
assert.equal(retrieved, inserted);
done();
});
});
beforeExit(function() {
assert.equal(count, inserted, "Didn't insert all rows");
assert.equal(count, retrieved, "Didn't retrieve all rows");
after(function(done) { db.close(done); });
});
};
});
test/profile.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
var util = require('util');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test Database profiling'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('profiling', function() {
var create = false;
var select = false;
db.on('profile', function(sql, nsecs) {
assert.ok(typeof nsecs === "number");
if (sql.match(/^SELECT/)) {
assert.ok(!select);
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);
}
var db;
before(function(done) {
db = new sqlite3.Database(':memory:', done);
db.on('profile', function(sql, nsecs) {
assert.ok(typeof nsecs === "number");
if (sql.match(/^SELECT/)) {
assert.ok(!select);
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.run("CREATE TABLE foo (id int)");
db.run("SELECT * FROM foo");
it('should profile a create table', function(done) {
assert.ok(!create);
db.run("CREATE TABLE foo (id int)", function(err) {
if (err) throw err;
process.nextTick(function() {
assert.ok(create);
done();
});
});
});
db.close();
beforeExit(function() {
assert.ok(create);
assert.ok(select);
it('should profile a select', function(done) {
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');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test running the same statement multiple times'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('rerunning statements', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
var count = 10;
var inserted = 0;
var retrieved = 0;
db.serialize(function() {
db.run("CREATE TABLE foo (id int)");
it('should create the table', function(done) {
db.run("CREATE TABLE foo (id int)", done);
});
var stmt = db.prepare("INSERT INTO foo VALUES(?)");
for (var i = 5; i < count; i++) {
stmt.run(i, function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize();
it('should insert repeatedly, reusing the same statement', function(done) {
var stmt = db.prepare("INSERT INTO foo VALUES(?)");
for (var i = 5; i < count; i++) {
stmt.run(i, function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize(done);
});
var collected = [];
var stmt = db.prepare("SELECT id FROM foo WHERE id = ?");
for (var i = 0; i < count; i++) {
stmt.get(i, function(err, row) {
if (err) throw err;
if (row) collected.push(row);
});
}
stmt.finalize(function() {
retrieved += collected.length;
assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]);
});
it('should retrieve repeatedly, resuing the same statement', function(done) {
var collected = [];
var stmt = db.prepare("SELECT id FROM foo WHERE id = ?");
for (var i = 0; i < count; i++) {
stmt.get(i, function(err, row) {
if (err) throw err;
if (row) collected.push(row);
});
}
stmt.finalize(function(err) {
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(retrieved, 5);
});
};
after(function(done) { db.close(done); });
});
test/scheduling.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
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) {
var error = false;
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)");
});
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) {
var error = false;
var errorEvent = false;
var db = new sqlite3.Database(':memory:');
db.on('error', function(err) {
errorEvent = true;
db.close();
db.run("CREATE TABLE foo (id int)", function(err) {
assert.ok(err.message, "SQLITE_MISUSE: Database handle is closed");
done();
});
});
db.close();
db.run("CREATE TABLE foo (id int)", function(err) {
assert.ok(err.message, "SQLITE_MISUSE: Database handle is closed");
error = true;
});
it('running a query after the database was closed', function(done) {
var db = new sqlite3.Database(':memory:');
beforeExit(function() {
assert.ok(error);
assert.ok(!errorEvent);
});
};
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();
});
});
var stmt = db.prepare("SELECT * FROM sqlite_master", function(err) {
if (err) throw err;
db.close(function(err) {
assert.ok(err);
assert.equal(err.message, "SQLITE_BUSY: unable to close due to unfinalised statements");
beforeExit(function() {
assert.ok(error);
// Running a statement now should not fail.
stmt.run(done);
});
});
});
};
});
test/serialization.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0);
exports['test serialize() and parallelize()'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('serialize() and parallelize()', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
var inserted1 = 0;
var inserted2 = 0;
......@@ -12,62 +12,33 @@ exports['test serialize() and parallelize()'] = function(beforeExit) {
var count = 1000;
db.serialize();
db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
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() {
it('should toggle', function(done) {
db.serialize();
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++) {
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;
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) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
......@@ -77,11 +48,57 @@ exports['test serialize(fn)'] = function(beforeExit) {
assert.equal(rows[i].blb, null);
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, 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 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) {
var db = new sqlite3.Database(':memory:');
var create = false;
var select = false;
db.on('trace', function(sql) {
if (sql.match(/^SELECT/)) {
assert.ok(!select);
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) {
if (sql.match(/^SELECT/)) {
assert.ok(!select);
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.run("CREATE TABLE foo (id int)");
db.run("SELECT * FROM foo");
});
db.serialize(function() {
db.run("CREATE TABLE foo (id int)");
db.run("SELECT * FROM foo");
db.close(function(err) {
if (err) throw err;
assert.ok(create);
assert.ok(select);
done();
});
});
db.close();
beforeExit(function() {
assert.ok(create);
assert.ok(select);
});
};
it('test disabling tracing #1', function(done) {
var db = new sqlite3.Database(':memory:');
exports['test disabling tracing #1'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
db.on('trace', function(sql) {});
db.removeAllListeners('trace');
db._events['trace'] = function(sql) {
assert.ok(false);
};
db.on('trace', function(sql) {});
db.removeAllListeners('trace');
db._events['trace'] = function(sql) {
assert.ok(false);
};
db.run("CREATE TABLE foo (id int)");
db.close(done);
});
db.run("CREATE TABLE foo (id int)");
db.close();
};
exports['test disabling tracing #2'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
it('test disabling tracing #2', function(done) {
var db = new sqlite3.Database(':memory:');
var trace = function(sql) {};
db.on('trace', trace);
db.removeListener('trace', trace);
db._events['trace'] = function(sql) {
assert.ok(false);
};
var trace = function(sql) {};
db.on('trace', trace);
db.removeListener('trace', trace);
db._events['trace'] = function(sql) {
assert.ok(false);
};
db.run("CREATE TABLE foo (id int)");
db.close();
};
db.run("CREATE TABLE foo (id int)");
db.close(done);
});
});
test/unicode.test.js
var sqlite3 = require('sqlite3');
var sqlite3 = require('..');
var assert = require('assert');
if (process.setMaxListeners) process.setMaxListeners(0);
function randomString() {
var str = '';
for (var i = Math.random() * 300; i > 0; i--) {
str += String.fromCharCode(Math.floor(Math.random() * 65536));
}
return str;
};
}
exports['test unicode characters'] = function(beforeExit) {
var db = new sqlite3.Database(':memory:');
describe('unicode', function() {
var db;
before(function(done) { db = new sqlite3.Database(':memory:', done); });
// Generate random data.
// Generate random data.
var data = [];
var length = Math.floor(Math.random() * 1000) + 200;
for (var i = 0; i < length; i++) {
......@@ -24,30 +23,37 @@ exports['test unicode characters'] = function(beforeExit) {
var inserted = 0;
var retrieved = 0;
db.serialize(function() {
db.run("CREATE TABLE foo (id int, txt text)");
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 0; i < data.length; i++) {
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) {
if (err) throw err;
for (var i = 0; i < rows.length; i++) {
assert.equal(rows[i].txt, data[i]);
retrieved++;
}
});
it('should create the table', function(done) {
db.run("CREATE TABLE foo (id int, txt text)", done);
});
it('should insert all values', function(done) {
var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
for (var i = 0; i < data.length; i++) {
stmt.run(i, data[i], function(err) {
if (err) throw err;
inserted++;
});
}
stmt.finalize(done);
});
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(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