Refactor [Sonar]

services/sonar/sonar-base.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const Joi = require('joi')
+const serverSecrets = require('../../lib/server-secrets')
+const { BaseJsonService } = require('..')
+const { isLegacyVersion } = require('./sonar-helpers')
+
+const schema = Joi.object({
+  component: Joi.object({
+    measures: Joi.array()
+      .items(
+        Joi.object({
+          metric: Joi.string(),
+          value: Joi.alternatives(
+            Joi.number().min(0),
+            Joi.allow('OK', 'ERROR')
+          ).required(),
+        }).required()
+      )
+      .required(),
+  }).required(),
+}).required()
+
+const legacyApiSchema = Joi.array()
+  .items(
+    Joi.object({
+      msr: Joi.array()
+        .items(
+          Joi.object({
+            key: Joi.string(),
+            val: Joi.alternatives(
+              Joi.number().min(0),
+              Joi.allow('OK', 'ERROR')
+            ).required(),
+          }).required()
+        )
+        .required(),
+    }).required()
+  )
+  .required()
+
+module.exports = class SonarBase extends BaseJsonService {
+  transform({ json, version }) {
+    const useLegacyApi = isLegacyVersion({ version })
+    const rawValue = useLegacyApi
+      ? json[0].msr[0].val
+      : json.component.measures[0].value
+    const value = parseInt(rawValue)
+
+    // Most values are numeric, but not all of them.
+    return { metricValue: value || rawValue }
+  }
+
+  async fetch({ version, protocol, host, component, metricName }) {
+    let qs, url
+    const useLegacyApi = isLegacyVersion({ version })
+
+    if (useLegacyApi) {
+      url = `${protocol}://${host}/api/resources`
+      qs = {
+        resource: component,
+        depth: 0,
+        metrics: metricName,
+        includeTrends: true,
+      }
+    } else {
+      url = `${protocol}://${host}/api/measures/component`
+      qs = {
+        componentKey: component,
+        metricKeys: metricName,
+      }
+    }
+
+    const options = { qs }
+
+    if (serverSecrets.sonarqube_token) {
+      options.auth = {
+        user: serverSecrets.sonarqube_token,
+      }
+    }
+
+    return this._requestJson({
+      schema: useLegacyApi ? legacyApiSchema : schema,
+      url,
+      options,
+      errorMessages: {
+        404: 'component or metric not found, or legacy API not supported',
+      },
+    })
+  }
+}

services/sonar/sonar-base.spec.js

@@ -0,0 +1,4 @@
+'use strict'
+
+// const SonarQubeBase = require('./sonarqube-base')
+

services/sonar/sonar-coverage.service.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const { coveragePercentage } = require('../color-formatters')
+const SonarBase = require('./sonar-base')
+const { patternBase, queryParamSchema } = require('./sonar-helpers')
+
+module.exports = class SonarCoverage extends SonarBase {
+  static get category() {
+    return 'coverage'
+  }
+
+  static get defaultBadgeData() {
+    return { label: 'coverage' }
+  }
+
+  static render({ coverage }) {
+    return {
+      message: `${coverage.toFixed(0)}%`,
+      color: coveragePercentage(coverage),
+    }
+  }
+
+  static get route() {
+    return {
+      base: 'sonar',
+      pattern: `${patternBase}/coverage`,
+      queryParamSchema,
+    }
+  }
+
+  async handle({ protocol, host, component }, { version }) {
+    const json = await this.fetch({
+      version,
+      protocol,
+      host,
+      component,
+      metricName: 'coverage',
+    })
+    const { metricValue: coverage } = this.transform({ json, version })
+    return this.constructor.render({ coverage })
+  }
+}

services/sonar/sonar-coverage.tester.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const t = (module.exports = require('../tester').createServiceTester())
+const { isIntegerPercentage } = require('../test-validators')
+
+t.create('Coverage')
+  .get(
+    '/http/sonar.petalslink.com/org.ow2.petals%3Apetals-se-ase/coverage.json'
+  )
+  .expectBadge({
+    label: 'coverage',
+    message: isIntegerPercentage,
+  })
+
+t.create('Coverage (legacy API supported)')
+  .get(
+    '/http/sonar.petalslink.com/org.ow2.petals%3Apetals-se-ase/coverage.json?version=4.2'
+  )
+  .expectBadge({
+    label: 'coverage',
+    message: isIntegerPercentage,
+  })

services/sonar/sonar-documented-api-density.service.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const SonarBase = require('./sonar-base')
+const {
+  patternBase,
+  queryParamSchema,
+  getLabel,
+  goodMetricColorScale,
+} = require('./sonar-helpers')
+
+const metric = 'public_documented_api_density'
+
+module.exports = class SonarDocumentedApiDensity extends SonarBase {
+  static get category() {
+    return 'analysis'
+  }
+
+  static get defaultBadgeData() {
+    return { label: getLabel({ metric }) }
+  }
+
+  static render({ density }) {
+    return {
+      message: `${density}%`,
+      color: goodMetricColorScale(density),
+    }
+  }
+
+  static get route() {
+    return {
+      base: 'sonar',
+      pattern: `${patternBase}/${metric}`,
+      queryParamSchema,
+    }
+  }
+
+  async handle({ protocol, host, component }, { version }) {
+    const json = await this.fetch({
+      version,
+      protocol,
+      host,
+      component,
+      metricName: metric,
+    })
+    const { metricValue: density } = this.transform({ json, version })
+    return this.constructor.render({ density })
+  }
+}

services/sonar/sonar-documented-api-density.spec.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { test, given } = require('sazerac')
+const SonarDocumentedApiDensity = require('./sonar-documented-api-density.service')
+
+describe('SonarDocumentedApiDensity', function() {
+  test(SonarDocumentedApiDensity.render, () => {
+    given({ density: 0 }).expect({
+      message: '0%',
+      color: 'red',
+    })
+    given({ density: 10 }).expect({
+      message: '10%',
+      color: 'orange',
+    })
+    given({ density: 20 }).expect({
+      message: '20%',
+      color: 'yellow',
+    })
+    given({ density: 50 }).expect({
+      message: '50%',
+      color: 'yellowgreen',
+    })
+    given({ density: 100 }).expect({
+      message: '100%',
+      color: 'brightgreen',
+    })
+  })
+})

services/sonar/sonar-documented-api-density.tester.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { isIntegerPercentage } = require('../test-validators')
+const t = (module.exports = require('../tester').createServiceTester())
+
+t.create('Documented API Density')
+  .get(
+    '/http/sonar.petalslink.com/org.ow2.petals%3Apetals-se-ase/public_documented_api_density.json'
+  )
+  .expectBadge({
+    label: 'public documented api density',
+    message: isIntegerPercentage,
+  })
+
+t.create('Documented API Density (legacy API supported)')
+  .get(
+    '/http/sonar.petalslink.com/org.ow2.petals%3Apetals-se-ase/public_documented_api_density.json?version=4.2'
+  )
+  .expectBadge({
+    label: 'public documented api density',
+    message: isIntegerPercentage,
+  })

services/sonar/sonar-fortify-rating.service.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const SonarBase = require('./sonar-base')
+const { patternBase, queryParamSchema } = require('./sonar-helpers')
+
+const colorMap = {
+  0: 'red',
+  1: 'orange',
+  2: 'yellow',
+  3: 'yellowgreen',
+  4: 'green',
+  5: 'brightgreen',
+}
+
+module.exports = class SonarFortifyRating extends SonarBase {
+  static get category() {
+    return 'analysis'
+  }
+
+  static get defaultBadgeData() {
+    return { label: 'fortify-security-rating' }
+  }
+
+  static render({ rating }) {
+    return {
+      message: `${rating}/5`,
+      color: colorMap[rating],
+    }
+  }
+
+  static get route() {
+    return {
+      base: 'sonar',
+      pattern: `${patternBase}/fortify-security-rating`,
+      queryParamSchema,
+    }
+  }
+
+  async handle({ protocol, host, component }, { version }) {
+    const json = await this.fetch({
+      version,
+      protocol,
+      host,
+      component,
+      metricName: 'fortify-security-rating',
+    })
+
+    const { metricValue: rating } = this.transform({ json, version })
+    return this.constructor.render({ rating })
+  }
+}

services/sonar/sonar-fortify-rating.tester.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const sinon = require('sinon')
+const t = (module.exports = require('../tester').createServiceTester())
+const serverSecrets = require('../../lib/server-secrets')
+const sonarToken = 'abc123def456'
+
+// The below tests are using a mocked API response because
+// neither SonarCloud.io nor any known public SonarQube deployments
+// have the Fortify plugin installed and in use, so there are no
+// available live endpoints to hit.
+t.create('Fortify Security Rating')
+  .before(() => {
+    serverSecrets['sonarqube_token'] = undefined
+    sinon.stub(serverSecrets, 'sonarqube_token').value(sonarToken)
+  })
+  .get(
+    '/http/sonar.petalslink.com/org.ow2.petals%3Apetals-se-ase/fortify-security-rating.json'
+  )
+  .intercept(nock =>
+    nock('http://sonar.petalslink.com/api/measures')
+      .get('/component')
+      .query({
+        componentKey: 'org.ow2.petals:petals-se-ase',
+        metricKeys: 'fortify-security-rating',
+      })
+      .basicAuth({ user: sonarToken })
+      .reply(200, {
+        component: {
+          measures: [
+            {
+              metric: 'fortify-security-rating',
+              value: 4,
+            },
+          ],
+        },
+      })
+  )
+  .finally(sinon.restore)
+  .expectBadge({
+    label: 'fortify-security-rating',
+    message: '4/5',
+  })
+
+t.create('Fortify Security Rating (legacy API supported)')
+  .get(
+    '/http/sonar.petalslink.com/org.ow2.petals%3Apetals-se-ase/fortify-security-rating.json?version=4.2'
+  )
+  .intercept(nock =>
+    nock('http://sonar.petalslink.com/api')
+      .get('/resources')
+      .query({
+        resource: 'org.ow2.petals:petals-se-ase',
+        depth: 0,
+        metrics: 'fortify-security-rating',
+        includeTrends: true,
+      })
+      .reply(200, [
+        {
+          msr: [
+            {
+              metric: 'fortify-security-rating',
+              val: 3,
+            },
+          ],
+        },
+      ])
+  )
+  .expectBadge({
+    label: 'fortify-security-rating',
+    message: '3/5',
+  })