feat: Added unit tests

Author: m-pizarro

src/rules-engine/evaluators/base-evaluator.ts

@@ -8,7 +8,7 @@ export default abstract class BaseEvaluator<K extends Rule> implements RuleEvalu
 
   abstract evaluateSingleResource(rule: K, data?: ResourceData): Promise<RuleFinding>
 
-  async evaluateMissingResource({ id, severity, resource }: K): Promise<RuleFinding> {
+  async evaluateMissingResource({ id, severity, resource }: Rule): Promise<RuleFinding> {
     return {
       id: `${id}/missing/${cuid()}`,
       resourceId: resource?.replace('[*]', ''),

tests/evaluators/js-evaluator.test.ts

@@ -66,4 +66,25 @@ describe('JsEvaluator', () => {
     )
     expect(passedRule.result).toEqual(Result.PASS)
   })
+
+  test('should return missing as result', async () => {
+    const finding = await evaluator.evaluateMissingResource(
+      { id: cuid() } as never
+    )
+    expect(finding.result).toEqual(Result.MISSING)
+  })
+
+  test('should contain "missing" at the id', async () => {
+    const finding = await evaluator.evaluateMissingResource(
+      { id: cuid() } as any
+    )
+    expect(finding.id.includes('missing')).toEqual(true)
+  })
+
+  test('should return the resource path at the resourceId', async () => {
+    const finding = await evaluator.evaluateMissingResource(
+      { id: cuid(), resource: 'resourcePath[*]'} as any
+    )
+    expect(finding.resourceId).toEqual('resourcePath')
+  })
 })

tests/evaluators/json-evaluator.test.ts

@@ -596,4 +596,25 @@ describe('JsonEvaluator', () => {
 
     expect(finding.result).toBe(Result.FAIL)
   })
+
+  test('should return missing as result', async () => {
+    const finding = await evaluator.evaluateMissingResource(
+      { id: cuid() } as never
+    )
+    expect(finding.result).toEqual(Result.MISSING)
+  })
+
+  test('should contain "missing" at the id', async () => {
+    const finding = await evaluator.evaluateMissingResource(
+      { id: cuid() } as any
+    )
+    expect(finding.id.includes('missing')).toEqual(true)
+  })
+
+  test('should return the resource path at the resourceId', async () => {
+    const finding = await evaluator.evaluateMissingResource(
+      { id: cuid(), resource: 'resourcePath[*]'} as any
+    )
+    expect(finding.resourceId).toEqual('resourcePath')
+  })
 })

tests/rules-engine.test.ts

@@ -1,8 +1,9 @@
 import RulesProvider from '../src/rules-engine'
-import { Engine, Rule } from '../src/rules-engine/types'
+import { Engine, Result, Rule } from '../src/rules-engine/types'
 import ManualEvaluatorMock from './evaluators/manual-evaluator.test'
 import JSONEvaluatordMock from './evaluators/json-evaluator.test'
 import DgraphDataProcessor from '../src/rules-engine/data-processors/dgraph-data-processor'
+import { RuleFinding } from '../src'
 
 const typenameToFieldMap = {
   resourceA: 'querySchemaA',
@@ -50,17 +51,17 @@ describe('RulesEngine', () => {
     )
   })
 
-  it('Should return an empty array processing a rule with no data', async () => {
+  it('Should return a missing finding type processing a rule with no data', async () => {
     const data = {}
 
     const processedRule = await rulesEngine.processRule(
       JSONEvaluatordMock.jsonRule,
       data
-    )
+    ) as RuleFinding[]
 
     expect(processedRule).toBeDefined()
-    expect(processedRule instanceof Array).toBeTruthy()
-    expect(processedRule.length).toBe(0)
+    expect(processedRule.length).toBe(1)
+    expect(processedRule[0].result).toBe(Result.MISSING)
   })
 
   it('Should return empty mutations array given an empty findings array', () => {