Merge pull request #89 from rohithaug/unit-tests

Added unit tests

client/test/pages/blog/components/card.test.jsx

@@ -0,0 +1,34 @@
+import { render, screen } from '@testing-library/react';
+import Card from '../../../../src/pages/blog/components/card';
+
+describe('Card component', () => {
+    const mockProps = {
+        blogId: '123',
+        title: 'Test Blog',
+        author: 'John Doe',
+        category: 'Technology',
+        time: '2022-08-01',
+        content: 'Lorem ipsum dolor sit amet',
+        imageFileName: 'test-image.jpg',
+    };
+
+    it('renders the card component with correct props', () => {
+        render(<Card {...mockProps} />);
+
+        // Assert that the card title is rendered
+        const titleElement = screen.getByText(mockProps.title);
+        expect(titleElement).toBeTruthy();
+
+        // Assert that the card author is rendered
+        const authorElement = screen.getByText(mockProps.author);
+        expect(authorElement).toBeTruthy();
+
+        // Assert that the card category is rendered
+        const categoryElement = screen.getByText(mockProps.category);
+        expect(categoryElement).toBeTruthy();
+
+        // ... Add more assertions for other elements in the card component
+    });
+
+    // Add more test cases as needed
+});

server/test/app/services/admin.service.test.js

@@ -0,0 +1,82 @@
+const adminService = require('../../../src/app/services/admin.service');
+const adminModel = require('../../../src/app/models/admin.model');
+const httpStatus = require('http-status');
+const apiError = require('../../../src/app/utils/apiError');
+
+describe('Admin Service', () => {
+    describe('createAdmin', () => {
+        it('should throw an error if email is already taken', async () => {
+            const adminBody = {
+                email: 'test@example.com',
+                password: 'password',
+                name: 'Test Admin'
+            };
+
+            adminModel.isEmailTaken = jest.fn().mockResolvedValue(true);
+
+            await expect(adminService.createAdmin(adminBody)).rejects.toThrow(apiError);
+            expect(adminModel.isEmailTaken).toHaveBeenCalledWith(adminBody.email);
+        });
+
+        it('should throw an error if there is an issue creating the admin', async () => {
+            const adminBody = {
+                email: 'test@example.com',
+                password: 'password',
+                name: 'Test Admin'
+            };
+
+            adminModel.isEmailTaken = jest.fn().mockResolvedValue(false);
+            adminModel.create = jest.fn().mockRejectedValue(new Error('Database error'));
+
+            await expect(adminService.createAdmin(adminBody)).rejects.toThrow(apiError);
+            expect(adminModel.isEmailTaken).toHaveBeenCalledWith(adminBody.email);
+            expect(adminModel.create).toHaveBeenCalledWith(adminBody);
+        });
+    });
+
+    describe('validateAdmin', () => {
+        it('should validate an existing admin', async () => {
+            const adminBody = {
+                email: 'test@example.com',
+                password: 'password'
+            };
+
+            const admin = {
+                email: 'test@example.com',
+                password: 'password',
+                name: 'Test Admin'
+            };
+
+            adminModel.findOne = jest.fn().mockResolvedValue(admin);
+
+            const result = await adminService.validateAdmin(adminBody);
+
+            expect(adminModel.findOne).toHaveBeenCalledWith({ email: adminBody.email, password: adminBody.password });
+            expect(result).toEqual(admin);
+        });
+
+        it('should throw an error if admin is not found', async () => {
+            const adminBody = {
+                email: 'test@example.com',
+                password: 'password'
+            };
+
+            adminModel.findOne = jest.fn().mockResolvedValue(null);
+
+            await expect(adminService.validateAdmin(adminBody)).rejects.toThrow(apiError);
+            expect(adminModel.findOne).toHaveBeenCalledWith({ email: adminBody.email, password: adminBody.password });
+        });
+
+        it('should throw an error if there is an issue validating the admin', async () => {
+            const adminBody = {
+                email: 'test@example.com',
+                password: 'password'
+            };
+
+            adminModel.findOne = jest.fn().mockRejectedValue(new Error('Database error'));
+
+            await expect(adminService.validateAdmin(adminBody)).rejects.toThrow(apiError);
+            expect(adminModel.findOne).toHaveBeenCalledWith({ email: adminBody.email, password: adminBody.password });
+        });
+    });
+});

server/test/app/services/analytics.service.test.js

@@ -0,0 +1,128 @@
+const httpStatus = require('http-status');
+const { trackerModel, blogModel } = require('../../../src/app/models');
+const { getAllBlogsIdAndCategory } = require('../../../src/app/services/blog.service');
+const apiError = require('../../../src/app/utils/apiError');
+const {
+  getMetrics,
+  getBlogMetrics,
+  getBulkMetrics
+} = require('../../../src/app/services/analytics.service');
+
+jest.mock('../../../src/app/models');
+jest.mock('../../../src/app/services/blog.service');
+jest.mock('../../../src/app/utils/apiError');
+
+describe('analytics.service', () => {
+  describe('getBlogMetrics', () => {
+    test('should return metrics object for a specific blog', async () => {
+      const trackerData = [
+        { blogId: '1', source: 'source1' },
+        { blogId: '1', source: 'source2' },
+        { blogId: '1', source: 'source1' }
+      ];
+      const blogData = { blogId: '1', title: 'Blog 1', likes: 5, dislikes: 2 };
+
+      trackerModel.find.mockResolvedValue(trackerData);
+      blogModel.findOne.mockResolvedValue(blogData);
+
+      const expectedMetrics = {
+        blogId: '1',
+        blogName: 'Blog 1',
+        uniqueVisit: 3,
+        source: {
+          source1: 2,
+          source2: 1
+        },
+        likes: 5,
+        dislikes: 2
+      };
+
+      const metrics = await getBlogMetrics('1');
+
+      expect(trackerModel.find).toHaveBeenCalledWith({ blogId: '1' });
+      expect(blogModel.findOne).toHaveBeenCalledWith({ blogId: '1' });
+      expect(metrics).toEqual(expectedMetrics);
+    });
+  });
+
+});
+
+describe('analytics.service - metrics object', () => {
+  describe('uniqueVisit', () => {
+    test('should have blog and category properties', () => {
+      const metrics = {
+        uniqueVisit: {
+          blog: {},
+          category: {}
+        },
+        source: {
+          consolidated: {},
+          blog: {}
+        },
+        likes: {},
+        dislikes: {}
+      };
+
+      expect(metrics.uniqueVisit).toHaveProperty('blog');
+      expect(metrics.uniqueVisit).toHaveProperty('category');
+    });
+  });
+
+  describe('source', () => {
+    test('should have consolidated and blog properties', () => {
+      const metrics = {
+        uniqueVisit: {
+          blog: {},
+          category: {}
+        },
+        source: {
+          consolidated: {},
+          blog: {}
+        },
+        likes: {},
+        dislikes: {}
+      };
+
+      expect(metrics.source).toHaveProperty('consolidated');
+      expect(metrics.source).toHaveProperty('blog');
+    });
+  });
+
+  describe('likes', () => {
+    test('should be an object', () => {
+      const metrics = {
+        uniqueVisit: {
+          blog: {},
+          category: {}
+        },
+        source: {
+          consolidated: {},
+          blog: {}
+        },
+        likes: {},
+        dislikes: {}
+      };
+
+      expect(metrics.likes).toBeInstanceOf(Object);
+    });
+  });
+
+  describe('dislikes', () => {
+    test('should be an object', () => {
+      const metrics = {
+        uniqueVisit: {
+          blog: {},
+          category: {}
+        },
+        source: {
+          consolidated: {},
+          blog: {}
+        },
+        likes: {},
+        dislikes: {}
+      };
+
+      expect(metrics.dislikes).toBeInstanceOf(Object);
+    });
+  });
+});

server/test/app/services/blog.service.test.js

@@ -0,0 +1,67 @@
+const httpStatus = require('http-status');
+const { blogModel } = require('../../../src/app/models');
+const apiError = require('../../../src/app/utils/apiError');
+const {
+  createBlog,
+  getBlog,
+  getAllBlogs,
+  getAllBlogsIdAndCategory,
+  updateBlog,
+  deleteBlog,
+  likeBlog,
+  dislikeBlog,
+} = require('../../../src/app/services/blog.service');
+
+jest.mock('../../../src/app/models');
+jest.mock('../../../src/app/utils/apiError');
+
+describe('blog.service', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('createBlog', () => {
+    it('should create a new blog', async () => {
+      const blogBody = { blogId: 'test-blog', title: 'Test Blog', content: 'Lorem ipsum dolor sit amet' };
+      const saveMock = jest.fn();
+      const user = { save: saveMock };
+
+      blogModel.isBlogIdTaken.mockResolvedValue(false);
+      blogModel.mockImplementation(() => user);
+
+      const result = await createBlog(blogBody);
+
+      expect(blogModel.isBlogIdTaken).toHaveBeenCalledWith(blogBody.blogId);
+      expect(blogModel).toHaveBeenCalledWith(blogBody);
+      expect(saveMock).toHaveBeenCalled();
+      expect(result).toBe(user);
+    });
+  });
+
+  describe('getBlog', () => {
+    it('should get a blog by ID', async () => {
+      const blogId = 'test-blog';
+      const findOneMock = jest.fn();
+      const blog = { blogId };
+
+      blogModel.findOne.mockResolvedValue(blog);
+
+      const result = await getBlog(blogId);
+
+      expect(blogModel.findOne).toHaveBeenCalledWith({ blogId });
+      expect(result).toBe(blog);
+    });
+  });
+
+  describe('getAllBlogs', () => {
+    it('should get all blogs', async () => {
+      const blogs = [{ blogId: 'blog1' }, { blogId: 'blog2' }];
+      blogModel.find.mockResolvedValue(blogs);
+
+      const result = await getAllBlogs();
+
+      expect(blogModel.find).toHaveBeenCalled();
+      expect(result).toBe(blogs);
+    });
+  });
+
+});

server/test/app/services/index.test.js

@@ -0,0 +1,19 @@
+const services = require('../../../src/app/services/index');
+
+describe('services', () => {
+  test('should export analyticsService', () => {
+    expect(services.analyticsService).toBeDefined();
+  });
+
+  test('should export blogService', () => {
+    expect(services.blogService).toBeDefined();
+  });
+
+  test('should export trackerService', () => {
+    expect(services.trackerService).toBeDefined();
+  });
+
+  test('should export adminService', () => {
+    expect(services.adminService).toBeDefined();
+  });
+});

server/test/app/services/tracker.service.test.js

@@ -0,0 +1,30 @@
+const httpStatus = require('http-status');
+const { trackBlogVisit } = require('../../../src/app/services/tracker.service');
+const { getBlog } = require('../../../src/app/services/blog.service');
+const { trackerModel } = require('../../../src/app/models');
+const apiError = require('../../../src/app/utils/apiError');
+
+jest.mock('../../../src/app/services/blog.service');
+jest.mock('../../../src/app/models');
+
+describe('trackBlogVisit', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should throw an error if eventBody does not contain blogId', async () => {
+    const eventBody = {};
+    const expectedError = new apiError(httpStatus.BAD_REQUEST, 'Insufficient data to track blog visit');
+
+    await expect(trackBlogVisit(eventBody)).rejects.toThrow(expectedError);
+  });
+
+  test('should throw an error if blog is not found', async () => {
+    const eventBody = { blogId: '123' };
+    const expectedError = new apiError(httpStatus.NOT_FOUND, 'Blog not found');
+    getBlog.mockResolvedValueOnce(null);
+
+    await expect(trackBlogVisit(eventBody)).rejects.toThrow(expectedError);
+    expect(getBlog).toHaveBeenCalledWith(eventBody.blogId);
+  });
+});