diff --git a/__tests__/getters/getCurl.test.ts b/__tests__/getters/getCurl.test.ts index 147e29f..78f58f0 100644 --- a/__tests__/getters/getCurl.test.ts +++ b/__tests__/getters/getCurl.test.ts @@ -1,9 +1,6 @@ import { getCurl } from '../../src/getters'; import { runOsquery, OsType } from '../../src/runOsquery'; -const replacer = (key: any, value: { toString: () => any }) => - typeof value === 'bigint' ? value.toString() : value; - jest.mock('../../src/runOsquery', () => ({ runOsquery: jest.fn(), OsType: { @@ -27,7 +24,7 @@ describe('getCurl', () => { result: 'result', }, ]; - mockRunOsquery.mockResolvedValue(JSON.stringify(expectedCurl, replacer)); + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedCurl)); await expect(getCurl()).resolves.toEqual(expectedCurl); expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM curl', [ diff --git a/__tests__/getters/getCurlCertificate.test.ts b/__tests__/getters/getCurlCertificate.test.ts index a4e41f4..131a25f 100644 --- a/__tests__/getters/getCurlCertificate.test.ts +++ b/__tests__/getters/getCurlCertificate.test.ts @@ -1,3 +1,42 @@ -test('getCurlCertificate.test.ts', () => { - expect(true).toBe(true); +import { getCurlCertificate } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +// Mock runOsquery function +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getCurlCertificate', () => { + it('resolves with curl_certificate table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedCurlCertificate = [ + { + hostname: 'example.com', + common_name: 'Example Common Name', + organization: 'Example Organization', + // ... add all other properties as per the structure ... + pem: 'Example PEM', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedCurlCertificate)); + + await expect(getCurlCertificate()).resolves.toEqual(expectedCurlCertificate); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM curl_certificate', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getCurlCertificate()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getEc2InstanceMetadata.test.ts b/__tests__/getters/getEc2InstanceMetadata.test.ts index 14b403a..1beaf75 100644 --- a/__tests__/getters/getEc2InstanceMetadata.test.ts +++ b/__tests__/getters/getEc2InstanceMetadata.test.ts @@ -1,3 +1,50 @@ -test('getEc2InstanceMetadata.test.ts', () => { - expect(true).toBe(true); +import { getEc2InstanceMetadata } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getEc2InstanceMetadata', () => { + it('resolves with ec2_instance_metadata table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedEc2InstanceMetadata = [ + { + instance_id: 'i-0abcd1234efgh5678', + instance_type: 't2.micro', + architecture: 'x86_64', + region: 'us-west-2', + availability_zone: 'us-west-2a', + local_hostname: 'ip-192-0-2-0', + local_ipv4: '192.0.2.0', + mac: '0A:1B:2C:3D:4E:5F', + security_groups: 'sg-0abcd1234efgh5678', + iam_arn: 'arn:aws:iam::123456789012:user/David', + ami_id: 'ami-0abcd1234efgh5678', + reservation_id: 'r-0abcd1234efgh5678', + account_id: '123456789012', + ssh_public_key: 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3F...', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedEc2InstanceMetadata)); + + await expect(getEc2InstanceMetadata()).resolves.toEqual(expectedEc2InstanceMetadata); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM ec2_instance_metadata', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getEc2InstanceMetadata()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getEc2InstanceTags.test.ts b/__tests__/getters/getEc2InstanceTags.test.ts index 696cc8e..808d5fc 100644 --- a/__tests__/getters/getEc2InstanceTags.test.ts +++ b/__tests__/getters/getEc2InstanceTags.test.ts @@ -1,3 +1,39 @@ -test('getEc2InstanceTags.test.ts', () => { - expect(true).toBe(true); +import { getEc2InstanceTags } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getEc2InstanceTags', () => { + it('resolves with ec2_instance_tags table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedEc2InstanceTags = [ + { + instance_id: 'i-0abcd1234efgh5678', + key: 'Name', + value: 'My Instance', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedEc2InstanceTags)); + + await expect(getEc2InstanceTags()).resolves.toEqual(expectedEc2InstanceTags); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM ec2_instance_tags', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getEc2InstanceTags()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getEtcHosts.test.ts b/__tests__/getters/getEtcHosts.test.ts index 0654048..52f92f7 100644 --- a/__tests__/getters/getEtcHosts.test.ts +++ b/__tests__/getters/getEtcHosts.test.ts @@ -1,3 +1,39 @@ -test('getEtcHosts.test.ts', () => { - expect(true).toBe(true); +import { getEtcHosts } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getEtcHosts', () => { + it('resolves with etc_hosts table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedEtcHosts = [ + { + address: '127.0.0.1', + hostnames: 'localhost', + pid_with_namespace: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedEtcHosts)); + + await expect(getEtcHosts()).resolves.toEqual(expectedEtcHosts); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM etc_hosts', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getEtcHosts()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getEtcProtocols.test.ts b/__tests__/getters/getEtcProtocols.test.ts index d9baa6c..9749af0 100644 --- a/__tests__/getters/getEtcProtocols.test.ts +++ b/__tests__/getters/getEtcProtocols.test.ts @@ -1,3 +1,40 @@ -test('getEtcProtocols.test.ts', () => { - expect(true).toBe(true); +import { getEtcProtocols } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getEtcProtocols', () => { + it('resolves with etc_protocols table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedEtcProtocols = [ + { + name: 'tcp', + number: 6, + alias: 'TCP', + comment: 'Transmission Control Protocol', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedEtcProtocols)); + + await expect(getEtcProtocols()).resolves.toEqual(expectedEtcProtocols); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM etc_protocols', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getEtcProtocols()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getEtcServices.test.ts b/__tests__/getters/getEtcServices.test.ts index d49524e..4c8dca2 100644 --- a/__tests__/getters/getEtcServices.test.ts +++ b/__tests__/getters/getEtcServices.test.ts @@ -1,3 +1,41 @@ -test('getEtcServices.test.ts', () => { - expect(true).toBe(true); +import { getEtcServices } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getEtcServices', () => { + it('resolves with etc_services table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedEtcServices = [ + { + name: 'http', + port: 80, + protocol: 'tcp', + aliases: '', + comment: 'World Wide Web HTTP', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedEtcServices)); + + await expect(getEtcServices()).resolves.toEqual(expectedEtcServices); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM etc_services', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getEtcServices()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getFile.test.ts b/__tests__/getters/getFile.test.ts index eb1172c..a03e83b 100644 --- a/__tests__/getters/getFile.test.ts +++ b/__tests__/getters/getFile.test.ts @@ -1,3 +1,62 @@ -test('getFile.test.ts', () => { - expect(true).toBe(true); +import { getFile } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getFile', () => { + it('resolves with file table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedFile = [ + { + path: '/path/to/file', + directory: '/path/to', + filename: 'file', + inode: 123456, + uid: 1001, + gid: 1001, + mode: 'rw-r--r--', + device: 64769, + size: 4096, + block_size: 4096, + atime: 1587152400, + mtime: 1587152400, + ctime: 1587152400, + btime: 1587152400, + hard_links: 1, + symlink: 0, + type: 'regular', + attributes: '', + volume_serial: '', + file_id: '', + file_version: '', + product_version: '', + original_filename: '', + bsd_flags: '', + pid_with_namespace: 0, + mount_namespace_id: '', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedFile)); + + await expect(getFile()).resolves.toEqual(expectedFile); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM file', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getFile()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getFirefoxAddons.test.ts b/__tests__/getters/getFirefoxAddons.test.ts index 197b4d1..a35a0ef 100644 --- a/__tests__/getters/getFirefoxAddons.test.ts +++ b/__tests__/getters/getFirefoxAddons.test.ts @@ -1,3 +1,50 @@ -test('getFirefoxAddons.test.ts', () => { - expect(true).toBe(true); +import { getFirefoxAddons } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getFirefoxAddons', () => { + it('resolves with firefox_addons table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedFirefoxAddons = [ + { + uid: 1, + name: 'Test Addon', + identifier: 'test@addon.com', + creator: 'Test Creator', + type: 'extension', + version: '1.0', + description: 'This is a test addon', + source_url: 'http://test.com', + visible: 1, + active: 1, + disabled: 0, + autoupdate: 1, + location: 'profile', + path: '/path/to/addon', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedFirefoxAddons)); + + await expect(getFirefoxAddons()).resolves.toEqual(expectedFirefoxAddons); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM firefox_addons', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getFirefoxAddons()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getGroups.test.ts b/__tests__/getters/getGroups.test.ts index 664efd8..c13a121 100644 --- a/__tests__/getters/getGroups.test.ts +++ b/__tests__/getters/getGroups.test.ts @@ -1,3 +1,43 @@ -test('getGroups.test.ts', () => { - expect(true).toBe(true); +import { getGroups } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getGroups', () => { + it('resolves with groups table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedGroups = [ + { + gid: 1000, + gid_signed: 1000, + groupname: 'testgroup', + group_sid: '', + comment: '', + is_hidden: 0, + pid_with_namespace: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedGroups)); + + await expect(getGroups()).resolves.toEqual(expectedGroups); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM groups', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getGroups()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getHash.test.ts b/__tests__/getters/getHash.test.ts index b10cf27..a696ef9 100644 --- a/__tests__/getters/getHash.test.ts +++ b/__tests__/getters/getHash.test.ts @@ -1,3 +1,43 @@ -test('getHash.test.ts', () => { - expect(true).toBe(true); +import { getHash } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getHash', () => { + it('resolves with hash table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedHashes = [ + { + path: '/path/to/file', + directory: '/path/to', + md5: '098f6bcd4621d373cade4e832627b4f6', + sha1: '5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8', + sha256: '6dcd4ce23d88e2ee95838f7b014b6284ff4a7acca8819c769ce6aec8f55a1834', + pid_with_namespace: 0, + mount_namespace_id: '', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedHashes)); + + await expect(getHash()).resolves.toEqual(expectedHashes); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM hash', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getHash()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getInterfaceAddresses.test.ts b/__tests__/getters/getInterfaceAddresses.test.ts index 081e25d..0508cf1 100644 --- a/__tests__/getters/getInterfaceAddresses.test.ts +++ b/__tests__/getters/getInterfaceAddresses.test.ts @@ -1,3 +1,43 @@ -test('getInterfaceAddresses.test.ts', () => { - expect(true).toBe(true); +import { getInterfaceAddresses } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getInterfaceAddresses', () => { + it('resolves with interface_addresses table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedInterfaceAddresses = [ + { + interface: 'eth0', + address: '192.168.0.1', + mask: '255.255.255.0', + broadcast: '192.168.0.255', + point_to_point: '', + type: 'ipv4', + friendly_name: 'Ethernet', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedInterfaceAddresses)); + + await expect(getInterfaceAddresses()).resolves.toEqual(expectedInterfaceAddresses); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM interface_addresses', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getInterfaceAddresses()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getInterfaceDetails.test.ts b/__tests__/getters/getInterfaceDetails.test.ts index 196432a..701873c 100644 --- a/__tests__/getters/getInterfaceDetails.test.ts +++ b/__tests__/getters/getInterfaceDetails.test.ts @@ -1,3 +1,71 @@ -test('getInterfaceDetails.test.ts', () => { - expect(true).toBe(true); +import { getInterfaceDetails } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getInterfaceDetails', () => { + it('resolves with interface_details table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedInterfaceDetails = [ + { + interface: 'eth0', + mac: 'AA:BB:CC:DD:EE:FF', + type: 6, + mtu: 1500, + metric: 100, + flags: 4163, + ipackets: 123, + opackets: 123, + ibytes: 123, + obytes: 123, + ierrors: 123, + oerrors: 123, + idrops: 123, + odrops: 123, + collisions: 123, + last_change: 123, + link_speed: 123, + pci_slot: '0000:00:03.0', + friendly_name: 'Ethernet', + description: 'Intel Ethernet Connection', + manufacturer: 'Intel', + connection_id: 'Ethernet', + connection_status: 'Connected', + enabled: 1, + physical_adapter: 1, + speed: 1000, + service: 'e1express', + dhcp_enabled: 1, + dhcp_lease_expires: '', + dhcp_lease_obtained: '', + dhcp_server: '', + dns_domain: '', + dns_domain_suffix_search_order: '', + dns_host_name: '', + dns_server_search_order: '', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedInterfaceDetails)); + + await expect(getInterfaceDetails()).resolves.toEqual(expectedInterfaceDetails); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM interface_details', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getInterfaceDetails()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getKernelInfo.test.ts b/__tests__/getters/getKernelInfo.test.ts index 3e55972..6999f2b 100644 --- a/__tests__/getters/getKernelInfo.test.ts +++ b/__tests__/getters/getKernelInfo.test.ts @@ -1,3 +1,31 @@ -test('getKernelInfo.test.ts', () => { - expect(true).toBe(true); -}); +import { getKernelInfo } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getKernelInfo', () => { + it('resolves with kernel_info table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedKernelInfo = { + version: '5.4.0-26-generic', + arguments: '', + path: '/boot/vmlinuz-5.4.0-26-generic', + device: '/dev/sda1', + }; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedKernelInfo)); + + await expect(getKernelInfo()).resolves.toEqual(expectedKernelInfo); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM kernel_info', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); +}); \ No newline at end of file diff --git a/__tests__/getters/getListeningPorts.test.ts b/__tests__/getters/getListeningPorts.test.ts index 9d8588c..f195a2e 100644 --- a/__tests__/getters/getListeningPorts.test.ts +++ b/__tests__/getters/getListeningPorts.test.ts @@ -1,3 +1,45 @@ -test('getListeningPorts.test.ts', () => { - expect(true).toBe(true); +import { getListeningPorts } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getListeningPorts', () => { + it('resolves with listening_ports table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedListeningPorts = [ + { + pid: 123, + port: 8080, + protocol: 6, + family: 2, + address: '0.0.0.0', + fd: 5, + socket: '0x55963a6f2f70', + net_namespace: '', + path: '', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedListeningPorts)); + + await expect(getListeningPorts()).resolves.toEqual(expectedListeningPorts); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM listening_ports', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getListeningPorts()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getLoggedInUsers.test.ts b/__tests__/getters/getLoggedInUsers.test.ts index 509b460..9d29d37 100644 --- a/__tests__/getters/getLoggedInUsers.test.ts +++ b/__tests__/getters/getLoggedInUsers.test.ts @@ -1,3 +1,42 @@ -test('getLoggedInUsers.test.ts', () => { - expect(true).toBe(true); +import { getLoggedInUsers } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getLoggedInUsers', () => { + it('resolves with logged_in_users table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedLoggedInUsers = [ + { + type: 'user', + user: 'jdoe', + tty: 'pts/1', + host: '192.168.1.1', + time: 1629293155, + pid: 12345, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedLoggedInUsers)); + + await expect(getLoggedInUsers()).resolves.toEqual(expectedLoggedInUsers); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM logged_in_users', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getLoggedInUsers()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getMemoryDevices.test.ts b/__tests__/getters/getMemoryDevices.test.ts index f06d375..efe0a6b 100644 --- a/__tests__/getters/getMemoryDevices.test.ts +++ b/__tests__/getters/getMemoryDevices.test.ts @@ -1,3 +1,45 @@ -test('getMemoryDevices.test.ts', () => { - expect(true).toBe(true); +import { getMemoryDevices } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getMemoryDevices', () => { + it('resolves with memory_devices table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedMemoryDevices = [ + { + handle: '0x0029', + location: 'DIMM_A0', + manufacturer: 'Micron', + part: '18KSF1G72PDZ-1G6E1', + serial: '0B250914', + size: '16384', + speed: '1600', + type: 'DDR3', + asset_tag: '0315_2708_00_A00', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedMemoryDevices)); + + await expect(getMemoryDevices()).resolves.toEqual(expectedMemoryDevices); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM memory_devices', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getMemoryDevices()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getNpmPackages.test.ts b/__tests__/getters/getNpmPackages.test.ts index 6181d7a..99195db 100644 --- a/__tests__/getters/getNpmPackages.test.ts +++ b/__tests__/getters/getNpmPackages.test.ts @@ -1,3 +1,46 @@ -test('getNpmPackages.test.ts', () => { - expect(true).toBe(true); +import { getNpmPackages } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getNpmPackages', () => { + it('resolves with npm_packages table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedNpmPackages = [ + { + name: 'express', + version: '4.17.1', + description: 'Fast, unopinionated, minimalist web framework', + author: 'TJ Holowaychuk (http://tjholowaychuk.com)', + license: 'MIT', + homepage: 'http://expressjs.com/', + path: '/usr/local/lib/node_modules/express', + directory: '/usr/local/lib/node_modules/express', + pid_with_namespace: 12345, + mount_namespace_id: '45678', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedNpmPackages)); + + await expect(getNpmPackages()).resolves.toEqual(expectedNpmPackages); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM npm_packages', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getNpmPackages()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsVersion.test.ts b/__tests__/getters/getOsVersion.test.ts index 2ae9f34..527db59 100644 --- a/__tests__/getters/getOsVersion.test.ts +++ b/__tests__/getters/getOsVersion.test.ts @@ -1,3 +1,47 @@ -test('getOsVersion.test.ts', () => { - expect(true).toBe(true); +import { getOsVersion } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsVersion', () => { + it('resolves with os_version table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsVersion = { + name: 'macOS', + version: '10.15.7', + major: 10, + minor: 15, + patch: 7, + build: '19H15', + platform: 'darwin', + platform_like: 'darwin', + codename: 'Catalina', + arch: 'x86_64', + install_date: 1596240000, + pid_with_namespace: 12345, + mount_namespace_id: '45678', + }; + mockRunOsquery.mockResolvedValue(JSON.stringify([expectedOsVersion])); // Mock as an array, getOsVersion expects the result as an array and selects the first element + + await expect(getOsVersion()).resolves.toEqual(expectedOsVersion); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM os_version', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsVersion()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsqueryEvents.test.ts b/__tests__/getters/getOsqueryEvents.test.ts index c523357..375a0e6 100644 --- a/__tests__/getters/getOsqueryEvents.test.ts +++ b/__tests__/getters/getOsqueryEvents.test.ts @@ -1,3 +1,43 @@ -test('getOsqueryEvents.test.ts', () => { - expect(true).toBe(true); +import { getOsqueryEvents } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsqueryEvents', () => { + it('resolves with osquery_events table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsqueryEvents = [ + { + name: 'fsevents', + publisher: 'kernel', + type: 'subscription', + subscriptions: 5, + events: 1200, + refreshes: 3, + active: 1, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsqueryEvents)); + + await expect(getOsqueryEvents()).resolves.toEqual(expectedOsqueryEvents); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_events', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsqueryEvents()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsqueryExtensions.test.ts b/__tests__/getters/getOsqueryExtensions.test.ts index d2f9498..094517b 100644 --- a/__tests__/getters/getOsqueryExtensions.test.ts +++ b/__tests__/getters/getOsqueryExtensions.test.ts @@ -1,3 +1,42 @@ -test('getOsqueryExtensions.test.ts', () => { - expect(true).toBe(true); +import { getOsqueryExtensions } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsqueryExtensions', () => { + it('resolves with osquery_extensions table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsqueryExtensions = [ + { + uuid: 123, + name: 'TestExtension', + version: '1.0.0', + sdk_version: '4.5.1', + path: '/usr/local/osquery/extensions/test_extension.ext', + type: 'extension', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsqueryExtensions)); + + await expect(getOsqueryExtensions()).resolves.toEqual(expectedOsqueryExtensions); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_extensions', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsqueryExtensions()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsqueryFlags.test.ts b/__tests__/getters/getOsqueryFlags.test.ts index 13d060c..563089c 100644 --- a/__tests__/getters/getOsqueryFlags.test.ts +++ b/__tests__/getters/getOsqueryFlags.test.ts @@ -1,3 +1,42 @@ -test('getOsqueryFlags.test.ts', () => { - expect(true).toBe(true); +import { getOsqueryFlags } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsqueryFlags', () => { + it('resolves with osquery_flags table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsqueryFlags = [ + { + name: 'disable_events', + type: 'bool', + description: 'Disable osquery publish/subscribe system.', + default_value: 'false', + value: 'false', + shell_only: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsqueryFlags)); + + await expect(getOsqueryFlags()).resolves.toEqual(expectedOsqueryFlags); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_flags', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsqueryFlags()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsqueryInfo.test.ts b/__tests__/getters/getOsqueryInfo.test.ts index 7665705..4371955 100644 --- a/__tests__/getters/getOsqueryInfo.test.ts +++ b/__tests__/getters/getOsqueryInfo.test.ts @@ -1,3 +1,46 @@ -test('getOsqueryInfo.test.ts', () => { - expect(true).toBe(true); +import { getOsqueryInfo } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsqueryInfo', () => { + it('resolves with osquery_info table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsqueryInfo = { + pid: 12345, + uuid: 'uuid', + instance_id: 'instance_id', + version: '4.5.1', + config_hash: 'config_hash', + config_valid: 1, + extensions: 'active', + build_platform: 'darwin', + build_distro: '10.15', + start_time: 1596250000, + watcher: 0, + platform_mask: 1, + }; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsqueryInfo)); + + await expect(getOsqueryInfo()).resolves.toEqual(expectedOsqueryInfo); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_info', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsqueryInfo()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsqueryPacks.test.ts b/__tests__/getters/getOsqueryPacks.test.ts index 4ab94f7..9c23e5f 100644 --- a/__tests__/getters/getOsqueryPacks.test.ts +++ b/__tests__/getters/getOsqueryPacks.test.ts @@ -1,3 +1,43 @@ -test('getOsqueryPacks.test.ts', () => { - expect(true).toBe(true); +import { getOsqueryPacks } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsqueryPacks', () => { + it('resolves with osquery_packs table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsqueryPacks = [ + { + name: 'TestPack', + platform: 'darwin', + version: '1.0.0', + shard: 0, + discovery_cache_hits: 5, + discovery_executions: 10, + active: 1, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsqueryPacks)); + + await expect(getOsqueryPacks()).resolves.toEqual(expectedOsqueryPacks); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_packs', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsqueryPacks()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsqueryRegistry.test.ts b/__tests__/getters/getOsqueryRegistry.test.ts index fe72bbe..8f81e06 100644 --- a/__tests__/getters/getOsqueryRegistry.test.ts +++ b/__tests__/getters/getOsqueryRegistry.test.ts @@ -1,3 +1,41 @@ -test('getOsqueryRegistry.test.ts', () => { - expect(true).toBe(true); +import { getOsqueryRegistry } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsqueryRegistry', () => { + it('resolves with osquery_registry table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsqueryRegistry = [ + { + registry: 'config', + name: 'filesystem', + owner_uuid: 0, + internal: 1, + active: 1, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsqueryRegistry)); + + await expect(getOsqueryRegistry()).resolves.toEqual(expectedOsqueryRegistry); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_registry', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsqueryRegistry()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getOsquerySchedule.test.ts b/__tests__/getters/getOsquerySchedule.test.ts index 3c0f94c..c7bb2c1 100644 --- a/__tests__/getters/getOsquerySchedule.test.ts +++ b/__tests__/getters/getOsquerySchedule.test.ts @@ -1,3 +1,52 @@ -test('getOsquerySchedule.test.ts', () => { - expect(true).toBe(true); +import { getOsquerySchedule } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getOsquerySchedule', () => { + it('resolves with osquery_schedule table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedOsquerySchedule = [ + { + name: 'TestQuery', + query: 'SELECT * FROM osquery_schedule', + interval: 10, + executions: 123, + last_executed: 123, + denylisted: 0, + output_size: 123, + wall_time: 123, + wall_time_ms: 123, + last_wall_time_ms: 123, + user_time: 123, + last_user_time: 123, + system_time: 123, + last_system_time: 123, + average_memory: 123, + last_memory: 123, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedOsquerySchedule)); + + await expect(getOsquerySchedule()).resolves.toEqual(expectedOsquerySchedule); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM osquery_schedule', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getOsquerySchedule()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getPlatformInfo.test.ts b/__tests__/getters/getPlatformInfo.test.ts index 48b5600..0fd8550 100644 --- a/__tests__/getters/getPlatformInfo.test.ts +++ b/__tests__/getters/getPlatformInfo.test.ts @@ -1,3 +1,45 @@ -test('getPlatformInfo.test.ts', () => { - expect(true).toBe(true); +import { getPlatformInfo } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getPlatformInfo', () => { + it('resolves with platform_info table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedPlatformInfo = [ + { + vendor: 'Apple Inc.', + version: 'MBP111.88Z.0167.B00.2001010101', + date: '01/01/01', + revision: '1.0', + extra: '', + firmware_type: 'EFI', + address: '0x7c000', + size: '0x10000', + volume_size: 8388608, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedPlatformInfo)); + + await expect(getPlatformInfo()).resolves.toEqual(expectedPlatformInfo); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM platform_info', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getPlatformInfo()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getProcessMemoryMap.test.ts b/__tests__/getters/getProcessMemoryMap.test.ts index 7acc91d..c6d1e09 100644 --- a/__tests__/getters/getProcessMemoryMap.test.ts +++ b/__tests__/getters/getProcessMemoryMap.test.ts @@ -1,3 +1,45 @@ -test('getProcessMemoryMap.test.ts', () => { - expect(true).toBe(true); +import { getProcessMemoryMap } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getProcessMemoryMap', () => { + it('resolves with process_memory_map table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedProcessMemoryMap = [ + { + pid: 1, + start: '00007fff5fc00000', + end: '00007fff5fc01000', + permissions: 'r-xp', + offset: 123, + device: 'fe:01', + inode: 123, + path: '', + pseudo: 1, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedProcessMemoryMap)); + + await expect(getProcessMemoryMap()).resolves.toEqual(expectedProcessMemoryMap); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM process_memory_map', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getProcessMemoryMap()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getProcessOpenSockets.test.ts b/__tests__/getters/getProcessOpenSockets.test.ts index c4315e4..b7c5953 100644 --- a/__tests__/getters/getProcessOpenSockets.test.ts +++ b/__tests__/getters/getProcessOpenSockets.test.ts @@ -1,3 +1,48 @@ -test('getProcessOpenSockets.test.ts', () => { - expect(true).toBe(true); +import { getProcessOpenSockets } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getProcessOpenSockets', () => { + it('resolves with process_open_sockets table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedProcessOpenSockets = [ + { + pid: 1, + fd: 123, + socket: 123, + family: 2, + protocol: 6, + local_address: '0.0.0.0', + remote_address: '0.0.0.0', + local_port: 631, + remote_port: 0, + path: '', + state: 'LISTEN', + net_namespace: '', + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedProcessOpenSockets)); + + await expect(getProcessOpenSockets()).resolves.toEqual(expectedProcessOpenSockets); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM process_open_sockets', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getProcessOpenSockets()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getProcesses.test.ts b/__tests__/getters/getProcesses.test.ts index 70207b1..31e47da 100644 --- a/__tests__/getters/getProcesses.test.ts +++ b/__tests__/getters/getProcesses.test.ts @@ -1,3 +1,76 @@ -test('getProcesses.test.ts', () => { - expect(true).toBe(true); +import { getProcesses } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { Processes } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getProcesses', () => { + it('resolves with processes table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedProcesses: Processes[] = [ + { + pid: 123, + name: "test", + path: "/usr/bin/test", + cmdline: "test -option", + state: "R", + cwd: "/home", + root: "/", + uid: 123, + gid: 123, + euid: 123, + egid: 123, + suid: 123, + sgid: 123, + on_disk: 1, + wired_size: 123, + resident_size: 123, + total_size: 123, + user_time: 123, + system_time: 123, + disk_bytes_read: 123, + disk_bytes_written: 123, + start_time: 123, + parent: 123, + pgroup: 123, + threads: 1, + nice: 0, + elevated_token: 0, + secure_process: 0, + protection_type: "Protected", + virtual_process: 0, + elapsed_time: 123, + handle_count: 123, + percent_processor_time: 123, + upid: 123, + uppid: 123, + cpu_type: 0, + cpu_subtype: 0, + translated: 0, + cgroup_path: "/system.slice/test.service" + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedProcesses)); + + await expect(getProcesses()).resolves.toEqual(expectedProcesses); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM processes', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getProcesses()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getPythonPackages.test.ts b/__tests__/getters/getPythonPackages.test.ts index 735017b..b4db8fe 100644 --- a/__tests__/getters/getPythonPackages.test.ts +++ b/__tests__/getters/getPythonPackages.test.ts @@ -1,3 +1,45 @@ -test('getPythonPackages.test.ts', () => { - expect(true).toBe(true); +import { getPythonPackages } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { PythonPackages } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getPythonPackages', () => { + it('resolves with python_packages table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedPythonPackages: PythonPackages[] = [ + { + name: "test", + version: "1.0.0", + summary: "Test package", + author: "Test author", + license: "MIT", + path: "/usr/lib/python3.8/site-packages/test", + directory: "/usr/lib/python3.8/site-packages", + pid_with_namespace: 1, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedPythonPackages)); + + await expect(getPythonPackages()).resolves.toEqual(expectedPythonPackages); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM python_packages', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getPythonPackages()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getRoutes.test.ts b/__tests__/getters/getRoutes.test.ts index 09cfc1d..e64bccb 100644 --- a/__tests__/getters/getRoutes.test.ts +++ b/__tests__/getters/getRoutes.test.ts @@ -1,3 +1,47 @@ -test('getRoutes.test.ts', () => { - expect(true).toBe(true); +import { getRoutes } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { Routes } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getRoutes', () => { + it('resolves with routes table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedRoutes: Routes[] = [ + { + destination: "192.168.1.0", + netmask: 24, + gateway: "192.168.1.1", + source: "192.168.1.100", + flags: 2, + interface: "eth0", + mtu: 1500, + metric: 1, + type: "U", + hopcount: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedRoutes)); + + await expect(getRoutes()).resolves.toEqual(expectedRoutes); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM routes', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getRoutes()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getSecureBoot.test.ts b/__tests__/getters/getSecureBoot.test.ts index 53a25ca..4c86ead 100644 --- a/__tests__/getters/getSecureBoot.test.ts +++ b/__tests__/getters/getSecureBoot.test.ts @@ -1,3 +1,40 @@ -test('getSecureBoot.test.ts', () => { - expect(true).toBe(true); +import { getSecureBoot } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { SecureBoot } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getSecureBoot', () => { + it('resolves with secureboot table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedSecureBoot: SecureBoot[] = [ + { + secure_boot: 1, + secure_mode: 1, + setup_mode: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedSecureBoot)); + + await expect(getSecureBoot()).resolves.toEqual(expectedSecureBoot); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM secureboot', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getSecureBoot()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getSshConfigs.test.ts b/__tests__/getters/getSshConfigs.test.ts index 3fb00b6..db4e20b 100644 --- a/__tests__/getters/getSshConfigs.test.ts +++ b/__tests__/getters/getSshConfigs.test.ts @@ -1,3 +1,41 @@ -test('getSshConfigs.test.ts', () => { - expect(true).toBe(true); +import { getSshConfigs } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { SshConfigs } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getSshConfigs', () => { + it('resolves with ssh_configs table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedSshConfigs: SshConfigs[] = [ + { + uid: 1000, + block: "Host", + option: "Port", + ssh_config_file: "/home/user/.ssh/config", + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedSshConfigs)); + + await expect(getSshConfigs()).resolves.toEqual(expectedSshConfigs); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM ssh_configs', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getSshConfigs()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getStartupItems.test.ts b/__tests__/getters/getStartupItems.test.ts index 1f6f9e9..68e6e73 100644 --- a/__tests__/getters/getStartupItems.test.ts +++ b/__tests__/getters/getStartupItems.test.ts @@ -1,3 +1,44 @@ -test('getStartupItems.test.ts', () => { - expect(true).toBe(true); +import { getStartupItems } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { StartupItems } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getStartupItems', () => { + it('resolves with startup_items table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedStartupItems: StartupItems[] = [ + { + name: "Test", + path: "/usr/bin/test", + args: "-option", + type: "Startup", + source: "System", + status: "Enabled", + username: "User", + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedStartupItems)); + + await expect(getStartupItems()).resolves.toEqual(expectedStartupItems); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM startup_items', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getStartupItems()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getSystemInfo.test.ts b/__tests__/getters/getSystemInfo.test.ts index 76c58c7..ddde0b4 100644 --- a/__tests__/getters/getSystemInfo.test.ts +++ b/__tests__/getters/getSystemInfo.test.ts @@ -1,3 +1,55 @@ -test('getSystemInfo.test.ts', () => { - expect(true).toBe(true); -}); +import { getSystemInfo } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { SystemInfo } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType + : { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getSystemInfo', () => { + it('resolves with system_info table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedSystemInfo: SystemInfo = { + hostname: "test", + uuid: "UUID", + cpu_type: "x86_64", + cpu_subtype: "Intel(R) Core(TM) i7-9700K CPU @ 3.60GHz", + cpu_brand: "Intel", + cpu_physical_cores: 8, + cpu_logical_cores: 8, + cpu_microcode: "0x96", + physical_memory: 123, + hardware_vendor: "Lenovo", + hardware_model: "ThinkPad", + hardware_version: "1.0", + hardware_serial: "SN123456", + board_vendor: "Lenovo", + board_model: "ThinkPad", + board_version: "1.0", + board_serial: "SN123456", + computer_name: "test", + local_hostname: "test.local", + }; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedSystemInfo)); + + await expect(getSystemInfo()).resolves.toEqual(expectedSystemInfo); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM system_info', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getSystemInfo()).rejects.toEqual('Command failed'); + }); +}); \ No newline at end of file diff --git a/__tests__/getters/getTime.test.ts b/__tests__/getters/getTime.test.ts index f3d39bd..75c6efe 100644 --- a/__tests__/getters/getTime.test.ts +++ b/__tests__/getters/getTime.test.ts @@ -1,3 +1,49 @@ -test('getTime.test.ts', () => { - expect(true).toBe(true); -}); +import { getTime } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { Time } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getTime', () => { + it('resolves with time table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedTime: Time = { + weekday: "Friday", + year: 2023, + month: 7, + day: 26, + hour: 12, + minutes: 0, + seconds: 0, + timezone: "UTC", + local_timezone: "UTC", + unix_time: 1691234567, + timestamp: "Fri, 26 Jul 2023 12:00:00 UTC", + datetime: "2023-07-26 12:00:00", + iso_8601: "2023-07-26T12:00:00Z", + win_timestamp: 123, + }; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedTime)); + + await expect(getTime()).resolves.toEqual(expectedTime); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM time', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getTime()).rejects.toEqual('Command failed'); + }); +}); \ No newline at end of file diff --git a/__tests__/getters/getUptime.test.ts b/__tests__/getters/getUptime.test.ts index 9d495cd..e71a2aa 100644 --- a/__tests__/getters/getUptime.test.ts +++ b/__tests__/getters/getUptime.test.ts @@ -1,3 +1,40 @@ -test('getUptime.test.ts', () => { - expect(true).toBe(true); +import { getUptime } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { Uptime } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getUptime', () => { + it('resolves with uptime table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedUptime: Uptime = { + days: 10, + hours: 12, + minutes: 0, + seconds: 0, + total_seconds: 123, + }; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedUptime)); + + await expect(getUptime()).resolves.toEqual(expectedUptime); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM uptime', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getUptime()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getUserGroups.test.ts b/__tests__/getters/getUserGroups.test.ts index e7d9b1e..64d6566 100644 --- a/__tests__/getters/getUserGroups.test.ts +++ b/__tests__/getters/getUserGroups.test.ts @@ -1,3 +1,39 @@ -test('getUserGroups.test.ts', () => { - expect(true).toBe(true); +import { getUserGroups } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { UserGroups } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getUserGroups', () => { + it('resolves with user_groups table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedUserGroups: UserGroups[] = [ + { + uid: 123, + gid: 123, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedUserGroups)); + + await expect(getUserGroups()).resolves.toEqual(expectedUserGroups); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM user_groups', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getUserGroups()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getUserSshKeys.test.ts b/__tests__/getters/getUserSshKeys.test.ts index 9e54968..d89abb0 100644 --- a/__tests__/getters/getUserSshKeys.test.ts +++ b/__tests__/getters/getUserSshKeys.test.ts @@ -1,3 +1,42 @@ -test('getUserSshKeys.test.ts', () => { - expect(true).toBe(true); +import { getUserSshKeys } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { UserSshKeys } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getUserSshKeys', () => { + it('resolves with user_ssh_keys table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedUserSshKeys: UserSshKeys[] = [ + { + uid: 123, + path: "/home/test/.ssh/id_rsa", + encrypted: 1, + key_type: "rsa", + pid_with_namespace: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedUserSshKeys)); + + await expect(getUserSshKeys()).resolves.toEqual(expectedUserSshKeys); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM user_ssh_keys', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getUserSshKeys()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getUsers.test.ts b/__tests__/getters/getUsers.test.ts index fafde2a..c1780d6 100644 --- a/__tests__/getters/getUsers.test.ts +++ b/__tests__/getters/getUsers.test.ts @@ -1,3 +1,49 @@ -test('getUsers.test.ts', () => { - expect(true).toBe(true); +import { getUsers } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { Users } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getUsers', () => { + it('resolves with users table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedUsers: Users[] = [ + { + uid: 123, + gid: 123, + uid_signed: 123, + gid_signed: 123, + username: "test", + description: "Test User", + directory: "/home/test", + shell: "/bin/bash", + uuid: "UUID", + type: "user", + is_hidden: 0, + pid_with_namespace: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedUsers)); + + await expect(getUsers()).resolves.toEqual(expectedUsers); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM users', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getUsers()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getYCloudInstanceMetadata.test.ts b/__tests__/getters/getYCloudInstanceMetadata.test.ts index 48af60c..cade071 100644 --- a/__tests__/getters/getYCloudInstanceMetadata.test.ts +++ b/__tests__/getters/getYCloudInstanceMetadata.test.ts @@ -1,3 +1,46 @@ -test('getYCloudInstanceMetadata.test.ts', () => { - expect(true).toBe(true); +import { getYCloudInstanceMetadata } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { YCloudInstanceMetadata } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getYCloudInstanceMetadata', () => { + it('resolves with ycloud_instance_metadata table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedYCloudInstanceMetadata: YCloudInstanceMetadata[] = [ + { + instance_id: "test", + folder_id: "test", + name: "test", + description: "test", + hostname: "test", + zone: "test", + ssh_public_key: "test", + serial_port_enabled: "test", + metadata_endpoint: "test", + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedYCloudInstanceMetadata)); + + await expect(getYCloudInstanceMetadata()).resolves.toEqual(expectedYCloudInstanceMetadata); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM ycloud_instance_metadata', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getYCloudInstanceMetadata()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getYaraEventResults.test.ts b/__tests__/getters/getYaraEventResults.test.ts index 65faa1a..3ce27a4 100644 --- a/__tests__/getters/getYaraEventResults.test.ts +++ b/__tests__/getters/getYaraEventResults.test.ts @@ -1,3 +1,47 @@ -test('getYaraEventResults.test.ts', () => { - expect(true).toBe(true); +import { getYaraEventResults } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { YaraEvents } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getYaraEventResults', () => { + it('resolves with yara_events table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedYaraEvents: YaraEvents[] = [ + { + target_path: "/test/file", + category: "test", + action: "test", + transaction_id: 1, + matches: "test", + count: 1, + strings: "test", + tags: "test", + time: 1618808843, + eid: "test", + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedYaraEvents)); + + await expect(getYaraEventResults()).resolves.toEqual(expectedYaraEvents); + expect(mockRunOsquery).toHaveBeenCalledWith('SELECT * FROM yara_events', [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getYaraEventResults()).rejects.toEqual('Command failed'); + }); }); diff --git a/__tests__/getters/getYaraResults.test.ts b/__tests__/getters/getYaraResults.test.ts index 8920ffd..c172d5b 100644 --- a/__tests__/getters/getYaraResults.test.ts +++ b/__tests__/getters/getYaraResults.test.ts @@ -1,3 +1,47 @@ -test('getYaraResults.test.ts', () => { - expect(true).toBe(true); +import { getYaraResults } from '../../src/getters'; +import { runOsquery, OsType } from '../../src/runOsquery'; +import { Yara } from '../../src/types/table_interfaces'; + +jest.mock('../../src/runOsquery', () => ({ + runOsquery: jest.fn(), + OsType: { + LINUX: 'linux', + DARWIN: 'darwin', + WINDOWS_NT: 'windows_nt', + }, +})); + +describe('getYaraResults', () => { + it('resolves with yara table on success', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + const expectedYara: Yara[] = [ + { + path: "/test/file", + matches: "test", + count: 1, + sig_group: "test", + sigfile: "test", + sigrule: "test", + strings: "test", + tags: "test", + sigurl: "test", + pid_with_namespace: 0, + }, + ]; + mockRunOsquery.mockResolvedValue(JSON.stringify(expectedYara)); + + await expect(getYaraResults('/test/file')).resolves.toEqual(expectedYara); + expect(mockRunOsquery).toHaveBeenCalledWith(`SELECT * FROM yara WHERE path='/test/file'`, [ + OsType.LINUX, + OsType.DARWIN, + OsType.WINDOWS_NT, + ]); + }); + + it('rejects with error on command failure', async () => { + const mockRunOsquery = runOsquery as jest.MockedFunction; + mockRunOsquery.mockRejectedValue('Command failed'); + + await expect(getYaraResults('/test/file')).rejects.toEqual('Command failed'); + }); }); diff --git a/coverage/badge-functions.svg b/coverage/badge-functions.svg index 9c2ddf8..23f76ce 100644 --- a/coverage/badge-functions.svg +++ b/coverage/badge-functions.svg @@ -1 +1 @@ -Coverage:functions: 5.37%Coverage:functions5.37% \ No newline at end of file +Coverage:functions: 20.78%Coverage:functions20.78% \ No newline at end of file diff --git a/coverage/badge-lines.svg b/coverage/badge-lines.svg index a6b4996..8b68500 100644 --- a/coverage/badge-lines.svg +++ b/coverage/badge-lines.svg @@ -1 +1 @@ -Coverage:lines: 29.04%Coverage:lines29.04% \ No newline at end of file +Coverage:lines: 40.57%Coverage:lines40.57% \ No newline at end of file diff --git a/coverage/badge-statements.svg b/coverage/badge-statements.svg index 7d0713e..fcdd507 100644 --- a/coverage/badge-statements.svg +++ b/coverage/badge-statements.svg @@ -1 +1 @@ -Coverage:statements: 29.04%Coverage:statements29.04% \ No newline at end of file +Coverage:statements: 40.57%Coverage:statements40.57% \ No newline at end of file diff --git a/coverage/coverage-summary.json b/coverage/coverage-summary.json index 43e40a4..85f3a27 100644 --- a/coverage/coverage-summary.json +++ b/coverage/coverage-summary.json @@ -1,4 +1,4 @@ -{"total": {"lines":{"total":1119,"covered":325,"skipped":0,"pct":29.04},"statements":{"total":1119,"covered":325,"skipped":0,"pct":29.04},"functions":{"total":279,"covered":15,"skipped":0,"pct":5.37},"branches":{"total":7,"covered":3,"skipped":0,"pct":42.85},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":"Unknown"}} -,"/Users/kc/Desktop/Code/node-osquery/src/getters.ts": {"lines":{"total":1101,"covered":312,"skipped":0,"pct":28.33},"functions":{"total":275,"covered":12,"skipped":0,"pct":4.36},"statements":{"total":1101,"covered":312,"skipped":0,"pct":28.33},"branches":{"total":0,"covered":0,"skipped":0,"pct":100}} +{"total": {"lines":{"total":1119,"covered":454,"skipped":0,"pct":40.57},"statements":{"total":1119,"covered":454,"skipped":0,"pct":40.57},"functions":{"total":279,"covered":58,"skipped":0,"pct":20.78},"branches":{"total":7,"covered":3,"skipped":0,"pct":42.85},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":"Unknown"}} +,"/Users/kc/Desktop/Code/node-osquery/src/getters.ts": {"lines":{"total":1101,"covered":441,"skipped":0,"pct":40.05},"functions":{"total":275,"covered":55,"skipped":0,"pct":20},"statements":{"total":1101,"covered":441,"skipped":0,"pct":40.05},"branches":{"total":0,"covered":0,"skipped":0,"pct":100}} ,"/Users/kc/Desktop/Code/node-osquery/src/runOsquery.ts": {"lines":{"total":18,"covered":13,"skipped":0,"pct":72.22},"functions":{"total":4,"covered":3,"skipped":0,"pct":75},"statements":{"total":18,"covered":13,"skipped":0,"pct":72.22},"branches":{"total":7,"covered":3,"skipped":0,"pct":42.85}} } diff --git a/src/types/table_interfaces.ts b/src/types/table_interfaces.ts index 9a71ead..6bf5569 100644 --- a/src/types/table_interfaces.ts +++ b/src/types/table_interfaces.ts @@ -173,8 +173,8 @@ export interface Curl { method: string; user_agent: string; response_code: number; - round_trip_time: bigint; - bytes: bigint; + round_trip_time: number; + bytes: number; result: string; } @@ -340,17 +340,17 @@ export interface InterfaceDetails { mtu: number; metric: number; flags: number; - ipackets: bigint; - opackets: bigint; - ibytes: bigint; - obytes: bigint; - ierrors: bigint; - oerrors: bigint; - idrops: bigint; - odrops: bigint; - collisions: bigint; - last_change: bigint; - link_speed: bigint; + ipackets: number; + opackets: number; + ibytes: number; + obytes: number; + ierrors: number; + oerrors: number; + idrops: number; + odrops: number; + collisions: number; + last_change: number; + link_speed: number; pci_slot: string; friendly_name: string; description: string; @@ -384,8 +384,8 @@ export interface ListeningPorts { protocol: number; family: number; address: string; - fd: bigint; - socket: bigint; + fd: number; + socket: number; path: string; net_namespace: string; } @@ -395,7 +395,7 @@ export interface LoggedInUsers { user: string; tty: string; host: string; - time: bigint; + time: number; pid: number; sid: string; registry_hive: string; @@ -448,7 +448,7 @@ export interface OsVersion { platform_like: string; codename: string; arch: string; - install_date: bigint; + install_date: number; pid_with_namespace: number; mount_namespace_id: string; } @@ -464,7 +464,7 @@ export interface OsqueryEvents { } export interface OsqueryExtensions { - uuid: bigint; + uuid: number; name: string; version: string; sdk_version: string; @@ -518,19 +518,19 @@ export interface OsquerySchedule { name: string; query: string; interval: number; - executions: bigint; - last_executed: bigint; + executions: number; + last_executed: number; denylisted: number; - output_size: bigint; - wall_time: bigint; - wall_time_ms: bigint; - last_wall_time_ms: bigint; - user_time: bigint; - last_user_time: bigint; - system_time: bigint; - last_system_time: bigint; - average_memory: bigint; - last_memory: bigint; + output_size: number; + wall_time: number; + wall_time_ms: number; + last_wall_time_ms: number; + user_time: number; + last_user_time: number; + system_time: number; + last_system_time: number; + average_memory: number; + last_memory: number; } export interface PlatformInfo { @@ -550,7 +550,7 @@ export interface ProcessMemoryMap { start: string; end: string; permissions: string; - offset: bigint; + offset: number; device: string; inode: number; path: string; @@ -559,8 +559,8 @@ export interface ProcessMemoryMap { export interface ProcessOpenSockets { pid: number; - fd: bigint; - socket: bigint; + fd: number; + socket: number; family: number; protocol: number; local_address: string; @@ -573,41 +573,41 @@ export interface ProcessOpenSockets { } export interface Processes { - pid: bigint; + pid: number; name: string; path: string; cmdline: string; state: string; cwd: string; root: string; - uid: bigint; - gid: bigint; - euid: bigint; - egid: bigint; - suid: bigint; - sgid: bigint; + uid: number; + gid: number; + euid: number; + egid: number; + suid: number; + sgid: number; on_disk: number; - wired_size: bigint; - resident_size: bigint; - total_size: bigint; - user_time: bigint; - system_time: bigint; - disk_bytes_read: bigint; - disk_bytes_written: bigint; - start_time: bigint; - parent: bigint; - pgroup: bigint; + wired_size: number; + resident_size: number; + total_size: number; + user_time: number; + system_time: number; + disk_bytes_read: number; + disk_bytes_written: number; + start_time: number; + parent: number; + pgroup: number; threads: number; nice: number; elevated_token: number; secure_process: number; protection_type: string; virtual_process: number; - elapsed_time: bigint; - handle_count: bigint; - percent_processor_time: bigint; - upid: bigint; - uppid: bigint; + elapsed_time: number; + handle_count: number; + percent_processor_time: number; + upid: number; + uppid: number; cpu_type: number; cpu_subtype: number; translated: number; @@ -670,7 +670,7 @@ export interface SystemInfo { cpu_physical_cores: number; cpu_logical_cores: number; cpu_microcode: string; - physical_memory: bigint; + physical_memory: number; hardware_vendor: string; hardware_model: string; hardware_version: string; @@ -697,7 +697,7 @@ export interface Time { timestamp: string; datetime: string; iso_8601: string; - win_timestamp: bigint; + win_timestamp: number; } export interface Uptime { @@ -705,16 +705,16 @@ export interface Uptime { hours: number; minutes: number; seconds: number; - total_seconds: bigint; + total_seconds: number; } export interface UserGroups { - uid: bigint; - gid: bigint; + uid: number; + gid: number; } export interface UserSshKeys { - uid: bigint; + uid: number; path: string; encrypted: number; key_type: string; @@ -722,10 +722,10 @@ export interface UserSshKeys { } export interface Users { - uid: bigint; - gid: bigint; - uid_signed: bigint; - gid_signed: bigint; + uid: number; + gid: number; + uid_signed: number; + gid_signed: number; username: string; description: string; directory: string; @@ -800,7 +800,7 @@ export interface Autoexec { export interface BackgroundActivitiesModerator { path: string; - last_execution_time: bigint; + last_execution_time: number; sid: string; } @@ -892,7 +892,7 @@ export interface Drivers { provider: string; manufacturer: string; driver_key: string; - date: bigint; + date: number; signed: number; } @@ -933,8 +933,8 @@ export interface LogicalDrives { device_id: string; type: string; description: string; - free_space: bigint; - size: bigint; + free_space: number; + size: number; file_system: string; boot_partition: number; } @@ -947,7 +947,7 @@ export interface LogonSessions { logon_type: string; session_id: number; logon_sid: string; - logon_time: bigint; + logon_time: number; logon_server: string; dns_domain_name: string; upn: string; @@ -987,8 +987,8 @@ export interface NTFSJournalEvents { parent_ref_number: string; drive_letter: string; file_attributes: string; - partial: bigint; - time: bigint; + partial: number; + time: number; eid: string; } @@ -996,7 +996,7 @@ export interface OfficeMRU { application: string; version: string; path: string; - last_opened_time: bigint; + last_opened_time: number; sid: string; } @@ -1013,21 +1013,21 @@ export interface Patches { export interface PhysicalDiskPerformance { name: string; - avg_disk_bytes_per_read: bigint; - avg_disk_bytes_per_write: bigint; - avg_disk_read_queue_length: bigint; - avg_disk_write_queue_length: bigint; + avg_disk_bytes_per_read: number; + avg_disk_bytes_per_write: number; + avg_disk_read_queue_length: number; + avg_disk_write_queue_length: number; avg_disk_sec_per_read: number; avg_disk_sec_per_write: number; current_disk_queue_length: number; - percent_disk_read_time: bigint; - percent_disk_write_time: bigint; - percent_disk_time: bigint; - percent_idle_time: bigint; + percent_disk_read_time: number; + percent_disk_write_time: number; + percent_disk_time: number; + percent_idle_time: number; } export interface Pipes { - pid: bigint; + pid: number; name: string; instances: number; max_instances: number; @@ -1035,7 +1035,7 @@ export interface Pipes { } export interface PowershellEvents { - time: bigint; + time: number; datetime: string; script_block_id: string; script_block_count: number; @@ -1101,7 +1101,7 @@ export interface Registry { name: string; type: string; data: string; - mtime: bigint; + mtime: number; } export interface ScheduledTask { @@ -1111,8 +1111,8 @@ export interface ScheduledTask { enabled: number; state: string; hidden: number; - last_run_time: bigint; - next_run_time: bigint; + last_run_time: number; + next_run_time: number; last_run_message: string; last_run_code: string; } @@ -1163,10 +1163,10 @@ export interface SharedResources { install_date: string; status: string; allow_maximum: number; - maximum_allowed: bigint; + maximum_allowed: number; name: string; path: string; - type: bigint; + type: number; type_name: string; } @@ -1174,17 +1174,17 @@ export interface Shellbags { sid: string; source: string; path: string; - modified_time: bigint; - created_time: bigint; - accessed_time: bigint; - mft_entry: bigint; + modified_time: number; + created_time: number; + accessed_time: number; + mft_entry: number; mft_sequence: number; } export interface Shimcache { entry: number; path: string; - modified_time: bigint; + modified_time: number; execution_flag: number; } @@ -1202,7 +1202,7 @@ export interface TpmInfo { export interface UserAssist { path: string; - last_execution_time: bigint; + last_execution_time: number; count: number; sid: string; } @@ -1210,7 +1210,7 @@ export interface UserAssist { export interface VideoInfo { color_depth: number; driver: string; - driver_date: bigint; + driver_date: number; driver_version: string; manufacturer: string; model: string; @@ -1328,9 +1328,9 @@ export interface WindowsSecurityProducts { export interface WindowsUpdateHistory { client_app_id: string; - date: bigint; + date: number; description: string; - hresult: bigint; + hresult: number; operation: string; result_code: string; server_selection: string; @@ -1338,7 +1338,7 @@ export interface WindowsUpdateHistory { support_url: string; title: string; update_id: string; - update_revision: bigint; + update_revision: number; } export interface WmiBiosInfo { @@ -1444,15 +1444,15 @@ export interface DeviceFile { partition: string; path: string; filename: string; - inode: bigint; - uid: bigint; - gid: bigint; + inode: number; + uid: number; + gid: number; mode: string; - size: bigint; + size: number; block_size: number; - atime: bigint; - mtime: bigint; - ctime: bigint; + atime: number; + mtime: number; + ctime: number; hard_links: number; type: string; } @@ -1460,7 +1460,7 @@ export interface DeviceFile { export interface DeviceHash { device: string; partition: string; - inode: bigint; + inode: number; md5: string; sha1: string; sha256: string; @@ -1471,10 +1471,10 @@ export interface DevicePartitions { partition: number; label: string; type: string; - offset: bigint; - blocks_size: bigint; - blocks: bigint; - inodes: bigint; + offset: number; + blocks_size: number; + blocks: number; + inodes: number; flags: number; } @@ -1552,22 +1552,22 @@ export interface DockerContainerPorts { export interface DockerContainerProcesses { id: string; - pid: bigint; + pid: number; name: string; cmdline: string; state: string; - uid: bigint; - gid: bigint; - euid: bigint; - egid: bigint; - suid: bigint; - sgid: bigint; - wired_size: bigint; - resident_size: bigint; - total_size: bigint; - start_time: bigint; - parent: bigint; - pgroup: bigint; + uid: number; + gid: number; + euid: number; + egid: number; + suid: number; + sgid: number; + wired_size: number; + resident_size: number; + total_size: number; + start_time: number; + parent: number; + pgroup: number; threads: number; nice: number; user: string; @@ -1580,28 +1580,28 @@ export interface DockerContainerStats { id: string; name: string; pids: number; - read: bigint; - preread: bigint; - interval: bigint; - disk_read: bigint; - disk_write: bigint; + read: number; + preread: number; + interval: number; + disk_read: number; + disk_write: number; num_procs: number; - cpu_total_usage: bigint; - cpu_kernelmode_usage: bigint; - cpu_usermode_usage: bigint; - system_cpu_usage: bigint; + cpu_total_usage: number; + cpu_kernelmode_usage: number; + cpu_usermode_usage: number; + system_cpu_usage: number; online_cpus: number; - pre_cpu_total_usage: bigint; - pre_cpu_kernelmode_usage: bigint; - pre_cpu_usermode_usage: bigint; - pre_system_cpu_usage: bigint; + pre_cpu_total_usage: number; + pre_cpu_kernelmode_usage: number; + pre_cpu_usermode_usage: number; + pre_system_cpu_usage: number; pre_online_cpus: number; - memory_usage: bigint; - memory_cached: bigint; - memory_max_usage: bigint; - memory_limit: bigint; - network_rx_bytes: bigint; - network_tx_bytes: bigint; + memory_usage: number; + memory_cached: number; + memory_max_usage: number; + memory_limit: number; + network_rx_bytes: number; + network_tx_bytes: number; } export interface DockerContainers { @@ -1610,10 +1610,10 @@ export interface DockerContainers { image: string; image_id: string; command: string; - created: bigint; + created: number; state: string; status: string; - pid: bigint; + pid: number; path: string; config_entrypoint: string; started_at: string; @@ -1633,8 +1633,8 @@ export interface DockerContainers { export interface DockerImageHistory { id: string; - created: bigint; - size: bigint; + created: number; + size: number; created_by: string; tags: string; comment: string; @@ -1654,8 +1654,8 @@ export interface DockerImageLayers { export interface DockerImages { id: string; - created: bigint; - size_bytes: bigint; + created: number; + size_bytes: number; tags: string; } @@ -1685,7 +1685,7 @@ export interface DockerInfo { os_type: string; architecture: string; cpus: number; - memory: bigint; + memory: number; http_proxy: string; https_proxy: string; no_proxy: string; @@ -1704,7 +1704,7 @@ export interface DockerNetworks { id: string; name: string; driver: string; - created: bigint; + created: number; enable_ipv6: number; subnet: string; gateway: string; @@ -1747,20 +1747,20 @@ export interface FileEvents { target_path: string; category: string; action: string; - transaction_id: bigint; - inode: bigint; - uid: bigint; - gid: bigint; + transaction_id: number; + inode: number; + uid: number; + gid: number; mode: string; - size: bigint; - atime: bigint; - mtime: bigint; - ctime: bigint; + size: number; + atime: number; + mtime: number; + ctime: number; md5: string; sha1: string; sha256: string; hashed: number; - time: bigint; + time: number; eid: string; } @@ -1775,7 +1775,7 @@ export interface HardwareEvents { model_id: string; serial: string; revision: string; - time: bigint; + time: number; eid: string; } @@ -1788,7 +1788,7 @@ export interface InterfaceIpv6 { } export interface KnownHosts { - uid: bigint; + uid: number; key: string; key_file: string; } @@ -1861,12 +1861,12 @@ export interface Mounts { device_alias: string; path: string; type: string; - blocks_size: bigint; - blocks: bigint; - blocks_free: bigint; - blocks_available: bigint; - inodes: bigint; - inodes_free: bigint; + blocks_size: number; + blocks: number; + blocks_free: number; + blocks_available: number; + inodes: number; + inodes_free: number; flags: string; } @@ -1900,42 +1900,42 @@ export interface ProcessEnvs { } export interface ProcessEvents { - pid: bigint; + pid: number; path: string; mode: string; cmdline: string; - cmdline_size: bigint; + cmdline_size: number; env: string; - env_count: bigint; - env_size: bigint; + env_count: number; + env_size: number; cwd: string; - auid: bigint; - uid: bigint; - euid: bigint; - gid: bigint; - egid: bigint; - owner_uid: bigint; - owner_gid: bigint; - atime: bigint; - mtime: bigint; - ctime: bigint; - btime: bigint; + auid: number; + uid: number; + euid: number; + gid: number; + egid: number; + owner_uid: number; + owner_gid: number; + atime: number; + mtime: number; + ctime: number; + btime: number; overflows: string; - parent: bigint; - time: bigint; - uptime: bigint; + parent: number; + time: number; + uptime: number; eid: string; - status: bigint; - fsuid: bigint; - suid: bigint; - fsgid: bigint; - sgid: bigint; + status: number; + fsuid: number; + suid: number; + fsgid: number; + sgid: number; syscall: string; } export interface ProcessOpenFiles { - pid: bigint; - fd: bigint; + pid: number; + fd: number; path: string; } @@ -1943,11 +1943,11 @@ export interface PrometheusMetrics { target_name: string; metric_name: string; metric_value: number; - timestamp_ms: bigint; + timestamp_ms: number; } export interface ShellHistory { - uid: bigint; + uid: number; time: number; command: string; history_file: string; @@ -1965,10 +1965,10 @@ export interface SmbiosTables { export interface SocketEvents { action: string; - pid: bigint; + pid: number; path: string; fd: string; - auid: bigint; + auid: number; status: string; family: number; protocol: number; @@ -1977,8 +1977,8 @@ export interface SocketEvents { local_port: number; remote_port: number; socket: string; - time: bigint; - uptime: bigint; + time: number; + uptime: number; eid: string; success: number; } @@ -2088,11 +2088,11 @@ export interface AptSources { } export interface BpfProcessEvents { - tid: bigint; - pid: bigint; - parent: bigint; - uid: bigint; - gid: bigint; + tid: number; + pid: number; + parent: number; + uid: number; + gid: number; cid: number; exit_code: string; probe_error: number; @@ -2103,16 +2103,16 @@ export interface BpfProcessEvents { duration: number; json_cmdline: string; ntime: string; - time: bigint; + time: number; eid: number; } export interface BpfSocketEvents { - tid: bigint; - pid: bigint; - parent: bigint; - uid: bigint; - gid: bigint; + tid: number; + pid: number; + parent: number; + uid: number; + gid: number; cid: number; exit_code: string; probe_error: number; @@ -2128,7 +2128,7 @@ export interface BpfSocketEvents { remote_port: number; duration: number; ntime: string; - time: bigint; + time: number; eid: number; } @@ -2136,7 +2136,7 @@ export interface DebPackages { name: string; version: string; source: string; - size: bigint; + size: number; arch: string; revision: string; status: string; @@ -2271,10 +2271,10 @@ export interface LxdNetworks { ipv4_address: string; ipv6_address: string; used_by: string; - bytes_received: bigint; - bytes_sent: bigint; - packets_received: bigint; - packets_sent: bigint; + bytes_received: number; + bytes_sent: number; + packets_received: number; + packets_sent: number; hwaddr: string; state: string; mtu: number; @@ -2285,18 +2285,18 @@ export interface LxdStoragePools { driver: string; source: string; size: string; - space_used: bigint; - space_total: bigint; - inodes_used: bigint; - inodes_total: bigint; + space_used: number; + space_total: number; + inodes_used: number; + inodes_total: number; } export interface MdDevices { device_name: string; status: string; raid_level: number; - size: bigint; - chunk_size: bigint; + size: number; + chunk_size: number; raid_disks: number; nr_raid_disks: number; working_disks: number; @@ -2305,7 +2305,7 @@ export interface MdDevices { spare_disks: number; superblock_state: string; superblock_version: string; - superblock_update_time: bigint; + superblock_update_time: number; bitmap_on_mem: string; bitmap_chunk_size: string; bitmap_external_file: string; @@ -2337,16 +2337,16 @@ export interface MdPersonalities { } export interface MemoryInfo { - memory_total: bigint; - memory_free: bigint; - memory_available: bigint; - buffers: bigint; - cached: bigint; - swap_cached: bigint; - active: bigint; - inactive: bigint; - swap_total: bigint; - swap_free: bigint; + memory_total: number; + memory_free: number; + memory_available: number; + buffers: number; + cached: number; + swap_cached: number; + active: number; + inactive: number; + swap_total: number; + swap_free: number; } export interface MemoryMap { @@ -2356,16 +2356,16 @@ export interface MemoryMap { } export interface Msr { - processor_number: bigint; - turbo_disabled: bigint; - turbo_ratio_limit: bigint; - platform_info: bigint; - perf_ctl: bigint; - perf_status: bigint; - feature_control: bigint; - rapl_power_limit: bigint; - rapl_energy_status: bigint; - rapl_power_units: bigint; + processor_number: number; + turbo_disabled: number; + turbo_ratio_limit: number; + platform_info: number; + perf_ctl: number; + perf_status: number; + feature_control: number; + rapl_power_limit: number; + rapl_energy_status: number; + rapl_power_units: number; } export interface PortageKeywords { @@ -2499,34 +2499,34 @@ export interface SelinuxSettings { export interface Shadow { password_status: string; hash_alg: string; - last_change: bigint; - min: bigint; - max: bigint; - warning: bigint; - inactive: bigint; - expire: bigint; - flag: bigint; + last_change: number; + min: number; + max: number; + warning: number; + inactive: number; + expire: number; + flag: number; username: string; } export interface SharedMemory { shmid: number; - owner_uid: bigint; - creator_uid: bigint; - pid: bigint; - creator_pid: bigint; - atime: bigint; - dtime: bigint; - ctime: bigint; + owner_uid: number; + creator_uid: number; + pid: number; + creator_pid: number; + atime: number; + dtime: number; + ctime: number; permissions: string; - size: bigint; + size: number; attached: number; status: string; locked: number; } export interface SyslogEvent { - time: bigint; + time: number; datetime: string; host: string; severity: number; @@ -2545,7 +2545,7 @@ export interface SystemdUnit { unit_file_state: string; following: string; object_path: string; - job_id: bigint; + job_id: number; job_type: string; job_path: string; fragment_path: string; diff --git a/yarn.lock b/yarn.lock index 5ebdc36..3e7e858 100644 --- a/yarn.lock +++ b/yarn.lock @@ -166,9 +166,9 @@ dependencies: "@babel/helper-plugin-utils" "^7.8.0" -"@babel/plugin-syntax-bigint@^7.8.3": +"@babel/plugin-syntax-number@^7.8.3": version "7.8.3" - resolved "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz" + resolved "https://registry.npmjs.org/@babel/plugin-syntax-number/-/plugin-syntax-number-7.8.3.tgz" integrity sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg== dependencies: "@babel/helper-plugin-utils" "^7.8.0" @@ -740,7 +740,7 @@ babel-preset-current-node-syntax@^1.0.0: integrity sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ== dependencies: "@babel/plugin-syntax-async-generators" "^7.8.4" - "@babel/plugin-syntax-bigint" "^7.8.3" + "@babel/plugin-syntax-number" "^7.8.3" "@babel/plugin-syntax-class-properties" "^7.8.3" "@babel/plugin-syntax-import-meta" "^7.8.3" "@babel/plugin-syntax-json-strings" "^7.8.3"