291 lines
13 KiB
JavaScript
291 lines
13 KiB
JavaScript
// Import necessary modules for testing
|
|
import { expect } from 'chai';
|
|
import ioClient from 'socket.io-client';
|
|
import { app, nodeIo, server } from '../modules/socketServer.mjs';
|
|
import { getNodeByNuid, deleteNodeByNuid } from '../modules/mongoNodesWrappers.mjs';
|
|
import { deleteSystemByName, getSystemByName } from '../modules/mongoSystemsWrappers.mjs';
|
|
import { logIntoServerWrapper } from '../../client/modules/socketClientWrappers.mjs';
|
|
|
|
import dotenv from 'dotenv';
|
|
dotenv.config()
|
|
|
|
process.env.SERVER_PORT = 6000
|
|
|
|
// Define necessary variables for testing, such as mocked database connections or socket instances
|
|
const localNodeConfig = {
|
|
serverIp: 'localhost',
|
|
serverPort: process.env.SERVER_PORT,
|
|
node: {
|
|
nuid: "4f29a6340901a12affc87047c0ac16b01b92496c460c880a2459abe8c7928374",
|
|
name: "testyv7",
|
|
location: "china",
|
|
capabilities: ["radio"]
|
|
},
|
|
nearbySystems: {
|
|
"Testing P25 System Name": {
|
|
"frequencies": [
|
|
155344000,
|
|
155444000,
|
|
155555000,
|
|
155588550
|
|
],
|
|
"mode": "p25",
|
|
"trunkFile": "trunk.tsv",
|
|
"whitelistFile": "whitelist.tsv"
|
|
}
|
|
}
|
|
};
|
|
|
|
const updatedLocalNodeConfig = {
|
|
node: {
|
|
nuid: localNodeConfig.node.nuid,
|
|
name: "updatedName",
|
|
location: "updatedLocation",
|
|
capabilities: ["radio", "weather"] // Updated capabilities
|
|
},
|
|
nearbySystems: {
|
|
"Testing P25 System Name": {
|
|
"frequencies": [
|
|
155444000,
|
|
155555000,
|
|
155500000
|
|
],
|
|
"mode": "p25",
|
|
"trunkFile": "trunk2.tsv",
|
|
"whitelistFile": "whitelist2.tsv"
|
|
}
|
|
}
|
|
};
|
|
|
|
// Start the Socket.IO server before running tests
|
|
let clientSocket; // The socket client
|
|
let serverClientSocket // The open client socket on the server
|
|
before(done => {
|
|
// Startup the node server
|
|
nodeIo.listen(process.env.SERVER_PORT || 3000, () => {
|
|
console.log(`server running at http://localhost:${process.env.SERVER_PORT}`);
|
|
});
|
|
|
|
// Connect a client socket to the server
|
|
clientSocket = ioClient.connect(`http://localhost:${process.env.SERVER_PORT}`);
|
|
|
|
nodeIo.on('connection', (socket) => {
|
|
serverClientSocket = socket;
|
|
done();
|
|
})
|
|
});
|
|
|
|
// Close the Socket.IO server after running tests
|
|
after(async () => {
|
|
// Disconnect client socket
|
|
clientSocket.disconnect();
|
|
|
|
// Close the server
|
|
nodeIo.close();
|
|
|
|
// Remove the test data
|
|
deleteNodeByNuid(localNodeConfig.node.nuid); // Delete the user
|
|
deleteSystemByName(Object.keys(localNodeConfig.nearbySystems)[0])
|
|
});
|
|
|
|
describe('Node Core Server Tests', () => {
|
|
// Test Node Login functionality
|
|
describe('Node Login', () => {
|
|
it('should add a new node if it does not exist', async () => {
|
|
// Simulate a node login request
|
|
// Use the getNodeByNuid mock function to simulate checking if node exists
|
|
const existingNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
// Assert that existingNode is null before node login
|
|
expect(existingNode).to.be.null;
|
|
|
|
// Wait for the update
|
|
const node_login = new Promise(res => {
|
|
clientSocket.on('node-login-successful', async () => {
|
|
res();
|
|
});
|
|
});
|
|
|
|
// Emit the login command
|
|
clientSocket.emit("node-login", localNodeConfig.node);
|
|
|
|
// Wait for the successful login event
|
|
await node_login;
|
|
|
|
// Now we need to check if the node is added to the database
|
|
// We can use getNodeByNuid again to verify if the node was added correctly
|
|
const addedNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
console.log("Added Node:", addedNode);
|
|
|
|
// Assert that the node is added correctly
|
|
expect(addedNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(addedNode).to.have.property('nuid', localNodeConfig.node.nuid);
|
|
expect(addedNode).to.have.property('name', localNodeConfig.node.name);
|
|
expect(addedNode).to.have.property('location', localNodeConfig.node.location);
|
|
expect(addedNode).to.have.deep.property('capabilities', localNodeConfig.node.capabilities);
|
|
})
|
|
it('should update a node if it exists', async () => {
|
|
// Simulate a node login request
|
|
// Use the getNodeByNuid mock function to simulate checking if node exists
|
|
const existingNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
// Assert that existingNode is matches the existing data before logging in
|
|
expect(existingNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(existingNode).to.have.property('nuid', localNodeConfig.node.nuid);
|
|
expect(existingNode).to.have.property('name', localNodeConfig.node.name);
|
|
expect(existingNode).to.have.property('location', localNodeConfig.node.location);
|
|
expect(existingNode).to.have.deep.property('capabilities', localNodeConfig.node.capabilities);
|
|
|
|
// Wait for the update
|
|
const node_login = new Promise(res => {
|
|
clientSocket.on('node-login-successful', async () => {
|
|
res();
|
|
});
|
|
});
|
|
|
|
// Emit the login command
|
|
clientSocket.emit("node-login", updatedLocalNodeConfig.node);
|
|
|
|
// Wait for the successful login event
|
|
await node_login;
|
|
|
|
// Now we need to check if the node is added to the database
|
|
// We can use getNodeByNuid again to verify if the node was added correctly
|
|
const updatedNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
console.log("Updated Node:", updatedNode);
|
|
|
|
// Assert that the node is added correctly
|
|
expect(updatedNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(updatedNode).to.have.property('nuid', updatedLocalNodeConfig.node.nuid);
|
|
expect(updatedNode).to.have.property('name', updatedLocalNodeConfig.node.name);
|
|
expect(updatedNode).to.have.property('location', updatedLocalNodeConfig.node.location);
|
|
expect(updatedNode).to.have.deep.property('capabilities', updatedLocalNodeConfig.node.capabilities);
|
|
})
|
|
});
|
|
|
|
// Test Node Update functionality
|
|
describe('Node Update', () => {
|
|
it('should add a node\'s nearby systems', async () => {
|
|
// Simulate an update request sent from the client to the server
|
|
|
|
// Get the existing node in the database
|
|
const existingNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
// Assert that existingNode matches the updatedLocalNodeConfig
|
|
expect(existingNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(existingNode).to.have.property('nuid', updatedLocalNodeConfig.node.nuid);
|
|
expect(existingNode).to.have.property('name', updatedLocalNodeConfig.node.name);
|
|
expect(existingNode).to.have.property('location', updatedLocalNodeConfig.node.location);
|
|
expect(existingNode).to.have.deep.property('capabilities', updatedLocalNodeConfig.node.capabilities);
|
|
|
|
// Get the system from the DB
|
|
const existsingSystem = await getSystemByName("Testing P25 System Name");
|
|
|
|
// Assert that there is no existing system in the DB
|
|
expect(existsingSystem).to.be.null;
|
|
|
|
// Wait for the update
|
|
const node_system_update = new Promise(res => {
|
|
clientSocket.on('node-update-successful', async () => {
|
|
res();
|
|
});
|
|
});
|
|
|
|
// Emit the update command
|
|
clientSocket.emit("node-update", updatedLocalNodeConfig);
|
|
|
|
// Wait for the successful update event
|
|
await node_system_update;
|
|
|
|
// Now we need to check if the system is added to the database
|
|
// We can use getNodeByNuid again to verify if the node was added correctly
|
|
const updatedNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
console.log("Updated Node:", updatedNode);
|
|
|
|
// Assert that the node is added correctly
|
|
expect(updatedNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(updatedNode).to.have.property('nuid', updatedLocalNodeConfig.node.nuid);
|
|
expect(updatedNode).to.have.property('name', updatedLocalNodeConfig.node.name);
|
|
expect(updatedNode).to.have.property('location', updatedLocalNodeConfig.node.location);
|
|
expect(updatedNode).to.have.deep.property('capabilities', updatedLocalNodeConfig.node.capabilities);
|
|
|
|
// Get the updated system
|
|
const addedSystem = await getSystemByName("Testing P25 System Name");
|
|
|
|
console.log("Added system:", addedSystem);
|
|
|
|
expect(addedSystem).to.have.property('_id'); // Check if _id property exists
|
|
expect(addedSystem).to.have.property('nodes'); // Check if nodes property exists
|
|
expect(addedSystem.nodes).to.include(updatedLocalNodeConfig.node.nuid) // Check if this node ID is in the nodes array
|
|
expect(addedSystem).to.have.deep.property('frequencies', updatedLocalNodeConfig.nearbySystems['Testing P25 System Name'].frequencies);
|
|
expect(addedSystem).to.have.property('mode', updatedLocalNodeConfig.nearbySystems['Testing P25 System Name'].mode);
|
|
});
|
|
|
|
it('should update a node and its nearby systems', async () => {
|
|
// Get the existing node in the database
|
|
const existingNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
// Assert that existingNode matches the updatedLocalNodeConfig
|
|
expect(existingNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(existingNode).to.have.property('nuid', updatedLocalNodeConfig.node.nuid);
|
|
expect(existingNode).to.have.property('name', updatedLocalNodeConfig.node.name);
|
|
expect(existingNode).to.have.property('location', updatedLocalNodeConfig.node.location);
|
|
expect(existingNode).to.have.deep.property('capabilities', updatedLocalNodeConfig.node.capabilities);
|
|
|
|
// Get the updated system
|
|
const existingSystem = await getSystemByName("Testing P25 System Name");
|
|
expect(existingSystem).to.have.property('_id'); // Check if _id property exists
|
|
expect(existingSystem).to.have.property('nodes'); // Check if nodes property exists
|
|
expect(existingSystem.nodes).to.include(updatedLocalNodeConfig.node.nuid) // Check if this node ID is in the nodes array
|
|
expect(existingSystem).to.have.deep.property('frequencies', updatedLocalNodeConfig.nearbySystems['Testing P25 System Name'].frequencies);
|
|
expect(existingSystem).to.have.property('mode', updatedLocalNodeConfig.nearbySystems['Testing P25 System Name'].mode);
|
|
|
|
|
|
// Wait for the update
|
|
const node_update = new Promise(res => {
|
|
clientSocket.on('node-update-successful', async () => {
|
|
res();
|
|
});
|
|
});
|
|
|
|
// Emit the update command
|
|
clientSocket.emit("node-update", localNodeConfig);
|
|
|
|
// Wait for the successful update event
|
|
await node_update;
|
|
|
|
const updatedNode = await getNodeByNuid(localNodeConfig.node.nuid);
|
|
|
|
console.log("Updated Node:", updatedNode);
|
|
|
|
// Assert that the node is added correctly
|
|
expect(updatedNode).to.have.property('_id'); // Check if _id property exists
|
|
expect(updatedNode).to.have.property('nuid', localNodeConfig.node.nuid);
|
|
expect(updatedNode).to.have.property('name', localNodeConfig.node.name);
|
|
expect(updatedNode).to.have.property('location', localNodeConfig.node.location);
|
|
expect(updatedNode).to.have.deep.property('capabilities', localNodeConfig.node.capabilities);
|
|
|
|
// Get the updated system
|
|
const updatedSystem = await getSystemByName("Testing P25 System Name");
|
|
|
|
console.log("Updated system:", updatedSystem);
|
|
|
|
expect(updatedSystem).to.have.property('_id'); // Check if _id property exists
|
|
expect(updatedSystem).to.have.property('nodes'); // Check if nodes property exists
|
|
expect(updatedSystem.nodes).include(localNodeConfig.node.nuid) // Check if this node ID is in the nodes array
|
|
expect(updatedSystem).to.have.deep.property('frequencies', localNodeConfig.nearbySystems['Testing P25 System Name'].frequencies);
|
|
expect(updatedSystem).to.have.property('mode', localNodeConfig.nearbySystems['Testing P25 System Name'].mode);
|
|
|
|
});
|
|
});
|
|
|
|
describe('Node Disconnect', () => {
|
|
it('should trigger cleanup actions upon socket disconnection', async () => {
|
|
// Write test code to simulate a socket disconnection
|
|
// Check if the appropriate cleanup actions are triggered
|
|
});
|
|
})
|
|
}); |