Initial migration to jasmine

- Still bugs in tests from migration

.gitea/workflows/DRBv3_server_build.yaml

@@ -25,14 +25,14 @@ jobs:
         uses: docker/setup-buildx-action@v2
         with: # replace it with your local IP
           config-inline: |
-            [registry."git.vpn.cusano.net"] 
-              http = false
-              insecure = false            
+            [registry."${{ secrets.LOCAL_GITEA_IP}}:3000"] 
+              http = true
+              insecure = true            
 
       - name: Login to DockerHub
         uses: docker/login-action@v2
         with:
-          registry: git.vpn.cusano.net # replace it with your local IP
+          registry: ${{ secrets.LOCAL_GITEA_IP}}:3000 # replace it with your local IP
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
           
@@ -52,5 +52,5 @@ jobs:
             linux/arm64                        
           push: true
           tags: | # replace it with your local IP and tags
-            git.vpn.cusano.net/${{ vars.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}
-            git.vpn.cusano.net/${{ vars.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ env.DOCKER_LATEST }}
+            ${{ secrets.LOCAL_GITEA_IP}}:3000/${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}
+            ${{ secrets.LOCAL_GITEA_IP}}:3000/${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ env.DOCKER_LATEST }}

Dockerfile

@@ -15,7 +15,7 @@ RUN npm install
 COPY . .
 
 # Expose the port on which your Node.js application will run
-EXPOSE 3420
+EXPOSE 3000
 
 # Command to run the Node.js application
 CMD ["node", "."]

discordBot/addons/gptInteraction.mjs

@@ -1,53 +0,0 @@
-import { DebugBuilder } from "../../modules/debugger.mjs";
-const log = new DebugBuilder("server", "discordBot.addons.gptInteraction");
-import { gptHandler } from "../modules/gptHandler.mjs";
-
-export const gptInteraction = async (nodeIo, message) => {
-    let conversation = [];
-
-    let prevMessages = await message.channel.messages.fetch({ limit: 10 });
-    prevMessages.reverse();
-
-    prevMessages.forEach((msg) => {
-        // Check if the message was sent within the last 24 hours
-        if (new Date().getTime() - msg.createdTimestamp > (24 * 60 * 60 * 1000)) {
-            return;
-        }
-
-        // Check if it's from a bot other than the server
-        if (msg.author.bot && msg.author.id !== nodeIo.serverClient.user.id) return;
-
-        const username = msg.author.username.replace(/\s+/g, '_').replace(/[^\w\s]/gi, '');
-
-        if (msg.author.id === nodeIo.serverClient.user.id) {
-            conversation.push({
-                role: 'assistant',
-                name: msg.author.id,
-                content: msg.content,
-            });
-
-            return;
-        }
-
-        conversation.push({
-            role: 'user',
-            name: msg.author.id,
-            content: msg.content.replace(`<@${nodeIo.serverClient.user.id}>`, ''),
-        });
-    });    
-    const response = await gptHandler(conversation);
-    if (response) {
-        const responseMessage = response.choices[0].message.content;
-        const chunkSize = 2500;
-
-        for (let i = 0; i < responseMessage.length; i += chunkSize) {
-            const chunk = responseMessage.substring(i, i + chunkSize);
-
-            log.DEBUG("Sending message chunk:", chunk);
-
-            await message.reply(chunk);
-        }
-    } else {
-        message.channel.send('Sorry, I encountered an error while processing your request.');
-    }
-}

discordBot/addons/linkCop.mjs

@@ -1,83 +0,0 @@
-import { DebugBuilder } from "../../modules/debugger.mjs";
-const log = new DebugBuilder("server", "discordBot.addons.linkCop");
-import { gptHandler } from "../modules/gptHandler.mjs";
-import dotenv from 'dotenv';
-dotenv.config();
-
-const approvedLinksChannel = "767303243285790721";
-const restrictedChannelIds = process.env.LINKCOP_RESTRICTED_CHANNEL_IDS.split(',');
-
-const linkRegExp = /(?:http[s]?:\/\/)?(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)/g
-
-export const linkCop = async (nodeIo, message) => {
-    if (message.channel.id == approvedLinksChannel || !restrictedChannelIds.includes(message.channel.id)) return false;    
-
-    const urls = String(message.content).matchAll(linkRegExp);
-    if (!urls || urls.length === 0) return false;
-    log.DEBUG("Found URLs: ", urls);
-
-    let conversation = [];
-
-    let prevMessages = await message.channel.messages.fetch({ limit: 2 });
-    prevMessages.reverse();
-
-    prevMessages.forEach((msg) => {
-        // Check if the message was sent within the last 5 minutes
-        if (new Date().getTime() - msg.createdTimestamp > (5 * 60 * 1000)) {
-            return;
-        }
-
-        // Check if it's from a bot other than the server
-        if (msg.author.bot && msg.author.id !== nodeIo.serverClient.user.id) return;
-
-        const username = msg.author.username.replace(/\s+/g, '_').replace(/[^\w\s]/gi, '');
-
-        if (msg.author.id === nodeIo.serverClient.user.id) {
-            conversation.push({
-                role: 'assistant',
-                name: msg.author.id,
-                content: msg.content,
-            });
-
-            return;
-        }
-
-        conversation.push({
-            role: 'user',
-            name: msg.author.id,
-            content: msg.content.replace(`<@${nodeIo.serverClient.user.id}>`, ''),
-        });
-    }); 
-
-    conversation.push({
-        role: 'system',
-        content: `There has been a link posted to a channel that links are not allowed in. The above messages are from the channel that links are not allowed including the message with the link. The message with the link is going to be deleted and moved to the '#links' channels. You should let the user know.`
-    });
-
-    const response = await gptHandler(conversation);
-
-    if (response) {
-        const responseMessage = response.choices[0].message.content;
-        const chunkSize = 2000;
-
-        for (let i = 0; i < responseMessage.length; i += chunkSize) {
-            const chunk = responseMessage.substring(i, i + chunkSize);
-
-            log.DEBUG("Sending message chunk:", chunk);
-
-            await message.reply(chunk);
-        }
-
-        const messageContent = {
-            'author': message.author,
-            'content': `<@${message.author.id}> - ${String(message.content)}`,
-            'channelId': message.channelId,
-            'links': urls
-        }
-    
-        await message.delete();
-        log.DEBUG("Message content: ", messageContent);    
-    
-        message.client.channels.cache.get(approvedLinksChannel).send(messageContent);
-    } 
-}

discordBot/commands/rssAdd.mjs

@@ -54,19 +54,18 @@ export const execute = async (nodeIo, interaction) => {
     var category = interaction.options.getString('category');
 
     if (!category) category = "ALL";
-    await interaction.reply(`Adding ${title} to the list of RSS sources, please wait...`);
 
     await addSource(title, link, category, interaction.guildId, interaction.channelId, (err, result) => {
       log.DEBUG("Result from adding entry", result);
 
       if (result) {
-        interaction.editReply(`Successfully added ${title} to the list of RSS sources`);
+        interaction.reply(`Successfully added ${title} to the list of RSS sources`);
       } else {
-        interaction.editReply(`${title} already exists in the list of RSS sources`);
+        interaction.reply(`${title} already exists in the list of RSS sources`);
       }
     });
   } catch (err) {
     log.ERROR(err)
-    await interaction.editReply(err.toString());
+    await interaction.reply(err.toString());
   }
 }

discordBot/commands/rssRemove.mjs

@@ -42,17 +42,17 @@ export async function autocomplete(nodeIo, interaction) {
 export const execute = async (nodeIo, interaction) => {
   try {
     var title = interaction.options.getString('title');
-    await interaction.reply(`Removing ${title} from the list of RSS sources, please wait...`);
+    interaction.reply(`Removing ${title} from the list of RSS sources, please wait...`);
 
     const results = await deleteFeedByTitle(title);
     if (!results) {
       log.WARN(`Failed to remove source: ${title}`);
-      await interaction.editReply(`Failed to remove source: '${title}'`);
+      interaction.editReply(`Failed to remove source: '${title}'`);
       return;
     }
-    await interaction.editReply(`${title} was successfully removed from the RSS sources.`)
+    interaction.editReply(`${title} was successfully removed from the RSS sources.`)
   } catch (err) {
     log.ERROR(err)
-    await interaction.editReply(err.toString());
+    interaction.editReply(err.toString());
   }
 }

discordBot/commands/rssTrigger.mjs

@@ -38,7 +38,6 @@ export const execute = async (nodeIo, interaction) => {
         //await interaction.reply(`**Online Sockets: '${sockets}'**`);
         await interaction.reply('Triggering RSS update');
         await updateFeeds(interaction.client);
-        await interaction.editReply('RSS Update Completed');
         //await interaction.channel.send('**Pong.**');
     } catch (err) {
         console.error(err);

discordBot/discordBot.mjs

@@ -79,7 +79,7 @@ export function addEnabledEventListeners(serverClient, _eventsPath = "./events")
 }
 
 // The discord client
-export const serverClient = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildPresences] });
+export const serverClient = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates] });
 
 // Run when the bot is ready
 serverClient.on('ready', async () => {

discordBot/events/guildCreate.mjs

@@ -1,16 +0,0 @@
-import { DebugBuilder } from "../../modules/debugger.mjs";
-const log = new DebugBuilder("server", "discordBot.events.guildCreate");
-import { Events } from 'discord.js';
-import { addEnabledCommands, addEnabledEventListeners } from "../discordBot.mjs";
-
-export const name = Events.GuildMemberAdd;
-
-export async function execute(nodeIo, guild) {
-    log.INFO("Bot has joined a new server", guild);
-
-    log.DEBUG("Refreshing commands enabled");
-    await addEnabledCommands(nodeIo.serverClient);
-
-    log.DEBUG("Refreshing events enabled");
-    await addEnabledEventListeners(nodeIo.serverClient);
-}

discordBot/events/guildMemberAdd.mjs

@@ -1,34 +0,0 @@
-import { DebugBuilder } from "../../modules/debugger.mjs";
-const log = new DebugBuilder("server", "discordBot.events.guildMemberAdd");
-import dotenv from 'dotenv';
-dotenv.config();
-import { Events } from 'discord.js';
-import { gptHandler } from "../modules/gptHandler.mjs";
-
-const welcomeChannel = process.env.WELCOME_CHANNEL_ID;
-
-export const name = Events.GuildMemberAdd;
-
-export async function execute(nodeIo, member) {
-    log.INFO("New user joined the server", member);
-    let conversation = [];
-    conversation.push({
-        role: 'system',
-        content: `There has been a new user that joined. Their name is '<@${member.id}>'. Please welcome them to the server and remind them about the rules.`
-    })
-
-    const response = await gptHandler(conversation);
-    if (response) {
-        const responseMessage = response.choices[0].message.content;
-        const chunkSize = 2500;
-
-        for (let i = 0; i < responseMessage.length; i += chunkSize) {
-            const chunk = responseMessage.substring(i, i + chunkSize);
-
-            log.DEBUG("Sending message chunk:", chunk);
-
-            await nodeIo.serverClient.channels.cache.get(welcomeChannel).send(chunk);
-        }
-    }
-
-}

discordBot/events/messageCreate.mjs

@@ -1,29 +0,0 @@
-import { DebugBuilder } from "../../modules/debugger.mjs";
-const log = new DebugBuilder("server", "discordBot.events.messageCreate");
-import dotenv from 'dotenv';
-dotenv.config();
-import { Events } from 'discord.js';
-import { gptInteraction } from '../addons/gptInteraction.mjs';
-import { linkCop } from '../addons/linkCop.mjs';
-
-const IGNORED_CHANNELS = process.env.IGNORED_CHANNEL_IDS.split(',');
-
-export const name = Events.MessageCreate;
-
-export async function execute(nodeIo, message) {
-    // Ignore ignored channels
-    if (IGNORED_CHANNELS.includes(message.channel.id)) return;
-
-    // Ignore messages from a bot
-    if (message.author.bot) return;
-
-    log.INFO("Message create", message);
-
-    // Check if the message mentions the bot
-    if (message.mentions.users.has(nodeIo.serverClient.user.id)) {
-        return await gptInteraction(nodeIo, message);
-    }
-
-    // Check if the message contains a link in a channel it shouldn't
-    if (await linkCop(nodeIo, message)) return;
-}

discordBot/modules/gptHandler.mjs

@@ -1,39 +0,0 @@
-import { DebugBuilder } from "../../modules/debugger.mjs";
-const log = new DebugBuilder("server", "discordBot.modules.gptHandler");
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { OpenAI } from 'openai';
-
-const openai = new OpenAI(process.env.OPENAI_API_KEY);
-
-let conversation = [];
-
-conversation.push({
-    role: 'system',
-    content: process.env.DRB_SERVER_INITIAL_PROMPT
-});
-
-export const gptHandler = async (additionalMessages) => {
-    // Add the additional messages to the conversation
-    conversation = conversation.concat(additionalMessages);
-    log.DEBUG("AI Conversation:", conversation);
-    try {
-        const response = await openai.chat.completions.create({
-            model: 'gpt-3.5-turbo',
-            messages: conversation,
-        }).catch((error) => log.ERROR("OpenAI Error: ", error));
-
-        log.DEBUG("AI Response:", response);
-
-        if (!response) {            
-            return false;
-        }
-
-        return response
-
-    } catch (error) {
-        console.error('Error generating response:', error);
-        return false;        
-    }
-}

package.json

@@ -4,27 +4,26 @@
   "description": "",
   "main": "server.js",
   "scripts": {
-    "test": "mocha --timeout 5000",
+    "test": "jasmine",
     "start": "node server.js"
   },
   "author": "Logan Cusano",
   "license": "ISC",
   "type": "module",
   "devDependencies": {
-    "chai": "^5.1.1",
+    "chai": "^5.1.0",
     "mocha": "^10.4.0",
     "socket.io-client": "^4.7.5"
   },
   "dependencies": {
-    "discord.js": "^14.15.2",
-    "dotenv": "^16.4.5",
-    "express": "^4.19.2",
-    "mongodb": "^6.7.0",
+    "discord.js": "^14.14.1",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "mongodb": "^6.3.0",
     "morgan": "^1.10.0",
     "node-html-parser": "^6.1.13",
-    "openai": "^4.47.3",
     "rss-parser": "^3.13.0",
-    "socket.io": "^4.7.5",
-    "user-agents": "^1.1.222"
+    "socket.io": "^4.7.2",
+    "user-agents": "^1.1.208"
   }
 }

rss-manager/sourceManager.mjs

@@ -1,5 +1,3 @@
-import { DebugBuilder } from "../modules/debugger.mjs";
-const log = new DebugBuilder("server", "sourceManager");
 import { createFeed, getFeedByLink, deleteFeedByLink } from '../modules/mongo-wrappers/mongoFeedsWrappers.mjs';
 
 class SourceManager {

spec/support/jasmine.json

@@ -0,0 +1,13 @@
+{
+  "spec_dir": "spec",
+  "spec_files": [
+    "**/*[sS]pec.?(m)js"
+  ],
+  "helpers": [
+    "helpers/**/*.?(m)js"
+  ],
+  "env": {
+    "stopSpecOnExpectationFailure": false,
+    "random": true
+  }
+}

spec/test/rssManager.spec.js.b

@@ -0,0 +1,29 @@
+import * as feedHandler from '../../rss-manager/feedHandler.mjs';
+import * as mw from '../../modules/mongo-wrappers/mongoFeedsWrappers.mjs';
+import * as drw from '../../discordBot/modules/rssWrappers.mjs';
+
+describe('feedHandler', () => {
+  it('should call updateFeeds', async () => {
+    // Spy on the updateFeeds function
+    const feedsSpy = spyOn(mw, 'getAllFeeds').and.stub();
+    const sendPostSpy = spyOn(drw, 'sendPost').and.stub();
+
+    // Call the function that triggers updateFeeds
+    // For example:
+    // someFunctionThatCallsUpdateFeeds();
+    console.log(await spyOn(feedHandler, 'updateFeeds').and.callThrough({
+      channels: {
+        cache: {
+          get: () => ([{
+            // Stub methods or properties of the channel object as needed for testing
+          }])
+        }
+      }
+    }));
+
+    // Add your expectations here to ensure updateFeeds was called
+    expect(feedsSpy).toHaveBeenCalled();
+    expect(sendPostSpy).toHaveBeenCalled();
+    // Add more specific expectations if needed
+  });
+});

spec/test/socketServerWrappers.spec.js

@@ -0,0 +1,494 @@
+// Import necessary modules for testing
+import ioClient from 'socket.io-client';
+import { deleteNodeByNuid, getNodeByNuid } from '../../modules/mongo-wrappers/mongoNodesWrappers.mjs';
+import { deleteSystemByName, getSystemByName } from '../../modules/mongo-wrappers/mongoSystemsWrappers.mjs';
+import { nodeDisconnectWrapper, checkIfNodeHasOpenDiscordClient, getNodeCurrentListeningSystem, checkIfNodeIsConnectedToVC, getNodeDiscordUsername, getNodeDiscordID, requestBotLeaveServer, requestNodeJoinSystem, requestNodeUpdate } from '../../modules/socketServerWrappers.mjs';
+import { nodeIo } from '../../modules/socketServer.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"
+        }
+    }
+};
+
+describe('Socket Server - Core Tests', () => {
+    // Start the Socket.IO server before running tests
+    let clientSocket; // The socket client
+    let serverClientSocket // The open client socket on the server
+    beforeAll(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
+    afterAll(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])
+    });
+    // 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).toEqual(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['_id']).toBeDefined(); // Check if _id property exists            
+            expect(addedNode['nuid']).toEqual(localNodeConfig.node.nuid);
+            expect(addedNode['name']).toEqual(localNodeConfig.node.name);
+            expect(addedNode['location']).toEqual(localNodeConfig.node.location);
+            expect(addedNode['capabilities']).toEqual(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['_id']).toBeDefined(); // Check if _id property exists            
+            expect(existingNode['nuid']).toEqual(localNodeConfig.node.nuid);
+            expect(existingNode['name']).toEqual(localNodeConfig.node.name);
+            expect(existingNode['location']).toEqual(localNodeConfig.node.location);
+            expect(existingNode['capabilities']).toEqual(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['_id']).toBeDefined(); // Check if _id property exists            
+            expect(updatedNode['nuid']).toEqual(updatedLocalNodeConfig.node.nuid);
+            expect(updatedNode['name']).toEqual(updatedLocalNodeConfig.node.name);
+            expect(updatedNode['location']).toEqual(updatedLocalNodeConfig.node.location);
+            expect(updatedNode['capabilities']).toEqual(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['_id']).toBeDefined(); // Check if _id property exists            
+            expect(existingNode['nuid']).toEqual(updatedLocalNodeConfig.node.nuid);
+            expect(existingNode['name']).toEqual(updatedLocalNodeConfig.node.name);
+            expect(existingNode['location']).toEqual(updatedLocalNodeConfig.node.location);
+            expect(existingNode['capabilities']).toEqual(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).toEqual(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['_id']).toBeDefined(); // Check if _id property exists            
+            expect(updatedNode['nuid']).toEqual(updatedLocalNodeConfig.node.nuid);
+            expect(updatedNode['name']).toEqual(updatedLocalNodeConfig.node.name);
+            expect(updatedNode['location']).toEqual(updatedLocalNodeConfig.node.location);
+            expect(updatedNode['capabilities']).toEqual(updatedLocalNodeConfig.node.capabilities);
+
+            // Get the updated system 
+            const addedSystem = await getSystemByName("Testing P25 System Name");
+
+            console.log("Added system:", addedSystem);
+
+            expect(addedSystem['_id']).toBeDefined(); // Check if _id property exists
+            expect(addedSystem['nodes']).toBeDefined(); // Check if nodes property exists
+            expect(addedSystem.nodes).toEqual(updatedLocalNodeConfig.node.nuid) // Check if this node ID is in the nodes array
+            expect(addedSystem['frequencies']).toEqual(updatedLocalNodeConfig.nearbySystems['Testing P25 System Name'].frequencies);
+            expect(addedSystem['mode']).toEqual(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['_id']).toBeDefined(); // Check if _id property exists
+            expect(existingNode['nuid']).toEqual(updatedLocalNodeConfig.node.nuid);
+            expect(existingNode['name']).toEqual(updatedLocalNodeConfig.node.name);
+            expect(existingNode['location']).toEqual(updatedLocalNodeConfig.node.location);
+            expect(existingNode['capabilities']).toEqual(updatedLocalNodeConfig.node.capabilities);
+
+            // Get the updated system 
+            const existingSystem = await getSystemByName("Testing P25 System Name");
+            expect(existingSystem['_id']).toBeDefined(); // Check if _id property exists
+            expect(existingSystem['nodes']).toBeDefined(); // Check if nodes property exists
+            expect(existingSystem.nodes).toContain(updatedLocalNodeConfig.node.nuid); // Check if this node ID is in the nodes array
+            expect(existingSystem['frequencies']).toEqual(updatedLocalNodeConfig.nearbySystems['Testing P25 System Name'].frequencies);
+            expect(existingSystem['mode']).toEqual(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['_id']).toBeDefined(); // Check if _id property exists
+            expect(updatedNode['nuid']).toEqual(localNodeConfig.node.nuid);
+            expect(updatedNode['name']).toEqual(localNodeConfig.node.name);
+            expect(updatedNode['location']).toEqual(localNodeConfig.node.location);
+            expect(updatedNode['capabilities']).toEqual(localNodeConfig.node.capabilities);
+
+            // Get the updated system 
+            const updatedSystem = await getSystemByName("Testing P25 System Name");
+
+            console.log("Updated system:", updatedSystem);
+
+            expect(updatedSystem['_id']).toBeDefined(); // Check if _id property exists
+            expect(updatedSystem['nodes']).toBeDefined(); // Check if nodes property exists
+            expect(updatedSystem.nodes).toContain(localNodeConfig.node.nuid); // Check if this node ID is in the nodes array
+            expect(updatedSystem['frequencies']).toEqual(localNodeConfig.nearbySystems['Testing P25 System Name'].frequencies);
+            expect(updatedSystem['mode']).toEqual(localNodeConfig.nearbySystems['Testing P25 System Name'].mode);
+        });
+    });
+
+    // Test getNodeCurrentListeningSystem
+    describe('Get Node Current Listening System', () => {
+        it('should correctly determine if the node is connected to a voice channel', async () => {
+            // Simulate that the client socket is listening to a system
+            const isConnectedToVC = true;
+            const guildId = 'mockGuildId';
+
+            // Emit the event to the server and wait for the response
+            const nodeReply = new Promise((resolve) => {
+                clientSocket.once('node-check-connected-status', (passedGuildId, callback) => {
+                    // Check if the passed guild ID matches the expected guild ID
+                    expect(passedGuildId).toEqual(guildId);
+                    // Simulate receiving the connection status from the client
+                    callback(isConnectedToVC);
+                });
+
+                // Call the function to check if the node is connected to a voice channel
+                const response = checkIfNodeIsConnectedToVC(nodeIo, guildId, localNodeConfig.node.nuid);
+                resolve(response);
+            });
+
+            // Wait for the promise to resolve
+            const response = await nodeReply;
+
+            // Assert that the response matches the expected connection status
+            expect(response).toEqual(isConnectedToVC);
+        });
+    });
+
+    // Test checkIfNodeIsConnectedToVC
+    describe('Check if Node is Connected to VC', () => {
+        it('Should correctly determine if the node is connected to a voice channel', async () => {
+            // Simulate that the client socket is listening to a system
+            const isConnectedToVC = true;
+            const guildId = 'mockGuildId';
+
+            // Emit the event to the server and wait for the response
+            const nodeReply = new Promise((resolve) => {
+                clientSocket.once('node-check-connected-status', (passedGuildId, callback) => {
+                    // Check if the passed guild ID matches the expected guild ID
+                    expect(passedGuildId).to.equal(guildId);
+                    // Simulate receiving the connection status from the client
+                    callback(isConnectedToVC);
+                });
+
+                // Call the function to check if the node is connected to a voice channel
+                const response = checkIfNodeIsConnectedToVC(nodeIo, guildId, localNodeConfig.node.nuid);
+                resolve(response);
+            });
+
+            // Wait for the promise to resolve
+            const response = await nodeReply;
+
+            // Assert that the response matches the expected connection status
+            expect(response).to.equal(isConnectedToVC);
+        });
+    });
+
+    // Test checkIfNodeHasOpenDiscordClient
+    describe('Check if Node has an open discord client', () => {
+        it('should correctly determine if the node has an open Discord client', async () => {
+            const isDiscordOpen = true;
+
+            // Emit the event to the server and wait for the response
+            const nodeReply = new Promise((resolve) => {
+                clientSocket.once('node-check-discord-open-client', (callback) => {
+                    // Simulate receiving the client status from the client
+                    callback(isDiscordOpen);
+                });
+
+                // Call the function to check if the node has an open Discord client
+                const response = checkIfNodeHasOpenDiscordClient(serverClientSocket);
+                resolve(response);
+            });
+
+            // Wait for the promise to resolve
+            const response = await nodeReply;
+
+            // Assert that the response matches the expected client status
+            expect(response).toEqual(isDiscordOpen);
+        });
+    });
+
+    // Test getNodeDiscordUsername
+    describe('Get the discord username from the client', () => {
+        it('should request the username from a specific client', async () => {
+            const discordUsername = "Test Discord Username";
+            const guildId = 'mockGuildId';
+
+            // Emit the event to the server and wait for the response
+            const nodeReply = new Promise((resolve) => {
+                clientSocket.once('node-get-discord-username', (passedGuildId, callback) => {
+                    // Check if the passed guild ID matches the expected guild ID
+                    expect(passedGuildId).toEqual(guildId);
+                    // Simulate receiving the username from the client
+                    callback(discordUsername);
+                });
+
+                // Call the function to get the Discord username
+                const username = getNodeDiscordUsername(nodeIo, guildId, localNodeConfig.node.nuid);
+                resolve(username);
+            });
+
+            // Wait for the promise to resolve
+            const username = await nodeReply;
+
+            // Assert that the username matches the expected username
+            expect(username).toEqual(discordUsername);
+        });
+    });
+
+    // Test getNodeDiscordID
+    describe('Get the discord ID from the client', () => {
+        it('Should get the ID from the client', async () => {
+            // Mocked Discord ID
+            const discordId = "mockDiscordID";
+
+            // Emit the event to the server and wait for the response
+            const nodeReply = new Promise((resolve) => {
+                // Listen for the 'node-get-discord-id' event from the server
+                clientSocket.once('node-get-discord-id', (callback) => {
+                    // Simulate receiving the Discord ID from the client
+                    callback(discordId);
+                });
+
+                // Call the function to get the Discord ID
+                const response = getNodeDiscordID(serverClientSocket);
+                resolve(response);
+            });
+
+            // Wait for the promise to resolve
+            const response = await nodeReply;
+
+            // Assert that the response matches the expected Discord ID
+            expect(response).toEqual(discordId);
+        });
+    });
+
+    // Test requestNodeJoinSystem
+    describe('Request Node Join System', () => {
+        it('Should send a request to the node to join a system', async () => {
+            const systemName = 'mockSystemName';
+            const channelId = 'mockChannelId';
+            const token = 'mockToken';
+
+            // Emit the event to the server and wait for the response
+            await new Promise(async (resolve) => {
+                clientSocket.once('node-join', (joinData) => {
+                    // Check if the passed system ID matches the expected system ID
+                    expect(joinData.clientID).toEqual(token);
+                    expect(joinData.channelID).toEqual(channelId);
+                    expect(joinData.system).toEqual(systemName);
+                    // Simulate receiving a success callback from the client
+                    resolve();
+                });
+
+                // Call the function to request joining a system
+                requestNodeJoinSystem(serverClientSocket, systemName, channelId, token);
+            });
+        });
+    });
+
+    // Test requestNodeLeaveSystem
+    describe('Request Node Leave System', () => {
+        it('Should send a request to the node to leave a given server', async () => {
+            const guildId = 'mockGuildId';
+
+            // Emit the event to the server and wait for the response
+            await new Promise(async (resolve) => {
+                clientSocket.once('node-leave', (passedGuildId) => {
+                    // Check if the passed system ID matches the expected system ID
+                    expect(passedGuildId).toEqual(guildId);
+                    // Simulate receiving a success callback from the client
+                    resolve();
+                });
+
+                // Call the function to request joining a system
+                requestBotLeaveServer(serverClientSocket, guildId);
+            });
+        });
+    });
+
+    // Test requestNodeUpdate
+    describe('Request Node Update', () => {
+        it('Should send the node a request to check for an update', async () => {
+            // Emit the event to the server and wait for the response
+            await new Promise((resolve) => {
+                clientSocket.once('node-request-update', (callback) => {
+                    // Simulate an out of date request
+                    expect(callback).toBeDefined();
+                    callback(true);
+                });
+
+                // Call the function to request updating node information
+                const response = requestNodeUpdate(serverClientSocket);
+                resolve(response);
+            });
+        });
+    });
+
+    // Test nodeDisconnectWrapper
+    describe('Node Disconnect Wrapper', () => {
+        it('Should disconnect the node and trigger cleanup actions', async () => {
+            // Mock the socket ID
+            const socketId = 'mockSocketId';
+
+            // Call the nodeDisconnectWrapper function
+            const result = await nodeDisconnectWrapper(socketId);
+
+            // Assert that the result is as expected (if any)
+            expect(result).toBeUndefined();
+        });
+    });
+});