@cloudcare/guance-front-tools 1.0.11 → 1.0.13

package/test/cli.test.mjs

@@ -0,0 +1,373 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+import { covert } from '../lib/scripts/grafana-covert-to-guance-core.js'
+import {
+  convertDashboard,
+} from '../skills/grafana-to-guance-dashboard/scripts/convert-grafana-dashboard.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const projectRoot = path.resolve(__dirname, '..')
+const cliPath = path.join(projectRoot, 'cli.js')
+const grafanaInputPath = path.join(projectRoot, 'lib/example/test2.json')
+const grafanaLoadInputPath = path.join(projectRoot, 'lib/example/grafana2.json')
+
+function runCli(args, options = {}) {
+  return spawnSync(process.execPath, [cliPath, ...args], {
+    cwd: projectRoot,
+    encoding: 'utf-8',
+    ...options,
+  })
+}
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'guance-front-tools-cli-'))
+}
+
+test('covert delegates to the shared converter implementation', () => {
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+
+  const actual = covert(grafanaDashboard)
+  const expected = convertDashboard(grafanaDashboard)
+
+  assert.deepEqual(actual, expected)
+})
+
+test('shared converter infers units from query text when panel unit is missing', () => {
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaLoadInputPath, 'utf-8'))
+
+  const actual = convertDashboard(grafanaDashboard)
+  const loadChart = actual.main.charts.find((chart) =>
+    chart.queries.some((query) => String(query?.query?.q || '').includes('load5s'))
+  )
+
+  assert.ok(loadChart)
+  assert.equal(loadChart.extend.settings.unitType, 'global')
+  assert.deepEqual(loadChart.extend.settings.globalUnit, ['custom', 'short'])
+})
+
+test('shared converter maps offset queries to guance compare settings', () => {
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+
+  const actual = convertDashboard(grafanaDashboard)
+  const serviceQpsChart = actual.main.charts.find((chart) => chart.name === '服务QPS')
+
+  assert.ok(serviceQpsChart)
+  assert.equal(serviceQpsChart.extend.settings.openCompare, true)
+  assert.deepEqual(serviceQpsChart.extend.settings.compareType, ['dayCompare', 'weekCompare'])
+  assert.deepEqual(serviceQpsChart.extend.settings.compares, [
+    { label: '日同比', value: 'dayCompare' },
+    { label: '周同比', value: 'weekCompare' },
+  ])
+  assert.equal(serviceQpsChart.extend.settings.compareChartType, 'sequence')
+})
+
+test('shared converter maps legend and table sort semantics into guance settings', () => {
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+
+  const actual = convertDashboard(grafanaDashboard)
+  const errorRateChart = actual.main.charts.find((chart) => chart.name === '系统错误率 - 节点维度')
+  const releaseTableChart = actual.main.charts.find((chart) => chart.name === '📚流水线发布(最近五天) -- 按服务筛选')
+
+  assert.ok(errorRateChart)
+  assert.equal(errorRateChart.extend.settings.sorderByOrder, 'desc')
+
+  assert.ok(releaseTableChart)
+  assert.equal(releaseTableChart.extend.settings.mainMeasurementSort, 'top')
+})
+
+test('shared converter maps repeat panels and infers bytes and seconds units', () => {
+  const actual = convertDashboard({
+    title: 'synthetic',
+    panels: [
+      {
+        id: 1,
+        title: 'Memory',
+        type: 'timeseries',
+        repeat: 'host',
+        repeatDirection: 'h',
+        maxPerRow: 4,
+        gridPos: { x: 0, y: 0, w: 12, h: 8 },
+        fieldConfig: { defaults: { custom: {} }, overrides: [] },
+        options: {},
+        targets: [{ expr: 'sum(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) by (instance)' }],
+      },
+      {
+        id: 2,
+        title: 'GC Pause',
+        type: 'timeseries',
+        gridPos: { x: 12, y: 0, w: 12, h: 8 },
+        fieldConfig: { defaults: { custom: {} }, overrides: [] },
+        options: {},
+        targets: [{ expr: 'rate(jvm_gc_pause_seconds_sum[1m]) by (instance)' }],
+      },
+    ],
+    templating: { list: [] },
+  })
+
+  assert.deepEqual(actual.main.charts[0].extend.settings.globalUnit, ['digital', 'B'])
+  assert.equal(actual.main.charts[0].extend.settings.repeatChartVariable, 'host')
+  assert.equal(actual.main.charts[0].extend.settings.repeatChartRowLimit, 4)
+  assert.equal(actual.main.charts[0].extend.settings.extend.layout.repeatDirection, 'h')
+  assert.deepEqual(actual.main.charts[1].extend.settings.globalUnit, ['time', 's'])
+})
+
+test('shared converter maps field override units into custom settings.units', () => {
+  const actual = convertDashboard({
+    title: 'synthetic-units',
+    panels: [
+      {
+        id: 1,
+        title: 'Custom Units',
+        type: 'timeseries',
+        gridPos: { x: 0, y: 0, w: 12, h: 8 },
+        fieldConfig: {
+          defaults: { custom: {} },
+          overrides: [
+            {
+              matcher: { id: 'byName', options: 'first(mem_used_percent)' },
+              properties: [{ id: 'unit', value: 'percent' }],
+            },
+          ],
+        },
+        options: {},
+        targets: [{ expr: 'first(mem_used_percent)' }],
+      },
+    ],
+    templating: { list: [] },
+  })
+
+  const settings = actual.main.charts[0].extend.settings
+  assert.equal(settings.unitType, 'custom')
+  assert.deepEqual(settings.units, [
+    {
+      key: 'first(mem_used_percent)',
+      name: 'first(mem_used_percent)',
+      unit: 'percent',
+      units: ['percent', 'percent'],
+    },
+  ])
+})
+
+test('shared converter maps fixed color overrides into settings.colors', () => {
+  const actual = convertDashboard({
+    title: 'synthetic-colors',
+    panels: [
+      {
+        id: 1,
+        title: 'Custom Colors',
+        type: 'timeseries',
+        gridPos: { x: 0, y: 0, w: 12, h: 8 },
+        fieldConfig: {
+          defaults: { custom: {} },
+          overrides: [
+            {
+              matcher: { id: 'byName', options: '95th percentile' },
+              properties: [{ id: 'color', value: { fixedColor: 'blue', mode: 'fixed' } }],
+            },
+            {
+              matcher: { id: 'byName', options: 'Requests' },
+              properties: [{ id: 'color', value: { mode: 'continuous-BlPu' } }],
+            },
+          ],
+        },
+        options: {},
+        targets: [{ expr: 'histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[1m]))' }],
+      },
+    ],
+    templating: { list: [] },
+  })
+
+  assert.deepEqual(actual.main.charts[0].extend.settings.colors, [
+    {
+      key: '95th percentile',
+      name: '95th percentile',
+      color: 'blue',
+    },
+  ])
+})
+
+test('shared converter maps topk and reduce limits into slimit', () => {
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+  const actual = convertDashboard(grafanaDashboard)
+  const pieChart = actual.main.charts.find((chart) => chart.name === 'QPS 节点间分布')
+
+  assert.ok(pieChart)
+  assert.equal(pieChart.extend.settings.slimit, 100)
+
+  const synthetic = convertDashboard({
+    title: 'synthetic-slimit',
+    panels: [
+      {
+        id: 1,
+        title: 'Toplist',
+        type: 'bargauge',
+        gridPos: { x: 0, y: 0, w: 12, h: 8 },
+        fieldConfig: { defaults: { custom: {} }, overrides: [] },
+        options: { reduceOptions: { limit: 15 } },
+        targets: [{ expr: 'sum(node_cpu_seconds_total) by (instance)' }],
+      },
+    ],
+    templating: { list: [] },
+  })
+
+  assert.equal(synthetic.main.charts[0].extend.settings.slimit, 15)
+})
+
+test('shared converter maps toplist thresholds and table mappings into color mapping settings', () => {
+  const actual = convertDashboard({
+    title: 'synthetic-color-mappings',
+    panels: [
+      {
+        id: 1,
+        title: 'Toplist',
+        type: 'bargauge',
+        gridPos: { x: 0, y: 0, w: 12, h: 8 },
+        fieldConfig: {
+          defaults: {
+            custom: {},
+            thresholds: {
+              mode: 'absolute',
+              steps: [
+                { color: 'green', value: null },
+                { color: 'red', value: 80 },
+              ],
+            },
+          },
+          overrides: [],
+        },
+        options: { reduceOptions: { limit: 10 } },
+        targets: [{ expr: 'sum(node_cpu_seconds_total) by (instance)' }],
+      },
+      {
+        id: 2,
+        title: 'Table',
+        type: 'table',
+        gridPos: { x: 12, y: 0, w: 12, h: 8 },
+        fieldConfig: {
+          defaults: { custom: {} },
+          overrides: [
+            {
+              matcher: { id: 'byName', options: 'status' },
+              properties: [
+                {
+                  id: 'mappings',
+                  value: [
+                    {
+                      type: 'value',
+                      options: {
+                        0: { text: 'OK' },
+                      },
+                    },
+                  ],
+                },
+                {
+                  id: 'color',
+                  value: { fixedColor: 'red', mode: 'fixed' },
+                },
+              ],
+            },
+          ],
+        },
+        transformations: [
+          {
+            id: 'organize',
+            options: {
+              renameByName: { status: '状态' },
+            },
+          },
+        ],
+        options: {},
+        targets: [{ rawSql: 'select status from demo' }],
+      },
+    ],
+    templating: { list: [] },
+  })
+
+  assert.deepEqual(actual.main.charts[0].extend.settings.colorMappings, [
+    {
+      value: [80],
+      bgColor: 'green',
+      operation: '<',
+    },
+    {
+      value: [80],
+      bgColor: 'red',
+      operation: '>=',
+    },
+  ])
+
+  assert.deepEqual(actual.main.charts[1].extend.settings.valColorMappings, [
+    {
+      field: '状态',
+      value: ['0'],
+      bgColor: '',
+      fontColor: 'red',
+      lineColor: '',
+      operation: '=',
+    },
+  ])
+})
+
+test('cli converts grafana dashboard to guance dashboard with explicit output path', () => {
+  const tempDir = createTempDir()
+  const outPath = path.join(tempDir, 'nested', 'guance-dashboard.json')
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+  const expected = covert(grafanaDashboard)
+
+  const result = runCli(['-d', grafanaInputPath, '-o', outPath])
+
+  assert.equal(result.status, 0, result.stderr || result.stdout)
+  assert.equal(fs.existsSync(outPath), true)
+
+  const actual = JSON.parse(fs.readFileSync(outPath, 'utf-8'))
+  assert.deepEqual(actual, expected)
+})
+
+test('cli supports shared converter flags and matches API output', () => {
+  const tempDir = createTempDir()
+  const outPath = path.join(tempDir, 'flags', 'guance-dashboard.json')
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+  const expected = convertDashboard(grafanaDashboard, {
+    guancePromqlCompatible: true,
+    keepGrafanaMeta: true,
+  })
+
+  const result = runCli([
+    '-d',
+    grafanaInputPath,
+    '-o',
+    outPath,
+    '--validate',
+    '--guance-promql-compatible',
+    '--keep-grafana-meta',
+  ])
+
+  assert.equal(result.status, 0, result.stderr || result.stdout)
+  assert.match(result.stdout, /Validated /)
+  assert.equal(fs.existsSync(outPath), true)
+
+  const actual = JSON.parse(fs.readFileSync(outPath, 'utf-8'))
+  assert.deepEqual(actual, expected)
+})
+
+test('cli writes default output file to current working directory', () => {
+  const tempDir = createTempDir()
+  const outPath = path.join(tempDir, 'guance-dashboard.json')
+  const grafanaDashboard = JSON.parse(fs.readFileSync(grafanaInputPath, 'utf-8'))
+  const expected = covert(grafanaDashboard)
+
+  const result = runCli(['-d', grafanaInputPath], { cwd: tempDir })
+
+  assert.equal(result.status, 0, result.stderr || result.stdout)
+  assert.equal(fs.existsSync(outPath), true)
+
+  const actual = JSON.parse(fs.readFileSync(outPath, 'utf-8'))
+  assert.deepEqual(actual, expected)
+})