fix(tests) 90% coverage for unit testing (#64)

* test(all): add some unit tests

* test(app): add some missing test files

* test(app): 0failed and 0 error

* test(app): add some tests for DTOs

* test(app): hit 70% coverage

* test(app): hit 80% coverage

* test(app): hit 90% coverage & fix some lengths conditions

Author: MarioRaafat

package.json

@@ -122,7 +122,22 @@
             "^.+\\.(t|j)s$": "ts-jest"
         },
         "collectCoverageFrom": [
-            "**/*.(t|j)s"
+            "**/*.(t|j)s",
+            "!**/*.dto.ts",
+            "!**/*.entity.ts",
+            "!**/*.interface.ts",
+            "!**/*.enum.ts",
+            "!**/*.constants.ts",
+            "!**/*.swagger.ts",
+            "!**/*.decorator.ts",
+            "!**/index.ts",
+            "!**/entities/**",
+            "!**/enums/**",
+            "!**/migrations/**",
+            "!**/seeds/**",
+            "!main.ts",
+            "!**/*.spec.ts",
+            "!**/node_modules/**"
         ],
         "coverageDirectory": "../coverage",
         "testEnvironment": "node",

src/app.controller.spec.ts

@@ -3,14 +3,49 @@ import { AppController } from './app.controller';
 import { AppService } from './app.service';
 
 describe('AppController', () => {
-    let appController: AppController;
+    let app_controller: AppController;
+    let app_service: AppService;
 
     beforeEach(async () => {
         const app: TestingModule = await Test.createTestingModule({
             controllers: [AppController],
             providers: [AppService],
         }).compile();
 
-        appController = app.get<AppController>(AppController);
+        app_controller = app.get<AppController>(AppController);
+        app_service = app.get<AppService>(AppService);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should be defined', () => {
+        expect(app_controller).toBeDefined();
+        expect(app_service).toBeDefined();
+    });
+
+    describe('checkHealth', () => {
+        it('should return application health status', () => {
+            const result = app_controller.checkHealth();
+            expect(result).toBe('Application is running');
+        });
+
+        it('should call app_service.getHealthStatus', () => {
+            const get_health_status_spy = jest.spyOn(app_service, 'getHealthStatus');
+
+            app_controller.checkHealth();
+
+            expect(get_health_status_spy).toHaveBeenCalledTimes(1);
+        });
+
+        it('should return the exact string from service', () => {
+            const mock_status = 'Custom health message';
+            jest.spyOn(app_service, 'getHealthStatus').mockReturnValue(mock_status);
+
+            const result = app_controller.checkHealth();
+
+            expect(result).toBe(mock_status);
+        });
     });
 });

src/app.module.spec.ts

@@ -0,0 +1,52 @@
+import { AppModule } from './app.module';
+import { MiddlewareConsumer } from '@nestjs/common';
+
+describe('AppModule', () => {
+    it('should be defined', () => {
+        expect(AppModule).toBeDefined();
+    });
+
+    it('should be a class', () => {
+        expect(typeof AppModule).toBe('function');
+    });
+
+    it('should have module decorator metadata', () => {
+        const imports = Reflect.getMetadata('imports', AppModule);
+        expect(imports).toBeDefined();
+        expect(Array.isArray(imports)).toBe(true);
+        expect(imports.length).toBeGreaterThan(0);
+    });
+
+    it('should have controllers metadata', () => {
+        const controllers = Reflect.getMetadata('controllers', AppModule);
+        expect(controllers).toBeDefined();
+        expect(Array.isArray(controllers)).toBe(true);
+    });
+
+    it('should have providers metadata', () => {
+        const providers = Reflect.getMetadata('providers', AppModule);
+        expect(providers).toBeDefined();
+        expect(Array.isArray(providers)).toBe(true);
+    });
+
+    describe('configure', () => {
+        it('should have configure method for middleware', () => {
+            const app_module = new AppModule();
+            expect(app_module.configure).toBeDefined();
+            expect(typeof app_module.configure).toBe('function');
+        });
+
+        it('should call consumer.apply in configure method', () => {
+            const app_module = new AppModule();
+            const mock_consumer = {
+                apply: jest.fn().mockReturnThis(),
+                forRoutes: jest.fn().mockReturnThis(),
+            } as unknown as MiddlewareConsumer;
+
+            app_module.configure(mock_consumer);
+
+            expect(mock_consumer.apply).toHaveBeenCalled();
+            // expect(mock_consumer.forRoutes).toHaveBeenCalledWith('*');
+        });
+    });
+});