Merge pull request #134 from green-code-initiative/133-add-a-getpriorityrule-core-service

feat(core-services): add priority rule + tests

Author: AMorgaut

shared/core-services/src/index.js

@@ -1,9 +1,12 @@
 import api from './adapter.js'
 import settings from './settings.service.js'
+
+import * as priorityRule from './priority-rule.service.js'
 import * as score from './score.service.js'
 
 export default {
     api,
     settings,
+    ...priorityRule,
     ...score
 }

shared/core-services/src/priority-rule.service.js

@@ -0,0 +1,72 @@
+/**
+ * @module priority-rule.services
+ * @description This module provides functions to recommend a priority rule to fix.
+ */
+
+import api from './adapter.js';
+
+/**
+ * @typedef {Object} DescriptionSection
+ * @property {string} key
+ * @property {string} content
+ * @property {string} [context]
+ */
+
+/**
+ * @typedef {Object} RuleDetails
+ * @property {string} key
+ * @property {string} name
+ * @property {string} htmlDesc
+ * @property {'INFO'|'MINOR'|'MAJOR'|'CRITICAL'|'BLOCKER'} severity
+ * @property {string[]} tags
+ * @property {string} langName
+ * @property {DescriptionSection[]} descriptionSections
+ */
+
+/**
+ * @param {Object} ruleFacet
+ * @returns {string}
+ */
+function getMostIssuesRule(ruleFacet) {
+    let ruleKey = null
+    let max = 0
+    for (let [key, value] of Object.entries(ruleFacet)) {
+        if (value > max) {
+            max = value
+            ruleKey = key 
+        }
+    }
+    return ruleKey
+}
+
+const SEVERITY_LEVELS = [
+    'BLOCKER',
+    'CRITICAL',
+    'MAJOR',
+    'MINOR,INFO'
+]
+
+/**
+ * Select a PriorityRule based the score calculation algorithm
+ * 
+ * @param {Object} config
+ * @param {string} config.project key of the project
+ * @param {string} config.branch 
+ * @returns {Promise<RuleDetails|null>}
+ */
+export async function getPriorityRule(config) {
+    let ruleKey;
+
+    for (let severity of SEVERITY_LEVELS) {
+        const ruleFacet = await api.services.getIssuesFacet('rules', { ...config, severity });
+        ruleKey = getMostIssuesRule(ruleFacet)
+        if (ruleKey) {
+            break
+        }
+    }
+
+    const ruleDetails = ruleKey ? 
+        await api.services.getRuleDetails(ruleKey) :
+        null
+    return ruleDetails;
+}

shared/core-services/src/priority-rule.service.spec.js

@@ -0,0 +1,70 @@
+import { vi, describe, expect, test } from 'vitest'
+
+import api from './adapter'
+import { getPriorityRule } from './priority-rule.service'
+
+vi.mock('./adapter', async () => ({ default: { services: {
+  getIssuesFacet: vi.fn(),
+  getRuleDetails: vi.fn().mockImplementation(key => ({
+    'blocker:key': { key },
+    'critical:key': { key },
+    'major:key': { key },
+    'minor:key': { key },
+    'info:key': { key },
+  })[key])
+}}}))
+
+const mockConfig = { project: 'foo' }
+
+function mockGetIssuesFacet(data) {
+  return (facet, config) => {
+    expect(config).toHaveProperty('severity')
+    expect(config).toHaveProperty('project', 'foo')
+    expect(facet).toBe('rules')
+    return data[config.severity] || {}
+  }
+}
+
+const BLOCKER = { 'blocker:key': 4, 'blocker:key2': 3 }
+const CRITICAL = { 'critical:key': 7, 'critical:key2': 4  }
+const MAJOR = { 'major:key': 12, 'critical:key2': 4 }
+const MINOR_OR_INFO = { 'minor:key': 31, 'info:key': 12, 'minor:key2': 4 }
+
+describe('getPriorityRule()', () => {
+
+  test('Should return Blocker issue related rule if one exist', async () => {
+    const mock = mockGetIssuesFacet({ BLOCKER, CRITICAL, MAJOR })
+    api.services.getIssuesFacet.mockImplementation(mock);
+    const rule = await getPriorityRule(mockConfig)   
+    expect(rule).toHaveProperty('key', 'blocker:key')
+  })
+
+  test('Should return Critical issue related rule if one exist and no blocker exist', async () => {
+    const mock = mockGetIssuesFacet({ CRITICAL, MAJOR })
+    api.services.getIssuesFacet.mockImplementation(mock);
+    const rule = await getPriorityRule(mockConfig)   
+    expect(rule).toHaveProperty('key', 'critical:key')
+  })
+
+  test('Should return major issue related rule if one exist and no blocker or critical exist', async () => {
+    const mock = mockGetIssuesFacet({  MAJOR, 'MINOR,INFO': MINOR_OR_INFO })
+    api.services.getIssuesFacet.mockImplementation(mock);
+    const rule = await getPriorityRule(mockConfig)   
+    expect(rule).toHaveProperty('key', 'major:key')
+  })
+
+  test('Should return minor issue related rule if one exist and no blocker, critical or major exist', async () => {
+    const mock = mockGetIssuesFacet({ 'MINOR,INFO': MINOR_OR_INFO })
+    api.services.getIssuesFacet.mockImplementation(mock);
+    const rule = await getPriorityRule(mockConfig)   
+    expect(rule).toHaveProperty('key', 'minor:key')
+  })
+
+  test('Should return null if no issue exist', async () => {
+    const mock = mockGetIssuesFacet({ })
+    api.services.getIssuesFacet.mockImplementation(mock);
+    const rule = await getPriorityRule(mockConfig)   
+    expect(rule).toBe(null)
+  })
+
+})

shared/core-services/src/score.service.spec.js

@@ -15,7 +15,7 @@ beforeAll(() => {
 });
 
 afterAll(() => {
-  // Mock the API calls
+  // Clean the API calls
 });
 
 describe('calculateProjectScore', () => {

shared/core-services/src/settings.service.spec.js

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, test } from 'vitest'
+
+import settings from './settings.service'
+
+let store;
+
+const storageApi = {
+  set: (key, value) => store[key] = value,
+  get: (key) => store[key],
+};
+
+beforeEach(()=> {
+  store = {};
+  settings.resetSettings()
+})
+
+describe('Settings service', () => {
+
+  describe('initStorage', () => {
+    test('apply the given store', async () => {
+      settings.initStorage(storageApi)
+      expect(settings.get('foo')).toBe(undefined)
+      settings.set('foo', 'bar')
+      expect(settings.get('foo')).toBe('bar')
+    })
+
+  })
+  
+  describe('storageReady', () => {
+    test('return false if not initialized', async () => {
+      expect(settings.storageReady).toBe(false)
+    })
+    test('return true if initialized', async () => {
+      settings.initStorage(storageApi)
+      expect(settings.storageReady).toBe(true)
+    })
+  })
+
+  describe('resetSettings', () => {
+    test('storageReady return false after initialized and reset', async () => {
+      settings.initStorage(storageApi)
+      settings.resetSettings()
+      expect(settings.storageReady).toBe(false)
+    })
+
+  })
+
+})