add test coverage for update worker

Author: bryopsida

src/patcher/backoff.service.ts

@@ -3,8 +3,12 @@ import { Redis } from 'ioredis'
 import { IConnOptionsService } from '../common/conn-options.service'
 import { ImageDescriptor } from '../kubernetes/k8s.service'
 
+export interface IBackoffService {
+  canIUpdate(descriptor: ImageDescriptor): Promise<boolean>
+}
+
 @Injectable()
-export class BackoffService implements OnModuleDestroy {
+export class BackoffService implements OnModuleDestroy, IBackoffService {
   private readonly redis: Redis
 
   constructor(

src/patcher/patcher.module.ts

@@ -13,6 +13,12 @@ import { BackoffService } from './backoff.service'
     CommonModule,
     KubernetesModule,
   ],
-  providers: [UpdateWorker, BackoffService],
+  providers: [
+    UpdateWorker,
+    {
+      provide: 'BACKOFF_SERVICE',
+      useClass: BackoffService,
+    },
+  ],
 })
 export class PatcherModule {}

src/patcher/update.consumer.spec.ts

@@ -0,0 +1,75 @@
+import { Test, TestingModule } from '@nestjs/testing'
+import {
+  ImageDescriptor,
+  Resource,
+  ResourceType,
+} from '../kubernetes/k8s.service'
+import { UpdateWorker } from './update.consumer'
+
+describe('UpdateWorker', () => {
+  let service: UpdateWorker
+  let module: TestingModule
+  let fakeK8s
+
+  beforeEach(async () => {
+    fakeK8s = {
+      triggerRollingUpdate: jest.fn(),
+    }
+    module = await Test.createTestingModule({
+      providers: [
+        {
+          provide: 'K8S_SERVICE',
+          useValue: fakeK8s,
+        },
+        {
+          provide: 'BACKOFF_SERVICE',
+          useValue: {
+            canIUpdate: (descriptor: ImageDescriptor): Promise<boolean> => {
+              if (descriptor.owner.name === 'TEST_1')
+                return Promise.resolve(false)
+              return Promise.resolve(true)
+            },
+          },
+        },
+        UpdateWorker,
+      ],
+    }).compile()
+
+    service = module.get<UpdateWorker>(UpdateWorker)
+  })
+  afterEach(async () => {
+    await module.close()
+  })
+
+  it('should be defined', () => {
+    expect(service).toBeDefined()
+  })
+
+  it('should not update when inside graceperiod', async () => {
+    const result = await service.rollout({
+      data: {
+        owner: {
+          name: 'TEST_1',
+          namespace: 'TEST_NAMESPACE_1',
+          type: ResourceType.DAEMONSET,
+        } as Resource,
+      },
+    } as unknown as any)
+    expect(result.updateScheduled).toBeFalsy()
+    expect(fakeK8s.triggerRollingUpdate.mock.calls.length).toBe(0)
+  })
+
+  it('should update when outside the graceperiod', async () => {
+    const result = await service.rollout({
+      data: {
+        owner: {
+          name: 'TEST_2',
+          namespace: 'TEST_NAMESPACE_2',
+          type: ResourceType.DAEMONSET,
+        } as Resource,
+      },
+    } as unknown as any)
+    expect(result.updateScheduled).toBeTruthy()
+    expect(fakeK8s.triggerRollingUpdate.mock.calls.length).toBe(1)
+  })
+})

src/patcher/update.consumer.ts

@@ -2,7 +2,7 @@ import { Processor, Process } from '@nestjs/bull'
 import { Inject, Logger } from '@nestjs/common'
 import { Job } from 'bull'
 import { IK8sService, ImageDescriptor } from '../kubernetes/k8s.service'
-import { BackoffService } from './backoff.service'
+import { IBackoffService } from './backoff.service'
 
 export interface ImageDescriptorUpdate extends ImageDescriptor {
   currentSha: string
@@ -13,11 +13,11 @@ export interface ImageDescriptorUpdate extends ImageDescriptor {
 export class UpdateWorker {
   private readonly logger = new Logger(UpdateWorker.name)
   private readonly k8sService: IK8sService
-  private readonly backoffService: BackoffService
+  private readonly backoffService: IBackoffService
 
   constructor(
     @Inject('K8S_SERVICE') k8s: IK8sService,
-    backoff: BackoffService
+    @Inject('BACKOFF_SERVICE') backoff: IBackoffService
   ) {
     this.k8sService = k8s
     this.backoffService = backoff