added testing for app.ts and mapping.ts

Author: zaradford

src/tests/app.test.ts

@@ -0,0 +1,207 @@
+import request from 'supertest';
+import app from '../app';
+import { authUrl, redeemCode } from '../auth';
+import * as properties from '../properties';
+import * as mappings from '../mappings';
+import * as utils from '../utils/utils';
+import { describe, beforeEach, it, expect, jest } from '@jest/globals';
+import { afterAll, beforeAll } from '@jest/globals';
+
+const Objects = {
+  Contact: 'Contact',
+  Company: 'Company'
+} as const;
+
+const PropertyType = {
+  String: 'String',
+  Number: 'Number',
+  Option: 'Option'
+} as const;
+
+const Direction = {
+  toHubSpot: 'toHubSpot',
+  toNative: 'toNative',
+  biDirectional: 'biDirectional'
+} as const;
+
+// Mock the modules
+jest.mock('../auth', () => ({
+  authUrl: 'mock-auth-url',
+  redeemCode: jest.fn()
+}));
+
+jest.mock('../properties', () => ({
+  checkForPropertyOrGroup: jest.fn(),
+  getHubSpotProperties: jest.fn(),
+  convertToPropertyForDB: jest.fn(),
+  createNativeProperty: jest.fn(),
+  createPropertyGroupForContacts: jest.fn().mockImplementation(async () => {
+    // Function returns void
+  })
+}));
+
+jest.mock('../mappings', () => ({
+  saveMapping: jest.fn(),
+  deleteMapping: jest.fn()
+}));
+
+jest.mock('../utils/utils', () => ({
+  getCustomerId: jest.fn()
+}));
+
+jest.mock('../utils/logger');
+
+describe('API Endpoints', () => {
+  // Setup and teardown
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  describe('GET /api/install', () => {
+    it('should return auth URL', async () => {
+      const response = await request(app).get('/api/install');
+      expect(response.status).toBe(200);
+      expect(response.text).toBe(authUrl);
+    });
+  });
+
+  describe('GET /oauth-callback', () => {
+
+    it('should handle OAuth callback error', async () => {
+      const mockCode = 'invalid-code';
+      (redeemCode as jest.MockedFunction<typeof redeemCode>).mockRejectedValue(new Error('OAuth Error'));
+
+      const response = await request(app)
+        .get('/oauth-callback')
+        .query({ code: mockCode });
+
+      expect(response.status).toBe(302);
+      expect(response.header.location).toContain('errMessage');
+    });
+  });
+
+  describe('GET /api/hubspot-properties', () => {
+    it('should return hubspot properties', async () => {
+      const mockProperties = {
+        contactProperties: [{ name: 'test-prop' }],
+        companyProperties: [{ name: 'test-company-prop' }]
+      };
+
+      (utils.getCustomerId as jest.MockedFunction<typeof utils.getCustomerId>).mockReturnValue('test-customer');
+      (properties.getHubSpotProperties as jest.MockedFunction<typeof properties.getHubSpotProperties>).mockResolvedValue(mockProperties);
+
+      const response = await request(app).get('/api/hubspot-properties');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockProperties);
+    });
+
+    it('should handle errors', async () => {
+      (utils.getCustomerId as jest.MockedFunction<typeof utils.getCustomerId>).mockReturnValue('test-customer');
+      (properties.getHubSpotProperties as jest.MockedFunction<typeof properties.getHubSpotProperties>).mockRejectedValue(new Error('Test error'));
+
+      const response = await request(app).get('/api/hubspot-properties');
+
+      expect(response.status).toBe(500);
+      expect(response.text).toBe('Internal Server Error');
+    });
+  });
+
+  describe('POST /api/native-properties', () => {
+    it('should create a native property', async () => {
+      const mockProperty = {
+        object: Objects.Contact,
+        name: 'test-prop',
+        customerId: 'test-customer',
+        label: 'Test Property',
+        type: PropertyType.String,
+        unique: false,
+        modificationMetadata: {}
+      };
+
+      const mockCustomerId = 'test-customer';
+
+      (utils.getCustomerId as jest.MockedFunction<typeof utils.getCustomerId>).mockReturnValue(mockCustomerId);
+      (properties.convertToPropertyForDB as jest.MockedFunction<typeof properties.convertToPropertyForDB>).mockReturnValue(mockProperty);
+      (properties.createNativeProperty as jest.MockedFunction<typeof properties.createNativeProperty>).mockResolvedValue(mockProperty);
+
+      const response = await request(app)
+        .post('/api/native-properties/')
+        .send(mockProperty);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockProperty);
+    });
+  });
+
+  describe('POST /api/mappings', () => {
+    it('should create a new mapping', async () => {
+      const mockMapping = {
+        object: Objects.Contact,
+        customerId: 'test-customer',
+        modificationMetadata: {},
+        id: 1,
+        nativeName: 'test',
+        hubspotName: 'test',
+        hubspotLabel: 'Test Label',
+        direction: Direction.biDirectional
+      };
+
+      (mappings.saveMapping as jest.MockedFunction<typeof mappings.saveMapping>).mockResolvedValue(mockMapping);
+
+      const response = await request(app)
+        .post('/api/mappings')
+        .send(mockMapping);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockMapping);
+    });
+
+    it('should handle errors', async () => {
+      (mappings.saveMapping as jest.MockedFunction<typeof mappings.saveMapping>).mockRejectedValue(new Error('Test error'));
+
+      const response = await request(app)
+        .post('/api/mappings')
+        .send({});
+
+      expect(response.status).toBe(500);
+      expect(response.text).toBe('Error saving mapping');
+    });
+  });
+
+  describe('DELETE /api/mappings/:mappingId', () => {
+    it('should delete a mapping', async () => {
+      const mockMappingId = 1;
+      const mockDeleteResult = {
+        object: Objects.Contact,
+        customerId: 'test-customer',
+        modificationMetadata: {},
+        id: mockMappingId,
+        nativeName: 'test',
+        hubspotName: 'test',
+        hubspotLabel: 'Test Label',
+        direction: Direction.biDirectional
+      };
+
+      (mappings.deleteMapping as jest.MockedFunction<typeof mappings.deleteMapping>).mockResolvedValue(mockDeleteResult);
+
+      const response = await request(app)
+        .delete(`/api/mappings/${mockMappingId}`);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockDeleteResult);
+    });
+
+    it('should handle invalid mapping ID', async () => {
+      const response = await request(app)
+        .delete('/api/mappings/invalid');
+
+      expect(response.status).toBe(400);
+      expect(response.text).toBe('Invalid mapping Id format');
+    });
+  });
+});

src/tests/mappings.test.ts

@@ -0,0 +1,182 @@
+import { getMappings, deleteMapping, saveMapping } from '../mappings';
+import { jest, describe, it, expect, beforeEach } from '@jest/globals';
+import prisma from '../../prisma/seed';
+import * as utils from '../utils/utils';
+import { Mapping } from '@prisma/client';
+import handleError from '../utils/error';
+
+// Mock the Prisma client
+jest.mock('../../prisma/seed', () => ({
+  mapping: {
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    upsert: jest.fn(),
+    delete: jest.fn(),
+  },
+}));
+
+// Mock utils - this needs to be updated
+jest.mock('../utils/utils', () => ({
+  getCustomerId: jest.fn(() => 'cust_123')  // Provide a default mock implementation
+}));
+
+// Mock error handler
+jest.mock('../utils/error', () => ({
+  __esModule: true,
+  default: jest.fn(),
+}));
+
+describe('Mappings Database Client', () => {
+  const mockMapping: Mapping = {
+    id: 1,
+    nativeName: 'test_mapping',
+    hubspotName: 'test_hubspot',
+    hubspotLabel: 'Test Label',
+    object: 'Contact',
+    direction: 'biDirectional',
+    customerId: 'cust_123',
+    modificationMetadata: {
+      archivable: true,
+      readOnlyValue: false,
+      readOnlyDefinition: false,
+    }
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getMappings', () => {
+    it('should successfully fetch mappings by customer ID', async () => {
+      const mockResults = [mockMapping];
+      (prisma.mapping.findMany as jest.Mock).mockResolvedValue(mockResults);
+
+      const result = await getMappings('cust_123');
+
+      expect(result).toEqual(mockResults);
+      expect(prisma.mapping.findMany).toHaveBeenCalledWith({
+        select: {
+          nativeName: true,
+          hubspotLabel: true,
+          hubspotName: true,
+          id: true,
+          object: true,
+          direction: true,
+          customerId: true,
+          modificationMetadata: true,
+        },
+        where: {
+          customerId: 'cust_123',
+        },
+      });
+    });
+
+    it('should handle empty results', async () => {
+      (prisma.mapping.findMany as jest.Mock).mockResolvedValue([]);
+
+      const result = await getMappings('cust_123');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle database errors', async () => {
+      const mockError = new Error('Database error');
+      (prisma.mapping.findMany as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await getMappings('cust_123');
+
+      expect(result).toBeUndefined();
+      expect(handleError).toHaveBeenCalledWith(
+        mockError,
+        'There was an issue while querying property mappings '
+      );
+    });
+  });
+
+  describe('deleteMapping', () => {
+    it('should successfully delete a mapping', async () => {
+      (prisma.mapping.delete as jest.Mock).mockResolvedValue(mockMapping);
+
+      const result = await deleteMapping(1);
+
+      expect(result).toEqual(mockMapping);
+      expect(prisma.mapping.delete).toHaveBeenCalledWith({
+        where: {
+          id: 1,
+        },
+      });
+    });
+
+    it('should handle non-existent mapping', async () => {
+      (prisma.mapping.delete as jest.Mock).mockResolvedValue(null);
+
+      const result = await deleteMapping(999);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle deletion errors', async () => {
+      const mockError = new Error('Database error');
+      (prisma.mapping.delete as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await deleteMapping(1);
+
+      expect(result).toBeUndefined();
+      expect(handleError).toHaveBeenCalledWith(
+        mockError,
+        'There was an issue while attempting to delete property mappings '
+      );
+    });
+  });
+
+  describe('saveMapping', () => {
+    it('should successfully create a new mapping', async () => {
+      (prisma.mapping.upsert as jest.Mock).mockImplementation((args) => Promise.resolve({
+        ...mockMapping,
+        nativeName: args.where.nativeName_object_customerId.nativeName,
+        customerId: args.where.nativeName_object_customerId.customerId,
+        object: args.where.nativeName_object_customerId.object,
+      }));
+
+      const result = await saveMapping(mockMapping);
+
+      expect(result).toEqual(mockMapping);
+      expect(prisma.mapping.upsert).toHaveBeenCalledWith({
+        where: {
+          nativeName_object_customerId: {
+            nativeName: mockMapping.nativeName,
+            customerId: 'cust_123',
+            object: mockMapping.object,
+          },
+        },
+        update: {
+          hubspotLabel: mockMapping.hubspotLabel,
+          hubspotName: mockMapping.hubspotName,
+          direction: mockMapping.direction,
+        },
+        create: {
+          hubspotLabel: mockMapping.hubspotLabel,
+          hubspotName: mockMapping.hubspotName,
+          nativeName: mockMapping.nativeName,
+          object: mockMapping.object,
+          customerId: 'cust_123',
+          direction: mockMapping.direction,
+          modificationMetadata: mockMapping.modificationMetadata,
+        },
+      });
+    });
+
+    it('should handle save errors', async () => {
+      const mockError = new Error('Database error');
+      (prisma.mapping.upsert as jest.Mock).mockRejectedValue(mockError);
+
+      const result = await saveMapping(mockMapping);
+
+      expect(result).toBeUndefined();
+      expect(handleError).toHaveBeenCalledWith(
+        mockError,
+        'There was an issue while attempting to save the property mapping '
+      );
+    });
+  });
+});