Questionnaire

package.json

@@ -33,6 +33,7 @@
     "class-validator": "^0.14.1",
     "csv-parser": "^3.2.0",
     "fs": "^0.0.1-security",
+    "module": "^1.1.0",
     "mongoose": "^8.12.1",
     "nanoid": "^3.3.11",
     "nodemailer": "^6.10.0",
@@ -44,9 +45,9 @@
   "devDependencies": {
     "@nestjs/cli": "^10.4.9",
     "@nestjs/schematics": "^10.0.0",
-    "@nestjs/testing": "^10.0.0",
+    "@nestjs/testing": "^10.4.15",
     "@types/express": "^5.0.0",
-    "@types/jest": "^29.5.2",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.3.1",
     "@types/supertest": "^6.0.0",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -55,7 +56,7 @@
     "eslint": "^8.0.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-prettier": "^5.0.0",
-    "jest": "^29.5.0",
+    "jest": "^29.7.0",
     "prettier": "^3.0.0",
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",

src/app/app.module.ts

@@ -8,9 +8,8 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
 import config from '../config/config';
 
 import { QuestionnaireResult, QuesResultSchema } from '../schemas/ques.schema';
-import { ResultModule } from 'src/result/result.module';
-import { TsfController } from 'src/tsf/tsf.controller';
-import { TsfService } from 'src/tsf/tsf.service';
+// import { TsfController } from 'src/tsf/tsf.controller';
+// import { TsfService } from 'src/tsf/tsf.service';
 import { QuestionnaireModule } from 'src/questionnaire/questionnaire.module';
 
 @Module({
@@ -42,10 +41,10 @@ import { QuestionnaireModule } from 'src/questionnaire/questionnaire.module';
 
     AuthModule,
     QuestionnaireModule,
-    ResultModule // Keeping ResultModule from ResultSaving branch
+    //ResultModule // Keeping ResultModule from ResultSaving branch
   ],
 
-  controllers: [AppController, TsfController],
-  providers: [AppService, TsfService],
+  controllers: [AppController/*, TsfController*/],
+  providers: [AppService/*, TsfService*/],
 })
 export class AppModule {}

src/questionnaire/ques.controller.spec.ts

@@ -0,0 +1,52 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { QuestionnaireController } from './ques.controller';
+import { QuestionnaireService } from './ques.service';
+import { JwtService } from '@nestjs/jwt';
+
+describe('QuestionnaireController', () => {
+    let controller: QuestionnaireController;
+    let service: QuestionnaireService;
+
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+          controllers: [QuestionnaireController],
+          providers: [
+            {
+              provide: QuestionnaireService,
+              useValue: {
+                calculation: jest.fn().mockResolvedValue({ percentage: 85 }),
+                getQuesResult: jest.fn().mockResolvedValue([{ userId: '123', total: 10 }]),
+              },
+            },
+            {
+              provide: JwtService,
+              useValue: {
+                sign: jest.fn().mockReturnValue('mocked-token'),
+                verify: jest.fn().mockReturnValue({ userId: 'mocked-user-id' }),
+              },
+            },
+          ],
+        }).compile();
+
+        controller = module.get<QuestionnaireController>(QuestionnaireController);
+        service = module.get<QuestionnaireService>(QuestionnaireService);
+    });
+
+    it('should be defined', () => {
+        expect(controller).toBeDefined();
+    });
+
+    it('should submit questionnaire and return score', async () => {
+        const req = { user: { userId: '123' } };
+        const body = { q1: 'A', q2: 'B' };
+
+        const result = await controller.submitQues(req, body);
+        expect(result.percentage).toBe(85);
+    });
+
+    it('should get user questionnaire history', async () => {
+        const req = { user: { userId: '123' } };
+        const result = await controller.getHistory(req);
+        expect(result.length).toBe(1);
+    });
+});

src/questionnaire/ques.controller.ts

@@ -1,7 +1,6 @@
 import { Controller, Post, Body, Get, Req, UseGuards, Param } from "@nestjs/common";
 import { QuestionnaireService } from "./ques.service";
-import { Request } from "express";
-import { AuthGuard } from "src/guards/auth.guard";
+import { AuthGuard } from "../guards/auth.guard";
 
 //questionnaire controller
 @Controller('questionnaire')
@@ -18,6 +17,7 @@ export class QuestionnaireController{
             //extracting userId from the request
             const userId = req.user["userId"];
 
+            //mapping the responses
            const responses = Object.entries(body).map(([key, value]) => ({key, value: String(value)}));
 
            return this.questionnaireService.calculation(userId, responses);

src/questionnaire/ques.service.spec.ts

@@ -0,0 +1,120 @@
+import { Test, TestingModule } from "@nestjs/testing";
+import { QuestionnaireService } from "./ques.service";
+import { getModelToken } from "@nestjs/mongoose";
+import { SaveResult } from "../schemas/result.schema";
+import { User } from "../schemas/user.schema";
+import { Model, Types } from "mongoose";
+import { JwtService } from "@nestjs/jwt";
+import { BadRequestException } from "@nestjs/common";
+
+describe("QuestionnaireService", () => {
+    let service: QuestionnaireService;
+    let resultModel: Model<SaveResult>;
+    let userModel: Model<User>;
+
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [
+                QuestionnaireService,
+                {
+                    provide: getModelToken(SaveResult.name),
+                    useValue: {
+                        create: jest.fn(),
+                    },
+                },
+                {
+                    provide: getModelToken(User.name),
+                    useValue: {
+                        findOne: jest.fn(),
+                    },
+                },
+                {
+                    provide: JwtService,
+                    useValue: {
+                        sign: jest.fn().mockReturnValue("mocked-token"),
+                        verify: jest.fn().mockReturnValue({ userId: "mocked-user-id" }),
+                    },
+                },
+            ],
+        }).compile();
+
+        service = module.get<QuestionnaireService>(QuestionnaireService);
+        resultModel = module.get<Model<SaveResult>>(getModelToken(SaveResult.name));
+        userModel = module.get<Model<User>>(getModelToken(User.name));
+    });
+
+    it("should be defined", () => {
+        expect(service).toBeDefined();
+    });
+
+    it("should calculate score correctly", async () => {
+        const validUserId = "67dbba701e18c22c410901dc"; // Existing user ID
+
+        jest.spyOn(userModel, "findOne").mockReturnValueOnce({
+            exec: jest.fn().mockResolvedValue({
+                _id: new Types.ObjectId(validUserId),
+            }),
+        } as any);
+
+        const responses = [
+            { key: "age", value: "55" },
+            { key: "gender", value: "Male" },
+            { key: "anemia", value: "Yes" },
+            { key: "hbp", value: "No" },
+            { key: "diabetes", value: "Yes" },
+            { key: "cvd", value: "No" },
+            { key: "heartattacks", value: "Yes" },
+            { key: "chf", value: "No" },
+        ];
+
+        service["markingSystem"] = {
+            gender: { "Male": 0, "Female": 1 },
+            anemia: { "Yes": 1, "No": 0 },
+            hbp: { "Yes": 1, "No": 0 },
+            diabetes: { "Yes": 1, "No": 0 },
+            cvd: { "Yes": 0, "No": 0 },
+            heartattacks: { "Yes": 1, "No": 0 },
+            chf: { "Yes": 0, "No": 0 },
+        };
+
+        const result = await service.calculation(validUserId, responses);
+        console.log("Debug Total:", result.total, "Percentage:", result.percentage);
+        expect(result.percentage).toBeCloseTo((result.total / 7) * 100);
+    });
+
+    it("should throw an error if user ID format is invalid", async () => {
+        await expect(service.calculation("invalid ID", [])).rejects.toThrow(BadRequestException);
+        await expect(service.calculation("invalid ID", [])).rejects.toThrow("Invalid user ID format");
+    });
+
+    it("should throw an error if user is not found", async () => {
+        const validUserId = new Types.ObjectId().toHexString(); // Generate a valid ObjectId
+
+        jest.spyOn(userModel, "findOne").mockReturnValueOnce({
+            exec: jest.fn().mockResolvedValue(null),
+        } as any);
+
+        await expect(service.calculation(validUserId, [])).rejects.toThrow("User not found");
+    });
+
+    it("should save result in database", async () => {
+        const validUserId = "67dbba701e18c22c410901dc"; // Use a real ObjectId
+
+        const mockSave = jest.fn().mockResolvedValue({
+            _id: "test123",
+            userId: new Types.ObjectId(validUserId),
+            total: 10,
+        });
+
+        jest.spyOn(resultModel, "create").mockResolvedValueOnce({
+            _id: "test123",
+            userId: new Types.ObjectId(validUserId),
+            total: 10,
+            save: mockSave, // Ensure save is properly mocked
+        } as any);
+
+        const result = await service.saveQuesResult(validUserId, 10);
+        expect(result).toBeDefined();
+        expect(result.total).toBe(10);
+    });
+});

src/questionnaire/ques.service.ts

@@ -1,12 +1,11 @@
-import { Inject, Injectable, OnModuleDestroy, OnModuleInit } from "@nestjs/common";
+import {  Injectable, OnModuleInit, BadRequestException } from "@nestjs/common";
 import { InjectModel } from "@nestjs/mongoose";
 import { Model } from "mongoose";
 import * as fs from "fs";
 import * as path from "path";
 import { Types } from "mongoose";
-import { SaveResult } from "src/schemas/result.schema";
-import { ResultService } from "src/result/result.service";
-import { User } from "src/schemas/user.schema";
+import { SaveResult } from "../schemas/result.schema";
+import { User } from "../schemas/user.schema";
 
 @Injectable()
 export class QuestionnaireService implements OnModuleInit{ //extracting the questions logic
@@ -25,7 +24,6 @@ export class QuestionnaireService implements OnModuleInit{ //extracting the ques
     readonly nonScorableFields = ["fName", "lName", "city", "address" ];
 
     constructor(
-        private resultService: ResultService,
         @InjectModel(SaveResult.name) private readonly resultModel: Model<SaveResult>,
         @InjectModel(User.name) private readonly userModel: Model<User>,
     ) {}
@@ -78,11 +76,15 @@ export class QuestionnaireService implements OnModuleInit{ //extracting the ques
             }
         }
 
+        if (!Types.ObjectId.isValid(userId)) {
+            throw new BadRequestException("Invalid user ID format");
+        }
+
         const existUser = await this.userModel.findOne({ _id: new Types.ObjectId(userId) }).exec();
         const percentage = (total/7) * 100;
         if(existUser){
             await this.saveQuesResult(userId, total);
-            return {percentage};
+            return {percentage, total};
 
         }
         else{
@@ -92,8 +94,15 @@ export class QuestionnaireService implements OnModuleInit{ //extracting the ques
 
     //saving result in the DB
     async saveQuesResult(userId: string, total: number){
-        const result = new this.resultModel({userId: new Types.ObjectId(userId), total});
-        return result.save();
+
+        if (!Types.ObjectId.isValid(userId)) {
+            throw new BadRequestException("Invalid user ID format");
+        }
+
+        return await this.resultModel.create({
+            userId: new Types.ObjectId(userId),
+            total,
+        });
     }
 
     async getQuesResult(userId: string){

src/questionnaire/questionnaire.module.ts

@@ -3,15 +3,15 @@ import { QuestionnaireController } from '../questionnaire/ques.controller';
 import { QuestionnaireService } from '../questionnaire/ques.service';
 import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
-import { ResultModule } from 'src/result/result.module';
-import { ResultService } from '../result/result.service';
+// import { ResultModule } from 'src/result/result.module';
+// import { ResultService } from '../result/result.service';
 import { User, UserSchema } from 'src/schemas/user.schema';
 
 @Module({
     imports: [
         MongooseModule.forFeature([{ name: SaveResult.name, schema: SaveResultSchema }]),     
         MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),    
-        ResultModule,
+        // ResultModule,
 
     ],
     controllers: [QuestionnaireController],