import test from 'node:test'
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import ts from 'typescript'
import * as vue from 'vue'
import { compileScript, parse } from '@vue/compiler-sfc'

function evaluate(source, imports = {}) {
  const compiled = ts.transpileModule(source, {
    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS }
  }).outputText
  const module = { exports: {} }
  new Function('require', 'module', 'exports', compiled)(
    (name) => {
      assert.ok(imports[name], `Unexpected dependency: ${name}`)
      return imports[name]
    },
    module,
    module.exports
  )
  return module.exports
}
const source = (path) => readFileSync(path, 'utf8')
const format = evaluate(source('src/utils/business/format.ts'))
const utils = evaluate(source('src/utils/business/gateway.ts'), { './format': format })
const constants = evaluate(source('src/config/constants/gateway.ts'))
const permissions = constants.GATEWAY_PERMISSIONS
const rule = {
  category: 'business',
  keyword: 'failed',
  match_type: 'contains',
  priority: 10,
  status: 1,
  operations: ['stop']
}
const group = {
  group_code: 'default',
  group_name: '默认组',
  max_qps: 20,
  reserved_qps: 5,
  operations: ['stop', 'start'],
  high_priority_operations: ['stop'],
  status: 1
}
const option = (value) => ({ value, label: `动态-${value}` })
const options = {
  error_categories: ['business', 'terminal'].map(option),
  exempt_sources: ['manual'].map(option),
  gateway_operations: ['stop', 'start', 'query_flow', 'query_status', 'query_realname'].map(option),
  match_types: ['contains', 'prefix', 'regex'].map(option),
  rate_limit_modes: ['default'].map(option),
  stop_resume_actions: ['stop', 'start'].map(option),
  stop_resume_results: ['success', 'failed', 'unknown', 'already_target', 'skipped'].map(option)
}
const success = (data) => ({ code: 0, data, msg: 'ok' })
const page = (items) => success({ items, total: items.length, page: 1, size: 20 })
const deferred = () => {
  let resolve
  const promise = new Promise((done) => {
    resolve = done
  })
  return { promise, resolve }
}
async function flush() {
  await new Promise((done) => setImmediate(done))
  await vue.nextTick()
}

test('all 17 gateway service contracts preserve methods, paths, params and response', async () => {
  const calls = []
  const response = success({ marker: true })
  const http = Object.fromEntries(
    ['get', 'post', 'put', 'del'].map((method) => [
      method,
      (args) => {
        calls.push({ method, ...args })
        return Promise.resolve(response)
      }
    ])
  )
  const base = evaluate(source('src/api/BaseService.ts'), { '@/utils/http': { default: http } })
  const { GatewayService: service } = evaluate(source('src/api/modules/gateway.ts'), {
    '../BaseService': base
  })
  const recordsQuery = {
    page: 2,
    page_size: 100,
    carrier_id: 0,
    start_time: '2026-10-01T00:00:00Z',
    end_time: '2026-10-24T00:00:00Z'
  }
  const contracts = [
    ['getRecords', [recordsQuery], 'get', '/card-stop-resume-records', 'params', recordsQuery],
    [
      'getCardRecords',
      [42, { page: 1 }],
      'get',
      '/iot-cards/42/stop-resume-records',
      'params',
      { page: 1 }
    ],
    ['getRules', [{ status: 0 }], 'get', '/gateway-error-classifications', 'params', { status: 0 }],
    ['createRule', [rule], 'post', '/gateway-error-classifications', 'data', rule],
    ['updateRule', [7, rule], 'put', '/gateway-error-classifications/7', 'data', rule],
    [
      'setRuleStatus',
      [7, 0],
      'put',
      '/gateway-error-classifications/7/status',
      'data',
      { status: 0 }
    ],
    ['deleteRule', [7], 'del', '/gateway-error-classifications/7', 'params', undefined],
    [
      'testRule',
      [{ operation: 'stop', message: 'failed', draft: rule }],
      'post',
      '/gateway-error-classifications/test',
      'data',
      { operation: 'stop', message: 'failed', draft: rule }
    ],
    ['getOptions', [], 'get', '/polling-options', 'params', undefined],
    [
      'getGroups',
      [{ only_global: false, carrier_id: 0, status: 0 }],
      'get',
      '/polling-rate-limit-groups',
      'params',
      { only_global: false, carrier_id: 0, status: 0 }
    ],
    ['createGroup', [group], 'post', '/polling-rate-limit-groups', 'data', group],
    ['getGroup', [4], 'get', '/polling-rate-limit-groups/4', 'params', undefined],
    ['updateGroup', [4, group], 'put', '/polling-rate-limit-groups/4', 'data', group],
    ['setGroupStatus', [4, 1], 'put', '/polling-rate-limit-groups/4/status', 'data', { status: 1 }],
    ['deleteGroup', [4], 'del', '/polling-rate-limit-groups/4', 'params', undefined],
    ['getCarrierStats', [60], 'get', '/polling-stats/carriers', 'params', { minutes: 60 }],
    [
      'getCarrierTrend',
      [0, { minutes: 10080, bucket_minutes: 60 }],
      'get',
      '/polling-stats/carriers/0/trend',
      'params',
      { minutes: 10080, bucket_minutes: 60 }
    ]
  ]
  for (const [method, args, verb, url, field, payload] of contracts) {
    assert.equal(await service[method](...args), response)
    assert.deepEqual(calls.at(-1), { method: verb, url: `/api/admin${url}`, [field]: payload })
  }
  assert.equal(calls.length, 17)
})

test('record dates are RFC3339, ordered and bounded to 31 days, optional only for cards', () => {
  assert.deepEqual(utils.gatewayTimeRange(['2026-10-01T08:00:00+08:00', '2026-11-01T00:00:00Z']), {
    start_time: '2026-10-01T00:00:00.000Z',
    end_time: '2026-11-01T00:00:00.000Z'
  })
  assert.deepEqual(utils.gatewayTimeRange(null, false), {})
  for (const range of [
    null,
    [],
    [''],
    ['invalid', 'invalid'],
    ['2026-10-02', '2026-10-01'],
    ['2026-10-01', '2026-11-01T00:00:00.001Z']
  ])
    assert.throws(() => utils.gatewayTimeRange(range))
  const [start, end] = utils.recentGatewayRange()
  assert.equal(end - start, 7 * 86400000)
})

test('limit groups validate QPS, operation subset, carrier zero and text limits', () => {
  assert.doesNotThrow(() => utils.validateGatewayGroup({ ...group, carrier_id: 0 }))
  assert.doesNotThrow(() =>
    utils.validateGatewayGroup({ ...group, reserved_qps: 0, high_priority_operations: [] })
  )
  for (const patch of [
    { max_qps: 0 },
    { max_qps: 10001 },
    { max_qps: 1.5 },
    { reserved_qps: -1 },
    { reserved_qps: 20 },
    { reserved_qps: 0.5 },
    { operations: [] },
    { high_priority_operations: [] },
    { high_priority_operations: ['query_flow'] },
    { group_code: ' ' },
    { group_name: 'x'.repeat(101) },
    { carrier_id: -1 }
  ])
    assert.throws(() => utils.validateGatewayGroup({ ...group, ...patch }))
})

test('rules validate required fields, priority and lengths, including draft rules', () => {
  assert.doesNotThrow(() => utils.validateGatewayRule(rule))
  for (const patch of [
    { keyword: ' ' },
    { keyword: 'x'.repeat(201) },
    { category: '' },
    { match_type: '' },
    { priority: 0 },
    { priority: 10001 },
    { priority: 1.2 },
    { remark: 'x'.repeat(501) }
  ])
    assert.throws(() => utils.validateGatewayRule({ ...rule, ...patch }))
})

test('unknown enums and statistic fields remain visible, without fabricated zeroes', () => {
  assert.equal(utils.gatewayLabel(options.gateway_operations, 'stop'), '动态-stop')
  assert.equal(
    utils.gatewayLabel(options.gateway_operations, 'future_operation'),
    'future_operation'
  )
  assert.equal(utils.gatewayValue(0), '0')
  assert.equal(utils.gatewayValue(false), 'false')
  assert.equal(utils.gatewayValue(null), '-')
  assert.deepEqual(utils.gatewayRows([{ future_metric: 12 }, 0, null]), [
    { future_metric: 12 },
    { value: 0 },
    { value: null }
  ])
  assert.deepEqual(
    utils.compactGatewayQuery({
      carrier_id: 0,
      status: 0,
      only_global: false,
      blank: '',
      missing: undefined
    }),
    { carrier_id: 0, status: 0, only_global: false }
  )
  assert.throws(() => utils.gatewayData({ code: 403, msg: '没有权限' }), /没有权限/)
})

function mountComponent(
  t,
  path,
  { superAdmin = false, perms = [], overrides = {}, props = {} } = {}
) {
  const calls = []
  const user = vue.reactive({ isSuperAdmin: superAdmin, perms })
  const service = Object.fromEntries(
    ['getRecords', 'getCardRecords', 'getRules', 'getGroups'].map((name) => [
      name,
      async (...args) => {
        calls.push({ name, args })
        return page([])
      }
    ])
  )
  Object.assign(service, { getOptions: async () => success(options) })
  for (const name of [
    'createRule',
    'updateRule',
    'setRuleStatus',
    'deleteRule',
    'testRule',
    'createGroup',
    'updateGroup',
    'setGroupStatus',
    'deleteGroup',
    'getGroup',
    'getCarrierStats',
    'getCarrierTrend'
  ])
    service[name] = async (...args) => {
      calls.push({ name, args })
      return success({
        ...group,
        id: 4,
        matched: true,
        rule_id: 0,
        category: 'business',
        category_name: '业务错误',
        keyword: 'failed',
        maybe_accepted: false,
        carriers: [],
        points: [],
        carrier_id: args[0]
      })
    }
  for (const [name, handler] of Object.entries(overrides))
    service[name] = async (...args) => {
      calls.push({ name, args })
      return handler(...args)
    }
  const imports = {
    vue,
    'vue-router': {
      useRouter: () => ({
        push: async (url) => {
          calls.push({ name: 'navigate', args: [url] })
        },
        back() {}
      }),
      useRoute: () => ({ params: { id: '4' } })
    },
    '@vueuse/core': { useWindowSize: () => ({ width: vue.ref(1200) }) },
    '@element-plus/icons-vue': { ArrowLeft: {} },
    '@/router/routesAlias': {
      RoutesAlias: { GatewayRateLimitGroupDetail: '/polling-management/rate-limit-groups/detail' }
    },
    '@/utils/business/format': format,
    '@/api/modules/carrier': {
      CarrierService: {
        getCarriers: async (...args) => {
          calls.push({ name: 'getCarriers', args })
          if (overrides.getCarriers) return overrides.getCarriers(...args)
          return page([{ id: 8, carrier_name: '模拟运营商' }])
        }
      }
    },
    'element-plus': {
      ElMessage: { success() {}, error() {} },
      ElMessageBox: { confirm: async () => {} }
    },
    '@/api/modules/gateway': { GatewayService: service },
    '@/store/modules/user': { useUserStore: () => user },
    '@/composables/useAuth': {
      useAuth: () => ({ hasAuth: (perm) => user.isSuperAdmin || user.perms.includes(perm) })
    },
    '@/config/constants/gateway': constants,
    '@/utils/business/gateway': utils,
    '@/components/business/gateway/GatewayOptionsNotice.vue': { default: {} },
    '@/components/business/gateway/GatewayRuleFields.vue': { default: {} },
    '@/components/business/gateway/GatewayDynamicData.vue': { default: {} },
    './GatewayOptionsNotice.vue': { default: {} }
  }
  imports['@/composables/useGateway'] = evaluate(source('src/composables/useGateway.ts'), imports)
  const { descriptor } = parse(source(path))
  const component = evaluate(
    compileScript(descriptor, { id: 'gateway-test' }).content,
    imports
  ).default
  let state
  const reactiveProps = vue.reactive(props)
  const renderer = vue.createRenderer({
    createComment: () => ({}),
    insert() {},
    remove() {},
    parentNode: () => null,
    nextSibling: () => null
  })
  const app = renderer.createApp({
    setup() {
      state = component.setup(reactiveProps, { expose() {}, emit() {} })
      return () => null
    }
  })
  app.mount({})
  t.after(() => app.unmount())
  return { state, calls, user, props: reactiveProps, service }
}
const rulePage = 'src/views/polling-management/error-classifications/index.vue'
const groupPage = 'src/views/polling-management/rate-limit-groups/index.vue'
const statsPage = 'src/views/polling-management/gateway-stats/index.vue'
const recordComponent = 'src/components/business/gateway/StopResumeRecords.vue'

test('ordinary users cannot maintain either rules or groups, even if handlers are called', async (t) => {
  for (const [path, area, save, mutate, input] of [
    [rulePage, 'rules', 'saveRule', 'changeRule', rule],
    [groupPage, 'groups', 'saveGroup', 'changeGroup', group]
  ]) {
    const { state, calls } = mountComponent(t, path, { perms: [permissions[area].page] })
    await flush()
    state.form.value = input
    await state[save]()
    await state[mutate]({ ...input, id: 1 }, true)
    assert.equal(
      calls.filter((call) => /create|update|delete|set.*Status/.test(call.name)).length,
      0
    )
    assert.match(state.editorError.value, /无权/)
  }
})

test('superadmin saves use write DTOs without record ids or timestamps', async (t) => {
  for (const [path, save, input, method] of [
    [rulePage, 'saveRule', rule, 'createRule'],
    [groupPage, 'saveGroup', group, 'createGroup']
  ]) {
    const { state, calls } = mountComponent(t, path, { superAdmin: true })
    await flush()
    state.form.value = { ...input }
    await state[save]()
    const call = calls.find((call) => call.name === method)
    assert.ok(call)
    assert.equal(call.args[0].id, undefined)
    if (method === 'createGroup') assert.equal(call.args[0].carrier_id, null)
    assert.equal(state.editorError.value, '')
  }
})

test('ordinary rule tests require page + button, validate drafts, and never write rules', async (t) => {
  const { state, calls, user } = mountComponent(t, rulePage, {
    perms: [permissions.rules.page, permissions.rules.test]
  })
  await flush()
  state.openTest()
  state.testForm.operation = 'stop'
  state.testForm.message = 'failed'
  state.includeDraft.value = true
  await state.runTest()
  assert.equal(calls.filter((call) => call.name === 'testRule').length, 0)
  state.draft.value = { ...rule }
  await state.runTest()
  assert.deepEqual(calls.find((call) => call.name === 'testRule').args[0], {
    operation: 'stop',
    message: 'failed',
    draft: rule
  })
  assert.equal(state.testResult.value.matched, true)
  user.perms = [permissions.rules.test]
  await state.runTest()
  assert.match(state.testError.value, /无权/)
  assert.equal(calls.filter((call) => call.name === 'testRule').length, 1)
})

test('test close/reopen discards a pending result', async (t) => {
  const pending = deferred()
  const { state } = mountComponent(t, rulePage, {
    superAdmin: true,
    overrides: { testRule: () => pending.promise }
  })
  await flush()
  state.openTest()
  Object.assign(state.testForm, { operation: 'stop', message: 'failed' })
  const running = state.runTest()
  state.testVisible.value = false
  await vue.nextTick()
  state.openTest()
  pending.resolve(success({ matched: true }))
  await running
  assert.equal(state.testResult.value, null)
})

test('enum failure is visible, blocks editing and can be retried with dynamic labels', async (t) => {
  let failed = true
  const { state } = mountComponent(t, rulePage, {
    superAdmin: true,
    overrides: {
      getOptions: () => (failed ? Promise.reject(new Error('枚举不可用')) : success(options))
    }
  })
  await flush()
  assert.equal(state.optionsReady.value, false)
  assert.match(state.optionsError.value, /枚举不可用/)
  state.openEditor()
  assert.equal(state.editorVisible.value, false)
  failed = false
  await state.loadOptions()
  assert.equal(state.optionsReady.value, true)
  assert.equal(state.label('gateway_operations', 'stop'), '动态-stop')
})

test('record queries validate time, preserve zero filters and isolate cards by real ID', async (t) => {
  const { state, calls, props } = mountComponent(t, recordComponent, {
    perms: [permissions.cardHistory],
    props: { cardId: 42, permission: permissions.cardHistory }
  })
  await flush()
  assert.equal(calls[0].name, 'getCardRecords')
  assert.equal(calls[0].args[0], 42)
  state.range.value = null
  await state.search()
  assert.deepEqual(calls.at(-1).args, [42, { page: 1, page_size: 20 }])
  props.cardId = 43
  await flush()
  assert.equal(calls.at(-1).args[0], 43)
  props.cardId = undefined
  props.permission = permissions.records.page
  await flush()
  assert.match(state.error.value, /无权/)
})

test('invalid global date ranges never request records; zero carrier survives', async (t) => {
  const { state, calls } = mountComponent(t, recordComponent, {
    perms: [permissions.records.page],
    props: { permission: permissions.records.page }
  })
  await flush()
  calls.length = 0
  state.range.value = null
  await state.search()
  assert.equal(calls.length, 0)
  state.range.value = [new Date('2026-10-01'), new Date('2026-10-24')]
  state.filters.carrier_id = 0
  await state.search()
  assert.equal(calls[0].args[0].carrier_id, 0)
})

test('list latest request wins and errors clear previous records', async (t) => {
  const first = deferred()
  const second = deferred()
  let count = 0
  const { state } = mountComponent(t, groupPage, {
    superAdmin: true,
    overrides: { getGroups: () => (++count === 1 ? first.promise : second.promise) }
  })
  const latest = state.load()
  second.resolve(page([{ ...group, id: 2 }]))
  await latest
  first.resolve(page([{ ...group, id: 1 }]))
  await flush()
  assert.equal(state.rows.value[0].id, 2)
})

test('group details require permissions before navigation to shop-style detail page', async (t) => {
  const { state, calls, user } = mountComponent(t, groupPage, { perms: [permissions.groups.page] })
  await flush()
  await state.openDetail(4)
  assert.equal(
    calls.some((call) => call.name === 'navigate'),
    false
  )
  user.perms.push(permissions.groups.detail)
  await state.openDetail(4)
  assert.equal(
    calls.find((call) => call.name === 'navigate').args[0],
    '/polling-management/rate-limit-groups/detail/4'
  )
})

test('statistics support account 0, reject bad bounds and retain raw unknown metrics', async (t) => {
  const { state, calls } = mountComponent(t, statsPage, {
    perms: [permissions.stats.page, permissions.stats.trend],
    overrides: {
      getCarrierTrend: (id) =>
        success({ carrier_id: id, points: [{ new_metric: 9, future_time: '2026-10-24' }] })
    }
  })
  await flush()
  state.carrierId.value = 0
  await state.loadTrend()
  assert.equal(state.trend.value.carrier_id, 0)
  assert.equal(state.trend.value.points[0].new_metric, 9)
  state.trendMinutes.value = 10081
  await state.loadTrend()
  assert.equal(calls.filter((call) => call.name === 'getCarrierTrend').length, 1)
  state.summaryMinutes.value = 61
  await state.loadSummary()
  assert.equal(calls.filter((call) => call.name === 'getCarrierStats').length, 1)
  assert.equal(state.trend.value, null)
})

test('route aliases match all four pages and ordinary permissions use colon codes', () => {
  const routes = source('src/router/routes/asyncRoutes.ts')
  const aliases = source('src/router/routesAlias.ts')
  for (const [name, segment] of [
    ['GatewayStopResumeRecords', 'stop-resume-records'],
    ['GatewayErrorClassifications', 'error-classifications'],
    ['GatewayRateLimitGroups', 'rate-limit-groups'],
    ['GatewayCallStats', 'gateway-stats']
  ]) {
    assert.ok(routes.includes(`name: '${name}'`))
    assert.ok(aliases.includes(`'/polling-management/${segment}'`))
    assert.ok(source(`src/views/polling-management/${segment}/index.vue`))
  }
  const flattened = Object.values(permissions).flatMap((value) =>
    typeof value === 'string' ? [value] : Object.values(value)
  )
  assert.equal(flattened.length, 10)
  for (const code of flattened) assert.match(code, /^[a-z_]+:[a-z_]+$/)
})

test('detail page checks permission and formats dates using the shop formatter', async (t) => {
  const path = 'src/views/polling-management/rate-limit-groups/detail.vue'
  const denied = mountComponent(t, path)
  await flush()
  assert.equal(
    denied.calls.some((call) => call.name === 'getGroup'),
    false
  )
  const allowed = mountComponent(t, path, { perms: [permissions.groups.detailPage] })
  await flush()
  assert.equal(allowed.state.detail.value.id, 4)
  assert.equal(allowed.state.formatDateTime('2026-10-24T10:00:00+08:00'), '2026-10-24 10:00:00')
})

test('gateway search expand toggles follow the >=4 rule', () => {
  for (const path of [recordComponent, rulePage, groupPage, statsPage]) {
    const matches = [...source(path).matchAll(/:show-expand="([^"]+)"/g)]
    assert.ok(matches.length)
    for (const match of matches) assert.match(match[1], /\.length >= 4$/)
  }
})

test('record time picker matches expiring assets estimated-expiry range configuration', async (t) => {
  const { descriptor } = parse(source('src/views/asset-management/expiring-assets/index.vue'))
  const script = ts.createSourceFile(
    'expiring-assets.ts',
    descriptor.scriptSetup.content,
    ts.ScriptTarget.Latest,
    true,
    ts.ScriptKind.TS
  )
  let reference
  function visit(node) {
    if (
      ts.isObjectLiteralExpression(node) &&
      node.properties.some(
        (property) =>
          ts.isPropertyAssignment(property) &&
          property.name.getText(script) === 'label' &&
          ts.isStringLiteral(property.initializer) &&
          property.initializer.text === '预计到期起止'
      )
    ) {
      reference = evaluate(`export const item = ${node.getText(script)}`).item
    }
    ts.forEachChild(node, visit)
  }
  visit(script)
  assert.ok(reference)
  const { state } = mountComponent(t, recordComponent, {
    perms: [permissions.records.page],
    props: { permission: permissions.records.page }
  })
  await flush()
  const item = state.searchItems.value.find((item) => item.prop === 'range')
  assert.equal(item.type, reference.type)
  assert.equal(item.elColSpan, reference.elColSpan)
  assert.deepEqual(item.config, reference.config)
  assert.equal(item.label, '记录时间')
})

test('business timestamps match shop list formatting and IDs retain zero', () => {
  const timestamp = '2026-10-24T10:00:00+08:00'
  assert.equal(utils.gatewayDisplayValue(timestamp, 'created_at'), format.formatDateTime(timestamp))
  assert.equal(
    utils.gatewayDisplayValue({ created_at: timestamp }),
    '{"created_at":"2026-10-24 10:00:00"}'
  )
  assert.equal(
    utils.gatewayDisplayValue(1792807200, 'timestamp'),
    format.formatDateTime(1792807200)
  )
  assert.equal(utils.gatewayDisplayValue(0, 'duration_ms'), '0')
  assert.equal(utils.gatewayOptionalId('0'), 0)
  assert.equal(utils.gatewayOptionalId(''), undefined)
  assert.throws(() => utils.gatewayOptionalId('-1'))
})

test('carrier name search uses exact backend parameters and remembers edit labels', async (t) => {
  const { state, calls } = mountComponent(t, groupPage, { superAdmin: true })
  await flush()
  await state.searchCarriers('运营商名称')
  assert.deepEqual(calls.at(-1), {
    name: 'getCarriers',
    args: [{ page: 1, page_size: 20, carrier_name: '运营商名称' }]
  })
  state.openEditor({ ...group, id: 7, carrier_id: 99, carrier_name: '原账户' })
  assert.equal(state.carrierOptions.value.find((option) => option.value === 99).label, '原账户')
  assert.equal(state.form.value.carrier_id, 99)
  assert.equal(state.searchItems.value[0].label, '运营商账户')
  assert.equal(state.searchItems.value[0].type, 'select')
})

test('carrier search ignores a late old response and retains selected account labels', async (t) => {
  const older = deferred()
  const { state } = mountComponent(t, groupPage, {
    superAdmin: true,
    overrides: {
      getCarriers: ({ carrier_name }) =>
        carrier_name === 'old' ? older.promise : page([{ id: 8, carrier_name: '新账户' }])
    }
  })
  await flush()
  const first = state.searchCarriers('old')
  await state.searchCarriers('new')
  state.selectCarrier(8)
  older.resolve(page([{ id: 9, carrier_name: '旧账户' }]))
  await first
  assert.equal(
    state.carrierOptions.value.some((option) => option.value === 9),
    false
  )
  assert.equal(state.carrierOptions.value.find((option) => option.value === 8).label, '新账户')
})

test('duplicate maintenance submits cannot send a second write while saving', async (t) => {
  const pending = deferred()
  const { state, calls } = mountComponent(t, rulePage, {
    superAdmin: true,
    overrides: { createRule: () => pending.promise }
  })
  await flush()
  state.form.value = { ...rule }
  const first = state.saveRule()
  await state.saveRule()
  assert.equal(calls.filter((call) => call.name === 'createRule').length, 1)
  pending.resolve(success(rule))
  await first
})

test('single-card history entry rejects missing IDs, other assets and denied permissions', () => {
  const text = source('src/views/asset-management/asset-information/index.vue')
  const functionText = text.match(/ {2}function showStopResumeRecords[\s\S]*?\n {2}}/)[0]
  const { create } = evaluate(
    `export const create = (cardInfo, hasAuth, stopResumePermission, stopResumeTarget, stopResumeVisible) => { ${functionText}; return showStopResumeRecords }`
  )
  const asset = vue.ref({
    asset_type: 'device',
    asset_id: 100,
    cards: [{ card_id: 42, iccid: 'CARD' }]
  })
  const target = vue.ref(null)
  const visible = vue.ref(false)
  let allowed = false
  const open = create(asset, () => allowed, vue.ref(permissions.deviceCardHistory), target, visible)
  open({ cardId: 42, iccid: 'CARD' })
  assert.equal(visible.value, false)
  allowed = true
  open({ cardId: 100, iccid: 'CARD' })
  assert.equal(visible.value, false)
  open({ cardId: 42, iccid: 'CARD' })
  assert.equal(target.value.cardId, 42)
  assert.equal(visible.value, true)
  visible.value = false
  asset.value = { asset_type: 'card', asset_id: 7, iccid: 'CARD-7' }
  open({ cardId: 42, iccid: 'CARD' })
  assert.equal(visible.value, false)
  open({ cardId: 7, iccid: 'CARD-7' })
  assert.equal(target.value.cardId, 7)
})