pogi 3.0.0-beta2 → 3.0.0-beta3

package/lib/test/pgServiceRestartTest.js

@@ -0,0 +1,1532 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const pgDb_1 = require("../pgDb");
+const yargs = require("yargs");
+const shell = require("shelljs");
+let argv = yargs
+    .usage('node pgServiceRestartTest.js\n Usage: $0')
+    .option('postgresOn', {
+    describe: 'the command line command which switches on the postgresql server',
+    type: "string"
+})
+    .option('postgresOff', {
+    describe: 'the command line command which switches off the postgresql server',
+    type: "string"
+})
+    .option('testParams', {
+    describe: 'check postgres Off & On params',
+    type: "boolean"
+})
+    .argv;
+function runCommand(command, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            shell.exec(command, { silent: options ? options.silent : true }, (code, stdout, stderr) => {
+                resolve({ stdout, stderr });
+            });
+        });
+    });
+}
+function asyncWaitMs(ms) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield new Promise(r => setTimeout(r, ms));
+    });
+}
+function syncWaitMs(ms) {
+    let origDate = +new Date();
+    let actDate = origDate;
+    while (origDate + ms > actDate) {
+        actDate = +new Date();
+    }
+}
+function postgresOff() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        console.log('Kill postgres server.');
+        yield runCommand(argv.postgresOff);
+    });
+}
+function postgresOn() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        console.log('Start postgres server.');
+        yield runCommand(argv.postgresOn);
+        yield asyncWaitMs(500);
+    });
+}
+const poolSize = 3;
+function testSchemaClear(db) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield db.run(`drop table if exists pgdb_test.names`);
+        yield db.run(`DROP TYPE IF EXISTS pgdb_test.mood CASCADE`);
+        yield db.run(`DROP TABLE IF EXISTS pgdb_test."enumArrayTable"`);
+    });
+}
+function testSchemaInit(db) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield testSchemaClear(db);
+        yield db.run(`create table pgdb_test.names (name varchar null)`);
+        yield db.run(`insert into pgdb_test.names (name) values ('Kuka'), ('Hapci')`);
+        yield db.run(`CREATE TYPE pgdb_test.mood AS ENUM('sad', 'ok', 'happy')`);
+        yield db.run(`CREATE TABLE pgdb_test."enumArrayTable"(m pgdb_test.mood[] NULL)`);
+        yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values (ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood])`);
+    });
+}
+function testDbFreeConnections(db) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let dedicatedConnections = new Array(poolSize).fill(null);
+        yield Promise.race([
+            asyncWaitMs(1000),
+            (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                for (let i = 0; i < dedicatedConnections.length; ++i) {
+                    dedicatedConnections[i] = yield db.dedicatedConnectionBegin();
+                }
+            }))()
+        ]);
+        if (dedicatedConnections.some(v => !v)) {
+            return new Error('Some of the connections are not free!');
+        }
+        for (let conn of dedicatedConnections) {
+            yield conn.dedicatedConnectionEnd();
+        }
+        return null;
+    });
+}
+function testInsertQuery(db) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let tableContents = yield db.query(`select * from pgdb_test.names`);
+        if (tableContents.length != 2) {
+            return new Error('Simple query fails');
+        }
+        let callbackCounter1 = 0;
+        yield db.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => {
+            ++callbackCounter1;
+        });
+        if (callbackCounter1 != 2) {
+            return new Error('Query with cursor callback fails');
+        }
+        let callbackCounter2 = 0;
+        let stream = yield db.queryAsStream(`select * from pgdb_test.names`);
+        yield new Promise((resolve, reject) => {
+            stream.on("data", (data) => {
+                ++callbackCounter2;
+            });
+            stream.on('error', reject);
+            stream.on('close', resolve);
+        });
+        if (callbackCounter2 != 2) {
+            return new Error('Query as stream fails');
+        }
+        return null;
+    });
+}
+function testNotificationSystem(db) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let result;
+        yield db.listen('testChannel', (data) => { result = data.payload; });
+        yield db.notify('testChannel', 'newData');
+        yield asyncWaitMs(1000);
+        if (result != 'newData') {
+            return new Error('Notification not working...');
+        }
+        yield db.unlisten('testChannel');
+    });
+}
+function testDbUsability(db) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log('TestSchemaInit');
+            yield testSchemaInit(db);
+            console.log('TestFreeConnections');
+            let error = yield testDbFreeConnections(db);
+            if (!error) {
+                console.log('TestInsertQueries');
+                error = yield testInsertQuery(db);
+            }
+            if (!error) {
+                console.log('TestNotifications');
+                error = yield testNotificationSystem(db);
+            }
+            yield testSchemaClear(db);
+            return error;
+        }
+        catch (e) {
+            return e;
+        }
+    });
+}
+function runTestInternal(db, test) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        let callCounter = 0;
+        let errorResult = null;
+        try {
+            yield test.fn(db, (value) => {
+                ++callCounter;
+                if (!value && !errorResult) {
+                    errorResult = new Error(`Error in test at the ${callCounter}. call.`);
+                }
+            });
+        }
+        catch (err) {
+            if (!errorResult) {
+                errorResult = err;
+            }
+        }
+        yield postgresOn();
+        if (!errorResult && !test.skipTestDb) {
+            errorResult = yield testDbUsability(db);
+        }
+        return errorResult;
+    });
+}
+let actTestCounter = 0;
+let errorMessages = [];
+function runTest(allTestCount, test) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        ++actTestCounter;
+        console.log('====================================================================================');
+        console.log(`${actTestCounter}/${allTestCount} Test starting: "${test.name}"`);
+        console.log('====================================================================================');
+        yield postgresOn();
+        let db = yield pgDb_1.PgDb.connect({
+            poolSize,
+            logger: {
+                log: console.log,
+                error: console.error
+            }
+        });
+        yield testSchemaInit(db);
+        let error = yield runTestInternal(db, test);
+        if (error) {
+            errorMessages.push({ testName: test.name, err: error });
+        }
+        yield db.close();
+        console.log('====================================================================================');
+        if (error) {
+            console.log(`${actTestCounter}/${allTestCount} Test errored: "${test.name}"`);
+        }
+        else {
+            console.log(`${actTestCounter}/${allTestCount} Test passed: "${test.name}"`);
+        }
+        console.log('====================================================================================');
+    });
+}
+let newConnectionTests = [
+    {
+        name: 'simple query 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield postgresOff();
+            try {
+                yield db.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'simple query 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield postgresOff();
+            try {
+                yield db.query(`select * from pgdb_test."enumArrayTable"`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db.query(`select * from pgdb_test."enumArrayTable"`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'queryWithCallback 1 - postgresOff before call',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield postgresOff();
+            try {
+                yield db.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, () => {
+                    isTrue(false);
+                });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'queryWithCallback 2 - postgresOff between calls',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let i = 0;
+            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                try {
+                    yield db.queryWithOnCursorCallback('select * from pgdb_test.names', {}, {}, (data) => {
+                        syncWaitMs(20);
+                        ++i;
+                        if (i % 10 == 0) {
+                            console.log('Record:', i);
+                        }
+                    });
+                    isTrue(false);
+                }
+                catch (e) {
+                    ++stageCounter;
+                }
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                console.log('Wait before postgres off...');
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            yield Promise.all([fn1(), fn2()]);
+            isTrue(i > 0 && i < 2000);
+            isTrue(stageCounter == 1);
+        }),
+    },
+    {
+        name: 'queryWithCallback 3 - postgresOff between calls, unknown oid',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let i = 0;
+            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                try {
+                    yield db.queryWithOnCursorCallback('select * from pgdb_test."enumArrayTable"', {}, {}, (data) => {
+                        syncWaitMs(20);
+                        ++i;
+                        if (i % 10 == 0) {
+                            console.log('Record:', i);
+                        }
+                    });
+                    isTrue(false);
+                }
+                catch (e) {
+                    ++stageCounter;
+                }
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                console.log('Wait before postgres off...');
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            yield Promise.all([fn1(), fn2()]);
+            isTrue(i > 0 && i < 2000);
+            isTrue(stageCounter == 1);
+        }),
+    },
+    {
+        name: 'queryAsStream 1 - postgresOff before call',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield postgresOff();
+            try {
+                let stream = yield db.queryAsStream(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'queryAsStream 2 - postgresOff between calls',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let stream = yield db.queryAsStream('select * from pgdb_test.names');
+            let i = 0;
+            let promise1 = new Promise((resolve, reject) => {
+                stream.on("data", (data) => {
+                    syncWaitMs(20);
+                    ++i;
+                    if (i % 10 == 0) {
+                        console.log(data.name);
+                    }
+                });
+                stream.on('error', (...params) => {
+                    ++stageCounter;
+                    reject(...params);
+                });
+                stream.on('close', resolve);
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            try {
+                yield Promise.all([promise1, fn2()]);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(i > 0 && i < 2000);
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'queryAsStream 3 - postgresOff between calls, unknown oid',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let stream = yield db.queryAsStream('select * from pgdb_test."enumArrayTable"');
+            let i = 0;
+            let promise1 = new Promise((resolve, reject) => {
+                stream.on("data", (data) => {
+                    syncWaitMs(20);
+                    ++i;
+                    if (i % 10 == 0) {
+                        console.log(data.name);
+                    }
+                });
+                stream.on('error', (...params) => {
+                    ++stageCounter;
+                    reject(...params);
+                });
+                stream.on('close', resolve);
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            try {
+                yield Promise.all([promise1, fn2()]);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(i == 0);
+            isTrue(stageCounter == 2);
+            yield postgresOff();
+        })
+    },
+];
+let dedicatedConnection_SimpleQueryTests = [
+    {
+        name: 'dedicated connection - empty 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield postgresOff();
+            try {
+                let db0 = yield db.dedicatedConnectionBegin();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'dedicated connection - empty 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'dedicated connection - simple query 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'dedicated connection - simple query 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'dedicated connection - simple query 3',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield db0.run(`truncate pgdb_test.names`);
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result[0].name == 'Morgo');
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'dedicated connection - simple query 4',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield db0.run(`truncate pgdb_test.names`);
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result[0].name == 'Morgo');
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'dedicated connection - simple query 5',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield db0.run(`truncate pgdb_test.names`);
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result[0].name == 'Morgo');
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'dedicated connection - simple query 6',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield db0.run(`truncate pgdb_test.names`);
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result[0].name == 'Morgo');
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'transaction - simple query 7',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result.length == 0);
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'transaction - simple query 8',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            try {
+                yield db0.transactionCommit();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result.length == 0);
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'transaction - simple query 9',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db0.transactionCommit();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result.length == 0);
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'transaction - simple query 10',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result.length == 0);
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'transaction - simple query 11',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.transactionCommit();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            let result = yield db.query(`select * from pgdb_test.names`);
+            isTrue(result.length == 0);
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'transaction - rollback 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield postgresOff();
+            try {
+                yield db0.transactionRollback();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'transaction - rollback 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+            yield postgresOff();
+            try {
+                yield db0.transactionRollback();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'transaction - rollback 3',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield postgresOff();
+            try {
+                yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db0.transactionRollback();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'transaction - rollback 4',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield db.run(`truncate pgdb_test.names`);
+            let db0 = yield db.transactionBegin();
+            yield postgresOff();
+            try {
+                yield db0.run(`insert into pgdb_test.names (name) values ('Morgo')`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            yield postgresOn();
+            try {
+                yield db0.transactionRollback();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 2);
+        })
+    }
+];
+let dedicatedConnection_StreamQueryTests = [
+    {
+        name: 'dedicated connection queryWithCallback - 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            let i = 0;
+            try {
+                yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(i == 0);
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'dedicated connection queryWithCallback - 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            let i = 0;
+            try {
+                yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            isTrue(i == 0);
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'dedicated connection queryWithCallback - 3',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            let i = 0;
+            try {
+                yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => { ++i; });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(i == 0);
+            isTrue(stageCounter == 2);
+        })
+    },
+    {
+        name: 'dedicated connection queryWithCallback 4 - postgresOff between calls',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let db0 = yield db.dedicatedConnectionBegin();
+            let i = 0;
+            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                try {
+                    yield db0.queryWithOnCursorCallback('select * from pgdb_test.names', {}, {}, (data) => {
+                        syncWaitMs(20);
+                        ++i;
+                        if (i % 10 == 0) {
+                            console.log('Record:', i);
+                        }
+                    });
+                    isTrue(false);
+                }
+                catch (e) {
+                    ++stageCounter;
+                }
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                console.log('Wait before postgres off...');
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            yield Promise.all([fn1(), fn2()]);
+            isTrue(i > 0 && i < 2000);
+            isTrue(stageCounter == 1);
+        }),
+    },
+    {
+        name: 'dedicated connection queryWithCallback 5 - postgresOff between calls, unknown oid',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let db0 = yield db.dedicatedConnectionBegin();
+            let i = 0;
+            let fn1 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                try {
+                    yield db0.queryWithOnCursorCallback('select * from pgdb_test."enumArrayTable"', {}, {}, (data) => {
+                        syncWaitMs(20);
+                        ++i;
+                        if (i % 10 == 0) {
+                            console.log('Record:', i);
+                        }
+                    });
+                    isTrue(false);
+                }
+                catch (e) {
+                    ++stageCounter;
+                }
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                console.log('Wait before postgres off...');
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            yield Promise.all([fn1(), fn2()]);
+            isTrue(i > 0 && i < 2000);
+            isTrue(stageCounter == 1);
+        }),
+    },
+    {
+        name: 'dedicated connection queryAsStream - 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            let stream;
+            try {
+                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            try {
+                yield new Promise((resolve, reject) => {
+                    stream.on("data", (data) => {
+                        isTrue(false);
+                    });
+                    stream.on('error', (...params) => {
+                        ++stageCounter;
+                        reject(...params);
+                    });
+                    stream.on('close', resolve);
+                });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 3);
+        })
+    },
+    {
+        name: 'dedicated connection queryAsStream - 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            let stream;
+            try {
+                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            try {
+                yield new Promise((resolve, reject) => {
+                    stream.on("data", (data) => {
+                        isTrue(false);
+                    });
+                    stream.on('error', (...params) => {
+                        ++stageCounter;
+                        reject(...params);
+                    });
+                    stream.on('close', resolve);
+                });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            isTrue(stageCounter == 4);
+        })
+    },
+    {
+        name: 'dedicated connection queryAsStream - 3',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            try {
+                yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            let stream;
+            try {
+                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            try {
+                yield new Promise((resolve, reject) => {
+                    stream.on("data", (data) => {
+                        isTrue(false);
+                    });
+                    stream.on('error', (...params) => {
+                        ++stageCounter;
+                        reject(...params);
+                    });
+                    stream.on('close', resolve);
+                });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 4);
+        })
+    },
+    {
+        name: 'dedicated connection queryAsStream 4 - postgresOff between calls',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v, i) => `'Smith${i}'`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test.names(name) values ${params}`);
+            let db0 = yield db.dedicatedConnectionBegin();
+            let stream = yield db0.queryAsStream('select * from pgdb_test.names');
+            let i = 0;
+            let promise1 = new Promise((resolve, reject) => {
+                stream.on("data", (data) => {
+                    syncWaitMs(20);
+                    ++i;
+                    if (i % 10 == 0) {
+                        console.log(data.name);
+                    }
+                });
+                stream.on('error', (...params) => {
+                    ++stageCounter;
+                    reject(...params);
+                });
+                stream.on('close', resolve);
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            try {
+                yield Promise.all([promise1, fn2()]);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(i > 0 && i < 2000);
+            isTrue(stageCounter == 2);
+        }),
+    },
+    {
+        name: 'dedicated connection queryAsStream 5 - postgresOff between calls, unknown oid',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let params = new Array(2000).fill(null).map((v) => `ARRAY['sad'::pgdb_test.mood, 'happy'::pgdb_test.mood]`).map(v => `(${v})`).join(', ');
+            yield db.run(`INSERT INTO pgdb_test."enumArrayTable"(m) values ${params}`);
+            let db0 = yield db.dedicatedConnectionBegin();
+            let stream = yield db0.queryAsStream('select * from pgdb_test."enumArrayTable"');
+            let i = 0;
+            let promise1 = new Promise((resolve, reject) => {
+                stream.on("data", (data) => {
+                    syncWaitMs(20);
+                    ++i;
+                    if (i % 10 == 0) {
+                        console.log(data.name);
+                    }
+                });
+                stream.on('error', (...params) => {
+                    ++stageCounter;
+                    reject(...params);
+                });
+                stream.on('close', resolve);
+            });
+            let fn2 = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+                yield asyncWaitMs(100);
+                yield postgresOff();
+            });
+            try {
+                yield Promise.all([promise1, fn2()]);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(i == 0);
+            isTrue(stageCounter == 2);
+            yield postgresOff();
+        }),
+    }
+];
+let postgresRestartTests = [
+    {
+        name: 'postgres restart 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            yield postgresOn();
+            try {
+                yield db0.dedicatedConnectionEnd();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'postgres restart 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.transactionBegin();
+            yield postgresOff();
+            yield postgresOn();
+            try {
+                yield db0.transactionRollback();
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'postgres restart 3',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            yield postgresOn();
+            try {
+                let result = yield db0.query(`select * from pgdb_test.names`);
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'postgres restart 4',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            yield postgresOn();
+            try {
+                let result = yield db0.queryWithOnCursorCallback(`select * from pgdb_test.names`, {}, {}, (data) => {
+                    isTrue(false);
+                });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'postgres restart 5',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            yield postgresOn();
+            let stream;
+            try {
+                stream = yield db0.queryAsStream(`select * from pgdb_test.names`);
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            try {
+                yield new Promise((resolve, reject) => {
+                    stream.on("data", (data) => {
+                        isTrue(false);
+                    });
+                    stream.on('error', (...params) => {
+                        ++stageCounter;
+                        reject(...params);
+                    });
+                    stream.on('close', resolve);
+                });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 3);
+        })
+    },
+];
+let postgresEndTests = [
+    {
+        name: 'postgres end 1',
+        skipTestDb: true,
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield postgresOff();
+            try {
+                yield db.close();
+                ++stageCounter;
+            }
+            catch (e) {
+                isTrue(false);
+            }
+            isTrue(stageCounter == 1);
+        })
+    }
+];
+let notifyTests = [
+    {
+        name: 'notification 1',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let stageCounter = 0;
+            yield postgresOff();
+            try {
+                yield db.listen('newChannel', (notif) => { });
+                isTrue(false);
+            }
+            catch (e) {
+                ++stageCounter;
+            }
+            isTrue(stageCounter == 1);
+        })
+    },
+    {
+        name: 'notification 2',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            yield db.listen('newChannel', (notif) => { });
+            yield postgresOff();
+            yield postgresOn();
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 3',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let result;
+            yield db.listen('newChannel', (notif) => { result = notif.payload; });
+            yield postgresOff();
+            yield postgresOn();
+            yield db.notify('newChannel', 'newValue');
+            yield asyncWaitMs(1000);
+            isTrue(result == 'newValue');
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 4',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let result;
+            yield db.listen('newChannel', (notif) => { result = notif.payload; });
+            yield postgresOff();
+            yield postgresOn();
+            yield db.run(`notify "newChannel", 'newValue'`);
+            yield asyncWaitMs(1000);
+            isTrue(result == 'newValue');
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 5',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let result;
+            yield db.listen('newChannel', (notif) => { result = notif.payload; });
+            yield postgresOff();
+            yield postgresOn();
+            let db0 = yield db.dedicatedConnectionBegin();
+            yield db0.run(`notify "newChannel", 'newValue'`);
+            yield asyncWaitMs(1000);
+            isTrue(result == 'newValue');
+            yield db.unlisten('newChannel');
+            yield db0.dedicatedConnectionEnd();
+        })
+    },
+    {
+        name: 'notification 6',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let i = 0;
+            let fn1 = (notif) => { i += +notif.payload; };
+            let fn2 = (notif) => { i += 2 * (+notif.payload); };
+            yield db.listen('newChannel', fn1);
+            yield postgresOff();
+            yield db.listen('newChannel', fn2);
+            yield postgresOn();
+            yield db.notify('newChannel', '1');
+            yield asyncWaitMs(1000);
+            isTrue(i == 3);
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 7',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let i = 0;
+            let fn1 = (notif) => { i += +notif.payload; };
+            let fn2 = (notif) => { i += 2 * (+notif.payload); };
+            yield db.listen('newChannel', fn1);
+            yield postgresOff();
+            yield db.listen('newChannel', fn2);
+            yield db.unlisten('newChannel', fn1);
+            yield postgresOn();
+            yield db.notify('newChannel', '1');
+            yield asyncWaitMs(1000);
+            isTrue(i == 2);
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 8',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let i = 0;
+            let j = 0;
+            let fn1 = (notif) => { i += +notif.payload; };
+            let fn2 = (notif) => { j += +notif.payload; };
+            yield db.listen('newChannel', fn1);
+            yield postgresOff();
+            try {
+                yield db.listen('newChannel2', fn2);
+                isTrue(false);
+            }
+            catch (e) {
+            }
+            yield postgresOn();
+            yield db.notify('newChannel', '1');
+            yield db.notify('newChannel2', '1');
+            yield asyncWaitMs(1000);
+            isTrue(i == 1);
+            isTrue(j == 0);
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 9',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let i = 0;
+            let fn1 = (notif) => { i += +notif.payload; };
+            yield db.listen('newChannel', fn1);
+            yield postgresOff();
+            try {
+                yield db.unlisten('newChannel', fn1);
+                isTrue(false);
+            }
+            catch (e) {
+            }
+            yield postgresOn();
+            yield db.notify('newChannel', '1');
+            yield asyncWaitMs(1000);
+            isTrue(i == 1);
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 10',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let i = 0;
+            let fn1 = (notif) => { i += +notif.payload; };
+            yield db.listen('newChannel', fn1);
+            yield postgresOff();
+            try {
+                yield db.unlisten('newChannel');
+                isTrue(false);
+            }
+            catch (e) {
+            }
+            yield postgresOn();
+            yield db.notify('newChannel', '1');
+            yield asyncWaitMs(1000);
+            isTrue(i == 1);
+            yield db.unlisten('newChannel');
+        })
+    },
+    {
+        name: 'notification 11 - automatic notification restart...',
+        fn: (db, isTrue) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let i = 0;
+            let fn1 = (notif) => { i += +notif.payload; };
+            yield db.listen('newChannel', fn1);
+            yield postgresOff();
+            yield postgresOn();
+            yield asyncWaitMs(3000);
+            let db2 = yield pgDb_1.PgDb.connect({});
+            yield db2.notify('newChannel', '1');
+            yield db2.close();
+            yield asyncWaitMs(1000);
+            isTrue(i == 1);
+            yield db.unlisten('newChannel');
+        })
+    }
+];
+function testParams() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        console.log('Start testing params');
+        let postgresOnCommandOk = true;
+        let postgresOffCommandOk = false;
+        let frameworkError = false;
+        try {
+            console.log('Postgres On test');
+            yield postgresOn();
+            try {
+                let db = yield pgDb_1.PgDb.connect({});
+            }
+            catch (e) {
+                postgresOnCommandOk = false;
+            }
+            console.log('Postgres Off test');
+            yield postgresOff();
+            try {
+                let db = yield pgDb_1.PgDb.connect({});
+            }
+            catch (e) {
+                postgresOffCommandOk = postgresOnCommandOk;
+            }
+            console.log('Postgres On test');
+            yield postgresOn();
+            try {
+                let db = yield pgDb_1.PgDb.connect({});
+            }
+            catch (e) {
+                postgresOnCommandOk = false;
+            }
+        }
+        catch (e) {
+            console.log('Unknown exception has found', e);
+            frameworkError = true;
+        }
+        if (!frameworkError) {
+            if (postgresOffCommandOk && postgresOnCommandOk) {
+                console.log('Postgres On/Off commands OK');
+            }
+            else {
+                if (!postgresOnCommandOk) {
+                    console.log('Postgres On command NOT OK');
+                }
+                if (!postgresOffCommandOk) {
+                    console.log('Postgres Off command NOT OK');
+                }
+            }
+        }
+        console.log('Postgres On/Off test end');
+    });
+}
+function runTests() {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        console.log('Start tests');
+        let allTests = [
+            ...newConnectionTests,
+            ...dedicatedConnection_SimpleQueryTests,
+            ...dedicatedConnection_StreamQueryTests,
+            ...postgresRestartTests,
+            ...notifyTests,
+            ...postgresEndTests
+        ];
+        let testNamePrefix = '';
+        try {
+            if (testNamePrefix) {
+                allTests = allTests.filter(v => v.name.startsWith(testNamePrefix));
+            }
+            for (let test of allTests) {
+                yield runTest(allTests.length, test);
+            }
+            console.log('All tests: ', actTestCounter);
+            console.log(`Problematic tests: ${errorMessages.length}`);
+            for (let errorMessage of errorMessages) {
+                console.log(`Error in "${errorMessage.testName}"`);
+                console.log(errorMessage.err);
+            }
+        }
+        catch (e) {
+            console.log('Error has found in the test framework!');
+            console.log(e);
+        }
+        console.log('All tests are finished');
+    });
+}
+(() => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (!argv.postgresOn || !argv.postgresOff) {
+        console.log('postgresOn or postgresOff parameter is missing!');
+        return;
+    }
+    if (argv.testParams) {
+        yield testParams();
+    }
+    else {
+        yield runTests();
+    }
+}))().catch(console.log);
+//# sourceMappingURL=pgServiceRestartTest.js.map