Backend tests for campaign middleware and sms campaign routes

.travis.yml

@@ -18,6 +18,9 @@ jobs:
         - npx lockfile-lint --type npm --path package-lock.json -o "https:" -o "file:" --allowed-hosts npm
       install:
         - npm ci
+      before-script:
+        - psql -c 'create database postmangovsg_test_1;' -U postgres
+        - psql -c 'create database postmangovsg_test_2;' -U postgres
       script:
         - npm run lint-no-fix
         - npm run test

backend/src/core/middlewares/tests/campaign.middleware.test.ts

@@ -0,0 +1,106 @@
+import { NextFunction, Request, Response } from 'express'
+import { Sequelize } from 'sequelize-typescript'
+import { Campaign, JobQueue, User } from '@core/models'
+import sequelizeLoader from '@test-utils/sequelize-loader'
+import { RedisService } from '@core/services'
+import { ChannelType, JobStatus } from '@core/constants'
+import { CampaignMiddleware } from '@core/middlewares/campaign.middleware'
+
+let sequelize: Sequelize
+let mockRequest: Partial<Request>
+let mockResponse: Partial<Response>
+const nextFunction: NextFunction = jest.fn()
+
+beforeEach(() => {
+  mockRequest = {}
+  mockResponse = {
+    sendStatus: jest.fn(),
+  }
+})
+
+beforeAll(async () => {
+  sequelize = await sequelizeLoader(process.env.JEST_WORKER_ID || '1')
+  await User.create({ id: 1, email: 'user@agency.gov.sg' })
+})
+
+afterEach(async () => {
+  await JobQueue.destroy({ where: {} })
+  await Campaign.destroy({ where: {} })
+})
+
+afterAll(async () => {
+  await User.destroy({ where: {} })
+  await sequelize.close()
+  RedisService.otpClient.quit()
+  RedisService.sessionClient.quit()
+})
+
+describe('canEditCampaign middleware', () => {
+  test('Should respond with 403 if campaign has a job in progress', async () => {
+    const campaign = await Campaign.create({
+      name: 'campaign-1',
+      userId: 1,
+      type: ChannelType.SMS,
+      valid: false,
+      protect: false,
+    })
+    await JobQueue.create({
+      campaignId: campaign.id,
+      status: JobStatus.Sending,
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+    }
+
+    await CampaignMiddleware.canEditCampaign(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(mockResponse.sendStatus).toBeCalledWith(403)
+  })
+
+  test('Should respond with 403 if campaign has an upload in progress', async () => {
+    const campaign = await Campaign.create({
+      name: `campaign-1`,
+      userId: 1,
+      type: ChannelType.SMS,
+      valid: false,
+      protect: false,
+      s3Object: { temp_filename: 'file' },
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+    }
+
+    await CampaignMiddleware.canEditCampaign(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(mockResponse.sendStatus).toBeCalledWith(403)
+  })
+
+  test('Returns next middleware if campaign has no job or upload in progress', async () => {
+    const campaign = await Campaign.create({
+      name: `campaign-1`,
+      userId: 1,
+      type: ChannelType.SMS,
+      valid: false,
+      protect: false,
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+    }
+
+    await CampaignMiddleware.canEditCampaign(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(nextFunction).toBeCalled()
+  })
+})

backend/src/email/middlewares/tests/email.middleware.test.ts

@@ -0,0 +1,90 @@
+import { NextFunction, Request, Response } from 'express'
+import { Sequelize } from 'sequelize-typescript'
+import { Campaign, JobQueue, User } from '@core/models'
+import sequelizeLoader from '@test-utils/sequelize-loader'
+import { RedisService } from '@core/services'
+import { ChannelType, JobStatus } from '@core/constants'
+import { EmailMiddleware } from '@email/middlewares/email.middleware'
+
+let sequelize: Sequelize
+let mockRequest: Partial<Request>
+let mockResponse: Partial<Response>
+const nextFunction: NextFunction = jest.fn()
+
+beforeEach(() => {
+  mockRequest = {}
+  mockResponse = {
+    sendStatus: jest.fn(),
+  }
+})
+
+beforeAll(async () => {
+  sequelize = await sequelizeLoader(process.env.JEST_WORKER_ID || '1')
+  await User.create({ id: 1, email: 'user@agency.gov.sg' })
+})
+
+afterEach(async () => {
+  await JobQueue.destroy({ where: {} })
+  await Campaign.destroy({ where: {} })
+})
+
+afterAll(async () => {
+  await User.destroy({ where: {} })
+  await sequelize.close()
+  RedisService.otpClient.quit()
+  RedisService.sessionClient.quit()
+})
+
+describe('isEmailCampaignOwnedByUser middleware', () => {
+  test('Returns 403 campaign does not belong to user', async () => {
+    const campaign = await Campaign.create({
+      name: 'campaign-1',
+      userId: 1,
+      type: ChannelType.Email,
+      valid: false,
+      protect: false,
+    })
+    await JobQueue.create({
+      campaignId: campaign.id,
+      status: JobStatus.Sending,
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+      session: { user: { id: 2 } } as any,
+    }
+
+    await EmailMiddleware.isEmailCampaignOwnedByUser(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(mockResponse.sendStatus).toBeCalledWith(403)
+  })
+
+  test('Returns next middleware when campaign belongs to user', async () => {
+    const campaign = await Campaign.create({
+      name: 'campaign-1',
+      userId: 1,
+      type: ChannelType.Email,
+      valid: false,
+      protect: false,
+    })
+    await JobQueue.create({
+      campaignId: campaign.id,
+      status: JobStatus.Sending,
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+      session: { user: { id: 1 } } as any,
+    }
+
+    await EmailMiddleware.isEmailCampaignOwnedByUser(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(nextFunction).toBeCalled()
+  })
+})

backend/src/sms/middlewares/sms-template.middleware.ts

@@ -63,7 +63,6 @@ const storeTemplate = async (
         valid: false,
         template: {
           body: updatedTemplate?.body,
-
           params: updatedTemplate?.params,
         },
       })

backend/src/sms/middlewares/tests/sms.middleware.test.ts

@@ -0,0 +1,90 @@
+import { NextFunction, Request, Response } from 'express'
+import { Sequelize } from 'sequelize-typescript'
+import { Campaign, JobQueue, User } from '@core/models'
+import sequelizeLoader from '@test-utils/sequelize-loader'
+import { RedisService } from '@core/services'
+import { ChannelType, JobStatus } from '@core/constants'
+import { SmsMiddleware } from '@sms/middlewares/sms.middleware'
+
+let sequelize: Sequelize
+let mockRequest: Partial<Request>
+let mockResponse: Partial<Response>
+const nextFunction: NextFunction = jest.fn()
+
+beforeEach(() => {
+  mockRequest = {}
+  mockResponse = {
+    sendStatus: jest.fn(),
+  }
+})
+
+beforeAll(async () => {
+  sequelize = await sequelizeLoader(process.env.JEST_WORKER_ID || '1')
+  await User.create({ id: 1, email: 'user@agency.gov.sg' })
+})
+
+afterEach(async () => {
+  await JobQueue.destroy({ where: {} })
+  await Campaign.destroy({ where: {} })
+})
+
+afterAll(async () => {
+  await User.destroy({ where: {} })
+  await sequelize.close()
+  RedisService.otpClient.quit()
+  RedisService.sessionClient.quit()
+})
+
+describe('isSmsCampaignOwnedByUser middleware', () => {
+  test('Returns 403 campaign does not belong to user', async () => {
+    const campaign = await Campaign.create({
+      name: 'campaign-1',
+      userId: 1,
+      type: ChannelType.SMS,
+      valid: false,
+      protect: false,
+    })
+    await JobQueue.create({
+      campaignId: campaign.id,
+      status: JobStatus.Sending,
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+      session: { user: { id: 2 } } as any,
+    }
+
+    await SmsMiddleware.isSmsCampaignOwnedByUser(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(mockResponse.sendStatus).toBeCalledWith(403)
+  })
+
+  test('Returns next middleware when campaign belongs to user', async () => {
+    const campaign = await Campaign.create({
+      name: 'campaign-1',
+      userId: 1,
+      type: ChannelType.SMS,
+      valid: false,
+      protect: false,
+    })
+    await JobQueue.create({
+      campaignId: campaign.id,
+      status: JobStatus.Sending,
+    })
+
+    mockRequest = {
+      params: { campaignId: String(campaign.id) },
+      session: { user: { id: 1 } } as any,
+    }
+
+    await SmsMiddleware.isSmsCampaignOwnedByUser(
+      mockRequest as Request,
+      mockResponse as Response,
+      nextFunction
+    )
+    expect(nextFunction).toBeCalled()
+  })
+})