joplin-plugin-backup 1.2.0 → 1.2.2

package/.github/workflows/buildAndTest.yml

@@ -0,0 +1,16 @@
+name: Build and test
+on: [push, pull_request]
+jobs:
+  buildAndTest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: "16"
+      - name: Install dependencies
+        run: npm install
+      - name: Build
+        run: npm run dist
+      - name: Run test
+        run: npm test

package/.husky/pre-push

@@ -1,4 +1,2 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
-
-npm test

package/__test__/backup.test.ts

@@ -298,6 +298,51 @@ describe("Backup", function () {
       expect(fs.existsSync(expected)).toBe(true);
     });
 
+    it(`retention = 1, folder exist with same files and folder`, async () => {
+      const emptyFolder = path.join(testPath.activeBackupJob, "emptyFolder");
+      const emptyFolderCheck = path.join(
+        testPath.backupBasePath,
+        "emptyFolder"
+      );
+      const folderNotes = path.join(testPath.activeBackupJob, "notes");
+      const folderNotesCheck = path.join(testPath.backupBasePath, "notes");
+      const file1 = path.join(folderNotes, "file.txt");
+      const file1Check = path.join(folderNotesCheck, "file.txt");
+      const file2 = path.join(testPath.activeBackupJob, "file.txt");
+      const file2Check = path.join(testPath.backupBasePath, "file.txt");
+      const file3Check = path.join(testPath.backupBasePath, "fileStay.txt");
+      const file4Check = path.join(folderNotesCheck, "fileNo.txt");
+      backup.backupBasePath = testPath.backupBasePath;
+      backup.activeBackupPath = testPath.activeBackupJob;
+
+      fs.emptyDirSync(testPath.backupBasePath);
+      fs.emptyDirSync(emptyFolderCheck);
+      fs.emptyDirSync(folderNotesCheck);
+      fs.writeFileSync(file1Check, "old file");
+      fs.writeFileSync(file2Check, "old file");
+      fs.writeFileSync(file3Check, "old file");
+      fs.writeFileSync(file4Check, "old file");
+
+      fs.emptyDirSync(testPath.activeBackupJob);
+      fs.emptyDirSync(emptyFolder);
+      fs.emptyDirSync(folderNotes);
+      fs.writeFileSync(file1, "new file");
+      fs.writeFileSync(file2, "new file");
+
+      backup.backupRetention = 1;
+
+      expect(await backup.moveFinishedBackup()).toBe(testPath.backupBasePath);
+      expect(fs.existsSync(folderNotes)).toBe(false);
+      expect(fs.existsSync(folderNotesCheck)).toBe(true);
+      expect(fs.existsSync(emptyFolderCheck)).toBe(true);
+      expect(fs.existsSync(file1Check)).toBe(true);
+      expect(fs.existsSync(file2Check)).toBe(true);
+      expect(fs.existsSync(file3Check)).toBe(true);
+      expect(fs.existsSync(file4Check)).toBe(false);
+      expect(backup.log.error).toHaveBeenCalledTimes(0);
+      expect(backup.log.warn).toHaveBeenCalledTimes(0);
+    });
+
     it(`retention > 1, file exist`, async () => {
       backup.backupBasePath = testPath.backupBasePath;
       backup.activeBackupPath = testPath.activeBackupJob;
@@ -483,9 +528,9 @@ describe("Backup", function () {
           backupRetention: 1,
           password: null,
           singleJex: true,
-          result: path.join(testPath.backupBasePath, "JoplinBackup.7z"),
+          result: path.join(testPath.backupBasePath),
           testFile: "testFile.txt",
-          checkFile: path.join(testPath.backupBasePath, "JoplinBackup.7z"),
+          checkFile: path.join(testPath.backupBasePath, "testFile.txt.7z"),
           saveBackupInfoCalled: 0,
         },
         {
@@ -493,9 +538,13 @@ describe("Backup", function () {
           backupRetention: 2,
           password: null,
           singleJex: true,
-          result: path.join(testPath.backupBasePath, "202101021630.7z"),
+          result: path.join(testPath.backupBasePath, "202101021630"),
           testFile: "testFile.txt",
-          checkFile: path.join(testPath.backupBasePath, "202101021630.7z"),
+          checkFile: path.join(
+            testPath.backupBasePath,
+            "202101021630",
+            "testFile.txt.7z"
+          ),
           saveBackupInfoCalled: 1,
         },
         {
@@ -756,86 +805,104 @@ describe("Backup", function () {
       expect(backup.log.transports.file.level).toBe("error");
     });
 
-    it(`move logfile`, async () => {
+    describe("move logfile", function () {
       const testCases = [
         {
+          description: "backupBasePath",
           zipArchive: "no",
           password: null,
           logDst: testPath.backupBasePath,
-          testLogFile: path.join(testPath.backupBasePath, "backup.log"),
         },
         {
+          description: "backupBasePath, password",
           zipArchive: "no",
-          password: null,
-          logDst: path.join(testPath.backupBasePath, "testDir"),
-          testLogFile: path.join(
-            testPath.backupBasePath,
-            "testDir",
-            "backup.log"
-          ),
+          password: "secret",
+          logDst: testPath.backupBasePath,
         },
         {
+          description: "backupBasePath, zip, password",
           zipArchive: "yes",
-          password: null,
-          logDst: path.join(testPath.backupBasePath, "testDir"),
-          testLogFile: path.join(
-            testPath.backupBasePath,
-            "testDir",
-            "backup.log"
-          ),
+          password: "secret",
+          logDst: testPath.backupBasePath,
         },
         {
+          description: "backupBasePath, zip one",
           zipArchive: "yesone",
           password: null,
-          logDst: path.join(testPath.backupBasePath, "Backup.7z"),
-          testLogFile: "backup.log",
+          logDst: path.join(testPath.backupBasePath, "retention.7z"),
         },
         {
+          description: "backupBasePath, zip one, password",
           zipArchive: "yesone",
           password: "secret",
-          logDst: path.join(testPath.backupBasePath, "Backup.7z"),
-          testLogFile: "backup.log",
+          logDst: path.join(testPath.backupBasePath, "retention.7z"),
+        },
+        {
+          description: "sub in backupBasePath",
+          zipArchive: "no",
+          password: null,
+          logDst: path.join(testPath.backupBasePath, "retentionfolder"),
         },
         {
+          description: "sub in backupBasePath, password",
           zipArchive: "no",
           password: "secret",
-          logDst: testPath.backupBasePath,
-          testLogFile: "backup.log",
+          logDst: path.join(testPath.backupBasePath, "retentionfolder"),
+        },
+        {
+          description: "sub in backupBasePath, zip",
+          zipArchive: "yes",
+          password: null,
+          logDst: path.join(testPath.backupBasePath, "retentionfolder"),
+        },
+        {
+          description: "sub in backupBasePath, password, zip",
+          zipArchive: "yes",
+          password: "secret",
+          logDst: path.join(testPath.backupBasePath, "retentionfolder"),
         },
       ];
 
-      backup.logFile = path.join(testPath.base, "test.log");
       for (const testCase of testCases) {
-        await createTestStructure();
-        if (testCase.zipArchive !== "yesone") {
-          fs.emptyDirSync(testCase.logDst);
-        }
-        if (testCase.zipArchive === "yesone") {
-          const dummyFile = path.join(testPath.base, "dummy");
-          fs.writeFileSync(dummyFile, "dummy");
-          await sevenZip.add(testCase.logDst, dummyFile, testCase.password);
-          expect(fs.existsSync(dummyFile)).toBe(true);
-          expect(fs.existsSync(testCase.logDst)).toBe(true);
-        }
-
-        fs.writeFileSync(backup.logFile, "log");
-
-        backup.zipArchive = testCase.zipArchive;
-        backup.password = testCase.password;
-
-        expect(fs.existsSync(backup.logFile)).toBe(true);
-        expect(await backup.moveLogFile(testCase.logDst)).toBe(true);
-        expect(fs.existsSync(backup.logFile)).toBe(false);
-
-        if (testCase.password !== null || testCase.zipArchive === "yesone") {
-          const fileList = await sevenZip.list(
-            testCase.logDst,
-            testCase.password
-          );
-          expect(fileList.map((f) => f.file)).toContain(testCase.testLogFile);
-        } else {
-          expect(fs.existsSync(testCase.testLogFile)).toBe(true);
-        }
+        it(`${testCase.description}`, async () => {
+          backup.logFile = path.join(testPath.base, "test.log");
+          backup.zipArchive = testCase.zipArchive;
+          backup.password = testCase.password;
+
+          await createTestStructure();
+
+          if (testCase.zipArchive === "yesone") {
+            const dummyFile = path.join(testPath.base, "dummy");
+            fs.writeFileSync(dummyFile, "dummy");
+            expect(fs.existsSync(dummyFile)).toBe(true);
+            await sevenZip.add(testCase.logDst, dummyFile, testCase.password);
+            expect(fs.existsSync(testCase.logDst)).toBe(true);
+          } else {
+            fs.emptyDirSync(testCase.logDst);
+          }
+
+          fs.writeFileSync(backup.logFile, "log");
+          expect(fs.existsSync(backup.logFile)).toBe(true);
+
+          expect(await backup.moveLogFile(testCase.logDst)).toBe(true);
+          expect(fs.existsSync(backup.logFile)).toBe(false);
+
+          let checkBackupLogFile = path.join(testCase.logDst, "backup.log");
+          if (testCase.zipArchive === "yesone") {
+            checkBackupLogFile = testCase.logDst;
+          } else if (testCase.password !== null) {
+            checkBackupLogFile = path.join(testCase.logDst, "backuplog.7z");
+          }
+          expect(fs.existsSync(checkBackupLogFile)).toBe(true);
+
+          if (testCase.password !== null || testCase.zipArchive === "yesone") {
+            const fileList = await sevenZip.list(
+              testCase.logDst,
+              testCase.password
+            );
+            expect(fileList.map((f) => f.file)).toContain("backup.log");
+          }
+        });
       }
     });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "joplin-plugin-backup",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "scripts": {
     "dist": "webpack --joplin-plugin-config buildMain && webpack --joplin-plugin-config buildExtraScripts && webpack --joplin-plugin-config createArchive",
     "prepare": "npm run dist && husky install",

package/publish/io.github.jackgruber.backup.json

@@ -2,7 +2,7 @@
 	"manifest_version": 1,
 	"id": "io.github.jackgruber.backup",
 	"app_min_version": "2.1.3",
-	"version": "1.2.0",
+	"version": "1.2.2",
 	"name": "Simple Backup",
 	"description": "Plugin to create manual and automatic backups.",
 	"author": "JackGruber",
@@ -16,6 +16,6 @@
 		"7zip",
 		"encrypted"
 	],
-	"_publish_hash": "sha256:5b9605100911c96c157853884f1fb8fc0e4374697f493dcbeb45fd09068e469d",
-	"_publish_commit": "master:1a5f98eef052081f501e9bcda2fd1f69f2dbeb04"
+	"_publish_hash": "sha256:ddc31c99405ef7aaa001b1dca7f52f57723975f8a7cdc2fc6f99f08c0ae0b6fb",
+	"_publish_commit": "master:84f2205b58043113c39f09d9c253bba260a11331"
 }