mysqlsyncr 1.1.10 → 1.2.1

package/__tests__/parser2.test.js

@@ -1,153 +1,156 @@
-import { parseCreateTableSQL, parseDatabaseStructure } from '../src/parsers';
-
-
-
-describe('Create Table Parser', () => {
-
-    test('should correctly parse a valid create table statement. Check #1', () => {
-        const input = `CREATE TABLE \`Alarms\` (
-            \`alarmId\` int NOT NULL AUTO_INCREMENT,
-            \`alarmRuleId\` int NOT NULL,
-            \`alarmStatus\` int NOT NULL,
-            \`alarmStatus_Text\` varchar(50) NOT NULL,
-            \`alarmCreated_Date\` timestamp NULL DEFAULT NULL,
-            \`alarmConfirmed_Date\` timestamp NULL DEFAULT NULL,
-            \`alarmRecall_Date\` timestamp NULL DEFAULT NULL,
-            \`activeAlarm\` tinyint(1) NOT NULL DEFAULT '0',
-            \`emailSent\` tinyint(1) DEFAULT '0',
-            \`emailSent_AnswerPlus\` tinyint(1) DEFAULT '0',
-            \`ticketEmailSent\` tinyint(1) DEFAULT '0',
-            \`type\` varchar(45) DEFAULT NULL,
-            \`oorValue\` float(10,2) DEFAULT NULL,
-            \`thresholdValue\` float(10,2) DEFAULT NULL,
-            \`dateCreated\` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
-            \`dateUpdated\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-            PRIMARY KEY (\`alarmId\`),
-            UNIQUE KEY \`UniqueAlarmRules\` (\`alarmRuleId\`),
-            KEY \`idx_alarms_alarmruleid_alarmstatus\` (\`alarmRuleId\`, \`alarmStatus\`)
-          ) ENGINE=InnoDB AUTO_INCREMENT=117 DEFAULT CHARSET=latin1 COMMENT='Alarm table for alarms '`;
-          
-
-        const expectedOutput = {
-            "name": "Alarms",
-            "columns": [
-              {
-                "Field": "alarmId",
-                "Type": "int",
-                "NotNull": true,
-                "AutoIncrement": true
-              },
-              {
-                "Field": "alarmRuleId",
-                "Type": "int",
-                "NotNull": true
-              },
-              {
-                "Field": "alarmStatus",
-                "Type": "int",
-                "NotNull": true
-              },
-              {
-                "Field": "alarmStatus_Text",
-                "Type": "varchar(50)",
-                "NotNull": true
-              },
-              {
-                "Field": "alarmCreated_Date",
-                "Type": "timestamp",
-                "Default": "NULL"
-              },
-              {
-                "Field": "alarmConfirmed_Date",
-                "Type": "timestamp",
-                "Default": "NULL"
-              },
-              {
-                "Field": "alarmRecall_Date",
-                "Type": "timestamp",
-                "Default": "NULL"
-              },
-              {
-                "Field": "activeAlarm",
-                "Type": "tinyint(1)",
-                "NotNull": true,
-                "Default": "0"
-              },
-              {
-                "Field": "emailSent",
-                "Type": "tinyint(1)",
-                "Default": "0"
-              },
-              {
-                "Field": "emailSent_AnswerPlus",
-                "Type": "tinyint(1)",
-                "Default": "0"
-              },
-              {
-                "Field": "ticketEmailSent",
-                "Type": "tinyint(1)",
-                "Default": "0"
-              },
-              {
-                "Field": "type",
-                "Type": "varchar(45)",
-                "Default": "NULL"
-              },
-              {
-                "Field": "oorValue",
-                "Type": "float(10,2)"
-              },
-              {
-                "Field": "thresholdValue",
-                "Type": "float(10,2)"
-              },
-              {
-                "Field": "dateCreated",
-                "Type": "timestamp",
-                "Default": "CURRENT_TIMESTAMP"
-              },
-              {
-                "Field": "dateUpdated",
-                "Type": "timestamp",
-                "NotNull": true,
-                "Default": "CURRENT_TIMESTAMP"
-              }
-            ],
-            "indexes": [
-              {
-                "ColumnName": [
-                  "alarmId"
-                ],
-                "Primary": true,
-                "Name": "PRIMARY"
-              },
-              {
-                "ColumnName": [
-                  "alarmRuleId"
-                ],
-                "Unique": true,
-                "Name": "UniqueAlarmRules"
-              },
-              {
-                "ColumnName": [
-                  "alarmRuleId",
-                  "alarmStatus"
-                ],
-                "Name": "idx_alarms_alarmruleid_alarmstatus"
-              }
-            ],
-            "constraints": [],
-            "engine": null,
-            "charset": null,
-            "collate": null
-          }
-    
-        
-
-        const result = parseCreateTableSQL(input);
-        console.log('Result:', JSON.stringify(result, null, 2))
-        expect(result).toEqual(expectedOutput);
-    });
-
-
+import { parseCreateTableSQL, parseDatabaseStructure } from '../src/parsers';
+
+
+
+describe('Create Table Parser', () => {
+
+    test('should correctly parse a valid create table statement. Check #1', () => {
+        const input = `CREATE TABLE \`Alarms\` (
+            \`alarmId\` int NOT NULL AUTO_INCREMENT,
+            \`alarmRuleId\` int NOT NULL,
+            \`alarmStatus\` int NOT NULL,
+            \`alarmStatus_Text\` varchar(50) NOT NULL,
+            \`alarmCreated_Date\` timestamp NULL DEFAULT NULL,
+            \`alarmConfirmed_Date\` timestamp NULL DEFAULT NULL,
+            \`alarmRecall_Date\` timestamp NULL DEFAULT NULL,
+            \`activeAlarm\` tinyint(1) NOT NULL DEFAULT '0',
+            \`emailSent\` tinyint(1) DEFAULT '0',
+            \`emailSent_AnswerPlus\` tinyint(1) DEFAULT '0',
+            \`ticketEmailSent\` tinyint(1) DEFAULT '0',
+            \`type\` varchar(45) DEFAULT NULL,
+            \`oorValue\` float(10,2) DEFAULT NULL,
+            \`thresholdValue\` float(10,2) DEFAULT NULL,
+            \`dateCreated\` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
+            \`dateUpdated\` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+            PRIMARY KEY (\`alarmId\`),
+            UNIQUE KEY \`UniqueAlarmRules\` (\`alarmRuleId\`),
+            KEY \`idx_alarms_alarmruleid_alarmstatus\` (\`alarmRuleId\`, \`alarmStatus\`)
+          ) ENGINE=InnoDB AUTO_INCREMENT=117 DEFAULT CHARSET=latin1 COMMENT='Alarm table for alarms '`;
+          
+
+        const expectedOutput = {
+            "name": "Alarms",
+            "columns": [
+              {
+                "Field": "alarmId",
+                "Type": "int",
+                "NotNull": true,
+                "AutoIncrement": true
+              },
+              {
+                "Field": "alarmRuleId",
+                "Type": "int",
+                "NotNull": true
+              },
+              {
+                "Field": "alarmStatus",
+                "Type": "int",
+                "NotNull": true
+              },
+              {
+                "Field": "alarmStatus_Text",
+                "Type": "varchar(50)",
+                "NotNull": true
+              },
+              {
+                "Field": "alarmCreated_Date",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "alarmConfirmed_Date",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "alarmRecall_Date",
+                "Type": "timestamp",
+                "Default": "NULL"
+              },
+              {
+                "Field": "activeAlarm",
+                "Type": "tinyint(1)",
+                "NotNull": true,
+                "Default": "0"
+              },
+              {
+                "Field": "emailSent",
+                "Type": "tinyint(1)",
+                "Default": "0"
+              },
+              {
+                "Field": "emailSent_AnswerPlus",
+                "Type": "tinyint(1)",
+                "Default": "0"
+              },
+              {
+                "Field": "ticketEmailSent",
+                "Type": "tinyint(1)",
+                "Default": "0"
+              },
+              {
+                "Field": "type",
+                "Type": "varchar(45)",
+                "Default": "NULL"
+              },
+              {
+                "Field": "oorValue",
+                "Type": "float(10,2)",
+                "Default": "NULL"
+              },
+              {
+                "Field": "thresholdValue",
+                "Type": "float(10,2)",
+                "Default": "NULL"
+              },
+              {
+                "Field": "dateCreated",
+                "Type": "timestamp",
+                "Default": "CURRENT_TIMESTAMP"
+              },
+              {
+                "Field": "dateUpdated",
+                "Type": "timestamp",
+                "NotNull": true,
+                "Default": "CURRENT_TIMESTAMP",
+                "OnUpdate": "CURRENT_TIMESTAMP"
+              }
+            ],
+            "indexes": [
+              {
+                "ColumnName": [
+                  "alarmId"
+                ],
+                "Primary": true,
+                "Name": "PRIMARY"
+              },
+              {
+                "ColumnName": [
+                  "alarmRuleId"
+                ],
+                "Unique": true,
+                "Name": "UniqueAlarmRules"
+              },
+              {
+                "ColumnName": [
+                  "alarmRuleId",
+                  "alarmStatus"
+                ],
+                "Name": "idx_alarms_alarmruleid_alarmstatus"
+              }
+            ],
+            "constraints": [],
+            "engine": null,
+            "charset": null,
+            "collate": null
+          }
+    
+        
+
+        const result = parseCreateTableSQL(input);
+        console.log('Result:', JSON.stringify(result, null, 2))
+        expect(result).toEqual(expectedOutput);
+    });
+
+
 }); 

package/__tests__/paths.test.js

@@ -0,0 +1,21 @@
+import path from 'path';
+import { packageRoot, isInsidePackage, assertOutsidePackage } from '../src/paths';
+
+describe('package folder check', () => {
+    test('finds the package root', () => {
+        expect(path.basename(path.join(packageRoot, 'package.json'))).toBe('package.json');
+        expect(require(path.join(packageRoot, 'package.json')).name).toBe('mysqlsyncr');
+    });
+
+    test('the package folder and anything under it are inside', () => {
+        expect(isInsidePackage(packageRoot)).toBe(true);
+        expect(isInsidePackage(path.join(packageRoot, 'db-dump'))).toBe(true);
+        expect(() => assertOutsidePackage(path.join(packageRoot, 'src', 'x'))).toThrow('inside the mysqlsyncr package folder');
+    });
+
+    test('sibling and parent folders are outside', () => {
+        expect(isInsidePackage(path.join(packageRoot, '..', 'db-dump'))).toBe(false);
+        expect(isInsidePackage(packageRoot + '-dumps')).toBe(false);
+        expect(isInsidePackage(path.dirname(packageRoot))).toBe(false);
+    });
+});

package/__tests__/prompt.test.js

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { PassThrough } from 'stream';
+import { promptForOptions, promptForPassword } from '../src/prompt';
+
+const defaults = () => ({ host: 'localhost', port: 3306, user: 'root', password: undefined, database: null, output: '../db-dump', write: false });
+
+// A folder holding a one-database template, as compare/update/rebuild need
+const templateDir = () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mysqlsyncr-prompt-'));
+    fs.mkdirSync(path.join(dir, 'Alerts'));
+    fs.writeFileSync(path.join(dir, 'Alerts', 'Alerts.json'), '{"tables":{}}');
+    return dir;
+};
+
+// Answers the prompts one line at a time, each once its question has been written
+const answer = async (answers, ask) => {
+    const input = new PassThrough();
+    const output = new PassThrough();
+    let written = '';
+    let next = 0;
+    output.on('data', (chunk) => {
+        written += chunk.toString();
+        if (/[:)] $/.test(written) && next < answers.length) {
+            written = '';
+            const line = answers[next++];
+            setImmediate(() => input.write(`${line}\r`));
+        }
+    });
+    let transcript = '';
+    output.on('data', (chunk) => { transcript += chunk.toString(); });
+    const result = await ask({ input, output });
+    return { result, transcript };
+};
+
+const run = async (answers, argv = defaults()) => {
+    const { result, transcript } = await answer(answers, (streams) => promptForOptions(argv, streams));
+    return { command: result, argv, transcript };
+};
+
+describe('promptForOptions', () => {
+    test('compare: asks for the connection, keeping defaults for blank answers', async () => {
+        const dir = templateDir();
+        const { command, argv, transcript } = await run(['1', 'db.example', '', 'admin', 'secret', '', dir]);
+        expect(command).toBe('compare');
+        expect(argv).toMatchObject({ host: 'db.example', port: 3306, user: 'admin', password: 'secret', database: null, output: dir });
+        expect(transcript).not.toContain('secret');
+        expect(transcript).toContain('typing is hidden');
+    });
+
+    test('a blank password is no password', async () => {
+        const { argv } = await run(['compare', '', '', '', '', '', templateDir()]);
+        expect(argv.password).toBe('');
+    });
+
+    test('accepts the command name and a single database; dump may use a new folder', async () => {
+        const { command, argv } = await run(['dump', '', '', '', '', 'Alerts', '/new/dump/folder']);
+        expect(command).toBe('dump');
+        expect(argv).toMatchObject({ database: 'Alerts', output: '/new/dump/folder' });
+    });
+
+    test('update needs confirming', async () => {
+        expect((await run(['update', '', '', '', '', '', templateDir(), 'n'])).command).toBeNull();
+        expect((await run(['update', '', '', '', '', '', templateDir(), 'y'])).command).toBe('update');
+    });
+
+    test('rebuild asks only for the folder and whether to write', async () => {
+        const dir = templateDir();
+        const { command, argv } = await run(['5', dir, 'y']);
+        expect(command).toBe('rebuild');
+        expect(argv).toMatchObject({ output: dir, write: true, host: 'localhost' });
+    });
+
+    test('ui asks nothing else', async () => {
+        expect((await run(['ui'])).command).toBe('ui');
+    });
+});
+
+describe('folder checks', () => {
+    test('asks again until the folder is outside the package', async () => {
+        const dir = templateDir();
+        const { command, argv, transcript } = await run(['rebuild', './templates', '', dir, 'n']);
+        expect(command).toBe('rebuild');
+        expect(argv.output).toBe(dir);
+        expect(transcript).toContain('inside the mysqlsyncr package folder');
+    });
+
+    test('compare asks again when the folder is missing or has no template', async () => {
+        const dir = templateDir();
+        const empty = fs.mkdtempSync(path.join(os.tmpdir(), 'mysqlsyncr-empty-'));
+        const { argv, transcript } = await run(['compare', '', '', '', '', '', path.join(dir, 'missing'), empty, dir]);
+        expect(argv.output).toBe(dir);
+        expect(transcript).toContain("doesn't exist");
+        expect(transcript).toContain('has no template in it');
+    });
+});
+
+describe('promptForPassword', () => {
+    test('asks without echoing, naming the user and host', async () => {
+        const { result, transcript } = await answer(['hunter2'], (streams) => promptForPassword({ user: 'root', host: 'localhost' }, streams));
+        expect(result).toBe('hunter2');
+        expect(transcript).toContain('for root@localhost');
+        expect(transcript).not.toContain('hunter2');
+    });
+});