Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Fixed remaining method declarations #1633

Merged
merged 6 commits into from Sep 8, 2022
Merged

Fixed remaining method declarations #1633

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
243fc43
fix method declarations to conform with napi default for methods
alexanderfloh Oct 11, 2021
4269ca4
fixup! fix method declarations to conform with napi default for methods
alexanderfloh Oct 12, 2021
6aaa6b7
Merge branch 'TryGhost:master' into master
alexanderfloh May 20, 2022
ce50f92
Merge branch 'TryGhost:master' into master
alexanderfloh Sep 7, 2022
b8b7913
Follow-up to PR#1510: fix remaining method declarations.
alexanderfloh Sep 8, 2022
313d05d
fixup! Follow-up to PR#1510: fix remaining method declarations.
alexanderfloh Sep 8, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
7 changes: 5 additions & 2 deletions src/backup.cc
View file
Open in desktop
Expand Up @@ -10,9 +10,12 @@ using namespace node_sqlite3;
Napi::Object Backup::Init(Napi::Env env, Napi::Object exports) {
Napi::HandleScope scope(env);

// declare napi_default_method here as it is only available in Node v14.12.0+
napi_property_attributes napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);

Napi::Function t = DefineClass(env, "Backup", {
InstanceMethod("step", &Backup::Step),
InstanceMethod("finish", &Backup::Finish),
InstanceMethod("step", &Backup::Step, napi_default_method),
InstanceMethod("finish", &Backup::Finish, napi_default_method),
InstanceAccessor("idle", &Backup::IdleGetter, nullptr),
InstanceAccessor("completed", &Backup::CompletedGetter, nullptr),
InstanceAccessor("failed", &Backup::FailedGetter, nullptr),
Expand Down
17 changes: 10 additions & 7 deletions src/statement.cc
View file
Open in desktop
Expand Up @@ -11,14 +11,17 @@ using namespace node_sqlite3;
Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
Napi::HandleScope scope(env);

// declare napi_default_method here as it is only available in Node v14.12.0+
napi_property_attributes napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);

Napi::Function t = DefineClass(env, "Statement", {
InstanceMethod("bind", &Statement::Bind),
InstanceMethod("get", &Statement::Get),
InstanceMethod("run", &Statement::Run),
InstanceMethod("all", &Statement::All),
InstanceMethod("each", &Statement::Each),
InstanceMethod("reset", &Statement::Reset),
InstanceMethod("finalize", &Statement::Finalize_),
InstanceMethod("bind", &Statement::Bind, napi_default_method),
InstanceMethod("get", &Statement::Get, napi_default_method),
InstanceMethod("run", &Statement::Run, napi_default_method),
InstanceMethod("all", &Statement::All, napi_default_method),
InstanceMethod("each", &Statement::Each, napi_default_method),
InstanceMethod("reset", &Statement::Reset, napi_default_method),
InstanceMethod("finalize", &Statement::Finalize_, napi_default_method),
});

exports.Set("Statement", t);
Expand Down
226 changes: 168 additions & 58 deletions test/patching.test.js
View file
Open in desktop
Expand Up @@ -2,73 +2,183 @@ var sqlite3 = require('..');
var assert = require('assert');

describe('patching', function() {
var db;
var originalFunctions = {};
describe("Database", function() {
var db;
var originalFunctions = {};

before(function() {
originalFunctions.close = sqlite3.Database.prototype.close;
originalFunctions.exec = sqlite3.Database.prototype.exec;
originalFunctions.wait = sqlite3.Database.prototype.wait;
originalFunctions.loadExtension = sqlite3.Database.prototype.loadExtension;
originalFunctions.serialize = sqlite3.Database.prototype.serialize;
originalFunctions.parallelize = sqlite3.Database.prototype.parallelize;
originalFunctions.configure = sqlite3.Database.prototype.configure;
originalFunctions.interrupt = sqlite3.Database.prototype.interrupt;
});

it('allow patching native functions', function() {
var myFun = function myFunction() {
return "Success";
}

assert.doesNotThrow(() => {
sqlite3.Database.prototype.close = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.exec = myFun;
before(function() {
originalFunctions.close = sqlite3.Database.prototype.close;
originalFunctions.exec = sqlite3.Database.prototype.exec;
originalFunctions.wait = sqlite3.Database.prototype.wait;
originalFunctions.loadExtension = sqlite3.Database.prototype.loadExtension;
originalFunctions.serialize = sqlite3.Database.prototype.serialize;
originalFunctions.parallelize = sqlite3.Database.prototype.parallelize;
originalFunctions.configure = sqlite3.Database.prototype.configure;
originalFunctions.interrupt = sqlite3.Database.prototype.interrupt;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.wait = myFun;

it('allow patching native functions', function() {
var myFun = function myFunction() {
return "Success";
}

assert.doesNotThrow(() => {
sqlite3.Database.prototype.close = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.exec = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.wait = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.loadExtension = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.serialize = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.parallelize = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.configure = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.interrupt = myFun;
});

db = new sqlite3.Database(':memory:');
assert.strictEqual(db.close(), "Success");
assert.strictEqual(db.exec(), "Success");
assert.strictEqual(db.wait(), "Success");
assert.strictEqual(db.loadExtension(), "Success");
assert.strictEqual(db.serialize(), "Success");
assert.strictEqual(db.parallelize(), "Success");
assert.strictEqual(db.configure(), "Success");
assert.strictEqual(db.interrupt(), "Success");
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.loadExtension = myFun;

after(function() {
if(db != null) {
sqlite3.Database.prototype.close = originalFunctions.close;
sqlite3.Database.prototype.exec = originalFunctions.exec;
sqlite3.Database.prototype.wait = originalFunctions.wait;
sqlite3.Database.prototype.loadExtension = originalFunctions.loadExtension;
sqlite3.Database.prototype.serialize = originalFunctions.serialize;
sqlite3.Database.prototype.parallelize = originalFunctions.parallelize;
sqlite3.Database.prototype.configure = originalFunctions.configure;
sqlite3.Database.prototype.interrupt = originalFunctions.interrupt;
db.close();
}
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.serialize = myFun;
});

describe('Statement', function() {
var db;
var statement;
var originalFunctions = {};

before(function() {
originalFunctions.bind = sqlite3.Statement.prototype.bind;
originalFunctions.get = sqlite3.Statement.prototype.get;
originalFunctions.run = sqlite3.Statement.prototype.run;
originalFunctions.all = sqlite3.Statement.prototype.all;
originalFunctions.each = sqlite3.Statement.prototype.each;
originalFunctions.reset = sqlite3.Statement.prototype.reset;
originalFunctions.finalize = sqlite3.Statement.prototype.finalize;
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.parallelize = myFun;

it('allow patching native functions', function() {
var myFun = function myFunction() {
return "Success";
}

assert.doesNotThrow(() => {
sqlite3.Statement.prototype.bind = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Statement.prototype.get = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Statement.prototype.run = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Statement.prototype.all = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Statement.prototype.each = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Statement.prototype.reset = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Statement.prototype.finalize = myFun;
});

db = new sqlite3.Database(':memory:');
statement = db.prepare("");
assert.strictEqual(statement.bind(), "Success");
assert.strictEqual(statement.get(), "Success");
assert.strictEqual(statement.run(), "Success");
assert.strictEqual(statement.all(), "Success");
assert.strictEqual(statement.each(), "Success");
assert.strictEqual(statement.reset(), "Success");
assert.strictEqual(statement.finalize(), "Success");
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.configure = myFun;

after(function() {
if(statement != null) {
sqlite3.Statement.prototype.bind = originalFunctions.bind;
sqlite3.Statement.prototype.get = originalFunctions.get;
sqlite3.Statement.prototype.run = originalFunctions.run;
sqlite3.Statement.prototype.all = originalFunctions.all;
sqlite3.Statement.prototype.each = originalFunctions.each;
sqlite3.Statement.prototype.reset = originalFunctions.reset;
sqlite3.Statement.prototype.finalize = originalFunctions.finalize;
}
if(db != null) {
db.close();
}
});
assert.doesNotThrow(() => {
sqlite3.Database.prototype.interrupt = myFun;
});

describe('Backup', function() {
var db;
var backup;
var originalFunctions = {};

before(function() {
originalFunctions.step = sqlite3.Backup.prototype.step;
originalFunctions.finish = sqlite3.Backup.prototype.finish;
});

db = new sqlite3.Database(':memory:');
assert.strictEqual(db.close(), "Success");
assert.strictEqual(db.exec(), "Success");
assert.strictEqual(db.wait(), "Success");
assert.strictEqual(db.loadExtension(), "Success");
assert.strictEqual(db.serialize(), "Success");
assert.strictEqual(db.parallelize(), "Success");
assert.strictEqual(db.configure(), "Success");
assert.strictEqual(db.interrupt(), "Success");
});
it('allow patching native functions', function() {
var myFun = function myFunction() {
return "Success";
}

assert.doesNotThrow(() => {
sqlite3.Backup.prototype.step = myFun;
});
assert.doesNotThrow(() => {
sqlite3.Backup.prototype.finish = myFun;
});

after(function() {
if(db != null) {
sqlite3.Database.prototype.close = originalFunctions.close;
sqlite3.Database.prototype.exec = originalFunctions.exec;
sqlite3.Database.prototype.wait = originalFunctions.wait;
sqlite3.Database.prototype.loadExtension = originalFunctions.loadExtension;
sqlite3.Database.prototype.serialize = originalFunctions.serialize;
sqlite3.Database.prototype.parallelize = originalFunctions.parallelize;
sqlite3.Database.prototype.configure = originalFunctions.configure;
sqlite3.Database.prototype.interrupt = originalFunctions.interrupt;
db.close();
}
});
db = new sqlite3.Database(':memory:');
backup = db.backup("somefile", myFun);
assert.strictEqual(backup.step(), "Success");
assert.strictEqual(backup.finish(), "Success");
});

after(function() {
if(backup != null) {
sqlite3.Backup.prototype.step = originalFunctions.step;
sqlite3.Backup.prototype.finish = originalFunctions.finish;
backup.finish();
}
if(db != null) {
db.close();
}
});
});
});