All testing files for question service

Author: LimZiJia

package-lock.json

@@ -30,17 +30,25 @@
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.13",
     "@types/jsonwebtoken": "^9.0.7",
+    "@types/mocha": "^10.0.8",
     "@types/mongoose": "^5.11.96",
     "@types/morgan": "^1.9.9",
     "@types/node": "^18.14.2",
+    "@types/sinon": "^17.0.1",
+    "@types/sinon-chai": "^4.0.0",
     "@types/ws": "^8.5.12",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
+    "chai": "^4.5.0",
+    "chai-http": "^4.4.0",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
+    "mocha": "^10.7.3",
     "nodemon": "^3.1.7",
     "prettier": "^3.3.3",
+    "sinon": "^17.0.1",
+    "sinon-chai": "^3.7.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.0",
     "typescript-eslint": "^8.11.0"

services/collaboration/package.json

@@ -12,6 +12,6 @@
     "allowJs": true,
     "checkJs": false
   },
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "tests/**/*"],
   "exclude": ["node_modules", "dist"]
 }

services/collaboration/tsconfig.json

@@ -0,0 +1,129 @@
+require('dotenv').config();
+import { expect } from 'chai';
+import sinon, { SinonStub } from 'sinon';
+import client, { Channel, Connection } from 'amqplib';
+import messageBroker from '../../src/events/broker';
+import config from '../../src/config';
+
+describe('MessageBroker', () => {
+    let connectStub: SinonStub;
+    let assertQueueStub: SinonStub;
+    let sendToQueueStub: SinonStub;
+    let consumeStub: SinonStub;
+    let ackStub: SinonStub;
+    let connection: Connection;
+    let channel: Channel;
+
+    beforeEach(() => {
+        connection = {
+            createChannel: sinon.stub(),
+            close: sinon.stub(),
+        } as unknown as Connection;
+
+        channel = {
+            assertQueue: sinon.stub(),
+            sendToQueue: sinon.stub(),
+            consume: sinon.stub(),
+            ack: sinon.stub(),
+        } as unknown as Channel;
+
+        connectStub = sinon.stub(client, 'connect').resolves(connection);
+        (connection.createChannel as SinonStub).resolves(channel);
+        assertQueueStub = channel.assertQueue as SinonStub;
+        sendToQueueStub = channel.sendToQueue as SinonStub;
+        consumeStub = channel.consume as SinonStub;
+        ackStub = channel.ack as SinonStub;
+
+        messageBroker['connected'] = false;
+        messageBroker['connection'] = undefined;
+        messageBroker['channel'] = undefined;
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    describe('connect', () => {
+        it('should connect to RabbitMQ', async () => {
+            await messageBroker.connect();
+
+            console.log(connectStub.args);
+            expect(connectStub).to.have.been.calledWith(config.BROKER_URL);
+            expect(connection.createChannel).to.have.been.called;
+            expect(messageBroker['connected']).to.be.true;
+        });
+
+        it('should not reconnect if already connected', async () => {
+            messageBroker['connection'] = connection;
+            messageBroker['channel'] = channel;
+            messageBroker['connected'] = true;
+
+            await messageBroker.connect();
+
+            expect(connectStub).not.to.have.been.called;
+            expect(connection.createChannel).not.to.have.been.called;
+        });
+
+        it('should throw an error if connection fails', async () => {
+            connectStub.rejects(new Error('Connection error'));
+
+            try {
+                await messageBroker.connect();
+            } catch (error) {
+                if (error instanceof Error) {
+                    expect(error.message).to.equal('Connection error');
+                }
+            }
+        });
+    });
+
+    describe('produce', () => {
+        it('should produce a message to the queue', async () => {
+            await messageBroker.produce('testQueue', { test: 'message' });
+
+            expect(connectStub).to.have.been.called;
+            expect(sendToQueueStub).to.have.been.calledWith('testQueue', Buffer.from(JSON.stringify({ test: 'message' })));
+        });
+
+        it('should throw an error if producing message fails', async () => {
+            sendToQueueStub.rejects(new Error('Produce error'));
+
+            try {
+                await messageBroker.produce('testQueue', { test: 'message' });
+            } catch (error) {
+                if (error instanceof Error) {
+                    expect(error.message).to.equal('Produce error');
+                }
+            }
+        });
+    });
+
+    describe('consume', () => {
+        it('should consume messages from the queue', async () => {
+            const onMessage = sinon.stub();
+            const msg = { content: Buffer.from(JSON.stringify({ test: 'message' })) };
+
+            consumeStub.yields(msg);
+
+            await messageBroker.consume('testQueue', onMessage);
+
+            expect(connectStub).to.have.been.called;
+            expect(assertQueueStub).to.have.been.calledWith('testQueue', { durable: true });
+            expect(consumeStub).to.have.been.calledWith('testQueue', sinon.match.func, { noAck: false });
+            expect(onMessage).to.have.been.calledWith({ test: 'message' });
+            expect(ackStub).to.have.been.calledWith(msg);
+        });
+
+        it('should throw an error if consuming message fails', async () => {
+            consumeStub.rejects(new Error('Consume error'));
+
+            try {
+                await messageBroker.consume('testQueue', sinon.stub());
+            } catch (error) {
+                if (error instanceof Error) {
+                    expect(error.message).to.equal('Consume error');
+                }
+            }
+        });
+    });
+});

services/question/tests/events/broker.spec.ts

@@ -0,0 +1,106 @@
+require('dotenv').config();
+import { expect } from 'chai';
+import sinon, { SinonStub } from 'sinon';
+import { Question } from '../../src/models/questionModel';
+import * as prod from '../../src/events/producer';
+import { consumeMatchFound, initializeConsumers } from'../../src/events/consumer';
+import { Difficulty, MatchFoundEvent } from '../../src/types/event';
+import messageBroker from '../../src/events/broker';
+import { Queues } from '../../src/events/queues';
+
+describe('consumeMatchFound', () => {
+    let findStub: SinonStub;
+    let produceMatchFailedEventStub: SinonStub;
+    let produceQuestionFoundEventStub: SinonStub;
+    let execStub: SinonStub;
+
+    beforeEach(() => {
+        findStub = sinon.stub(Question, 'find');
+        produceMatchFailedEventStub = sinon.stub(prod, 'produceMatchFailedEvent');
+        produceQuestionFoundEventStub = sinon.stub(prod, 'produceQuestionFoundEvent');
+        execStub = sinon.stub().returnsThis();
+        findStub.returns({ exec: execStub });
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should produce a match failed event if no questions are found', async () => {
+        const msg: MatchFoundEvent = {
+            user1: { requestId: 'user1', id: 'id1', username: 'user1', email: '[email protected]' },
+            user2: { requestId: 'user2', id: 'id2', username: 'user2', email: '[email protected]' },
+            topics: ['topic1'],
+            difficulty: Difficulty.Easy,
+        };
+
+        execStub.resolves([]);
+
+        await consumeMatchFound(msg);
+
+        expect(findStub).to.have.been.calledWith({ topics: { $in: ['topic1'] }, difficulty: 'Easy' });
+        expect(produceMatchFailedEventStub).to.have.been.calledWith('user1', 'user2');
+        expect(produceQuestionFoundEventStub).not.to.have.been.called;
+    });
+
+    it('should produce a question found event if questions are found', async () => {
+        const msg: MatchFoundEvent = {
+            user1: { requestId: 'user1', id: 'id1', username: 'user1', email: '[email protected]' },
+            user2: { requestId: 'user2', id: 'id2', username: 'user2', email: '[email protected]' },
+            topics: ['topic1'],
+            difficulty: Difficulty.Easy,
+        };
+
+        const mockQuestions = [
+            { title: 'Question 1', description: 'Description 1', topics: ['topic1'], difficulty: 'Easy' },
+        ];
+
+        execStub.resolves(mockQuestions);
+
+        await consumeMatchFound(msg);
+
+        expect(findStub).to.have.been.calledWith({ topics: { $in: ['topic1'] }, difficulty: 'Easy' });
+        expect(produceMatchFailedEventStub).not.to.have.been.called;
+        expect(produceQuestionFoundEventStub).to.have.been.calledWith(msg.user1, msg.user2, mockQuestions[0]);
+    });
+
+    it('should handle errors during question retrieval', async () => {
+        const msg: MatchFoundEvent = {
+            user1: { requestId: 'user1', id: 'id1', username: 'user1', email: '[email protected]' },
+            user2: { requestId: 'user2', id: 'id2', username: 'user2', email: '[email protected]' },
+            topics: ['topic1'],
+            difficulty: Difficulty.Easy,
+        };
+
+        const error = new Error('Database error');
+        execStub.rejects(error);
+
+        try {
+            await consumeMatchFound(msg);
+        } catch (err) {
+            expect(err).to.equal(error);
+        }
+
+        expect(findStub).to.have.been.calledWith({ topics: { $in: ['topic1'] }, difficulty: 'Easy' });
+        expect(produceMatchFailedEventStub).not.to.have.been.called;
+        expect(produceQuestionFoundEventStub).not.to.have.been.called;
+    });
+});
+
+describe('initializeConsumers', () => {
+    let consumeStub: SinonStub;
+
+    beforeEach(() => {
+        consumeStub = sinon.stub(messageBroker, 'consume');
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should initialize consumers correctly', () => {
+        initializeConsumers();
+
+        expect(consumeStub).to.have.been.calledWith(Queues.MATCH_FOUND, consumeMatchFound);
+    });
+});

services/question/tests/events/consumer.spec.ts

@@ -0,0 +1,49 @@
+require('dotenv').config();
+import { expect } from 'chai';
+import sinon, { SinonStub } from 'sinon';
+import * as producer from '../../src/events/producer';
+import messageBroker from '../../src/events/broker';
+import { Queues } from '../../src/events/queues';
+import { UserWithRequest, Question, IdType, QuestionFoundEvent, MatchFailedEvent, Difficulty } from '../../src/types/event';
+
+describe('Producer Tests', () => {
+    let produceStub: SinonStub;
+
+    beforeEach(() => {
+        produceStub = sinon.stub(messageBroker, 'produce');
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    describe('produceQuestionFoundEvent', () => {
+        it('should produce a question found event', async () => {
+            const user1: UserWithRequest = { requestId: 'user1', id: 'id1', username: 'user1', email: '[email protected]' };
+            const user2: UserWithRequest = { requestId: 'user2', id: 'id2', username: 'user2', email: '[email protected]' };
+            const question: Question = { id: 1, title: 'Question 1', description: 'Description 1', topics: ['topic1'], difficulty: Difficulty.Easy };
+
+            const expectedMessage: QuestionFoundEvent = {
+                user1,
+                user2,
+                question,
+            };
+
+            await producer.produceQuestionFoundEvent(user1, user2, question);
+
+            expect(produceStub).to.have.been.calledWith(Queues.QUESTION_FOUND, expectedMessage);
+        });
+    });
+
+    describe('produceMatchFailedEvent', () => {
+        it('should produce a match failed event', async () => {
+            const requestId1: IdType = 'request1';
+            const requestId2: IdType = 'request2';
+            const expectedMessage: MatchFailedEvent = { requestId1, requestId2, reason: 'No questions were found' };
+
+            await producer.produceMatchFailedEvent(requestId1, requestId2);
+
+            expect(produceStub).to.have.been.calledWith(Queues.MATCH_FAILED, expectedMessage);
+        });
+    });
+});