Merge pull request '1.1.0' (#1) from 1.1.0 into master

Reviewed-on: #1

.env.sample

@@ -0,0 +1,3 @@
+URL=https://192.168.1.1
+ADMIN_USER=<username>
+ADMIN_PASS=<password>

README.md

@@ -19,3 +19,7 @@ Copy the `.env.sample` file to `.env` and fill in the required values.
 ```bash
 npm run test
 ```
+
+## Contributing
+
+Use `npm run lint:check` to check for linting errors and `npm run lint:fix` to fix them.

package.json

@@ -5,14 +5,14 @@
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "lint": "semistandard --fix tests/**/*.js",
+    "lint:check": "semistandard tests/**/*.js",
+    "lint:fix": "semistandard --fix tests/**/*.js",
     "codegen": "npx playwright codegen",
-    "test": "playwright test",
+    "test": "playwright test"
-    "prepare": "npm run lint"
   },
   "husky": {
     "hooks": {
-      "pre-commit": "npm run lint"
+      "pre-commit": "npm run lint:fix"
     }
   },
   "keywords": [],

tests/dashboards/netdata.spec.js

@@ -1,80 +1,78 @@
-import { test, expect } from "@playwright/test";
+import { test, expect } from '@playwright/test';
 
-test.describe("General - Dashboard - Netdata", () => {
+test.describe('General - Dashboard - Netdata', () => {
   test.beforeEach(async ({ page }) => {
-    await page.goto("/dash-netdata", { waitUntil: "load" });
+    await page.goto('/dash-netdata', { waitUntil: 'load' });
   });
 
-  test("Title", async ({ page }) => {
+  test('Title', async ({ page }) => {
     const title = await page.title();
-    expect(title).toBe("Difuse - Dashboard - Netdata");
+    expect(title).toBe('Difuse - Dashboard - Netdata');
   });
 
-  test("Check Netdata iframe loading", async ({ page }) => {
+  test('Check Netdata iframe loading', async ({ page }) => {
-    const iframeElement = await page.locator("#netdataFrame");
+    const iframeElement = await page.locator('#netdataFrame');
     await expect(iframeElement).toBeTruthy();
 
-    const netdataContent = await page.locator(
+    const netDataContent = await page.locator('.charts-body');
-      `//div[@class='flex-sc-1m6gk2e-0 layout__Wrapper-sc-1d05imu-0 frXvTZ kLLhdj']`
+    expect(netDataContent).toBeTruthy();
-    );
-    expect(netdataContent).toBeTruthy();
   });
 
-  test("Netdata Key Elements", async ({ page }) => {
+  test('Netdata Key Elements', async ({ page }) => {
-    const systemOverview = await page.getByRole("heading", {
+    const systemOverview = await page.getByRole('heading', {
-      name: "System Overview",
+      name: 'System Overview'
     });
-    const CPUs = await page.getByRole("heading", { name: "Memory" });
+    const cpuS = await page.getByRole('heading', { name: 'Memory' });
-    const disks = await page.getByRole("heading", { name: "Disks" });
+    const disks = await page.getByRole('heading', { name: 'Disks' });
-    const newtworkStack = await page.getByRole("heading", {
+    const newtworkStack = await page.getByRole('heading', {
-      name: "Networking Stack",
+      name: 'Networking Stack'
     });
-    const Ipv4 = await page.getByRole("heading", { name: "IPv4 Networking" });
+    const ipv4 = await page.getByRole('heading', { name: 'IPv4 Networking' });
-    const Ipv6 = await page.getByRole("heading", { name: "IPv6 Networking" });
+    const ipv6 = await page.getByRole('heading', { name: 'IPv6 Networking' });
-    const networkInterfaces = await page.getByRole("heading", {
+    const networkInterfaces = await page.getByRole('heading', {
-      name: "Network Interfaces",
+      name: 'Network Interfaces'
     });
-    const firewall = await page.getByRole("heading", {
+    const firewall = await page.getByRole('heading', {
-      name: "Firewall (netfilter)",
+      name: 'Firewall (netfilter)'
     });
-    const netdataMonitoring = await page.getByRole("heading", {
+    const netdataMonitoring = await page.getByRole('heading', {
-      name: "Netdata Monitoring",
+      name: 'Netdata Monitoring'
     });
 
     expect(
       systemOverview &&
-        CPUs &&
+        cpuS &&
         disks &&
         newtworkStack &&
-        Ipv4 &&
+        ipv4 &&
-        Ipv6 &&
+        ipv6 &&
         networkInterfaces &&
         firewall &&
         netdataMonitoring
     ).toBeTruthy();
   });
 
-  test("Display System Overview Chart", async ({ page }) => {
+  test('Display System Overview Chart', async ({ page }) => {
-    const diskRead = await page.locator("#easypiechart-system.io-1-chart");
+    const diskRead = await page.locator('#easypiechart-system.io-1-chart');
     await expect(diskRead).toBeTruthy();
 
-    const diskWrite = await page.locator("#easypiechart-system.io-2-chart");
+    const diskWrite = await page.locator('#easypiechart-system.io-2-chart');
     await expect(diskWrite).toBeTruthy();
 
-    const CPUguage = await page.locator("#gauge-system.cpu-3-chart");
+    const cpuGuage = await page.locator('#gauge-system.cpu-3-chart');
-    await expect(CPUguage).toBeTruthy();
+    await expect(cpuGuage).toBeTruthy();
 
-    const netInbound = await page.locator("#easypiechart-system.net-4-chart");
+    const netInbound = await page.locator('#easypiechart-system.net-4-chart');
     await expect(netInbound).toBeTruthy();
 
-    const netOutbound = await page.locator("#easypiechart-system.net-5-chart");
+    const netOutbound = await page.locator('#easypiechart-system.net-5-chart');
     await expect(netOutbound).toBeTruthy();
 
-    const userRAM = await page.locator("#easypiechart-system.ram-6-chart");
+    const userRAM = await page.locator('#easypiechart-system.ram-6-chart');
     await expect(userRAM).toBeTruthy();
 
     await expect(
-      diskRead && diskWrite && CPUguage && netInbound && netOutbound && userRAM
+      diskRead && diskWrite && cpuGuage && netInbound && netOutbound && userRAM
     ).toBeTruthy();
   });
 });

tests/dashboards/network-analyzer/deep-packet-inspection.spec.js

@@ -0,0 +1,283 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('General - Dashboard - Network Analyzer - Deep Packet Inspection', () => {
+  test.describe('Overview', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/deep-packet-inspector', { waitUntil: 'load' });
+    });
+
+    test('Title', async ({ page }) => {
+      const title = await page.title();
+      expect(title).toBe(
+        'Difuse - Dashboard - Network Analyzer - Deep Packet Inspector (DPI)'
+      );
+    });
+
+    test('Deep Packet Inspection (DPI)', async ({ page }) => {
+      expect(await page.$('p:has-text("Deep Packet Inspection (DPI)")')).toBeTruthy();
+    });
+
+    test('Tabs', async ({ page }) => {
+      const overviewTab = await page.locator('#overview-tab-dpi');
+      const detailExplorerTab = await page.locator('#detail-tab-dpi');
+      const liveViewTab = await page.locator('#liveview-tab-dpi');
+      const settingsTab = await page.locator('#settings-tab-dpi');
+
+      expect(overviewTab && detailExplorerTab && liveViewTab && settingsTab).toBeTruthy();
+    });
+
+    test('Overview Top Cards', async ({ page }) => {
+      const inspectedFlows = await page.getByRole('heading', { name: 'Inspected Flows' });
+      const inspectedFlowsIcon = await page.locator('.mdi-magnify');
+
+      const inspectedFlowsValue = await page.textContent('#tip');
+      expect(typeof parseInt(inspectedFlowsValue)).toBe('number');
+
+      const applications = await page.getByRole('heading', { name: 'Applications' });
+      const applicationsIcon = await page.locator('.mdi-apps');
+
+      const applicationsValue = await page.textContent('#tia');
+      expect(typeof parseInt(applicationsValue)).toBe('number');
+
+      const countries = await page.getByRole('heading', { name: 'Countries' });
+      const countriesIcon = await page.locator('.mdi-earth');
+
+      const countriesValue = await page.textContent('#tcc');
+      expect(typeof parseInt(countriesValue)).toBe('number');
+
+      const domains = await page.getByRole('heading', { name: 'Domains' });
+      const domainsIcon = await page.locator('.mdi-server');
+
+      const domainsValue = await page.textContent('#tia');
+      expect(typeof parseInt(domainsValue)).toBe('number');
+
+      expect(inspectedFlows && applications && countries && domains).toBeTruthy();
+      expect(inspectedFlowsIcon && applicationsIcon && countriesIcon && domainsIcon).toBeTruthy();
+    });
+
+    test('Connections by Country', async ({ page }) => {
+      expect(await page.$('p:has-text("Connections by Country")')).toBeTruthy();
+    });
+
+    test('DPI Map', async ({ page }) => {
+      const dpiMap = await page.locator('#dpi-map');
+      const isVisible = await dpiMap.isVisible();
+      const isEnabled = await dpiMap.isEnabled();
+
+      expect(isVisible && isEnabled).toBeTruthy();
+    });
+
+    test('Detected Applications', async ({ page }) => {
+      expect(await page.$('p:has-text("Detected Application")')).toBeTruthy();
+    });
+
+    test('Detected Applications Filter', async ({ page }) => {
+      const filterField = await page.locator('#filter-field-apps');
+      expect(filterField).toBeTruthy();
+
+      const typeField = await page.locator('#filter-type-apps');
+      expect(typeField).toBeTruthy();
+
+      const valueField = await page.locator('#filter-value-categories');
+      expect(valueField).toBeTruthy();
+    });
+
+    test('Clear Filter', async ({ page }) => {
+      const clearFilter = await page.locator('#filter-clear-apps');
+      expect(clearFilter).toBeTruthy();
+    });
+
+    test('Download PDF Button', async ({ page }) => {
+      const button = await page.$('button[data-type="PDF"].download-table-apps');
+      expect(button).toBeTruthy();
+      const buttonName = await button.textContent();
+      expect(buttonName).toBe('Download PDF');
+    });
+
+    test('Download XLSX Button', async ({ page }) => {
+      const button = await page.$('button[data-type="XLSX"].download-table-apps');
+      expect(button).toBeTruthy();
+      const buttonName = await button.textContent();
+      expect(buttonName).toBe('Download XLSX');
+    });
+
+    test('Download CSV Button', async ({ page }) => {
+      const button = await page.$('button[data-type="CSV"].download-table-apps');
+      expect(button).toBeTruthy();
+      const buttonName = await button.textContent();
+      expect(buttonName).toBe('Download CSV');
+    });
+
+    test('Download JSON Button', async ({ page }) => {
+      const button = await page.$('button[data-type="JSON"].download-table-apps');
+      expect(button).toBeTruthy();
+      const buttonName = await button.textContent();
+      expect(buttonName).toBe('Download JSON');
+    });
+  });
+
+  test.describe('Detail Explorer Tab', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/deep-packet-inspector', {
+        waitUntil: 'networkidle'
+      });
+
+      await page.click('#detail-tab-dpi');
+    });
+
+    test('Detail Explorer Top Cards', async ({ page }) => {
+      const disoveredIps = await page.$('header', { name: 'Discovered IPs' });
+      const dicoveredIpsIcon = await page.locator('.mdi-magnify');
+
+      const disoveredIpsValue = await page.textContent('#deips');
+      expect(typeof parseInt(disoveredIpsValue)).toBe('number');
+
+      const disoveredMacS = await page.$('header', { name: 'Discovered MACs' });
+      const disoveredMacSicon = await page.locator('.mdi-magnify');
+
+      const disoveredMacSValue = await page.textContent('#demacs');
+      expect(typeof parseInt(disoveredMacSValue)).toBe('number');
+
+      expect(disoveredIps && disoveredMacS).toBeTruthy();
+      expect(dicoveredIpsIcon && disoveredMacSicon).toBeTruthy();
+    });
+
+    test('Detected Network Peers', async ({ page }) => {
+      expect(await page.$('p:has-text("Detected Network Peers")')).toBeTruthy();
+    });
+
+    test('Detected Network Filter', async ({ page }) => {
+      const filterField = await page.locator('#filter-field-de1');
+      const loadFilterField = await filterField.isVisible();
+      expect(loadFilterField).toBeTruthy();
+
+      const typeField = await page.locator('#filter-type-de1');
+      const loadType = await typeField.isVisible();
+      expect(loadType).toBeTruthy();
+
+      const valueField = await page.locator('#filter-value-de1');
+      const loadValue = await valueField.isVisible();
+      expect(loadValue).toBeTruthy();
+    });
+
+    test('Explorer Clear Filter Button', async ({ page }) => {
+      const clearFilter = await page.locator('#filter-clear-de1');
+      expect(await clearFilter.isVisible()).toBeTruthy();
+    });
+
+    test('Explorer Download PDF Button', async ({ page }) => {
+      const button = await page.$('button[data-type="PDF"].download-table-de1');
+      const isVisible = await button.isVisible();
+      const isEnabled = await button.isEnabled();
+      const buttonName = await button.textContent();
+
+      expect(isVisible && isEnabled).toBeTruthy();
+      expect(buttonName).toBe('Download PDF');
+    });
+
+    test('Explorer Download XLSX Button', async ({ page }) => {
+      const button = await page.$('button[data-type="XLSX"].download-table-de1');
+      const isVisible = await button.isVisible();
+      const buttonName = await button.textContent();
+
+      expect(isVisible).toBeTruthy();
+      expect(buttonName).toBe('Download XLSX');
+    });
+
+    test('Explorer Download CSV Button', async ({ page }) => {
+      const button = await page.$('button[data-type="CSV"].download-table-de1');
+      const isVisible = await button.isVisible();
+      const isEnabled = await button.isEnabled();
+      const buttonName = await button.textContent();
+
+      expect(isVisible && isEnabled).toBeTruthy();
+      expect(buttonName).toBe('Download CSV');
+    });
+
+    test('Explorer Download JSON Button', async ({ page }) => {
+      const button = await page.$('button[data-type="JSON"].download-table-de1');
+      const isVisible = await button.isVisible();
+      const isEnabled = await button.isEnabled();
+      const buttonName = await button.textContent();
+
+      expect(isVisible && isEnabled).toBeTruthy();
+      expect(buttonName).toBe('Download JSON');
+    });
+
+    test('Explore Peer Table', async ({ page }) => {
+      const table = page.locator('#de2-sec');
+      await expect(table).toBeHidden();
+    });
+  });
+
+  test.describe('Live View Tab', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/deep-packet-inspector', { waitUntil: 'networkidle' });
+
+      await page.click('#liveview-tab-dpi');
+    });
+
+    test('Toggle icon is Pause', async ({ page }) => {
+      const toggleIcon = await page.locator('#toggle-icon');
+      const classAttribute = await toggleIcon.getAttribute('class');
+      expect(classAttribute).toContain('mdi-pause');
+    });
+
+    test('Toggle icon is Play', async ({ page }) => {
+      await page.click('#toggle-icon');
+      const toggleIcon = await page.locator('#toggle-icon');
+      const classAttribute = await toggleIcon.getAttribute('class');
+      expect(classAttribute).toContain('mdi-play');
+    });
+
+    test('Live Code Check', async ({ page }) => {
+      const code = await page.locator('#liveview');
+      expect(code).toBeTruthy();
+      const codeData = await code.getAttribute('class');
+      expect(codeData).toContain('json');
+    });
+  });
+
+  test.describe('Settings', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/deep-packet-inspector', { waitUntil: 'networkidle' });
+      await page.click('#settings-tab-dpi');
+    });
+
+    test('Enable Label', async ({ page }) => {
+      expect(await page.$('label:has-text("Enable")')).toBeTruthy();
+    });
+
+    test('Enable Checkbox', async ({ page }) => {
+      const checkbox = await page.locator('input.cb-enable');
+      expect(checkbox).toBeTruthy();
+    });
+
+    test('Ignore Bittorrent Traffic', async ({ page }) => {
+      expect(await page.$('label:has-text("Ignore Bittorrent Traffic")')).toBeTruthy();
+    });
+
+    test('Ignore Bittorrent Traffic Checkbox', async ({ page }) => {
+      const checkbox = await page.locator('input.cb-ignorebtt');
+      expect(checkbox).toBeTruthy();
+    });
+
+    test('Maximum Storage', async ({ page }) => {
+      expect(await page.$('label:has-text("Maximum Storage")')).toBeTruthy();
+    });
+
+    test('Maximum Storage Input', async ({ page }) => {
+      const input = await page.locator('#max-storage');
+      expect(input).toBeTruthy();
+    });
+
+    test('Save Button', async ({ page }) => {
+      const button = await page.getByRole('button', { name: 'Save' });
+      const visible = await button.isVisible();
+      expect(visible).toBeTruthy();
+
+      const type = await button.getAttribute('type');
+      expect(type).toBe('submit');
+    });
+  });
+});

tests/dashboards/network-analyzer/traffic-monitor.spec.js

@@ -0,0 +1,184 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('General - Dashboard - Network Analyzer - Traffic Monitor', () => {
+  test.describe('Traffic Distribution', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/traffic-monitor', {
+        waitUntil: 'networkidle'
+      });
+    });
+
+    test('Title', async ({ page }) => {
+      const title = await page.title();
+      expect(title).toBe(
+        'Difuse - Dashboard - Network Analyzer - Traffic Monitor'
+      );
+    });
+
+    test('Traffic Monitor', async ({ page }) => {
+      expect(await page.$('p:has-text("Traffic Monitor")')).toBeTruthy();
+    });
+
+    test('Traffic Monitor select Date', async ({ page }) => {
+      const selectElement = page.locator('select.period-select');
+
+      const options = await selectElement.locator('option');
+
+      const optionCount = await options.count();
+      const date = [];
+      for (let i = 0; i < optionCount; i++) {
+        const option = options.nth(i);
+        const value = await option.getAttribute('value');
+        date.push(value);
+      }
+
+      await selectElement.selectOption(date[1]);
+
+      const selectedValue = await selectElement.inputValue();
+      expect(selectedValue).toBe(date[1]);
+    });
+
+    test('Tabs', async ({ page }) => {
+      const distributionTab = await page.locator('#distribution-tab-bwm');
+      const applicationTab = await page.locator('#app-tab-bwm');
+      const ipTab = await page.locator('#ip-tab-bwm');
+      const exportTab = await page.locator('#export-tab-bwm');
+
+      expect(distributionTab && applicationTab && ipTab && exportTab).toBeTruthy();
+    });
+
+    test('Traffic Distribution Top Cards', async ({ page }) => {
+      const hosts = await page.getByRole('heading', { name: 'Hosts' });
+      const hostsIcon = await page.locator('.mdi-server-network');
+
+      const hostsValue = await page.textContent('#thc');
+      expect(typeof parseInt(hostsValue)).toBe('number');
+
+      const upload = await page.getByRole('heading', { name: 'Upload' });
+      const uploadIcon = await page.locator('.mdi-upload');
+
+      const uploadValue = await page.textContent('#tuc');
+      expect(typeof parseInt(uploadValue)).toBe('number');
+
+      const download = await page.getByRole('heading', { name: 'Download' });
+      const downloadIcon = await page.locator('.mdi-download');
+
+      const downloadValue = await page.textContent('#tdc');
+      expect(typeof parseInt(downloadValue)).toBe('number');
+
+      const connections = await page.getByRole('heading', {
+        name: 'Connections'
+      });
+      const connectionsIcon = await page.locator('.mdi-lan-connect');
+
+      const connectionsValue = await page.textContent('#tcc');
+      expect(typeof parseInt(connectionsValue)).toBe('number');
+
+      expect(hosts && upload && download && connections).toBeTruthy();
+      expect(
+        hostsIcon && uploadIcon && downloadIcon && connectionsIcon
+      ).toBeTruthy();
+    });
+
+    test('Traffic', async ({ page }) => {
+      expect(await page.$('p:has-text("Traffic")')).toBeTruthy();
+      expect(await page.isVisible('#chart-1'));
+    });
+
+    test('Connections', async ({ page }) => {
+      expect(await page.$('p:has-text("Connections")')).toBeTruthy();
+      expect(await page.isVisible('#chart-2'));
+    });
+
+    test('Traffic Distribution', async ({ page }) => {
+      expect(await page.$('p:has-text("Traffic Distribution")')).toBeTruthy();
+    });
+  });
+
+  test.describe('Application Protocol', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/traffic-monitor', {
+        waitUntil: 'networkidle'
+      });
+
+      await page.click('#app-tab-bwm');
+    });
+
+    test('Download / Application', async ({ page }) => {
+      expect(await page.$('p:has-text("Download / Application")')).toBeTruthy();
+      expect(await page.isVisible('#chart-3'));
+    });
+
+    test('Upload / Application', async ({ page }) => {
+      expect(await page.$('p:has-text("Upload / Application")')).toBeTruthy();
+      expect(await page.isVisible('#chart-4'));
+    });
+
+    test('Application Protocol', async ({ page }) => {
+      expect(await page.$('p:has-text("Application Protocol")')).toBeTruthy();
+    });
+  });
+
+  test.describe('Internet Protocol', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/traffic-monitor', {
+        waitUntil: 'networkidle'
+      });
+
+      await page.click('#app-tab-bwm');
+    });
+
+    test('IPv4 vs. IPv6', async ({ page }) => {
+      expect(await page.$('p:has-text("IPv4 vs. IPv6")')).toBeTruthy();
+      expect(await page.isVisible('#chart-5'));
+    });
+
+    test('Dualstack Distribution', async ({ page }) => {
+      expect(await page.$('p:has-text("Dualstack Distribution")')).toBeTruthy();
+      expect(await page.isVisible('#chart-6'));
+    });
+
+    test('Usage by Host', async ({ page }) => {
+      expect(await page.$('p:has-text("Usage by Host")')).toBeTruthy();
+    });
+  });
+
+  test.describe('Export', () => {
+    test.beforeEach(async ({ page }) => {
+      await page.goto('network-analyzer/traffic-monitor', { waitUntil: 'load' });
+      await page.click('#export-tab-bwm');
+    });
+
+    test('Grouped By Mac (CSV) Download Button', async ({ page }) => {
+      const groupedByMac = await page.locator('a:has-text("Grouped By Mac (CSV)")');
+      const isVisible = await groupedByMac.isVisible();
+      const isEnabled = await groupedByMac.isEnabled();
+      expect(isVisible).toBeTruthy();
+      expect(isEnabled).toBeTruthy();
+    });
+
+    test('Grouped By IP (CSV) Download Button', async ({ page }) => {
+      const groupedByIp = await page.locator('a:has-text("Grouped By IP (CSV)")');
+      const isVisible = await groupedByIp.isVisible();
+      const isEnabled = await groupedByIp.isEnabled();
+      expect(isVisible).toBeTruthy();
+      expect(isEnabled).toBeTruthy();
+    });
+
+    test('Grouped By Protocol (CSV) Download Button', async ({ page }) => {
+      const groupedByProtocol = await page.locator('a:has-text("Grouped By Protocol (CSV)")');
+      const isVisible = await groupedByProtocol.isVisible();
+      const isEnabled = await groupedByProtocol.isEnabled();
+      expect(isVisible).toBeTruthy();
+      expect(isEnabled).toBeTruthy();
+    });
+
+    test('JSON Dump Download Button', async ({ page }) => {
+      const jsonDump = await page.locator('a:has-text("JSON Dump")');
+      const isVisible = await jsonDump.isVisible();
+      const isEnabled = await jsonDump.isEnabled();
+      expect(isVisible).toBeTruthy();
+      expect(isEnabled).toBeTruthy();
+    });
+  });
+});