2020-10-12 13:09:35 +00:00
|
|
|
import { expect } from 'chai';
|
2021-04-06 03:32:44 +00:00
|
|
|
import { stub } from 'sinon';
|
2020-10-12 20:25:16 +00:00
|
|
|
import * as systeminformation from 'systeminformation';
|
2021-04-06 03:32:44 +00:00
|
|
|
import { fs } from 'mz';
|
|
|
|
|
|
|
|
import * as sysInfo from '../src/lib/system-info';
|
2020-10-12 20:25:16 +00:00
|
|
|
|
|
|
|
function toMb(bytes: number) {
|
|
|
|
return Math.floor(bytes / 1024 / 1024);
|
|
|
|
}
|
|
|
|
|
2021-04-06 03:32:44 +00:00
|
|
|
describe('System information', async () => {
|
|
|
|
const fsSizeStub = stub(systeminformation, 'fsSize');
|
|
|
|
const memStub = stub(systeminformation, 'mem');
|
|
|
|
const currentLoadStub = stub(systeminformation, 'currentLoad');
|
|
|
|
const cpuTempStub = stub(systeminformation, 'cpuTemperature');
|
|
|
|
|
|
|
|
after(() => {
|
|
|
|
fsSizeStub.restore();
|
|
|
|
memStub.restore();
|
|
|
|
currentLoadStub.restore();
|
|
|
|
cpuTempStub.restore();
|
|
|
|
});
|
2020-10-12 20:25:16 +00:00
|
|
|
|
2020-10-12 13:09:35 +00:00
|
|
|
describe('Delta-based filtering', () => {
|
|
|
|
it('should correctly filter cpu usage', () => {
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({ cpu_usage: 21 }, {
|
|
|
|
cpu_usage: 20,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal(['cpu_usage']);
|
|
|
|
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({ cpu_usage: 10 }, {
|
|
|
|
cpu_usage: 20,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal([]);
|
|
|
|
});
|
|
|
|
|
|
|
|
it('should correctly filter cpu temperature', () => {
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({ cpu_temp: 21 }, {
|
|
|
|
cpu_temp: 22,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal(['cpu_temp']);
|
|
|
|
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({ cpu_temp: 10 }, {
|
|
|
|
cpu_temp: 20,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal([]);
|
|
|
|
});
|
|
|
|
|
|
|
|
it('should correctly filter memory usage', () => {
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({ memory_usage: 21 }, {
|
|
|
|
memory_usage: 22,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal(['memory_usage']);
|
|
|
|
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({ memory_usage: 10 }, {
|
|
|
|
memory_usage: 20,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal([]);
|
|
|
|
});
|
|
|
|
|
|
|
|
it('should not filter if we didnt have a past value', () => {
|
|
|
|
expect(
|
|
|
|
sysInfo.filterNonSignificantChanges({}, {
|
|
|
|
memory_usage: 22,
|
|
|
|
cpu_usage: 10,
|
|
|
|
cpu_temp: 5,
|
|
|
|
} as sysInfo.SystemInfo),
|
|
|
|
).to.deep.equal([]);
|
|
|
|
});
|
|
|
|
});
|
2020-10-12 20:25:16 +00:00
|
|
|
|
2021-04-06 03:32:44 +00:00
|
|
|
describe('CPU information', async () => {
|
|
|
|
it('gets CPU usage', async () => {
|
|
|
|
currentLoadStub.resolves(mockCPU.load);
|
|
|
|
const cpuUsage = await sysInfo.getCpuUsage();
|
|
|
|
// Make sure it is a whole number
|
|
|
|
expect(cpuUsage % 1).to.equal(0);
|
|
|
|
// Make sure it's the right number given the mocked data
|
|
|
|
expect(cpuUsage).to.equal(1);
|
|
|
|
});
|
|
|
|
|
|
|
|
it('gets CPU temp', async () => {
|
|
|
|
cpuTempStub.resolves(mockCPU.temp);
|
|
|
|
const tempInfo = await sysInfo.getCpuTemp();
|
|
|
|
// Make sure it is a whole number
|
|
|
|
expect(tempInfo % 1).to.equal(0);
|
|
|
|
// Make sure it's the right number given the mocked data
|
|
|
|
expect(tempInfo).to.equal(51);
|
|
|
|
});
|
|
|
|
|
|
|
|
it('gets CPU ID', async () => {
|
|
|
|
const fsStub = stub(fs, 'readFile').resolves(
|
|
|
|
// @ts-ignore TS thinks we can't return a buffer...
|
|
|
|
Buffer.from([
|
|
|
|
0x31,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x30,
|
|
|
|
0x31,
|
|
|
|
0x62,
|
|
|
|
0x39,
|
|
|
|
0x33,
|
|
|
|
0x66,
|
|
|
|
0x33,
|
|
|
|
0x66,
|
|
|
|
0x00,
|
|
|
|
]),
|
|
|
|
);
|
|
|
|
const cpuId = await sysInfo.getCpuId();
|
|
|
|
expect(cpuId).to.equal('1000000001b93f3');
|
|
|
|
fsStub.restore();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
describe('Memory information', async () => {
|
2020-10-12 20:25:16 +00:00
|
|
|
it('should return the correct value for memory usage', async () => {
|
2021-04-06 03:32:44 +00:00
|
|
|
memStub.resolves(mockMemory);
|
|
|
|
const memoryInfo = await sysInfo.getMemoryInformation();
|
|
|
|
expect(memoryInfo).to.deep.equal({
|
|
|
|
total: toMb(mockMemory.total),
|
|
|
|
used: toMb(
|
|
|
|
mockMemory.total -
|
|
|
|
mockMemory.free -
|
|
|
|
(mockMemory.cached + mockMemory.buffers),
|
|
|
|
),
|
2020-10-12 20:25:16 +00:00
|
|
|
});
|
2021-04-06 03:32:44 +00:00
|
|
|
});
|
|
|
|
});
|
2020-10-12 20:25:16 +00:00
|
|
|
|
2021-04-06 03:32:44 +00:00
|
|
|
describe('Storage information', async () => {
|
|
|
|
it('should return info on /data mount', async () => {
|
|
|
|
fsSizeStub.resolves(mockFS);
|
|
|
|
const storageInfo = await sysInfo.getStorageInfo();
|
|
|
|
expect(storageInfo).to.deep.equal({
|
|
|
|
blockDevice: '/dev/mmcblk0p6',
|
|
|
|
storageUsed: 1118,
|
|
|
|
storageTotal: 29023,
|
|
|
|
});
|
|
|
|
});
|
2020-10-12 20:25:16 +00:00
|
|
|
|
2021-04-06 03:32:44 +00:00
|
|
|
it('should handle no /data mount', async () => {
|
|
|
|
fsSizeStub.resolves([]);
|
|
|
|
const storageInfo = await sysInfo.getStorageInfo();
|
|
|
|
expect(storageInfo).to.deep.equal({
|
|
|
|
blockDevice: '',
|
|
|
|
storageUsed: undefined,
|
|
|
|
storageTotal: undefined,
|
|
|
|
});
|
2020-10-12 20:25:16 +00:00
|
|
|
});
|
|
|
|
});
|
2020-10-12 13:09:35 +00:00
|
|
|
});
|
2021-04-06 03:32:44 +00:00
|
|
|
|
|
|
|
const mockCPU = {
|
|
|
|
temp: {
|
|
|
|
main: 50.634,
|
|
|
|
cores: [],
|
|
|
|
max: 50.634,
|
|
|
|
socket: [],
|
|
|
|
},
|
|
|
|
load: {
|
|
|
|
avgLoad: 0.6,
|
|
|
|
currentLoad: 1.4602487831260142,
|
|
|
|
currentLoadUser: 0.7301243915630071,
|
|
|
|
currentLoadSystem: 0.7301243915630071,
|
|
|
|
currentLoadNice: 0,
|
|
|
|
currentLoadIdle: 98.53975121687398,
|
|
|
|
currentLoadIrq: 0,
|
|
|
|
rawCurrentLoad: 5400,
|
|
|
|
rawCurrentLoadUser: 2700,
|
|
|
|
rawCurrentLoadSystem: 2700,
|
|
|
|
rawCurrentLoadNice: 0,
|
|
|
|
rawCurrentLoadIdle: 364400,
|
|
|
|
rawCurrentLoadIrq: 0,
|
|
|
|
cpus: [
|
|
|
|
{
|
|
|
|
load: 1.8660812294182216,
|
|
|
|
loadUser: 0.7683863885839737,
|
|
|
|
loadSystem: 1.0976948408342482,
|
|
|
|
loadNice: 0,
|
|
|
|
loadIdle: 98.13391877058177,
|
|
|
|
loadIrq: 0,
|
|
|
|
rawLoad: 1700,
|
|
|
|
rawLoadUser: 700,
|
|
|
|
rawLoadSystem: 1000,
|
|
|
|
rawLoadNice: 0,
|
|
|
|
rawLoadIdle: 89400,
|
|
|
|
rawLoadIrq: 0,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
load: 1.7204301075268817,
|
|
|
|
loadUser: 0.8602150537634409,
|
|
|
|
loadSystem: 0.8602150537634409,
|
|
|
|
loadNice: 0,
|
|
|
|
loadIdle: 98.27956989247312,
|
|
|
|
loadIrq: 0,
|
|
|
|
rawLoad: 1600,
|
|
|
|
rawLoadUser: 800,
|
|
|
|
rawLoadSystem: 800,
|
|
|
|
rawLoadNice: 0,
|
|
|
|
rawLoadIdle: 91400,
|
|
|
|
rawLoadIrq: 0,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
load: 1.186623516720604,
|
|
|
|
loadUser: 0.9708737864077669,
|
|
|
|
loadSystem: 0.2157497303128371,
|
|
|
|
loadNice: 0,
|
|
|
|
loadIdle: 98.8133764832794,
|
|
|
|
loadIrq: 0,
|
|
|
|
rawLoad: 1100,
|
|
|
|
rawLoadUser: 900,
|
|
|
|
rawLoadSystem: 200,
|
|
|
|
rawLoadNice: 0,
|
|
|
|
rawLoadIdle: 91600,
|
|
|
|
rawLoadIrq: 0,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
load: 1.0752688172043012,
|
|
|
|
loadUser: 0.3225806451612903,
|
|
|
|
loadSystem: 0.7526881720430108,
|
|
|
|
loadNice: 0,
|
|
|
|
loadIdle: 98.9247311827957,
|
|
|
|
loadIrq: 0,
|
|
|
|
rawLoad: 1000,
|
|
|
|
rawLoadUser: 300,
|
|
|
|
rawLoadSystem: 700,
|
|
|
|
rawLoadNice: 0,
|
|
|
|
rawLoadIdle: 92000,
|
|
|
|
rawLoadIrq: 0,
|
|
|
|
},
|
|
|
|
],
|
|
|
|
},
|
|
|
|
};
|
|
|
|
const mockFS = [
|
|
|
|
{
|
|
|
|
fs: 'overlay',
|
|
|
|
type: 'overlay',
|
|
|
|
size: 30433308672,
|
|
|
|
used: 1172959232,
|
|
|
|
available: 27684696064,
|
|
|
|
use: 4.06,
|
|
|
|
mount: '/',
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fs: '/dev/mmcblk0p6',
|
|
|
|
type: 'ext4',
|
|
|
|
size: 30433308672,
|
|
|
|
used: 1172959232,
|
|
|
|
available: 27684696064,
|
|
|
|
use: 4.06,
|
|
|
|
mount: '/data',
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fs: '/dev/mmcblk0p1',
|
|
|
|
type: 'vfat',
|
|
|
|
size: 41281536,
|
|
|
|
used: 7219200,
|
|
|
|
available: 34062336,
|
|
|
|
use: 17.49,
|
|
|
|
mount: '/boot/config.json',
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fs: '/dev/disk/by-state/resin-state',
|
|
|
|
type: 'ext4',
|
|
|
|
size: 19254272,
|
|
|
|
used: 403456,
|
|
|
|
available: 17383424,
|
|
|
|
use: 2.27,
|
|
|
|
mount: '/mnt/root/mnt/state',
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fs: '/dev/disk/by-uuid/ba1eadef-4660-4b03-9e71-9f33257f292c',
|
|
|
|
type: 'ext4',
|
|
|
|
size: 313541632,
|
|
|
|
used: 308860928,
|
|
|
|
available: 0,
|
|
|
|
use: 100,
|
|
|
|
mount: '/mnt/root/mnt/sysroot/active',
|
|
|
|
},
|
|
|
|
{
|
|
|
|
fs: '/dev/mmcblk0p2',
|
|
|
|
type: 'ext4',
|
|
|
|
size: 313541632,
|
|
|
|
used: 299599872,
|
|
|
|
available: 0,
|
|
|
|
use: 100,
|
|
|
|
mount: '/mnt/root/mnt/sysroot/inactive',
|
|
|
|
},
|
|
|
|
];
|
|
|
|
const mockMemory = {
|
|
|
|
total: 4032724992,
|
|
|
|
free: 2182356992,
|
|
|
|
used: 1850368000,
|
|
|
|
active: 459481088,
|
|
|
|
available: 3573243904,
|
|
|
|
buffers: 186269696,
|
|
|
|
cached: 1055621120,
|
|
|
|
slab: 252219392,
|
|
|
|
buffcache: 1494110208,
|
|
|
|
swaptotal: 2016358400,
|
|
|
|
swapused: 0,
|
|
|
|
swapfree: 2016358400,
|
|
|
|
};
|