feat: local provider scheduled command adapter unit test

packages/framework-provider-local-infrastructure/src/scheduler.ts

@@ -6,24 +6,38 @@ interface ScheduledCommandInfo {
   metadata: ScheduledCommandMetadata
 }
 
-export function configureScheduler(config: BoosterConfig, userProject: any): void {
+export function configureScheduler(config: BoosterConfig, userProject: any): scheduler.Job[] {
   const triggerScheduleCommand = userProject['boosterTriggerScheduledCommand']
+  const cronJobs: scheduler.Job[] = []
   Object.keys(config.scheduledCommandHandlers)
     .map((scheduledCommandName) => buildScheduledCommandInfo(config, scheduledCommandName))
     .filter((scheduledCommandInfo) => scheduledCommandInfo.metadata.scheduledOn)
     .forEach((scheduledCommandInfo) => {
-      scheduler.scheduleJob(scheduledCommandInfo.name, createCronExpression(scheduledCommandInfo.metadata), () => {
-        triggerScheduleCommand({ typeName: scheduledCommandInfo.name })
-      })
+      const cronJob = scheduler.scheduleJob(
+        scheduledCommandInfo.name,
+        createCronExpression(scheduledCommandInfo.metadata),
+        () => {
+          triggerScheduleCommand({ typeName: scheduledCommandInfo.name })
+        }
+      )
+      cronJobs.push(cronJob)
     })
+  return cronJobs
 }
 
-function createCronExpression(scheduledCommandMetadata: ScheduledCommandMetadata): string {
-  const { minute = '*', hour = '*', day = '*', month = '*', weekDay = '*' } = scheduledCommandMetadata.scheduledOn
-  return `${minute} ${hour} ${day} ${month} ${weekDay}`
+export function createCronExpression(scheduledCommandMetadata: ScheduledCommandMetadata): string {
+  const {
+    second = '*',
+    minute = '*',
+    hour = '*',
+    day = '*',
+    month = '*',
+    weekDay = '*',
+  } = scheduledCommandMetadata.scheduledOn
+  return `${second} ${minute} ${hour} ${day} ${month} ${weekDay}`
 }
 
-function buildScheduledCommandInfo(config: BoosterConfig, scheduledCommandName: string): ScheduledCommandInfo {
+export function buildScheduledCommandInfo(config: BoosterConfig, scheduledCommandName: string): ScheduledCommandInfo {
   return {
     name: scheduledCommandName,
     metadata: config.scheduledCommandHandlers[scheduledCommandName],

packages/framework-provider-local-infrastructure/test/scheduler.test.ts

@@ -0,0 +1,84 @@
+import { BoosterConfig } from '@boostercloud/framework-types'
+import { restore, SinonStub, SinonStubbedInstance, createStubInstance, replace, stub, useFakeTimers } from 'sinon'
+import { configureScheduler, createCronExpression, buildScheduledCommandInfo } from '../src/scheduler'
+import { expect } from './expect'
+import { describe } from 'mocha'
+import { random } from 'faker'
+
+declare class UserProject {
+  constructor()
+  boosterTriggerScheduledCommand: (rawRequest: unknown) => void
+}
+describe('Local Scheduler', () => {
+  let mockUserProjectStub: SinonStubbedInstance<UserProject>
+  let mockScheduledCommand: any
+  let mockConfig: BoosterConfig
+  let mockScheduledCommandName: string
+  let queryStub: SinonStub
+  let clock: any
+
+  beforeEach(() => {
+    class CheckCart {
+      public static async handle(): Promise<void> {
+        console.log('handle')
+      }
+    }
+    class UserProject {
+      boosterTriggerScheduledCommand(rawRequest: unknown): void {
+        console.log('rawRequest: ', rawRequest)
+      }
+    }
+
+    clock = useFakeTimers()
+
+    mockScheduledCommandName = random.word()
+    queryStub = stub()
+
+    mockUserProjectStub = createStubInstance(UserProject)
+    replace(mockUserProjectStub, 'boosterTriggerScheduledCommand', queryStub as any)
+
+    mockConfig = buildConfig()
+    mockConfig.scheduledCommandHandlers[mockScheduledCommandName] = {
+      class: CheckCart,
+      scheduledOn: {},
+    }
+
+    mockScheduledCommand = buildScheduledCommandInfo(mockConfig, mockScheduledCommandName)
+  })
+
+  afterEach(() => {
+    restore()
+  })
+
+  describe('buildScheduledCommandInfo', () => {
+    it('should return expected scheduled command info', async () => {
+      const result = await buildScheduledCommandInfo(mockConfig, mockScheduledCommandName)
+      expect(result).to.be.deep.equal({
+        name: mockScheduledCommandName,
+        metadata: mockConfig.scheduledCommandHandlers[mockScheduledCommandName],
+      })
+    })
+  })
+
+  describe('createCronExpression', () => {
+    it('should return expected cron expression', async () => {
+      const result = await createCronExpression(mockScheduledCommand.metadata)
+      expect(result).to.be.equal('* * * * * *')
+    })
+  })
+
+  describe('configureScheduler', () => {
+    it('should call scedule job', async () => {
+      const results = configureScheduler(mockConfig, mockUserProjectStub)
+      clock.tick(3250)
+      setTimeout(() => {
+        results.forEach((result) => result.cancel())
+      }, 3250)
+      expect(queryStub).to.have.callCount(3)
+    })
+  })
+
+  function buildConfig(): BoosterConfig {
+    return new BoosterConfig('test')
+  }
+})

packages/framework-provider-local/src/library/scheduled-adapter.ts

@@ -1,6 +1,6 @@
 import { Logger, ScheduledCommandEnvelope, UUID } from '@boostercloud/framework-types'
 
-interface LocalScheduleCommandEnvelope {
+export interface LocalScheduleCommandEnvelope {
   typeName: string
 }
 

packages/framework-provider-local/test/helpers/scheduled-helper.ts

@@ -0,0 +1,11 @@
+import { random } from 'faker'
+
+interface LocalScheduleCommandEnvelope {
+  typeName: string
+}
+
+export function createMockLocalScheduleCommandEnvelope(): Partial<LocalScheduleCommandEnvelope> {
+  return {
+    typeName: random.word()
+  }
+}

packages/framework-provider-local/test/library/scheduled-adapter.test.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { SinonStub, stub, replace, restore } from 'sinon'
+import { rawScheduledInputToEnvelope, LocalScheduleCommandEnvelope } from '../../src/library/scheduled-adapter'
+import { createMockLocalScheduleCommandEnvelope } from '../helpers/scheduled-helper'
+import { UUID } from '@boostercloud/framework-types'
+import { expect } from '../expect'
+import { random } from 'faker'
+
+describe('Local provider scheduled-adapter', () => {
+  describe('rawScheduledInputToEnvelope', () => {
+    let mockScheduledEnvelop: Partial<LocalScheduleCommandEnvelope>
+    let mockEmptyScheduledEnvelop: Partial<unknown>
+    let mockUuid: string
+
+    let debugStub: SinonStub
+    let generateStub: SinonStub
+
+    let logger: any
+
+    beforeEach(() => {
+      mockUuid = random.uuid()
+
+      mockScheduledEnvelop = createMockLocalScheduleCommandEnvelope()
+      mockEmptyScheduledEnvelop = {}
+
+      debugStub = stub()
+      generateStub = stub().returns(mockUuid)
+
+      logger = {
+        debug: debugStub,
+      }
+      replace(UUID, 'generate', generateStub)
+    })
+
+    afterEach(() => {
+      restore()
+    })
+
+    it('should call logger.debug', async () => {
+      await rawScheduledInputToEnvelope(mockScheduledEnvelop, logger)
+
+      expect(debugStub).to.have.been.calledOnceWith(
+        'Received LocalScheduleCommand request: ',
+        mockScheduledEnvelop
+      )
+    })
+
+    it('should thrown an exception for empty typeName', async () => {
+      const error =  new Error(
+        `typeName is not defined or empty, scheduled command envelope should have the structure {typeName: string }, but you gave ${JSON.stringify(
+            mockEmptyScheduledEnvelop
+        )}`
+      )
+      expect(rawScheduledInputToEnvelope(mockEmptyScheduledEnvelop, logger)).to.be.rejectedWith(error)
+    })
+
+    it('should generate expected envelop', async () => {
+      const result = await rawScheduledInputToEnvelope(mockScheduledEnvelop, logger)
+      expect(result).to.be.deep.equal({
+        requestID: mockUuid,
+        typeName: mockScheduledEnvelop.typeName
+      })
+    })
+  })
+})