initial_update

.gitignore

@@ -0,0 +1,27 @@
+# Ignore test-related folders
+allure_report/
+__test__/
+__mocks__/
+coverage/
+test_report/
+
+# Ignore test configuration and setup files
+jest.config.js
+jest.setup.js
+jesthtmlreporter.config.json
+babel.config.js
+postTestSetup.js
+preTestSetup.js
+runE2ETests.js
+
+# Ignore environment files
+.env
+
+# Ignore database files
+data.db
+
+# Ignore video files
+*.mp4
+
+# Ignore node_modules
+node_modules

Dockerfile

@@ -0,0 +1,40 @@
+# Stage 1: Build the React frontend
+FROM node:16 AS build
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the React frontend code
+COPY frontend/package.json frontend/package-lock.json ./frontend/
+RUN cd frontend && npm install
+
+# Build the React app (inside the frontend folder)
+COPY frontend ./frontend
+RUN cd frontend && npm run build
+
+# Stage 2: Set up the Node.js backend
+FROM node:16
+
+# Set the working directory
+WORKDIR /app
+
+# Copy backend code
+COPY backend/package.json backend/package-lock.json ./backend/
+RUN cd backend && npm install
+
+# Copy the React build files from Stage 1 to the backend/build folder
+COPY --from=build /app/frontend/build ./backend/build
+
+# Copy the backend source code
+COPY backend ./backend
+
+RUN mkdir -p /app/backend/database && chmod -R 777 /app/backend/database
+
+
+# Expose the backend's port
+EXPOSE 7860
+
+WORKDIR /app/backend
+
+# Start the backend server
+CMD [ "node", "./index.js"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Genomatics React Modularised V2
-emoji: 📚
-colorFrom: indigo
-colorTo: gray
+title: Geno React Modularised
+emoji: 🏃
+colorFrom: pink
+colorTo: red
 sdk: docker
 pinned: false
 ---

backend/__tests__/config/googleOAuth.test.js

@@ -0,0 +1,77 @@
+const { google } = require('googleapis'); // Import googleapis here
+jest.mock('googleapis', () => ({
+  google: {
+    auth: {
+      OAuth2: jest.fn().mockImplementation(() => ({
+        setCredentials: jest.fn(),
+        isTokenExpiring: jest.fn(),
+        refreshAccessToken: jest.fn(),
+      })),
+    },
+  },
+}));
+
+describe('googleOAuth client', () => {
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    process.env.CLIENT_ID = 'test-client-id';
+    process.env.CLIENT_SECRET = 'test-client-secret';
+    process.env.REDIRECT_URI = 'http://localhost';
+  });
+
+  it('should initialize OAuth2 client with credentials from .env', () => {
+    // Import the oAuth2Client after setting environment variables and mocks
+    const { oAuth2Client } = require('../../config/googleOAuth');
+    
+    // Test if OAuth2 constructor was called with the expected parameters
+    expect(google.auth.OAuth2).toHaveBeenCalledWith(
+      'test-client-id',
+      'test-client-secret',
+      'http://localhost'
+    );
+    expect(oAuth2Client).toBeDefined();
+  });
+
+  it('should call setCredentials on OAuth2 client with proper tokens', async () => {
+    const tokens = { access_token: 'access-token', refresh_token: 'refresh-token' };
+
+    const { oAuth2Client } = require('../../config/googleOAuth'); // Ensure this is required here
+    oAuth2Client.setCredentials(tokens);
+
+    expect(oAuth2Client.setCredentials).toHaveBeenCalledWith(tokens);
+  });
+
+  it('should call refreshAccessToken and handle success', async () => {
+    const mockRefreshResponse = {
+      credentials: {
+        access_token: 'new-access-token',
+        refresh_token: 'new-refresh-token',
+      },
+    };
+
+    const { oAuth2Client } = require('../../config/googleOAuth'); // Ensure this is required here
+    oAuth2Client.refreshAccessToken.mockResolvedValueOnce(mockRefreshResponse);
+
+    const response = await oAuth2Client.refreshAccessToken();
+    expect(response.credentials.access_token).toBe('new-access-token');
+    expect(oAuth2Client.refreshAccessToken).toHaveBeenCalled();
+  });
+
+  it('should call refreshAccessToken and handle error', async () => {
+    const { oAuth2Client } = require('../../config/googleOAuth'); // Ensure this is required here
+    oAuth2Client.refreshAccessToken.mockRejectedValueOnce(new Error('Token refresh failed'));
+
+    await expect(oAuth2Client.refreshAccessToken()).rejects.toThrow('Token refresh failed');
+    expect(oAuth2Client.refreshAccessToken).toHaveBeenCalled();
+  });
+
+  it('should correctly check if the token is expiring', () => {
+    const { oAuth2Client } = require('../../config/googleOAuth'); // Ensure this is required here
+    oAuth2Client.isTokenExpiring.mockReturnValue(true);
+
+    const isExpiring = oAuth2Client.isTokenExpiring();
+    expect(isExpiring).toBe(true);
+    expect(oAuth2Client.isTokenExpiring).toHaveBeenCalled();
+  });
+});

backend/__tests__/config/refreshTokens.test.js

@@ -0,0 +1,101 @@
+const { checkAndRefreshAccessToken } = require('../../utils/refreshToken');
+const { oAuth2Client } = require('../../config/googleOAuth');
+
+jest.mock('../../config/googleOAuth', () => ({
+    oAuth2Client: {
+        setCredentials: jest.fn(),
+        isTokenExpiring: jest.fn(),
+        refreshAccessToken: jest.fn(),
+    },
+}));
+
+describe('checkAndRefreshAccessToken', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Set mock tokens in environment before each test
+        process.env.ACCESS_TOKEN = 'test-access-token';
+        process.env.REFRESH_TOKEN = 'test-refresh-token';
+    });
+
+    afterEach(() => {
+        // Clear the environment variables after each test
+        delete process.env.ACCESS_TOKEN;
+        delete process.env.REFRESH_TOKEN;
+    });
+
+    it('should use tokens from .env and set credentials', async () => {
+        oAuth2Client.isTokenExpiring.mockReturnValue(false);
+
+        const tokens = await checkAndRefreshAccessToken();
+
+        expect(oAuth2Client.setCredentials).toHaveBeenCalledWith({
+            access_token: 'test-access-token',
+            refresh_token: 'test-refresh-token',
+        });
+        expect(tokens).toEqual({
+            access_token: 'test-access-token',
+            refresh_token: 'test-refresh-token',
+        });
+    });
+
+    it('should refresh tokens if the access token is expiring', async () => {
+        oAuth2Client.isTokenExpiring.mockReturnValue(true);
+        oAuth2Client.refreshAccessToken.mockResolvedValueOnce({
+            credentials: {
+                access_token: 'new-access-token',
+                refresh_token: 'new-refresh-token',
+            },
+        });
+
+        const tokens = await checkAndRefreshAccessToken();
+
+        expect(oAuth2Client.refreshAccessToken).toHaveBeenCalled();
+        expect(oAuth2Client.setCredentials).toHaveBeenCalledWith({
+            access_token: 'new-access-token',
+            refresh_token: 'new-refresh-token',
+        });
+        expect(tokens).toEqual({
+            access_token: 'new-access-token',
+            refresh_token: 'new-refresh-token',
+        });
+    });
+
+    it('should log an error if token refresh fails', async () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+        oAuth2Client.isTokenExpiring.mockReturnValue(true);
+        oAuth2Client.refreshAccessToken.mockRejectedValueOnce(new Error('Refresh failed'));
+
+        const tokens = await checkAndRefreshAccessToken();
+
+        expect(oAuth2Client.refreshAccessToken).toHaveBeenCalled();
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error refreshing access token:', expect.any(Error));
+        expect(tokens).toEqual({
+            access_token: 'test-access-token',
+            refresh_token: 'test-refresh-token',
+        });
+
+        consoleErrorSpy.mockRestore();
+    });
+
+    it('should log a message if no tokens are found in .env', async () => {
+        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+        
+        // Set the environment variables to undefined to simulate missing tokens
+        delete process.env.ACCESS_TOKEN;
+        delete process.env.REFRESH_TOKEN;
+
+        const tokens = await checkAndRefreshAccessToken();
+
+        // Ensure the log message was printed
+        expect(consoleLogSpy).toHaveBeenCalledWith('No tokens found in .env file. Please authenticate.');
+        
+        // Ensure that setCredentials is NOT called because no tokens were provided
+        expect(oAuth2Client.setCredentials).not.toHaveBeenCalled();
+
+        // Check that the returned tokens are empty as expected
+        expect(tokens).toEqual({});
+
+        // Clean up the spy
+        consoleLogSpy.mockRestore();
+    });
+});

backend/__tests__/controller/applicantController.test.js

@@ -0,0 +1,132 @@
+const { submitJobApplication } = require('../../controller/applicantController');
+const { checkExistingJobApplication, insertJobApplication } = require('../../utils/jobRequestDB');
+const { checkAndRefreshAccessToken } = require('../../utils/refreshToken');
+const { google } = require('googleapis');
+const { oAuth2Client } = require('../../config/googleOAuth');
+
+// Mock the dependencies
+jest.mock('../../utils/jobRequestDB', () => ({
+    checkExistingJobApplication: jest.fn(),
+    insertJobApplication: jest.fn(),
+}));
+
+jest.mock('../../utils/refreshToken', () => ({
+    checkAndRefreshAccessToken: jest.fn(),
+}));
+
+// Mock googleapis and oAuth2Client setup
+jest.mock('googleapis', () => ({
+    google: {
+        auth: {
+            OAuth2: jest.fn().mockImplementation(() => ({
+                setCredentials: jest.fn(),
+            })),
+        },
+        gmail: jest.fn().mockReturnValue({
+            users: {
+                messages: {
+                    send: jest.fn(),
+                },
+            },
+        }),
+    },
+}));
+
+describe('submitJobApplication', () => {
+    let req;
+    let res;
+
+    beforeEach(() => {
+        // Mock request and response objects
+        req = {
+            body: {
+                name: 'John Doe',
+                email: '[email protected]',
+                phone: '1234567890',
+                experience: '5 years',
+                role: 'Software Engineer',
+                linkedin: 'https://linkedin.com/in/johndoe',
+            },
+            file: {
+                originalname: 'resume.pdf',
+                buffer: Buffer.from('file data'),
+            },
+        };
+        res = {
+            status: jest.fn().mockReturnThis(), // Mocking status method to return 'res' object itself
+            send: jest.fn().mockReturnThis(),    // Mocking send method
+            json: jest.fn().mockReturnThis(),    // Mocking json method
+        };
+    
+        // Clear previous mocks
+        jest.clearAllMocks();
+    });
+
+    it('should return an error if any required fields are missing', async () => {
+        req.body.email = ''; // Missing email
+
+        await submitJobApplication(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.json).toHaveBeenCalledWith({ error: 'Please fill in all required fields.' });
+    });
+
+    it('should return an error if email format is invalid', async () => {
+        req.body.email = 'invalid-email'; // Invalid email format
+
+        await submitJobApplication(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.json).toHaveBeenCalledWith({ error: 'Please enter a valid email address.' });
+    });
+
+    it('should refresh access token if needed', async () => {
+        await submitJobApplication(req, res);
+
+        expect(checkAndRefreshAccessToken).toHaveBeenCalled();
+    });
+
+    it('should return an error if job application already exists', async () => {
+        checkExistingJobApplication.mockResolvedValueOnce(true); // Simulate an existing job application
+    
+        await submitJobApplication(req, res);
+    
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'Your Job request for the role Software Engineer is already in queue'
+        });
+    });
+
+    it('should successfully submit job application and send an email', async () => {
+        checkExistingJobApplication.mockResolvedValueOnce(false); // Simulate no existing application
+        insertJobApplication.mockResolvedValueOnce(); // Simulate successful insertion
+
+        // Mocking Gmail API call
+        google.gmail().users.messages.send.mockResolvedValueOnce({
+            data: { id: 'message-id' },
+        });
+
+        await submitJobApplication(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.json).toHaveBeenCalledWith({ message: 'Application submitted successfully!', response: { data: { id: 'message-id' } } });
+
+        // Check if email was sent
+        expect(google.gmail().users.messages.send).toHaveBeenCalled();
+    });
+
+    it('should handle errors while sending the email', async () => {
+        checkExistingJobApplication.mockResolvedValueOnce(false); // Simulate no existing application
+        insertJobApplication.mockResolvedValueOnce(); // Simulate successful insertion
+
+        // Simulate email sending failure
+        google.gmail().users.messages.send.mockRejectedValueOnce(new Error('Email sending failed'));
+
+        await submitJobApplication(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.json).toHaveBeenCalledWith({
+            error: 'Failed to send job application reception email, however your job application has been received successfully!',
+        });
+    });
+});

backend/__tests__/controller/authController.test.js

@@ -0,0 +1,81 @@
+const { redirectToGoogleOAuth, handleOAuthCallback } = require('../../controller/authController');
+const { oAuth2Client } = require('../../config/googleOAuth');
+
+// Mock dependencies
+jest.mock('../../config/googleOAuth', () => ({
+    oAuth2Client: {
+        generateAuthUrl: jest.fn(),
+        getToken: jest.fn(),
+        setCredentials: jest.fn(),
+    }
+}));
+
+describe('Google OAuth Controller', () => {
+
+    // Test for redirectToGoogleOAuth
+    it('should redirect to Google OAuth URL', async () => {
+        const req = {}; // Mock the request if needed
+        const res = {
+            redirect: jest.fn()  // Mock the redirect method
+        };
+
+        // Simulate generating the auth URL
+        const expectedAuthUrl = 'https://accounts.google.com/o/oauth2/v2/auth?access_type=offline&scope=https://www.googleapis.com/auth/gmail.send+https://www.googleapis.com/auth/calendar.readonly';
+        oAuth2Client.generateAuthUrl.mockReturnValueOnce(expectedAuthUrl);
+
+        // Call the function
+        redirectToGoogleOAuth(req, res);
+
+        // Verify the redirect URL
+        expect(res.redirect).toHaveBeenCalledWith(expectedAuthUrl);
+    });
+
+    // Test for handleOAuthCallback (success)
+    it('should handle OAuth callback successfully and send a success message', async () => {
+        const req = { query: { code: 'valid-code' } };  // Simulate the query parameter with a valid code
+        const res = {
+            send: jest.fn(),     // Mock the send method
+            status: jest.fn().mockReturnThis(), // Mock status to chain calls
+        };
+
+        // Mock the oAuth2Client methods
+        const mockTokens = {
+            access_token: 'access-token',
+            refresh_token: 'refresh-token',
+        };
+
+        // Mock the getToken method to resolve with mock tokens
+        oAuth2Client.getToken.mockResolvedValueOnce({
+            tokens: mockTokens,
+        });
+
+        // Mock the setCredentials method to resolve
+        oAuth2Client.setCredentials.mockImplementationOnce(() => {});
+
+        // Call the function
+        await handleOAuthCallback(req, res);
+
+        // Check if the send method was called with the expected success message
+        expect(res.send).toHaveBeenCalledWith('Authorization successful! You can now send emails.');
+    });
+
+    // Test for handleOAuthCallback (error scenario)
+    it('should handle OAuth callback error and send failure message', async () => {
+        const req = { query: { code: 'invalid-code' } };  // Simulate an invalid code
+        const res = {
+            send: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+
+        // Mock the oAuth2Client methods to throw an error
+        oAuth2Client.getToken.mockRejectedValueOnce(new Error('OAuth error'));
+
+        // Call the function
+        await handleOAuthCallback(req, res);
+
+        // Check if the status was set to 500 and send was called with the failure message
+        expect(res.status).toHaveBeenCalledWith(500);
+        expect(res.send).toHaveBeenCalledWith('Failed to authenticate with Google');
+    });
+
+});

backend/__tests__/controller/contactController.test.js

@@ -0,0 +1,198 @@
+// Importing dependencies once to avoid re-declaration errors
+const { submitContactForm } = require('../../controller/contactController');
+const { checkAndRefreshAccessToken } = require('../../utils/refreshToken');
+const { checkExistingContactRequest, insertContactRequest } = require('../../utils/contactRequestDB');
+const fetch = require('node-fetch');
+const { google } = require('googleapis');
+
+// Mock dependencies
+jest.mock('../../utils/refreshToken', () => ({
+    checkAndRefreshAccessToken: jest.fn(),
+}));
+
+jest.mock('../../utils/contactRequestDB', () => ({
+    checkExistingContactRequest: jest.fn(),
+    insertContactRequest: jest.fn(),
+}));
+
+jest.mock('node-fetch', () => jest.fn().mockResolvedValue({
+    json: jest.fn().mockResolvedValue({ success: true })
+}));
+
+// Mock googleapis and oAuth2Client setup
+jest.mock('googleapis', () => ({
+    google: {
+        auth: {
+            OAuth2: jest.fn().mockImplementation(() => ({
+                setCredentials: jest.fn(),
+            })),
+        },
+        gmail: jest.fn().mockReturnValue({
+            users: {
+                messages: {
+                    send: jest.fn(),
+                },
+            },
+        }),
+    },
+}));
+
+describe('Contact Controller', () => {
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should handle contact form submission successfully', async () => {
+        const req = {
+            body: {
+                name: 'John Doe',
+                email: '[email protected]',
+                phone: '1234567890',
+                subject: 'Inquiry',
+                message: 'Hello, I have a question.',
+            },
+        };
+
+        const res = {
+            send: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+
+        // Mock dependencies
+        checkAndRefreshAccessToken.mockResolvedValueOnce();
+        checkExistingContactRequest.mockResolvedValueOnce(null);  // Simulate no existing request
+        insertContactRequest.mockResolvedValueOnce();
+
+        // Mock the Gmail API response
+        google.gmail().users.messages.send.mockResolvedValueOnce({
+            data: {
+                id: '123',
+                threadId: '456',
+            },
+        });
+        
+
+        // Call the controller function
+        await submitContactForm(req, res);
+
+        // Check the successful response
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalledWith({
+            message: 'Contact message sent successfully!',
+            response: {data: { id: '123', threadId: '456' }}, 
+        });
+
+        // Check if the required functions were called
+        expect(checkAndRefreshAccessToken).toHaveBeenCalledTimes(1);
+        expect(checkExistingContactRequest).toHaveBeenCalledWith('John Doe', '[email protected]', 'Inquiry');
+        expect(insertContactRequest).toHaveBeenCalledWith('John Doe', '[email protected]', '1234567890', 'Inquiry', 'Hello, I have a question.');
+        expect(google.gmail().users.messages.send).toHaveBeenCalledTimes(1);
+        expect(fetch).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return error if contact request with same subject exists', async () => {
+        const req = {
+            body: {
+                name: 'John Doe',
+                email: '[email protected]',
+                phone: '1234567890',
+                subject: 'Inquiry',
+                message: 'Hello, I have a question.',
+            },
+        };
+
+        const res = {
+            send: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+
+        // Mock dependencies
+        checkAndRefreshAccessToken.mockResolvedValueOnce();
+        checkExistingContactRequest.mockResolvedValueOnce(true); // Simulate an existing request
+        insertContactRequest.mockResolvedValueOnce();
+
+        // Call the function
+        await submitContactForm(req, res);
+
+        // Check if it returned the error message for existing request
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'Your contact request with same subject is in queue',
+        });
+
+        // Check if insertContactRequest wasn't called
+        expect(insertContactRequest).not.toHaveBeenCalled();
+    });
+
+    it('should return an error if required fields are missing', async () => {
+        const req = {
+            body: {
+                name: 'John Doe',
+                email: '[email protected]',
+                phone: '', // Missing phone
+                subject: 'Inquiry',
+                message: 'Hello, I have a question.',
+            },
+        };
+
+        const res = {
+            send: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+
+        // Call the function
+        await submitContactForm(req, res);
+
+        // Check if the response was the correct error message
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({ error: 'All fields are required.' });
+
+        // Check if any other functions were called (they shouldn't have been)
+        expect(checkAndRefreshAccessToken).not.toHaveBeenCalled();
+        expect(checkExistingContactRequest).not.toHaveBeenCalled();
+        expect(insertContactRequest).not.toHaveBeenCalled();
+        expect(fetch).not.toHaveBeenCalled();
+    });
+
+    it('should handle error when sending email fails', async () => {
+        const req = {
+            body: {
+                name: 'John Doe',
+                email: '[email protected]',
+                phone: '1234567890',
+                subject: 'Inquiry',
+                message: 'Hello, I have a question.',
+            },
+        };
+
+        const res = {
+            send: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+
+        // Mock dependencies
+        checkAndRefreshAccessToken.mockResolvedValueOnce();
+        checkExistingContactRequest.mockResolvedValueOnce(null); // Simulate no existing request
+        insertContactRequest.mockResolvedValueOnce();
+
+        // Simulate Gmail API failure
+        google.gmail().users.messages.send.mockRejectedValueOnce(new Error('Email send failed'));
+
+        // Call the controller function
+        await submitContactForm(req, res);
+
+        // Check the error response
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'Failed to send Contact request confirmation email, however request registered successfully!',
+        });
+
+        // Check if other functions were called
+        expect(checkAndRefreshAccessToken).toHaveBeenCalledTimes(1);
+        expect(checkExistingContactRequest).toHaveBeenCalledWith('John Doe', '[email protected]', 'Inquiry');
+        expect(insertContactRequest).toHaveBeenCalledWith('John Doe', '[email protected]', '1234567890', 'Inquiry', 'Hello, I have a question.');
+        expect(google.gmail().users.messages.send).toHaveBeenCalledTimes(1);
+    });
+
+});

backend/__tests__/controller/demo/dateAvailability.test.js

@@ -0,0 +1,81 @@
+const { checkDateAvailability, getAvailableDates } = require('../../../controller/dateAvailability');
+const { runSelectQuery } = require('../../../utils/queries');
+const { isHoliday } = require('../../../controller/holidays');
+const { DateTime } = require('luxon');
+
+// Mock dependencies
+jest.mock('../../../utils/queries', () => ({
+    runSelectQuery: jest.fn(),
+}));
+
+jest.mock('../../../controller/holidays', () => ({
+    isHoliday: jest.fn(),
+}));
+
+describe('Date Availability Module', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('checkDateAvailability', () => {
+        it('should return true if the date is available (less than 11 bookings)', async () => {
+            runSelectQuery.mockResolvedValue([{ count: 5 }]);
+
+            const result = await checkDateAvailability('2025-01-01');
+            expect(runSelectQuery).toHaveBeenCalledWith(
+                'SELECT COUNT(*) AS count FROM demo_requests WHERE demo_date = ?;',
+                ['2025-01-01']
+            );
+            expect(result).toBe(true);
+        });
+
+        it('should return false if the date is fully booked (11 or more bookings)', async () => {
+            runSelectQuery.mockResolvedValue([{ count: 11 }]);
+
+            const result = await checkDateAvailability('2025-01-01');
+            expect(result).toBe(false);
+        });
+
+        it('should handle empty results gracefully', async () => {
+            runSelectQuery.mockResolvedValue([]);
+
+            const result = await checkDateAvailability('2025-01-01');
+            expect(result).toBe(true); // No bookings mean the date is available
+        });
+    });
+
+    describe('getAvailableDates', () => {
+        it('should return 14 available dates excluding holidays and weekends', async () => {
+            const currentDate = DateTime.fromISO('2025-01-01', { zone: 'Asia/Kolkata' });
+    
+            // Mock isHoliday to return false for all dates
+            isHoliday.mockImplementation(async () => false);
+    
+            // Mock runSelectQuery to simulate all dates have <11 bookings
+            runSelectQuery.mockImplementation(async () => [{ count: 0 }]);
+    
+            const result = await getAvailableDates(currentDate);
+    
+            // Check that 14 dates are returned
+            expect(result.length).toBe(14);
+        });
+
+        it('should skip holidays, Sundays, and 1st/3rd/5th Saturdays', async () => {
+            const currentDate = DateTime.fromISO('2025-01-01', { zone: 'Asia/Kolkata' });
+
+            // Mock isHoliday to return true for specific dates
+            isHoliday.mockImplementation(async date =>
+                ['2025-01-02', '2025-01-05'].includes(date)
+            );
+
+            // Mock runSelectQuery to simulate availability
+            runSelectQuery.mockImplementation(async () => [{ count: 0 }]);
+
+            const result = await getAvailableDates(currentDate);
+
+            // Ensure skipped dates are not in the result
+            expect(result).not.toContain('2025-01-02');
+            expect(result).not.toContain('2025-01-05');
+        });
+    });
+});

backend/__tests__/controller/demo/holidays.test.js

@@ -0,0 +1,128 @@
+const { getIndiaTamilHolidays, refreshHolidays, isHoliday } = require('../../../controller/holidays');
+const { google } = require('googleapis');
+const { oAuth2Client } = require('../../../config/googleOAuth');
+const { checkAndRefreshAccessToken } = require('../../../utils/refreshToken');
+
+// Mock the dependencies
+jest.mock('googleapis', () => ({
+    google: {
+        calendar: jest.fn().mockReturnValue({
+            events: {
+                list: jest.fn(),
+            },
+        }),
+    },
+}));
+
+jest.mock('../../../utils/refreshToken', () => ({
+    checkAndRefreshAccessToken: jest.fn(),
+}));
+
+jest.mock('../../../config/googleOAuth', () => ({
+    oAuth2Client: {
+        setCredentials: jest.fn(),
+    },
+}));
+
+describe('Holidays Controller', () => {
+    let mockResponse;
+    let consoleLogSpy;
+    let setTimeoutSpy;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // Mock response to return a list of holiday events
+        mockResponse = {
+            data: {
+                items: [
+                    {
+                        summary: 'Holiday 1',
+                        start: { date: '2025-01-01' },
+                        end: { date: '2025-01-01' },
+                    },
+                    {
+                        summary: 'Holiday 2',
+                        start: { date: '2025-02-01' },
+                        end: { date: '2025-02-02' },
+                    },
+                ],
+            },
+        };
+
+        checkAndRefreshAccessToken.mockResolvedValue({ access_token: 'valid-token' });
+        google.calendar().events.list.mockResolvedValue(mockResponse);
+
+        // Spy on console.log to suppress output during tests
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+        // Spy on setTimeout to suppress interval during tests
+        setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation((fn, delay) => fn());
+    });
+
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        setTimeoutSpy.mockRestore();
+    });
+
+    describe('getIndiaTamilHolidays', () => {
+        it('should return a list of holidays', async () => {
+            const holidays = await getIndiaTamilHolidays();
+
+            expect(holidays).toEqual([
+                { festival: 'Holiday 1', date: '2025-01-01' },
+                { festival: 'Holiday 2', date: '2025-02-01' },
+                { festival: 'Holiday 2', date: '2025-02-02' },
+            ]);
+            expect(google.calendar().events.list).toHaveBeenCalledTimes(1);
+            expect(checkAndRefreshAccessToken).toHaveBeenCalledTimes(1);
+        });
+
+        it('should return an error if OAuth credentials are missing', async () => {
+            checkAndRefreshAccessToken.mockResolvedValueOnce(null);
+
+            const result = await getIndiaTamilHolidays();
+            expect(result).toEqual({ error: 'OAuth credentials missing. Please authorize the app first.' });
+        });
+
+        it('should handle errors properly', async () => {
+            google.calendar().events.list.mockRejectedValueOnce(new Error('API Error'));
+
+            await expect(getIndiaTamilHolidays()).rejects.toThrow('API Error');
+        });
+    });
+
+    describe('refreshHolidays', () => {
+        it('should refresh holidays and log them', async () => {
+            await refreshHolidays();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith('India Holidays:', expect.any(Array));
+            expect(consoleLogSpy).toHaveBeenCalledWith('Total holidays:', 3);
+            expect(consoleLogSpy).toHaveBeenCalledWith('Last holiday:', expect.any(Object));
+        });
+
+        it('should handle retrying on error', async () => {
+            google.calendar().events.list.mockRejectedValueOnce(new Error('API Error'));
+
+            await refreshHolidays();
+
+            expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 10000);
+        });
+    });
+
+    describe('isHoliday', () => {
+        it('should return true if the date is a holiday', async () => {
+            await refreshHolidays();
+
+            const result = await isHoliday('2025-01-01');
+            expect(result).toBe(true);
+        });
+
+        it('should return false if the date is not a holiday', async () => {
+            await refreshHolidays();
+
+            const result = await isHoliday('2025-01-03');
+            expect(result).toBe(false);
+        });
+    });
+});

backend/__tests__/controller/demo/slots.test.js

@@ -0,0 +1,142 @@
+const { getAvailableSlots, getBookedSlots } = require('../../../controller/slots');
+const { runSelectQuery } = require('../../../utils/queries');
+
+// Mock the runSelectQuery function
+jest.mock('../../../utils/queries', () => ({
+    runSelectQuery: jest.fn(),
+}));
+
+describe('Slots Controller', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('getBookedSlots', () => {
+        it('should throw an error if no date is provided', async () => {
+            await expect(getBookedSlots()).rejects.toThrow('Date is required');
+        });
+        
+
+        it('should return an empty array if no slots are found for a valid date', async () => {
+            const date = '2025-01-01';
+            runSelectQuery.mockResolvedValueOnce([]); // Simulate no booked slots
+
+            const slots = await getBookedSlots(date);
+
+            expect(slots).toEqual([]); // No booked slots
+            expect(runSelectQuery).toHaveBeenCalledWith(
+                expect.any(String),
+                date
+            );
+        });
+
+        it('should return a list of booked slots for a given date', async () => {
+            const date = '2025-01-01';
+            const mockBookedSlots = [
+                { slot: '10:00 - 10:30' },
+                { slot: '11:30 - 12:00' },
+            ];
+            runSelectQuery.mockResolvedValueOnce(mockBookedSlots);
+
+            const slots = await getBookedSlots(date);
+
+            expect(slots).toEqual(['10:00 - 10:30', '11:30 - 12:00']);
+            expect(runSelectQuery).toHaveBeenCalledWith(
+                expect.any(String),
+                date
+            );
+        });
+
+        it('should handle missing slot property gracefully', async () => {
+            const date = '2025-01-01';
+            const mockBookedSlots = [
+                { slot: '10:00 - 10:30' },
+                { /* missing slot property */ },
+            ];
+            runSelectQuery.mockResolvedValueOnce(mockBookedSlots);
+
+            const slots = await getBookedSlots(date);
+
+            expect(slots).toEqual(['10:00 - 10:30']); // Ignore the entry without a slot
+        });
+    });
+
+    describe('getAvailableSlots', () => {
+        it('should throw an error if no date is provided', async () => {
+            await expect(getAvailableSlots()).rejects.toThrow('Date is required');
+        });
+
+        it('should throw an error for invalid date format', async () => {
+            const invalidDate = '2025-01-32';
+            await expect(getAvailableSlots(invalidDate)).rejects.toThrow('Invalid date format. Expected YYYY-MM-DD');
+        });
+
+        it('should return all general slots if no slots are booked for a given date', async () => {
+            const date = '2025-01-01';
+            runSelectQuery.mockResolvedValueOnce([]); // Simulate no booked slots
+
+            const availableSlots = await getAvailableSlots(date);
+
+            expect(availableSlots).toEqual([
+                '10:00 - 10:30', '10:45 - 11:15', '11:30 - 12:00', '12:15 - 12:45', '13:00 - 13:30',
+                '13:45 - 14:15', '14:30 - 15:00', '15:15 - 15:45', '16:00 - 16:30', '16:45 - 17:15', '17:30 - 18:00'
+            ]);
+            expect(runSelectQuery).toHaveBeenCalledWith(
+                expect.any(String),
+                date
+            );
+        });
+
+        it('should return available slots after removing booked slots', async () => {
+            const date = '2025-01-01';
+            const mockBookedSlots = [
+                { slot: '10:00 - 10:30' },
+                { slot: '11:30 - 12:00' },
+            ];
+            runSelectQuery.mockResolvedValueOnce(mockBookedSlots);
+
+            const availableSlots = await getAvailableSlots(date);
+
+            expect(availableSlots).toEqual([
+                '10:45 - 11:15', '12:15 - 12:45', '13:00 - 13:30', '13:45 - 14:15',
+                '14:30 - 15:00', '15:15 - 15:45', '16:00 - 16:30', '16:45 - 17:15', '17:30 - 18:00'
+            ]);
+            expect(runSelectQuery).toHaveBeenCalledWith(
+                expect.any(String),
+                date
+            );
+        });
+
+        it('should handle empty results gracefully', async () => {
+            const date = '2025-01-01';
+            const mockBookedSlots = []; // No booked slots
+            runSelectQuery.mockResolvedValueOnce(mockBookedSlots);
+
+            const availableSlots = await getAvailableSlots(date);
+
+            expect(availableSlots).toEqual([
+                '10:00 - 10:30', '10:45 - 11:15', '11:30 - 12:00', '12:15 - 12:45', '13:00 - 13:30',
+                '13:45 - 14:15', '14:30 - 15:00', '15:15 - 15:45', '16:00 - 16:30', '16:45 - 17:15', '17:30 - 18:00'
+            ]);
+            expect(runSelectQuery).toHaveBeenCalledWith(
+                expect.any(String),
+                date
+            );
+        });
+
+        it('should throw an error if general slots are not properly defined', async () => {
+            const date = '2025-01-01';
+            const mockBookedSlots = [{ slot: '10:00 - 10:30' }];
+            runSelectQuery.mockResolvedValueOnce(mockBookedSlots);
+
+            // Temporarily break the generalSlots array
+            const originalGeneralSlots = [...global.generalSlots];
+            global.generalSlots = undefined;
+
+            await expect(getAvailableSlots(date)).rejects.toThrow('General slots are not properly defined');
+
+            // Restore the general slots for other tests
+            global.generalSlots = originalGeneralSlots;
+        });
+    });
+});

backend/__tests__/controller/demo/utils.test.js

@@ -0,0 +1,77 @@
+const { createDateTimeSlotMapping, slotsInUserZone, getDatesSlots } = require('../../../controller/utils');
+const { DateTime } = require('luxon');
+
+describe('Utils Controller', () => {
+
+    describe('createDateTimeSlotMapping', () => {
+        it('should map date-time to slots correctly', () => {
+            const data = [
+                { '2025-01-01': ['10:00 - 10:30', '11:00 - 11:30'] },
+                { '2025-01-02': ['12:00 - 12:30'] }
+            ];
+            const expected = {
+                '2025-01-01T10:00': '10:00 - 10:30',
+                '2025-01-01T11:00': '11:00 - 11:30',
+                '2025-01-02T12:00': '12:00 - 12:30'
+            };
+            const result = createDateTimeSlotMapping(data);
+            expect(result).toEqual(expected);
+        });
+
+        it('should return an empty object if no data is provided', () => {
+            const result = createDateTimeSlotMapping([]);
+            expect(result).toEqual({});
+        });
+
+        it('should handle invalid date format gracefully', () => {
+            const data = [
+                { '2025-01-01': ['10:00 - 10:30'] },
+                { '2025-31-31': ['11:00 - 11:30'] } // Invalid date format
+            ];
+            const result = createDateTimeSlotMapping(data);
+            expect(result['2025-31-31T11:00']).toBeUndefined(); // Should not map an invalid date
+        });
+    });
+
+    describe('slotsInUserZone', () => {
+        it('should convert slot times correctly for user timezone', async () => {
+            const inter = {
+                '2025-01-01T10:00': '10:00 - 10:30',
+                '2025-01-01T11:00': '11:00 - 11:30'
+            };
+            const timezone = 'America/New_York';
+            const result = await slotsInUserZone(inter, timezone);
+            console.log(result);
+            expect(result['2024-12-31T23:30:00.000-05:00']).toBe('23:30 - 00:00 (America/New_York)');
+        });
+    });
+
+    describe('getDatesSlots', () => {
+        it('should organize slots by date correctly', async () => {
+            const input = {
+                '2025-01-01T10:00': '10:00 - 10:30',
+                '2025-01-01T11:00': '11:00 - 11:30',
+                '2025-01-02T12:00': '12:00 - 12:30'
+            };
+            const result = await getDatesSlots(input);
+            expect(result).toEqual({
+                '2025-01-01': ['10:00 - 10:30', '11:00 - 11:30'],
+                '2025-01-02': ['12:00 - 12:30']
+            });
+        });
+
+        it('should handle empty input', async () => {
+            const input = {};
+            const result = await getDatesSlots(input);
+            expect(result).toEqual({});
+        });
+
+        it('should handle invalid timestamp formats', async () => {
+            const input = {
+                'invalid-date': '10:00 - 10:30'
+            };
+            const result = await getDatesSlots(input);
+            expect(result).toEqual({});
+        });
+    });
+});

backend/__tests__/controller/demoRequestController.test.js

@@ -0,0 +1,293 @@
+const { demoRequest } = require('../../controller/demoRequestController');
+const { checkExistingDemoRequest, insertDemoRequest } = require('../../utils/demoRequestDB');
+const { checkAndRefreshAccessToken } = require('../../utils/refreshToken');
+const { oAuth2Client } = require('../../config/googleOAuth');
+const { google } = require('googleapis');
+const fetch = require('node-fetch');
+const { DateTime } = require('luxon');
+
+jest.mock('../../utils/demoRequestDB', () => ({
+    checkExistingDemoRequest: jest.fn(),
+    insertDemoRequest: jest.fn(),
+}));
+
+jest.mock('../../utils/refreshToken', () => ({
+    checkAndRefreshAccessToken: jest.fn(),
+}));
+
+jest.mock('../../config/googleOAuth', () => ({
+    oAuth2Client: {
+        setCredentials: jest.fn(),
+    },
+}));
+
+jest.mock('node-fetch', () => jest.fn());
+
+jest.mock('googleapis', () => ({
+    google: {
+        gmail: jest.fn().mockReturnValue({
+            users: {
+                messages: {
+                    send: jest.fn(),
+                },
+            },
+        }),
+    },
+}));
+
+describe('demoRequest Controller', () => {
+    let req, res;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        req = {
+            body: {
+                name: 'John Doe',
+                email: '[email protected]',
+                company: 'Example Corp',
+                product: 'Test Product',
+                demoDate: '2025-02-01',
+                selectedSlot: '10:00 - 11:00 (IST)',
+                phone: '+1234567890',
+                additionalComments: 'Looking forward to it!',
+                timezone: 'America/New_York',
+            },
+        };
+
+        res = {
+            status: jest.fn().mockReturnThis(),
+            send: jest.fn(),
+        };
+    });
+
+    it('should return 400 if required fields are missing', async () => {
+        req.body = {}; // Missing fields
+
+        await demoRequest(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({ error: 'Please fill in all required fields.' });
+    });
+
+    it('should return 400 if demo request already exists within 15 days', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(true);
+
+        await demoRequest(req, res);
+
+        expect(checkExistingDemoRequest).toHaveBeenCalledWith(
+            'John Doe',
+            '[email protected]',
+            'Test Product',
+            '2025-02-01',
+            '+1234567890'
+        );
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'You have already requested a demo for this product within 15 days. Our team will get back to you shortly.',
+        });
+    });
+
+    it('should insert a new demo request if no existing request is found', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        await demoRequest(req, res);
+
+        const convertedDemoDate = DateTime.fromISO(req.body.demoDate, { zone: 'utc' })
+            .setZone('Asia/Kolkata')
+            .toFormat('yyyy-MM-dd');
+
+        expect(insertDemoRequest).toHaveBeenCalledWith(
+            'John Doe',
+            '[email protected]',
+            'Example Corp',
+            'Test Product',
+            convertedDemoDate,
+            '10:00 - 11:00',
+            '+1234567890',
+            'Looking forward to it!'
+        );
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalledWith({
+            message: 'Demo request submitted successfully! Our team will get in touch with you soon.',
+            response: {},
+        });
+    });
+
+    it('should send an email via Gmail API', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        await demoRequest(req, res);
+
+        expect(google.gmail().users.messages.send).toHaveBeenCalledWith({
+            userId: 'me',
+            requestBody: {
+                raw: expect.any(String),
+            },
+        });
+    });
+
+    it('should handle email sending failure gracefully', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockRejectedValueOnce(new Error('Email API Error'));
+
+        await demoRequest(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'Failed to send demo request confirmation email, however the demo request has been registered successfully!',
+        });
+    });
+
+    it('should call VAPI API with correct data', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        // Mock fetch response for the VAPI API call
+        fetch.mockResolvedValueOnce({
+            json: jest.fn().mockResolvedValueOnce({ success: true }),
+        });
+
+        await demoRequest(req, res);
+
+        expect(fetch).toHaveBeenCalledWith('https://api.vapi.ai/call', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${process.env.VAPI_KEY}`,
+            },
+            body: JSON.stringify({
+                name: '+1234567890_2025-01-28_DRC',
+                assistantId: `${process.env.DEMO_ASSISTANT_ID}`,
+                assistantOverrides: {
+                    variableValues: {
+                        name: 'John Doe',
+                        product_name: 'Test Product',
+                        demo_date: '2025-02-01',
+                        slot: '10:00 - 11:00 (IST)',
+                        comments: 'Looking forward to it!',
+                    },
+                },
+                customer: {
+                    number: '+1234567890',
+                },
+                phoneNumberId: `${process.env.PHONE_NUMBER_ID}`,
+            }),
+        });
+    });
+
+    it('should correctly convert the selected time slot to Asia/Kolkata timezone', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        await demoRequest(req, res);
+
+        // Ensure the demo date and time are converted to Asia/Kolkata timezone
+        const convertedTime = '10:00 - 11:00'; // Expected converted time
+        expect(insertDemoRequest).toHaveBeenCalledWith(
+            'John Doe',
+            '[email protected]',
+            'Example Corp',
+            'Test Product',
+            expect.any(String), // Date will be formatted and converted
+            convertedTime,
+            '+1234567890',
+            'Looking forward to it!'
+        );
+    });
+
+    it('should return 400 if product field is missing', async () => {
+        req.body.product = ''; // Missing product
+
+        await demoRequest(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({ error: 'Please fill in all required fields.' });
+    });
+
+    it('should generate correctly formatted HTML email content', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        await demoRequest(req, res);
+
+        const expectedHtmlMessage = `
+        <div style="font-family: Arial, sans-serif; color: #333;">
+            <img src="https://www.genomatics.in/wp-content/uploads/2020/01/cropped-LOGO-1-1.png" alt="Genomatics Logo">
+            <h2 style="color: #0056b3;">Hello John Doe,</h2>
+            <p>Thank you for requesting a demo of our <strong>Genomatics</strong> product: <strong>Test Product</strong>. We're excited to showcase how our solutions can benefit your team at <strong>Example Corp</strong>.</p>
+            <p><strong>Requested demo date:</strong> 2025-02-01 - Time zone: America/New_York</p>
+            <p><strong>Preferred time slot:</strong> 10:00 - 11:00 (IST)</p>
+            <p>We'll be in touch soon to confirm the details. In the meantime, please feel free to reach out with any specific questions or topics you’d like us to cover during the demo.</p>
+            <h3 style="color: #0056b3;">Additional Message from You:</h3>
+            <p>Looking forward to it!</p>
+            <p style="margin-top: 20px;">Best regards,</p>
+            <p><strong>The Genomatics Team</strong></p>
+            <hr style="border: 0; height: 1px; background: #ddd; margin: 20px 0;">
+            <p style="font-size: 12px; color: #666;">
+                This email was sent in response to your request for a demo on the Genomatics platform.
+            </p>
+        </div>`;
+
+        expect(google.gmail().users.messages.send).toHaveBeenCalledWith({
+            userId: 'me',
+            requestBody: {
+                raw: expect.any(String),
+            },
+        });
+
+        // Verify that email content matches the expected content
+        const emailContent = google.gmail().users.messages.send.mock.calls[0][0].requestBody.raw;
+        expect(emailContent).toContain(expectedHtmlMessage);
+    });
+
+    it('should handle fetch API error during VAPI call', async () => {
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        // Mock fetch to throw an error during VAPI API call
+        fetch.mockRejectedValueOnce(new Error('VAPI call failed'));
+
+        await demoRequest(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'Failed to send demo request confirmation email, however the demo request has been registered successfully!',
+        });
+    });
+
+    it('should correctly handle daylight saving time transitions for timezones', async () => {
+        req.body.timezone = 'America/New_York'; // A timezone with daylight saving time transition
+
+        checkExistingDemoRequest.mockResolvedValueOnce(false);
+        checkAndRefreshAccessToken.mockResolvedValueOnce({});
+        google.gmail().users.messages.send.mockResolvedValueOnce({}); // Mock email sending
+
+        await demoRequest(req, res);
+
+        // Test if the correct timezone is applied
+        const convertedDemoDate = DateTime.fromISO(req.body.demoDate, { zone: 'utc' })
+            .setZone('America/New_York')
+            .toFormat('yyyy-MM-dd');
+
+        expect(insertDemoRequest).toHaveBeenCalledWith(
+            'John Doe',
+            '[email protected]',
+            'Example Corp',
+            'Test Product',
+            convertedDemoDate,
+            '10:00 - 11:00',
+            '+1234567890',
+            'Looking forward to it!'
+        );
+    });
+});

backend/__tests__/controller/subscriptionController.test.js

@@ -0,0 +1,131 @@
+const { handleSubscriptionEmail } = require('../../controller/subscriptionController');
+const { addSubscriber } = require('../../utils/addSubscriber');
+const { checkAndRefreshAccessToken } = require('../../utils/refreshToken');
+const { google } = require('googleapis');
+const { oAuth2Client } = require('../../config/googleOAuth');
+
+// Mock the dependencies
+jest.mock('../../utils/addSubscriber', () => ({
+    addSubscriber: jest.fn(),
+}));
+
+jest.mock('../../utils/refreshToken', () => ({
+    checkAndRefreshAccessToken: jest.fn(),
+}));
+
+// Mock googleapis and oAuth2Client setup
+jest.mock('googleapis', () => ({
+    google: {
+        auth: {
+            OAuth2: jest.fn().mockImplementation(() => ({
+                setCredentials: jest.fn(),
+            })),
+        },
+        gmail: jest.fn().mockReturnValue({
+            users: {
+                messages: {
+                    send: jest.fn(),
+                },
+            },
+        }),
+    },
+}));
+
+describe('handleSubscriptionEmail', () => {
+    let req;
+    let res;
+    let userTokens;
+
+    beforeEach(() => {
+        // Mock request and response objects
+        req = {
+            body: {
+                email: '[email protected]',
+            },
+        };
+        res = {
+            status: jest.fn().mockReturnThis(), // Mocking status method to return 'res' object itself
+            send: jest.fn().mockReturnThis(),    // Mocking send method
+            json: jest.fn().mockReturnThis(),    // Mocking json method
+        };
+        
+        oAuth2Client.credentials = { access_token: 'fake-access-token', refresh_token: `fake-refresh-token` }; // Mocked OAuth tokens
+        
+        // Clear previous mocks
+        jest.clearAllMocks();
+    });
+
+    it('should return an error if email is missing', async () => {
+        req.body.email = ''; // Missing email
+
+        await handleSubscriptionEmail(req, res);    
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({ error: 'Email is required' });
+    });
+
+    it('should return an error if OAuth credentials are missing', async () => {
+        req.body.email = '[email protected]'; // Valid email
+        oAuth2Client.credentials = null; // Mocked OAuth tokens
+    
+        addSubscriber.mockResolvedValueOnce({ status: 200, message: 'Subscriber added' });
+    
+        await handleSubscriptionEmail(req, res);
+    
+        expect(res.status).toHaveBeenCalledWith(500);
+        expect(res.send).toHaveBeenCalledWith({ error: 'OAuth credentials missing. Please authorize the app first.' });
+    });
+
+    it('should successfully subscribe a user and send a subscription email', async () => {
+        addSubscriber.mockResolvedValueOnce({ status: 200, message: 'Subscriber added' }); // Mock success
+        checkAndRefreshAccessToken.mockResolvedValueOnce(); // Mock successful token refresh
+
+        oAuth2Client.credentials = { access_token: 'fake-access-token', refresh_token: `fake-refresh-token` }; // Mocked OAuth tokens
+
+        google.gmail().users.messages.send.mockResolvedValueOnce({
+            data: { id: '123', threadId: '456' }, // Mock successful email sending
+        });
+    
+        await handleSubscriptionEmail(req, res);
+    
+        expect(res.status).toHaveBeenCalledWith(200);
+        expect(res.send).toHaveBeenCalledWith({
+            message: 'Subscription email sent!',
+            response: { data: { id: '123', threadId: '456' } },
+        });
+    
+        expect(addSubscriber).toHaveBeenCalledWith('[email protected]');
+        expect(checkAndRefreshAccessToken).toHaveBeenCalledTimes(1);
+        expect(google.gmail().users.messages.send).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return an error if email is already in the database', async () => {
+        const result = {
+            error: 'Email already exists',
+            status: 400,
+        };
+        addSubscriber.mockResolvedValueOnce(result); // Simulate email already existing
+
+        await handleSubscriptionEmail(req, res);
+
+        expect(res.status).toHaveBeenCalledWith(400);
+        expect(res.send).toHaveBeenCalledWith({ error: 'Email already exists' });
+
+        expect(addSubscriber).toHaveBeenCalledWith('[email protected]');
+    });
+
+    it('should handle error when sending email fails', async () => {
+        addSubscriber.mockResolvedValueOnce({ status: 200, message: 'Subscriber added' }); // Mock success
+        google.gmail().users.messages.send.mockRejectedValueOnce(new Error('Failed to send email')); // Mock email send failure
+    
+        await handleSubscriptionEmail(req, res);
+    
+        expect(res.status).toHaveBeenCalledWith(500);
+        expect(res.send).toHaveBeenCalledWith({
+            error: 'Failed to send subscription confirmation email, however you are subscribed and will receive newsletters',
+        });
+    
+        expect(addSubscriber).toHaveBeenCalledWith('[email protected]');
+        expect(google.gmail().users.messages.send).toHaveBeenCalledTimes(1);
+    });
+});

backend/__tests__/db.test.js

@@ -0,0 +1,64 @@
+// initializeDatabase.test.js
+const { initializeDatabase } = require('../utils/setupDB'); // Import the function
+const { runQuery } = require('../utils/queries');  // Import the runQuery function
+
+jest.mock('../utils/queries'); // Mock the runQuery function
+
+describe('initializeDatabase', () => {
+  beforeEach(() => {
+    // Clear all previous mocks before each test
+    jest.clearAllMocks();
+  });
+
+  it('should call runQuery for each table creation query', async () => {
+    // Arrange: Simulate the successful execution of runQuery
+    runQuery.mockResolvedValueOnce({}); // Mocking a successful query execution
+
+    // Act: Call the initializeDatabase function
+    await initializeDatabase();
+
+    // Assert: Check that runQuery was called once for each table creation query
+    const tableCreationQueries = [
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS subscribers'),
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS applicants'),
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS demo_requests'),
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS contact_requests'),
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS purchases'),
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS jobs')
+    ];
+
+    tableCreationQueries.forEach((query, index) => {
+      expect(runQuery).toHaveBeenNthCalledWith(index + 1, query);
+    });
+  });
+
+  it('should handle errors properly if runQuery fails', async () => {
+    // Arrange: Simulate a failure when runQuery is called
+    runQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    // Act & Assert: Call the function and expect it to log the error
+    await expect(initializeDatabase()).resolves.not.toThrow(); // Since error is logged but not re-thrown
+    expect(runQuery).toHaveBeenCalled();
+  });
+
+  it('should log successful table creation', async () => {
+    // Arrange: Mock successful query responses
+    runQuery.mockResolvedValueOnce({}); // Mocking a successful query execution
+
+    // Act: Call the function and capture the console log output
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {}); // Spy on console.log
+
+    await initializeDatabase();
+
+    // Assert: Check that each table creation success message is logged
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Table 'subscribers' is checked/created successfully."));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Table 'applicants' is checked/created successfully."));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Table 'demo_requests' is checked/created successfully."));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Table 'contact_requests' is checked/created successfully."));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Table 'purchases' is checked/created successfully."));
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Table 'jobs' is checked/created successfully."));
+    
+    // Cleanup the spy
+    logSpy.mockRestore();
+  });
+});

backend/__tests__/db/addSubscriber.test.js

@@ -0,0 +1,95 @@
+const { addSubscriber } = require('../../utils/addSubscriber'); // Import the addSubscriber function
+const { runQuery, runSelectQuery } = require('../../utils/queries');  // Import the functions that interact with the DB
+
+jest.mock('../../utils/queries'); // Mock the runQuery and runSelectQuery functions
+
+describe('addSubscriber', () => {
+  beforeEach(() => {
+    // Clear all previous mocks before each test
+    jest.clearAllMocks();
+  });
+
+  it('should return an error if the email already exists', async () => {
+    // Arrange: Mock the result of runSelectQuery to simulate that the email already exists
+    const email = '[email protected]';
+    runSelectQuery.mockResolvedValueOnce([{ email }]); // Simulate an existing email in the database
+
+    // Act: Call the addSubscriber function
+    const result = await addSubscriber(email);
+
+    // Assert: Ensure the function returns the correct error response
+    expect(result).toEqual({ status: 400, error: 'You have already subscribed!!' });
+    expect(runSelectQuery).toHaveBeenCalledWith('SELECT * FROM subscribers WHERE email = ?', [email]);
+    expect(runQuery).not.toHaveBeenCalled(); // Ensure runQuery was not called since email already exists
+  });
+
+  it('should add a new subscriber if the email does not exist', async () => {
+    // Arrange: Mock the result of runSelectQuery to simulate that the email does not exist
+    const email = '[email protected]';
+    runSelectQuery.mockResolvedValueOnce([]); // Simulate no matching email in the database
+    runQuery.mockResolvedValueOnce({}); // Mock the successful insert query
+
+    // Act: Call the addSubscriber function
+    const result = await addSubscriber(email);
+
+    // Assert: Ensure the subscriber was added and a success message is returned
+    expect(result).toEqual({ status: 200, message: 'Subscriber added' });
+    expect(runSelectQuery).toHaveBeenCalledWith('SELECT * FROM subscribers WHERE email = ?', [email]);
+    expect(runQuery).toHaveBeenCalledWith(
+      'INSERT INTO subscribers (date, time, email) VALUES (DATE("now"), TIME("now"), ?)',
+      [email]
+    );
+  });
+
+  it('should handle errors properly if there is a database error', async () => {
+    // Arrange: Simulate an error in the database operation
+    const email = '[email protected]';
+    runSelectQuery.mockResolvedValueOnce([]); // Simulate no matching email
+    runQuery.mockRejectedValueOnce(new Error('Database error')); // Simulate an error during the insert
+
+    // Act: Call the addSubscriber function
+    const result = await addSubscriber(email);
+
+    // Assert: Ensure the error is logged and the error response is returned
+    expect(result).toEqual({ status: 500, error: 'Failed to add subscriber' });
+    expect(runSelectQuery).toHaveBeenCalledWith('SELECT * FROM subscribers WHERE email = ?', [email]);
+    expect(runQuery).toHaveBeenCalledWith(
+      'INSERT INTO subscribers (date, time, email) VALUES (DATE("now"), TIME("now"), ?)',
+      [email]
+    );
+  });
+
+  it('should log success message when a new subscriber is added', async () => {
+    // Arrange: Mock the result of runSelectQuery to simulate that the email does not exist
+    const email = '[email protected]';
+    runSelectQuery.mockResolvedValueOnce([]); // Simulate no matching email
+    runQuery.mockResolvedValueOnce({}); // Mock successful insert
+
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {}); // Spy on console.log
+
+    // Act: Call the addSubscriber function
+    await addSubscriber(email);
+
+    // Assert: Ensure the success message is logged
+    expect(logSpy).toHaveBeenCalledWith('Subscriber added successfully');
+    
+    logSpy.mockRestore(); // Clean up the spy
+  });
+
+  it('should log an error message if there is a database error', async () => {
+    // Arrange: Simulate an error scenario
+    const email = '[email protected]';
+    runSelectQuery.mockResolvedValueOnce([]); // Simulate no matching email
+    runQuery.mockRejectedValueOnce(new Error('Database error')); // Simulate insert error
+
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {}); // Spy on console.error
+
+    // Act: Call the addSubscriber function
+    await addSubscriber(email);
+
+    // Assert: Ensure the error message is logged
+    expect(errorSpy).toHaveBeenCalledWith('Database error:', expect.any(Error));
+    
+    errorSpy.mockRestore(); // Clean up the spy
+  });
+});

backend/__tests__/db/contactRequestDB.test.js

@@ -0,0 +1,90 @@
+const { checkExistingContactRequest, insertContactRequest } = require('../../utils/contactRequestDB');
+const { runQuery, runSelectQuery } = require('../../utils/queries');
+
+jest.mock('../../utils/queries');
+
+describe('checkExistingContactRequest', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return true if a contact request with the same name, email, and subject exists', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const subject = 'Inquiry';
+    runSelectQuery.mockResolvedValueOnce([{ name, email, subject }]);
+
+    const result = await checkExistingContactRequest(name, email, subject);
+
+    expect(result).toBe(true);
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`SELECT * FROM contact_requests WHERE name = ? AND email = ? AND subject = ?;`),
+      [name, email, subject]
+    );
+  });
+
+  it('should return false if no contact request with the same name, email, and subject exists', async () => {
+    const name = 'Jane Doe';
+    const email = '[email protected]';
+    const subject = 'Support';
+    runSelectQuery.mockResolvedValueOnce([]);
+
+    const result = await checkExistingContactRequest(name, email, subject);
+
+    expect(result).toBe(false);
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`SELECT * FROM contact_requests WHERE name = ? AND email = ? AND subject = ?;`),
+      [name, email, subject]
+    );
+  });
+
+  it('should handle database errors gracefully when checking existing contact requests', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const subject = 'Inquiry';
+    runSelectQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(checkExistingContactRequest(name, email, subject)).rejects.toThrow('Database error');
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`SELECT * FROM contact_requests WHERE name = ? AND email = ? AND subject = ?;`),
+      [name, email, subject]
+    );
+  });
+});
+
+describe('insertContactRequest', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should insert a contact request successfully', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const phone = '1234567890';
+    const subject = 'Inquiry';
+    const message = 'Hello, I have a question.';
+    runQuery.mockResolvedValueOnce({});
+
+    await insertContactRequest(name, email, phone, subject, message);
+
+    expect(runQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`INSERT INTO contact_requests (date, time, name, email, phone, subject, message) VALUES (DATE("now"), TIME("now"), ?, ?, ?, ?, ?);`),
+      [name, email, phone, subject, message]
+    );
+  });
+
+  it('should handle errors properly if the insert query fails', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const phone = '1234567890';
+    const subject = 'Inquiry';
+    const message = 'Hello, I have a question.';
+    runQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(insertContactRequest(name, email, phone, subject, message)).rejects.toThrow('Database error');
+    expect(runQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`INSERT INTO contact_requests (date, time, name, email, phone, subject, message) VALUES (DATE("now"), TIME("now"), ?, ?, ?, ?, ?);`),
+      [name, email, phone, subject, message]
+    );
+  });
+});

backend/__tests__/db/demoRequestDB.test.js

@@ -0,0 +1,120 @@
+const { checkExistingDemoRequest, insertDemoRequest } = require('../../utils/demoRequestDB');
+const { runQuery, runSelectQuery } = require('../../utils/queries');
+
+jest.mock('../../utils/queries');
+
+describe('checkExistingDemoRequest', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return true if a demo request with the same name, email, product, demoDate, and phone exists', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const product = 'Software XYZ';
+    const demoDate = '2025-02-15';
+    const phone = '1234567890';
+    runSelectQuery.mockResolvedValueOnce([{ name, email, product, demo_date: demoDate, phone }]);
+
+    const result = await checkExistingDemoRequest(name, email, product, demoDate, phone);
+
+    expect(result).toBe(true);
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`
+        SELECT * FROM demo_requests 
+        WHERE name = ? AND email = ? AND product = ? 
+        AND ABS(julianday(demo_date) - julianday(?)) <= 15 AND phone = ?;
+    `),
+      [name, email, product, demoDate, phone]
+    );
+  });
+
+  it('should return false if no demo request with the same name, email, product, demoDate, and phone exists', async () => {
+    const name = 'Jane Doe';
+    const email = '[email protected]';
+    const product = 'Software XYZ';
+    const demoDate = '2025-02-15';
+    const phone = '9876543210';
+    runSelectQuery.mockResolvedValueOnce([]);
+
+    const result = await checkExistingDemoRequest(name, email, product, demoDate, phone);
+
+    expect(result).toBe(false);
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`
+        SELECT * FROM demo_requests 
+        WHERE name = ? AND email = ? AND product = ? 
+        AND ABS(julianday(demo_date) - julianday(?)) <= 15 AND phone = ?;
+    `),
+      [name, email, product, demoDate, phone]
+    );
+  });
+
+  it('should handle database errors gracefully when checking existing demo requests', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const product = 'Software XYZ';
+    const demoDate = '2025-02-15';
+    const phone = '1234567890';
+    runSelectQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(checkExistingDemoRequest(name, email, product, demoDate, phone)).rejects.toThrow('Database error');
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`
+        SELECT * FROM demo_requests 
+        WHERE name = ? AND email = ? AND product = ? 
+        AND ABS(julianday(demo_date) - julianday(?)) <= 15 AND phone = ?;
+    `),
+      [name, email, product, demoDate, phone]
+    );
+  });
+});
+
+describe('insertDemoRequest', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should insert a demo request successfully', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const company = 'ABC Corp';
+    const product = 'Software XYZ';
+    const demoDate = '2025-02-15';
+    const slot = '10:00 AM';
+    const phone = '1234567890';
+    const message = 'Looking forward to the demo!';
+    runQuery.mockResolvedValueOnce({});
+
+    await insertDemoRequest(name, email, company, product, demoDate, slot, phone, message);
+
+    expect(runQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`
+        INSERT INTO demo_requests (date, time, name, email, company, product, demo_date, slot, phone, comments) 
+        VALUES (DATE("now"), TIME("now"), ?, ?, ?, ?, ?, ?, ?, ?);
+    `),
+      [name, email, company, product, demoDate, slot, phone, message]
+    );
+  });
+
+  it('should handle errors properly if the insert query fails', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const company = 'ABC Corp';
+    const product = 'Software XYZ';
+    const demoDate = '2025-02-15';
+    const slot = '10:00 AM';
+    const phone = '1234567890';
+    const message = 'Looking forward to the demo!';
+    runQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(insertDemoRequest(name, email, company, product, demoDate, slot, phone, message)).rejects.toThrow('Database error');
+    expect(runQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`
+        INSERT INTO demo_requests (date, time, name, email, company, product, demo_date, slot, phone, comments) 
+        VALUES (DATE("now"), TIME("now"), ?, ?, ?, ?, ?, ?, ?, ?);
+    `),
+      [name, email, company, product, demoDate, slot, phone, message]
+    );
+  });
+});

backend/__tests__/db/jobRequestDB.test.js

@@ -0,0 +1,105 @@
+const { checkExistingJobApplication, insertJobApplication } = require('../../utils/jobRequestDB');
+const { runQuery, runSelectQuery } = require('../../utils/queries');
+
+jest.mock('../../utils/queries');
+
+describe('checkExistingJobApplication', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return true if a job application with the same name, email, and role exists', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const role = 'Developer';
+
+    runSelectQuery.mockResolvedValueOnce([{ name, email, role }]);
+
+    const result = await checkExistingJobApplication(name, email, role);
+
+    expect(result).toBe(true);
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`SELECT * FROM applicants WHERE name = ? AND email = ? AND role = ?;`),
+      [name, email, role]
+    );
+  });
+
+  it('should return false if no job application with the same name, email, and role exists', async () => {
+    const name = 'Jane Doe';
+    const email = '[email protected]';
+    const role = 'Designer';
+
+    runSelectQuery.mockResolvedValueOnce([]);
+
+    const result = await checkExistingJobApplication(name, email, role);
+
+    expect(result).toBe(false);
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`SELECT * FROM applicants WHERE name = ? AND email = ? AND role = ?;`),
+      [name, email, role]
+    );
+  });
+
+  it('should handle database errors gracefully when checking for existing job applications', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const role = 'Developer';
+
+    runSelectQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(checkExistingJobApplication(name, email, role)).rejects.toThrow('Database error');
+    expect(runSelectQuery).toHaveBeenCalledWith(
+      expect.stringContaining(`SELECT * FROM applicants WHERE name = ? AND email = ? AND role = ?;`),
+      [name, email, role]
+    );
+  });
+});
+
+describe('insertJobApplication', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should insert a job application successfully', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const phone = '1234567890';
+    const experience = '5 years';
+    const role = 'Developer';
+    const linkedin = 'https://linkedin.com/johndoe';
+    const resume = Buffer.from('resume data');
+    const filename = 'resume.pdf';
+
+    runQuery.mockResolvedValueOnce({});
+
+    await insertJobApplication(name, email, phone, experience, role, linkedin, resume, filename);
+
+    expect(runQuery).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `INSERT INTO applicants (date, time, name, email, phone, experience, role, linkedin, resume, filename) VALUES (DATE("now"), TIME("now"), ?, ?, ?, ?, ?, ?, ?, ?);`
+      ),
+      [name, email, phone, experience, role, linkedin, resume, filename]
+    );
+  });
+
+  it('should handle errors properly if the insert query fails', async () => {
+    const name = 'John Doe';
+    const email = '[email protected]';
+    const phone = '1234567890';
+    const experience = '5 years';
+    const role = 'Developer';
+    const linkedin = 'https://linkedin.com/johndoe';
+    const resume = Buffer.from('resume data');
+    const filename = 'resume.pdf';
+
+    runQuery.mockRejectedValueOnce(new Error('Database error'));
+
+    await expect(insertJobApplication(name, email, phone, experience, role, linkedin, resume, filename)).rejects.toThrow('Database error');
+    expect(runQuery).toHaveBeenCalledWith(
+      expect.stringContaining(
+        `INSERT INTO applicants (date, time, name, email, phone, experience, role, linkedin, resume, filename) VALUES (DATE("now"), TIME("now"), ?, ?, ?, ?, ?, ?, ?, ?);`
+      ),
+      [name, email, phone, experience, role, linkedin, resume, filename]
+    );
+  });
+});

backend/__tests__/routes/applicantRoutes.test.js

@@ -0,0 +1,73 @@
+const request = require('supertest');
+const express = require('express');
+const app = express();
+const { submitJobApplication } = require('../../controller/applicantController'); 
+const applicantRoutes = require('../../routes/applicantRoutes');
+
+// Jest timeout increased to prevent timeouts
+jest.setTimeout(10000);
+
+// Middleware to parse JSON and form data
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Mocking the controller function
+jest.mock('../../controller/applicantController', () => ({
+    submitJobApplication: jest.fn(),
+}));
+
+// Use the route in the app
+app.use('/api', applicantRoutes);
+
+describe('Applicant Routes', () => {
+    beforeEach(() => {
+        jest.clearAllMocks(); 
+    });
+
+    it('should successfully submit a job application', async () => {
+        const mockFile = Buffer.from('fake file content');
+        
+        // Mock successful response
+        submitJobApplication.mockImplementation((req, res) => {
+            res.status(200).json({ message: 'Application submitted successfully' });
+        });
+
+        const response = await request(app)
+            .post('/api/submit-job-application')
+            .attach('resume', mockFile, 'test_resume.pdf') 
+            .field('name', 'John Doe')  
+            .field('email', '[email protected]')
+            .expect(200);
+
+        expect(response.body.message).toBe('Application submitted successfully');
+    });
+
+    it('should return 400 if no resume is provided', async () => {
+        submitJobApplication.mockImplementation((req, res) => {
+            res.status(400).json({ error: 'No resume uploaded' });
+        });
+
+        const response = await request(app)
+            .post('/api/submit-job-application')
+            .field('name', 'John Doe')
+            .field('email', '[email protected]') 
+            .expect(400);
+
+        expect(response.body.error).toBe('No resume uploaded');
+    });
+
+    it('should handle errors gracefully', async () => {
+        submitJobApplication.mockImplementation((req, res) => {
+            res.status(500).json({ error: 'Something went wrong' });
+        });
+
+        const response = await request(app)
+            .post('/api/submit-job-application')
+            .attach('resume', Buffer.from('fake file content'), 'test_resume.pdf')
+            .field('name', 'John Doe')
+            .field('email', '[email protected]')
+            .expect(500);
+
+        expect(response.body.error).toBe('Something went wrong');
+    });
+});

backend/allure-results/0015a6cd-e653-4a79-ba26-0af43fabbf07-result.json

@@ -0,0 +1 @@
+{"uuid":"0015a6cd-e653-4a79-ba26-0af43fabbf07","name":"should handle empty results gracefully","historyId":"07c64f737f02e55d0fcf270fc88e4122:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.controller.demo.dateAvailability.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"2"},{"name":"parentSuite","value":"Date Availability Module"},{"name":"suite","value":"checkDateAvailability"}],"links":[],"start":1738134362878,"fullName":"__tests__/controller/demo/dateAvailability.test.js#Date Availability Module checkDateAvailability should handle empty results gracefully","testCaseId":"07c64f737f02e55d0fcf270fc88e4122","stop":1738134362879}

backend/allure-results/0110d1ba-d337-4de1-9021-f9af16a0683f-container.json

@@ -0,0 +1 @@
+{"uuid":"0110d1ba-d337-4de1-9021-f9af16a0683f","name":"beforeEach","children":["29098c4e-4c22-4620-ab3b-cbb19e3d20c7"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134362293,"name":"beforeEach","stop":1738134362293}],"afters":[]}

backend/allure-results/016c5d0f-35ce-411e-90a1-61de74ab2ca3-container.json

@@ -0,0 +1 @@
+{"uuid":"016c5d0f-35ce-411e-90a1-61de74ab2ca3","name":"beforeEach","children":["089e2be5-c31a-455c-841e-3f676ddfd3f6"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134362568,"name":"beforeEach","stop":1738134362568}],"afters":[]}

backend/allure-results/01ea98eb-5e95-43b8-b98c-48074cf6284d-container.json

@@ -0,0 +1 @@
+{"uuid":"01ea98eb-5e95-43b8-b98c-48074cf6284d","name":"beforeEach","children":["0eb2fc93-b1c7-40eb-b8e3-c6698747952f"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134363951,"name":"beforeEach","stop":1738134363952}],"afters":[]}

backend/allure-results/01f5e8cb-ddab-404c-b698-c33f012c014b-container.json

@@ -0,0 +1 @@
+{"uuid":"01f5e8cb-ddab-404c-b698-c33f012c014b","name":"afterEach","children":["1982483e-00ea-4e03-8760-34a80ea65b71"],"befores":[],"afters":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738133802587,"name":"afterEach","stop":1738133802587}]}

backend/allure-results/02297a4a-89e7-479a-b92e-a8cd2bee7916-container.json

@@ -0,0 +1 @@
+{"uuid":"02297a4a-89e7-479a-b92e-a8cd2bee7916","name":"beforeEach","children":["413b14db-f238-4422-971b-08c18c5659af"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134319166,"name":"beforeEach","stop":1738134319166}],"afters":[]}

backend/allure-results/02c0b00b-1aa8-498b-83a2-1a37af9977ba-result.json

@@ -0,0 +1 @@
+{"uuid":"02c0b00b-1aa8-498b-83a2-1a37af9977ba","name":"should return a list of booked slots for a given date","historyId":"13bd204f774f5d66e5352bb0e5628906:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.controller.demo.slots.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"3"},{"name":"parentSuite","value":"Slots Controller"},{"name":"suite","value":"getBookedSlots"}],"links":[],"start":1738133800851,"fullName":"__tests__/controller/demo/slots.test.js#Slots Controller getBookedSlots should return a list of booked slots for a given date","testCaseId":"13bd204f774f5d66e5352bb0e5628906","stop":1738133800853}

backend/allure-results/02f5da12-8970-4dff-aeb3-75c9714f2818-container.json

@@ -0,0 +1 @@
+{"uuid":"02f5da12-8970-4dff-aeb3-75c9714f2818","name":"beforeEach","children":["caa49835-a394-4e87-bb29-8eaf769513f0"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134318609,"name":"beforeEach","stop":1738134318610}],"afters":[]}

backend/allure-results/0336cd99-4664-4319-8288-b6712f0f9353-container.json

@@ -0,0 +1 @@
+{"uuid":"0336cd99-4664-4319-8288-b6712f0f9353","name":"afterEach","children":["47b2aca6-5e15-48de-9395-c0198587de22"],"befores":[],"afters":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738133804125,"name":"afterEach","stop":1738133804125}]}

backend/allure-results/0394dd9b-43c3-4ae1-93e9-563120bc3609-container.json

@@ -0,0 +1 @@
+{"uuid":"0394dd9b-43c3-4ae1-93e9-563120bc3609","name":"beforeEach","children":["6ffbe1df-a94f-4b3e-93bf-debf5f7b7aba"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738133803622,"name":"beforeEach","stop":1738133803623}],"afters":[]}

backend/allure-results/04c86ce6-b07e-4c64-af20-1a52682cc83d-container.json

@@ -0,0 +1 @@
+{"uuid":"04c86ce6-b07e-4c64-af20-1a52682cc83d","name":"afterEach","children":["0015a6cd-e653-4a79-ba26-0af43fabbf07"],"befores":[],"afters":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134362879,"name":"afterEach","stop":1738134362879}]}

backend/allure-results/04ea9714-733a-45e9-b0cc-7cc1aa55db15-container.json

@@ -0,0 +1 @@
+{"uuid":"04ea9714-733a-45e9-b0cc-7cc1aa55db15","name":"afterEach","children":["2b018f77-86c2-4aca-97ba-0f7a13f6165c"],"befores":[],"afters":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134360705,"name":"afterEach","stop":1738134360707}]}

backend/allure-results/05878ed9-0262-45d3-a27e-270827d51608-result.json

@@ -0,0 +1 @@
+{"uuid":"05878ed9-0262-45d3-a27e-270827d51608","name":"should return an error if OAuth credentials are missing","historyId":"734c4f6702939dad1db8c195b765d5c9:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.controller.subscriptionController.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"1"},{"name":"parentSuite","value":"handleSubscriptionEmail"}],"links":[],"start":1738133803636,"fullName":"__tests__/controller/subscriptionController.test.js#handleSubscriptionEmail should return an error if OAuth credentials are missing","testCaseId":"734c4f6702939dad1db8c195b765d5c9","stop":1738133803639}

backend/allure-results/05cbfb2c-ea16-4f24-bd3d-f2386b85cde6-container.json

@@ -0,0 +1 @@
+{"uuid":"05cbfb2c-ea16-4f24-bd3d-f2386b85cde6","name":"beforeEach","children":["34b5f767-d539-4c9b-a4e4-df3a2b2e1237"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134361718,"name":"beforeEach","stop":1738134361718}],"afters":[]}

backend/allure-results/06bb4d63-55c7-44df-9572-66d7583c1658-container.json

@@ -0,0 +1 @@
+{"uuid":"06bb4d63-55c7-44df-9572-66d7583c1658","name":"beforeEach","children":["3c8e9d74-108a-4549-9123-bccb972f7b43"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134364433,"name":"beforeEach","stop":1738134364433}],"afters":[]}

backend/allure-results/077c5367-cc30-4fef-83c9-68b2137156b1-container.json

@@ -0,0 +1 @@
+{"uuid":"077c5367-cc30-4fef-83c9-68b2137156b1","name":"beforeEach","children":["e0800728-f403-4bb0-902f-ca1d478d4c9c"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134316718,"name":"beforeEach","stop":1738134316718}],"afters":[]}

backend/allure-results/07e2e71f-c12c-42aa-83ef-ae7c75fc7a73-result.json

@@ -0,0 +1 @@
+{"uuid":"07e2e71f-c12c-42aa-83ef-ae7c75fc7a73","name":"should call runQuery for each table creation query","historyId":"2708c10dc7a9525026f0ef93874778a6:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.db.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"3"},{"name":"parentSuite","value":"initializeDatabase"}],"links":[],"start":1738134363945,"fullName":"__tests__/db.test.js#initializeDatabase should call runQuery for each table creation query","testCaseId":"2708c10dc7a9525026f0ef93874778a6","stop":1738134363984}

backend/allure-results/089e2be5-c31a-455c-841e-3f676ddfd3f6-result.json

@@ -0,0 +1 @@
+{"uuid":"089e2be5-c31a-455c-841e-3f676ddfd3f6","name":"should handle errors properly if the insert query fails","historyId":"ecb0f74af105dfe6dc2534c3c03b6394:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.db.jobRequestDB.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"1"},{"name":"parentSuite","value":"insertJobApplication"}],"links":[],"start":1738134362568,"fullName":"__tests__/db/jobRequestDB.test.js#insertJobApplication should handle errors properly if the insert query fails","testCaseId":"ecb0f74af105dfe6dc2534c3c03b6394","stop":1738134362571}

backend/allure-results/092b09aa-d891-4211-b725-2cb53f0bc367-result.json

@@ -0,0 +1 @@
+{"uuid":"092b09aa-d891-4211-b725-2cb53f0bc367","name":"should handle errors properly","historyId":"576da12b25442688502c27aba589b5f4:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.controller.demo.holidays.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"3"},{"name":"parentSuite","value":"Holidays Controller"},{"name":"suite","value":"getIndiaTamilHolidays"}],"links":[],"start":1738134316692,"fullName":"__tests__/controller/demo/holidays.test.js#Holidays Controller getIndiaTamilHolidays should handle errors properly","testCaseId":"576da12b25442688502c27aba589b5f4","stop":1738134316698}

backend/allure-results/098ef27c-b326-44df-9190-c2f20c1ada8e-container.json

@@ -0,0 +1 @@
+{"uuid":"098ef27c-b326-44df-9190-c2f20c1ada8e","name":"beforeEach","children":["2f843ff8-0689-4452-8006-19d5646056cc"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134318200,"name":"beforeEach","stop":1738134318200}],"afters":[]}

backend/allure-results/0a34e919-c2a0-47c0-8c9c-f7baa3bb0098-result.json

@@ -0,0 +1 @@
+{"uuid":"0a34e919-c2a0-47c0-8c9c-f7baa3bb0098","name":"should return true if a job application with the same name, email, and role exists","historyId":"2eaa16996f06ff3c1362aed34070279c:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.db.jobRequestDB.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"1"},{"name":"parentSuite","value":"checkExistingJobApplication"}],"links":[],"start":1738134318180,"fullName":"__tests__/db/jobRequestDB.test.js#checkExistingJobApplication should return true if a job application with the same name, email, and role exists","testCaseId":"2eaa16996f06ff3c1362aed34070279c","stop":1738134318193}

backend/allure-results/0a4254f9-1cdb-4c56-8bba-bfc9e2424b4d-container.json

@@ -0,0 +1 @@
+{"uuid":"0a4254f9-1cdb-4c56-8bba-bfc9e2424b4d","name":"afterEach","children":["a43c59fb-041b-4808-a344-b7df55474f39"],"befores":[],"afters":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738133802982,"name":"afterEach","stop":1738133802982}]}

backend/allure-results/0a5de36d-ec71-4d0a-9d60-f17bc71ead0f-result.json

@@ -0,0 +1 @@
+{"uuid":"0a5de36d-ec71-4d0a-9d60-f17bc71ead0f","name":"should throw an error if general slots are not properly defined","historyId":"6dfb9140c55c1ec840a8bfa35c817316:d41d8cd98f00b204e9800998ecf8427e","status":"broken","statusDetails":{"message":"undefined is not iterable (cannot read property Symbol(Symbol.iterator))","trace":"TypeError: undefined is not iterable (cannot read property Symbol(Symbol.iterator))\n    at _iterableToArray (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/iterableToArray.js:2:48)\n    at _toConsumableArray (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/toConsumableArray.js:6:34)\n    at _callee10$ (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/__tests__/controller/demo/slots.test.js:133:39)\n    at tryCatch (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/regeneratorRuntime.js:45:16)\n    at Generator.<anonymous> (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/regeneratorRuntime.js:133:17)\n    at Generator.next (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/regeneratorRuntime.js:74:21)\n    at asyncGeneratorStep (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/asyncToGenerator.js:3:17)\n    at _next (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/asyncToGenerator.js:17:9)\n    at /data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/asyncToGenerator.js:22:7\n    at new Promise (<anonymous>)\n    at Object.<anonymous> (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/@babel/runtime/helpers/asyncToGenerator.js:14:12)\n    at Promise.then.completed (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/utils.js:298:28)\n    at new Promise (<anonymous>)\n    at callAsyncCircusFn (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/utils.js:231:10)\n    at _callCircusTest (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/run.js:316:40)\n    at processTicksAndRejections (node:internal/process/task_queues:96:5)\n    at _runTest (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/run.js:252:3)\n    at _runTestsForDescribeBlock (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/run.js:126:9)\n    at _runTestsForDescribeBlock (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/run.js:121:9)\n    at _runTestsForDescribeBlock (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/run.js:121:9)\n    at run (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/run.js:71:3)\n    at runAndTransformResultsToJestFormat (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js:122:21)\n    at jestAdapter (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.js:79:19)\n    at runTestInternal (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-runner/build/runTest.js:367:16)\n    at runTest (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-runner/build/runTest.js:444:34)\n    at Object.worker (/data/darshan/data/genomatics-site-react-tailwind/versions/geno-react-modularised/backend/node_modules/jest-runner/build/testWorker.js:106:12)"},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.controller.demo.slots.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"3"},{"name":"parentSuite","value":"Slots Controller"},{"name":"suite","value":"getAvailableSlots"}],"links":[],"start":1738133800901,"fullName":"__tests__/controller/demo/slots.test.js#Slots Controller getAvailableSlots should throw an error if general slots are not properly defined","testCaseId":"6dfb9140c55c1ec840a8bfa35c817316","stop":1738133800903}

backend/allure-results/0bdecd77-aed5-4cbc-bec8-4149ac95cf00-container.json

@@ -0,0 +1 @@
+{"uuid":"0bdecd77-aed5-4cbc-bec8-4149ac95cf00","name":"beforeEach","children":["23ae57ad-ca22-4cd3-b75c-da0bd515c826"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134316940,"name":"beforeEach","stop":1738134316940}],"afters":[]}

backend/allure-results/0ca292e2-e5f8-4bfd-959d-46fb6c883444-result.json

@@ -0,0 +1 @@
+{"uuid":"0ca292e2-e5f8-4bfd-959d-46fb6c883444","name":"should handle errors properly if the insert query fails","historyId":"ebe32158e8d9d95830c96140ceb08de9:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.db.demoRequestDB.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"2"},{"name":"parentSuite","value":"insertDemoRequest"}],"links":[],"start":1738133804135,"fullName":"__tests__/db/demoRequestDB.test.js#insertDemoRequest should handle errors properly if the insert query fails","testCaseId":"ebe32158e8d9d95830c96140ceb08de9","stop":1738133804137}

backend/allure-results/0d6fb9a5-b36a-4e35-b985-d89ac351cc09-container.json

@@ -0,0 +1 @@
+{"uuid":"0d6fb9a5-b36a-4e35-b985-d89ac351cc09","name":"beforeEach","children":["c0033509-0b15-4b75-ab25-65b996d98a64"],"befores":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134318957,"name":"beforeEach","stop":1738134318957}],"afters":[]}

backend/allure-results/0da168e7-8953-4657-9458-dd5e186abe96-result.json

@@ -0,0 +1 @@
+{"uuid":"0da168e7-8953-4657-9458-dd5e186abe96","name":"should return true if a demo request with the same name, email, product, demoDate, and phone exists","historyId":"cf295a79793f2c923b75425847a58d87:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.db.demoRequestDB.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"1"},{"name":"parentSuite","value":"checkExistingDemoRequest"}],"links":[],"start":1738134362943,"fullName":"__tests__/db/demoRequestDB.test.js#checkExistingDemoRequest should return true if a demo request with the same name, email, product, demoDate, and phone exists","testCaseId":"cf295a79793f2c923b75425847a58d87","stop":1738134362961}

backend/allure-results/0dc24df0-7b61-44bb-af09-0f71a0d88f53-container.json

@@ -0,0 +1 @@
+{"uuid":"0dc24df0-7b61-44bb-af09-0f71a0d88f53","name":"afterEach","children":["2ff5b722-f94a-4bd7-84b3-c862281b159c"],"befores":[],"afters":[{"status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"start":1738134317142,"name":"afterEach","stop":1738134317142}]}

backend/allure-results/0dd25a26-4fcb-4370-a3e5-52758cee400a-result.json

@@ -0,0 +1 @@
+{"uuid":"0dd25a26-4fcb-4370-a3e5-52758cee400a","name":"should return all general slots if no slots are booked for a given date","historyId":"f6b2f672fe18b502f2bafc9e90dfca64:d41d8cd98f00b204e9800998ecf8427e","status":"passed","statusDetails":{},"stage":"finished","steps":[],"attachments":[],"parameters":[],"labels":[{"name":"language","value":"javascript"},{"name":"framework","value":"jest"},{"name":"package","value":"__tests__.controller.demo.slots.test.js"},{"name":"host","value":"cur4"},{"name":"thread","value":"2"},{"name":"parentSuite","value":"Slots Controller"},{"name":"suite","value":"getAvailableSlots"}],"links":[],"start":1738134316722,"fullName":"__tests__/controller/demo/slots.test.js#Slots Controller getAvailableSlots should return all general slots if no slots are booked for a given date","testCaseId":"f6b2f672fe18b502f2bafc9e90dfca64","stop":1738134316725}