Enforce semicolons in eslint

Signed-off-by: Panu Horsmalahti <phorsmalahti@mirantis.com>

src/common/__tests__/cluster-store.test.ts

@@ -5,9 +5,9 @@ import { Cluster } from "../../main/cluster";
 import { ClusterStore } from "../cluster-store";
 import { workspaceStore } from "../workspace-store";
 
-const testDataIcon = fs.readFileSync("test-data/cluster-store-migration-icon.png")
+const testDataIcon = fs.readFileSync("test-data/cluster-store-migration-icon.png");
 
-console.log("") // fix bug
+console.log(""); // fix bug
 
 let clusterStore: ClusterStore;
 
@@ -18,15 +18,15 @@ describe("empty config", () => {
       'tmp': {
         'lens-cluster-store.json': JSON.stringify({})
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   describe("with foo cluster added", () => {
     beforeEach(() => {
@@ -43,30 +43,30 @@ describe("empty config", () => {
           workspace: workspaceStore.currentWorkspaceId
         })
       );
-    })
+    });
 
     it("adds new cluster to store", async () => {
       const storedCluster = clusterStore.getById("foo");
       expect(storedCluster.id).toBe("foo");
       expect(storedCluster.preferences.terminalCWD).toBe("/tmp");
       expect(storedCluster.preferences.icon).toBe("data:image/jpeg;base64, iVBORw0KGgoAAAANSUhEUgAAA1wAAAKoCAYAAABjkf5");
-    })
+    });
 
     it("adds cluster to default workspace", () => {
       const storedCluster = clusterStore.getById("foo");
       expect(storedCluster.workspace).toBe("default");
-    })
+    });
 
     it("removes cluster from store", async () => {
       await clusterStore.removeById("foo");
       expect(clusterStore.getById("foo")).toBeUndefined();
-    })
+    });
 
     it("sets active cluster", () => {
       clusterStore.setActive("foo");
       expect(clusterStore.active.id).toBe("foo");
-    })
-  })
+    });
+  });
 
   describe("with prod and dev clusters added", () => {
     beforeEach(() => {
@@ -89,8 +89,8 @@ describe("empty config", () => {
           kubeConfigPath: ClusterStore.embedCustomKubeConfig("dev", "fancy config"),
           workspace: "workstation"
         })
-      )
-    })
+      );
+    });
 
     it("check if store can contain multiple clusters", () => {
       expect(clusterStore.hasClusters()).toBeTruthy();
@@ -104,42 +104,42 @@ describe("empty config", () => {
       expect(wsClusters.length).toBe(2);
       expect(wsClusters[0].id).toBe("prod");
       expect(wsClusters[1].id).toBe("dev");
-    })
+    });
 
     it("check if cluster's kubeconfig file saved", () => {
       const file = ClusterStore.embedCustomKubeConfig("boo", "kubeconfig");
       expect(fs.readFileSync(file, "utf8")).toBe("kubeconfig");
-    })
+    });
 
     it("check if reorderring works for same from and to", () => {
-      clusterStore.swapIconOrders("workstation", 1, 1)
+      clusterStore.swapIconOrders("workstation", 1, 1);
 
       const clusters = clusterStore.getByWorkspaceId("workstation");
-      expect(clusters[0].id).toBe("prod")
-      expect(clusters[0].preferences.iconOrder).toBe(0)
-      expect(clusters[1].id).toBe("dev")
-      expect(clusters[1].preferences.iconOrder).toBe(1)
-    })
+      expect(clusters[0].id).toBe("prod");
+      expect(clusters[0].preferences.iconOrder).toBe(0);
+      expect(clusters[1].id).toBe("dev");
+      expect(clusters[1].preferences.iconOrder).toBe(1);
+    });
 
     it("check if reorderring works for different from and to", () => {
-      clusterStore.swapIconOrders("workstation", 0, 1)
+      clusterStore.swapIconOrders("workstation", 0, 1);
 
       const clusters = clusterStore.getByWorkspaceId("workstation");
-      expect(clusters[0].id).toBe("dev")
-      expect(clusters[0].preferences.iconOrder).toBe(0)
-      expect(clusters[1].id).toBe("prod")
-      expect(clusters[1].preferences.iconOrder).toBe(1)
-    })
+      expect(clusters[0].id).toBe("dev");
+      expect(clusters[0].preferences.iconOrder).toBe(0);
+      expect(clusters[1].id).toBe("prod");
+      expect(clusters[1].preferences.iconOrder).toBe(1);
+    });
 
     it("check if after icon reordering, changing workspaces still works", () => {
-      clusterStore.swapIconOrders("workstation", 1, 1)
-      clusterStore.getById("prod").workspace = "default"
+      clusterStore.swapIconOrders("workstation", 1, 1);
+      clusterStore.getById("prod").workspace = "default";
 
       expect(clusterStore.getByWorkspaceId("workstation").length).toBe(1);
       expect(clusterStore.getByWorkspaceId("default").length).toBe(1);
-    })
-  })
-})
+    });
+  });
+});
 
 describe("config with existing clusters", () => {
   beforeEach(() => {
@@ -176,21 +176,21 @@ describe("config with existing clusters", () => {
           ]
         })
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("allows to retrieve a cluster", () => {
     const storedCluster = clusterStore.getById('cluster1');
     expect(storedCluster.id).toBe('cluster1');
     expect(storedCluster.preferences.terminalCWD).toBe('/foo');
-  })
+  });
 
   it("allows to delete a cluster", () => {
     clusterStore.removeById('cluster2');
@@ -198,18 +198,18 @@ describe("config with existing clusters", () => {
     expect(storedCluster).toBeTruthy();
     const storedCluster2 = clusterStore.getById('cluster2');
     expect(storedCluster2).toBeUndefined();
-  })
+  });
 
   it("allows getting all of the clusters", async () => {
     const storedClusters = clusterStore.clustersList;
-    expect(storedClusters.length).toBe(3)
-    expect(storedClusters[0].id).toBe('cluster1')
-    expect(storedClusters[0].preferences.terminalCWD).toBe('/foo')
-    expect(storedClusters[1].id).toBe('cluster2')
-    expect(storedClusters[1].preferences.terminalCWD).toBe('/foo2')
-    expect(storedClusters[2].id).toBe('cluster3')
-  })
-})
+    expect(storedClusters.length).toBe(3);
+    expect(storedClusters[0].id).toBe('cluster1');
+    expect(storedClusters[0].preferences.terminalCWD).toBe('/foo');
+    expect(storedClusters[1].id).toBe('cluster2');
+    expect(storedClusters[1].preferences.terminalCWD).toBe('/foo2');
+    expect(storedClusters[2].id).toBe('cluster3');
+  });
+});
 
 describe("pre 2.0 config with an existing cluster", () => {
   beforeEach(() => {
@@ -229,17 +229,17 @@ describe("pre 2.0 config with an existing cluster", () => {
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("migrates to modern format with kubeconfig in a file", async () => {
     const config = clusterStore.clustersList[0].kubeConfigPath;
     expect(fs.readFileSync(config, "utf8")).toBe("kubeconfig content");
-  })
-})
+  });
+});
 
 describe("pre 2.6.0 config with a cluster that has arrays in auth config", () => {
   beforeEach(() => {
@@ -257,15 +257,15 @@ describe("pre 2.6.0 config with a cluster that has arrays in auth config", () =>
           },
         })
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("replaces array format access token and expiry into string", async () => {
     const file = clusterStore.clustersList[0].kubeConfigPath;
@@ -273,8 +273,8 @@ describe("pre 2.6.0 config with a cluster that has arrays in auth config", () =>
     const kc = yaml.safeLoad(config);
     expect(kc.users[0].user['auth-provider'].config['access-token']).toBe("should be string");
     expect(kc.users[0].user['auth-provider'].config['expiry']).toBe("should be string");
-  })
-})
+  });
+});
 
 describe("pre 2.6.0 config with a cluster icon", () => {
   beforeEach(() => {
@@ -297,23 +297,23 @@ describe("pre 2.6.0 config with a cluster icon", () => {
         }),
         "icon_path": testDataIcon,
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("moves the icon into preferences", async () => {
     const storedClusterData = clusterStore.clustersList[0];
     expect(storedClusterData.hasOwnProperty('icon')).toBe(false);
     expect(storedClusterData.preferences.hasOwnProperty('icon')).toBe(true);
     expect(storedClusterData.preferences.icon.startsWith("data:;base64,")).toBe(true);
-  })
-})
+  });
+});
 
 describe("for a pre 2.7.0-beta.0 config without a workspace", () => {
   beforeEach(() => {
@@ -334,21 +334,21 @@ describe("for a pre 2.7.0-beta.0 config without a workspace", () => {
           },
         })
       }
-    }
+    };
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("adds cluster to default workspace", async () => {
     const storedClusterData = clusterStore.clustersList[0];
     expect(storedClusterData.workspace).toBe('default');
-  })
-})
+  });
+});
 
 describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
   beforeEach(() => {
@@ -378,19 +378,19 @@ describe("pre 3.6.0-beta.1 config with an existing cluster", () => {
     mockFs(mockOpts);
     clusterStore = ClusterStore.getInstance<ClusterStore>();
     return clusterStore.load();
-  })
+  });
 
   afterEach(() => {
     mockFs.restore();
-  })
+  });
 
   it("migrates to modern format with kubeconfig in a file", async () => {
     const config = clusterStore.clustersList[0].kubeConfigPath;
     expect(fs.readFileSync(config, "utf8")).toBe("kubeconfig content");
-  })
+  });
 
   it("migrates to modern format with icon not in file", async () => {
     const { icon } = clusterStore.clustersList[0].preferences;
     expect(icon.startsWith("data:;base64,")).toBe(true);
-  })
-})
+  });
+});

src/common/__tests__/event-bus.test.ts

@@ -1,15 +1,15 @@
-import { appEventBus, AppEvent } from "../event-bus"
+import { appEventBus, AppEvent } from "../event-bus";
 
 describe("event bus tests", () => {
   describe("emit", () => {
     it("emits an event", () => {
-      let event: AppEvent = null
+      let event: AppEvent = null;
       appEventBus.addListener((data) => {
-        event = data
-      })
+        event = data;
+      });
 
-      appEventBus.emit({name: "foo", action: "bar"})
-      expect(event.name).toBe("foo")
-    })
-  })
-})
+      appEventBus.emit({name: "foo", action: "bar"});
+      expect(event.name).toBe("foo");
+    });
+  });
+});

src/common/__tests__/search-store.test.ts

@@ -2,7 +2,7 @@
  * @jest-environment jsdom
  */
 
-import { SearchStore } from "../search-store"
+import { SearchStore } from "../search-store";
 
 let searchStore: SearchStore = null;
 
@@ -10,17 +10,17 @@ const logs = [
   "1:M 30 Oct 2020 16:17:41.553 # Connection with replica 172.17.0.12:6379 lost",
   "1:M 30 Oct 2020 16:17:41.623 * Replica 172.17.0.12:6379 asks for synchronization",
   "1:M 30 Oct 2020 16:17:41.623 * Starting Partial resynchronization request from 172.17.0.12:6379 accepted. Sending 0 bytes of backlog starting from offset 14407."
-]
+];
 
 describe("search store tests", () => {
   beforeEach(async () => {
     searchStore = new SearchStore();
-  })
+  });
 
   it("does nothing with empty search query", () => {
     searchStore.onSearch([], "");
     expect(searchStore.occurrences).toEqual([]);
-  })
+  });
 
   it("doesn't break if no text provided", () => {
     searchStore.onSearch(null, "replica");
@@ -28,53 +28,53 @@ describe("search store tests", () => {
 
     searchStore.onSearch([], "replica");
     expect(searchStore.occurrences).toEqual([]);
-  })
+  });
 
   it("find 3 occurences across 3 lines", () => {
     searchStore.onSearch(logs, "172");
     expect(searchStore.occurrences).toEqual([0, 1, 2]);
-  })
+  });
 
   it("find occurences within 1 line (case-insensitive)", () => {
     searchStore.onSearch(logs, "Starting");
     expect(searchStore.occurrences).toEqual([2, 2]);
-  })
+  });
 
   it("sets overlay index equal to first occurence", () => {
     searchStore.onSearch(logs, "Replica");
     expect(searchStore.activeOverlayIndex).toBe(0);
-  })
+  });
 
   it("set overlay index to next occurence", () => {
     searchStore.onSearch(logs, "172");
     searchStore.setNextOverlayActive();
     expect(searchStore.activeOverlayIndex).toBe(1);
-  })
+  });
 
   it("sets overlay to last occurence", () => {
     searchStore.onSearch(logs, "172");
     searchStore.setPrevOverlayActive();
     expect(searchStore.activeOverlayIndex).toBe(2);
-  })
+  });
 
   it("gets line index where overlay is located", () => {
     searchStore.onSearch(logs, "synchronization");
     expect(searchStore.activeOverlayLine).toBe(1);
-  })
+  });
 
   it("escapes string for using in regex", () => {
     const regex = searchStore.escapeRegex("some.interesting-query\\#?()[]");
     expect(regex).toBe("some\\.interesting\\-query\\\\\\#\\?\\(\\)\\[\\]");
-  })
+  });
 
   it("gets active find number", () => {
     searchStore.onSearch(logs, "172");
     searchStore.setNextOverlayActive();
     expect(searchStore.activeFind).toBe(2);
-  })
+  });
 
   it("gets total finds number", () => {
     searchStore.onSearch(logs, "Starting");
     expect(searchStore.totalFinds).toBe(2);
-  })
-})
+  });
+});

src/common/__tests__/user-store.test.ts

@@ -1,4 +1,4 @@
-import mockFs from "mock-fs"
+import mockFs from "mock-fs";
 
 jest.mock("electron", () => {
   return {
@@ -7,55 +7,55 @@ jest.mock("electron", () => {
       getPath: () => 'tmp',
       getLocale: () => 'en'
     }
-  }
-})
+  };
+});
 
-import { UserStore } from "../user-store"
-import { SemVer } from "semver"
-import electron from "electron"
+import { UserStore } from "../user-store";
+import { SemVer } from "semver";
+import electron from "electron";
 
 describe("user store tests", () => {
   describe("for an empty config", () => {
     beforeEach(() => {
-      UserStore.resetInstance()
-      mockFs({ tmp: { 'config.json': "{}" } })
-    })
+      UserStore.resetInstance();
+      mockFs({ tmp: { 'config.json': "{}" } });
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("allows setting and retrieving lastSeenAppVersion", () => {
       const us = UserStore.getInstance<UserStore>();
 
       us.lastSeenAppVersion = "1.2.3";
       expect(us.lastSeenAppVersion).toBe("1.2.3");
-    })
+    });
 
     it("allows adding and listing seen contexts", () => {
       const us = UserStore.getInstance<UserStore>();
 
-      us.seenContexts.add('foo')
-      expect(us.seenContexts.size).toBe(1)
+      us.seenContexts.add('foo');
+      expect(us.seenContexts.size).toBe(1);
 
-      us.seenContexts.add('foo')
-      us.seenContexts.add('bar')
-      expect(us.seenContexts.size).toBe(2) // check 'foo' isn't added twice
-      expect(us.seenContexts.has('foo')).toBe(true)
-      expect(us.seenContexts.has('bar')).toBe(true)
-    })
+      us.seenContexts.add('foo');
+      us.seenContexts.add('bar');
+      expect(us.seenContexts.size).toBe(2); // check 'foo' isn't added twice
+      expect(us.seenContexts.has('foo')).toBe(true);
+      expect(us.seenContexts.has('bar')).toBe(true);
+    });
 
     it("allows setting and getting preferences", () => {
       const us = UserStore.getInstance<UserStore>();
 
       us.preferences.httpsProxy = 'abcd://defg';
 
-      expect(us.preferences.httpsProxy).toBe('abcd://defg')
-      expect(us.preferences.colorTheme).toBe(UserStore.defaultTheme)
+      expect(us.preferences.httpsProxy).toBe('abcd://defg');
+      expect(us.preferences.colorTheme).toBe(UserStore.defaultTheme);
 
       us.preferences.colorTheme = "light";
-      expect(us.preferences.colorTheme).toBe('light')
-    })
+      expect(us.preferences.colorTheme).toBe('light');
+    });
 
     it("correctly resets theme to default value", async () => {
       const us = UserStore.getInstance<UserStore>();
@@ -64,7 +64,7 @@ describe("user store tests", () => {
       us.preferences.colorTheme = "some other theme";
       await us.resetTheme();
       expect(us.preferences.colorTheme).toBe(UserStore.defaultTheme);
-    })
+    });
 
     it("correctly calculates if the last seen version is an old release", () => {
       const us = UserStore.getInstance<UserStore>();
@@ -73,12 +73,12 @@ describe("user store tests", () => {
 
       us.lastSeenAppVersion = (new SemVer(electron.app.getVersion())).inc("major").format();
       expect(us.isNewVersion).toBe(false);
-    })
-  })
+    });
+  });
 
   describe("migrations", () => {
     beforeEach(() => {
-      UserStore.resetInstance()
+      UserStore.resetInstance();
       mockFs({
         'tmp': {
           'config.json': JSON.stringify({
@@ -87,17 +87,17 @@ describe("user store tests", () => {
             lastSeenAppVersion: '1.2.3'
           })
         }
-      })
-    })
+      });
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("sets last seen app version to 0.0.0", () => {
       const us = UserStore.getInstance<UserStore>();
 
-      expect(us.lastSeenAppVersion).toBe('0.0.0')
-    })
-  })
-})
+      expect(us.lastSeenAppVersion).toBe('0.0.0');
+    });
+  });
+});

src/common/__tests__/workspace-store.test.ts

@@ -1,4 +1,4 @@
-import mockFs from "mock-fs"
+import mockFs from "mock-fs";
 
 jest.mock("electron", () => {
   return {
@@ -7,36 +7,36 @@ jest.mock("electron", () => {
       getPath: () => 'tmp',
       getLocale: () => 'en'
     }
-  }
-})
+  };
+});
 
-import { Workspace, WorkspaceStore } from "../workspace-store"
+import { Workspace, WorkspaceStore } from "../workspace-store";
 
 describe("workspace store tests", () => {
   describe("for an empty config", () => {
     beforeEach(async () => {
-      WorkspaceStore.resetInstance()
-      mockFs({ tmp: { 'lens-workspace-store.json': "{}" } })
+      WorkspaceStore.resetInstance();
+      mockFs({ tmp: { 'lens-workspace-store.json': "{}" } });
 
       await WorkspaceStore.getInstance<WorkspaceStore>().load();
-    })
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("default workspace should always exist", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(ws.workspaces.size).toBe(1);
       expect(ws.getById(WorkspaceStore.defaultId)).not.toBe(null);
-    })
+    });
 
     it("cannot remove the default workspace", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(() => ws.removeWorkspaceById(WorkspaceStore.defaultId)).toThrowError("Cannot remove");
-    })
+    });
 
     it("can update workspace description", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -50,7 +50,7 @@ describe("workspace store tests", () => {
       ws.updateWorkspace(workspace);
 
       expect(ws.getById("foobar").description).toBe("Foobar description");
-    })
+    });
 
     it("can add workspaces", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -61,13 +61,13 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.getById("123").name).toBe("foobar");
-    })
+    });
 
     it("cannot set a non-existent workspace to be active", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(() => ws.setActive("abc")).toThrow("doesn't exist");
-    })
+    });
 
     it("can set a existent workspace to be active", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -78,7 +78,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(() => ws.setActive("abc")).not.toThrowError();
-    })
+    });
 
     it("can remove a workspace", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -94,7 +94,7 @@ describe("workspace store tests", () => {
       ws.removeWorkspaceById("123");
 
       expect(ws.workspaces.size).toBe(2);
-    })
+    });
 
     it("cannot create workspace with existent name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -105,7 +105,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
+    });
 
     it("cannot create workspace with empty name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -116,7 +116,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
+    });
 
     it("cannot create workspace with ' ' name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -127,7 +127,7 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
+    });
 
     it("trim workspace name", () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
@@ -138,12 +138,12 @@ describe("workspace store tests", () => {
       }));
 
       expect(ws.workspacesList.length).toBe(1);  // default workspace only
-    })
-  })
+    });
+  });
 
   describe("for a non-empty config", () => {
     beforeEach(async () => {
-      WorkspaceStore.resetInstance()
+      WorkspaceStore.resetInstance();
       mockFs({
         tmp: {
           'lens-workspace-store.json': JSON.stringify({
@@ -157,19 +157,19 @@ describe("workspace store tests", () => {
             }]
           })
         }
-      })
+      });
 
       await WorkspaceStore.getInstance<WorkspaceStore>().load();
-    })
+    });
 
     afterEach(() => {
-      mockFs.restore()
-    })
+      mockFs.restore();
+    });
 
     it("doesn't revert to default workspace", async () => {
       const ws = WorkspaceStore.getInstance<WorkspaceStore>();
 
       expect(ws.currentWorkspaceId).toBe("abc");
-    })
-  })
-})
+    });
+  });
+});