Initialize unit testing and code coverage

* add: vitest configs

* added vitest scripts to package

* test coverage of src code

* initial unit testing

* added new testing workflows

* comments added, overlapping tests removed

* decouple env, tests

---------

Co-authored-by: Kevin Dang <kevinthedang_1@outlook.com>

tests/commands.test.ts

@@ -0,0 +1,27 @@
+// describe marks a test suite
+// expect takes a value from an expression
+// it marks a test case
+import { describe, expect, it } from 'vitest'
+import commands from '../src/commands'
+
+/**
+ * Commands test suite, tests the commands object
+ * Each command is to be tested elsewhere, this file
+ * is to ensure that the commands object is defined.
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#commands', () => {
+    // test definition of commands object
+    it('references defined object', () => {
+        // toBe compares the value to the expected value
+        expect(typeof commands).toBe('object')
+    })
+
+    // test specific commands in the object
+    it('references specific commands', () => {
+        const commandsString = commands.map(e => e.name).join(', ')
+        expect(commandsString).toBe('thread, message-style, message-stream, toggle-chat, shutoff, modify-capacity')
+    })
+})

tests/events.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import events from '../src/events'
+
+/**
+ * Events test suite, tests the events object
+ * Each event is to be tested elsewhere, this file
+ * is to ensure that the events object is defined.
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#events', () => {
+    // test definition of events object
+    it('references defined object', () => {
+        expect(typeof events).toBe('object')
+    })
+
+    // test specific events in the object
+    it('references specific events', () => {
+        const eventsString = events.map(e => e.key.toString()).join(', ')
+        expect(eventsString).toBe('ready, messageCreate, interactionCreate')
+    })
+})

tests/getEnvVar.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import { getEnvVar } from '../src/utils'
+
+/**
+ * getEnvVar test suite, tests the getEnvVar function
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#getEnvVar', () => {
+    // dummy set of keys
+    const keys = {
+        clientToken: 'CLIENT_TOKEN',
+    }
+
+    // set keys in environment
+    process.env['clientToken'] = keys.clientToken
+
+    // test for non-empty string
+    it('returns a non-empty string', () => {
+        expect(getEnvVar('CLIENT_TOKEN')).not.toBe('')
+    })
+
+    // test for string type
+    it('returns a string', () => {
+        expect(typeof getEnvVar('CLIENT_TOKEN')).toBe('string')
+    })
+
+    // test for distinct key
+    it('returns a distinct key', () => {
+        expect(getEnvVar('CLIENT_TOKEN')).toEqual(process.env[keys.clientToken])
+    })
+
+    // test for fallback case
+    it('returns a fallback', () => {
+        expect(getEnvVar('NON_EXISTENT_KEY', 'fallback')).toBe('fallback')
+    })
+
+    // test that all keys are consistently found
+    it('returns all keys found', () => {
+        for (const key in keys) {
+            expect(getEnvVar(key)).toEqual(keys[key])
+        }
+    })
+
+    // test that an error is thrown if key is not found
+    it('throws an error if key is not found', () => {
+        expect(() => getEnvVar('NON_EXISTENT_KEY')).toThrowError()
+    })
+})

tests/mentionClean.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+import { clean } from '../src/utils/mentionClean'
+import { getEnvVar } from '../src/utils'
+
+/**
+ * MentionClean test suite, tests the clean function
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#clean', () => {
+    // test for id removal from message
+    it('removes the mention from a message', () => {
+        const message = `<@${getEnvVar('CLIENT_UID')}> Hello, World!`
+        expect(clean(message)).toBe('Hello, World!')
+    })
+})

tests/queue.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+import { Queue } from '../src/queues/queue'
+
+/**
+ * Queue test suite, tests the Queue class
+ * 
+ * @param name name of the test suite
+ * @param fn function holding tests to run
+ */
+describe('#queue', () => {
+    let queue= new Queue<string>()
+
+    // test for queue creation
+    it('creates a new queue', () => {
+        expect(queue).not.toBeNull()
+    })
+
+    // test for queue capacity creation
+    it('adds specific capacity to the queue', () => {
+        queue = new Queue<string>(2)
+        expect(queue).not.toBeNull()
+    })
+
+    // test for enqueue success, size update
+    it('adds items to the queue', () => {
+        queue.enqueue('hello')
+        expect(queue.size()).toBe(1)
+    })
+
+    // test for multiple enqueue success, size update
+    it('adds multiple items to the queue', () => {
+        queue.enqueue('world')
+        expect(queue.size()).toBe(2)
+    })
+
+    // test for enqueue failure upon capacity overflow
+    it('throws an error when the queue is full', () => {
+        expect(() => queue.enqueue('!')).toThrowError()
+    })
+
+    // test for getItems success
+    it('returns all items in the queue', () => {
+        expect(queue.getItems()).toEqual(['hello', 'world'])
+    })
+
+    // test for pop success, size update
+    it('removes an item from the front of the queue', () => {
+        queue.pop()
+        expect(queue.size() && queue.getItems()[0]).toBe(1 && 'hello')
+    })
+
+    // test for dequeue success, size update
+    it('removes an item from the back of the queue', () => {
+        queue.dequeue()
+        expect(queue.size() && queue.getItems()[0]).toBe(0 && 'world')
+    })
+
+    // test for getItems success with nothing in the list
+    it('returns an empty array when the queue is empty', () => {
+        expect(queue.getItems()).toEqual([])
+    })
+})