tests/auth.setup.js

@@ -5,7 +5,7 @@ const authFile = 'playwright/.auth/user.json';
 test('Authenticate', async ({ page }) => {
   await page.goto('/login');
   await page.waitForSelector('input[name="user"]', { timeout: 3000 });
-  await page.getByPlaceholder('Username').fill( process.env.ADMIN_USER);
+  await page.getByPlaceholder('Username').fill(process.env.ADMIN_USER);
   await page.getByPlaceholder('Password').fill(process.env.ADMIN_PASS);
   await page.getByRole('link', { name: 'Login' }).click();
   await page.waitForSelector('span:has-text("Quick Actions")', { timeout: 3000 });

tests/dashboards/netdata.spec.js

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