25601018106

Committed 09 May 2026 12:22PM UTC coverage: 33.99% (-31.1%) from 65.107%

Build # 25601018106

Build Type

Pull #615

github

Committed by

web-flow

Commit Message

Merge 1ef509ec3 into 36e5af87e

Pull Request Pull Request #615: test: add unit tests for remaining app workers (#489)

Coverage Stats

788 of 3170 branches covered (24.86%)

Branch coverage included in aggregate %.

0 of 8 new or added lines in 2 files covered. (0.0%)

1822 existing lines in 87 files now uncovered.

2352 of 6068 relevant lines covered (38.76%)

13.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/cli/commands/dev.ts

import { confirm, isCancel, cancel } from '@clack/prompts'
import ora from 'ora'

import { runCleanDb } from '../../clean-db'
import { runCommand } from '../utils/process'
import { runStop } from './stop'

type DevOptions = {
  yes?: boolean
}

const ensureConfirmed = async (message: string, yes?: boolean): Promise<boolean> => {
  if (yes) {
    return true
  }

  if (!process.stdin.isTTY) {
    throw new Error('Interactive confirmation is unavailable. Re-run with --yes.')
  }

  const answer = await confirm({ message, initialValue: false })
  if (isCancel(answer)) {
    cancel('Operation cancelled')
    return false
  }

  return answer
}

const runWithSpinner = async (
  loadingText: string,
  successText: string,
  failureText: string,
  action: () => Promise<number>,
): Promise<number> => {
  const spinner = ora(loadingText).start()

  try {
    const code = await action()
    if (code === 0) {
      spinner.succeed(successText)
    } else {
      spinner.fail(failureText)
    }

    return code
  } catch (error) {
    spinner.fail(failureText)
    throw error
  }
}

export const runDevDbClean = async (rawArgs: string[], options: DevOptions = {}): Promise<number> => {
  if (rawArgs.length === 0) {
    const confirmed = await ensureConfirmed('Delete all events from the database?', options.yes)
    if (!confirmed) {
      return 1
    }

    return runWithSpinner('Cleaning database...', 'Database clean completed', 'Database clean failed', () =>
      runCleanDb(['--all', '--force']),
    )
  }

  return runWithSpinner('Cleaning database...', 'Database clean completed', 'Database clean failed', () =>
    runCleanDb(rawArgs),
  )
}

export const runDevDbReset = async (options: DevOptions): Promise<number> => {
  const confirmed = await ensureConfirmed('Reset database and rerun migrations?', options.yes)
  if (!confirmed) {
    return 1
  }

  const spinner = ora('Resetting database (rollback)...').start()

  let code = await runCommand('pnpm', ['run', 'db:migrate:rollback', '--', '--all'])
  if (code !== 0) {
    spinner.fail('Database reset failed during rollback')
    return code
  }

  spinner.text = 'Resetting database (migrate)...'
  code = await runCommand('pnpm', ['run', 'db:migrate'])
  if (code === 0) {
    spinner.succeed('Database reset completed')
  } else {
    spinner.fail('Database reset failed during migrate')
  }

  return code
}

export const runDevSeedRelay = async (): Promise<number> => {
  return runWithSpinner('Seeding relay data...', 'Relay seed completed', 'Relay seed failed', () =>
    runCommand('pnpm', ['run', 'db:seed']),
  )
}

export const runDevDockerClean = async (options: DevOptions): Promise<number> => {
  const confirmed = await ensureConfirmed('Run docker system prune and docker volume prune?', options.yes)
  if (!confirmed) {
    return 1
  }

  let code = await runStop({ all: true }, [])
  if (code !== 0) {
    return code
  }

  code = await runCommand('docker', ['system', 'prune', '-a', '-f'])
  if (code !== 0) {
    return code
  }

  return runCommand('docker', ['volume', 'prune', '-f'])
}

export const runDevTestUnit = async (): Promise<number> => {
  return runWithSpinner('Running unit tests...', 'Unit tests completed', 'Unit tests failed', () =>
    runCommand('pnpm', ['run', 'test:unit']),
  )
}

export const runDevTestCli = async (): Promise<number> => {
  return runWithSpinner('Running CLI tests...', 'CLI tests completed', 'CLI tests failed', () =>
    runCommand('pnpm', ['run', 'test:cli']),
  )
}

export const runDevTestIntegration = async (): Promise<number> => {
  return runWithSpinner(
    'Running integration tests...',
    'Integration tests completed',
    'Integration tests failed',
    () => runCommand('pnpm', ['run', 'test:integration']),
  )
}

export const runDevTestPerfConnection = async (): Promise<number> => {
  return runWithSpinner(
    'Running connection rate limit performance test...',
    'Connection rate limit test completed',
    'Connection rate limit test failed',
    () => runCommand('k6', ['run', 'test/performance/connection-limiting-k6.ts']),
  )
}

export const runDevTestPerfMessage = async (): Promise<number> => {
  return runWithSpinner(
    'Running message rate limit performance test...',
    'Message rate limit test completed',
    'Message rate limit test failed',
    () => runCommand('k6', ['run', 'test/performance/message-limiting-k6.ts']),
  )
}

UNCOV 1	import { confirm, isCancel, cancel } from '@clack/prompts'	×
UNCOV 2	import ora from 'ora'	×
3
UNCOV 4	import { runCleanDb } from '../../clean-db'	×
UNCOV 5	import { runCommand } from '../utils/process'	×
UNCOV 6	import { runStop } from './stop'	×
7
8	type DevOptions = {
9	yes?: boolean
10	}
11
UNCOV 12	const ensureConfirmed = async (message: string, yes?: boolean): Promise<boolean> => {	×
13	if (yes) {	×
14	return true	×
15	}
16
17	if (!process.stdin.isTTY) {	×
18	throw new Error('Interactive confirmation is unavailable. Re-run with --yes.')	×
19	}
20
21	const answer = await confirm({ message, initialValue: false })	×
22	if (isCancel(answer)) {	×
23	cancel('Operation cancelled')	×
24	return false	×
25	}
26
27	return answer	×
28	}
29
UNCOV 30	const runWithSpinner = async (	×
31	loadingText: string,
32	successText: string,
33	failureText: string,
34	action: () => Promise<number>,
35	): Promise<number> => {
36	const spinner = ora(loadingText).start()	×
37
38	try {	×
39	const code = await action()	×
40	if (code === 0) {	×
41	spinner.succeed(successText)	×
42	} else {
43	spinner.fail(failureText)	×
44	}
45
46	return code	×
47	} catch (error) {
48	spinner.fail(failureText)	×
49	throw error	×
50	}
51	}
52
UNCOV 53	export const runDevDbClean = async (rawArgs: string[], options: DevOptions = {}): Promise<number> => {	×
54	if (rawArgs.length === 0) {	×
55	const confirmed = await ensureConfirmed('Delete all events from the database?', options.yes)	×
56	if (!confirmed) {	×
57	return 1	×
58	}
59
60	return runWithSpinner('Cleaning database...', 'Database clean completed', 'Database clean failed', () =>	×
61	runCleanDb(['--all', '--force']),	×
62	)
63	}
64
65	return runWithSpinner('Cleaning database...', 'Database clean completed', 'Database clean failed', () =>	×
66	runCleanDb(rawArgs),	×
67	)
68	}
69
UNCOV 70	export const runDevDbReset = async (options: DevOptions): Promise<number> => {	×
71	const confirmed = await ensureConfirmed('Reset database and rerun migrations?', options.yes)	×
72	if (!confirmed) {	×
73	return 1	×
74	}
75
76	const spinner = ora('Resetting database (rollback)...').start()	×
77
78	let code = await runCommand('pnpm', ['run', 'db:migrate:rollback', '--', '--all'])	×
79	if (code !== 0) {	×
80	spinner.fail('Database reset failed during rollback')	×
81	return code	×
82	}
83
84	spinner.text = 'Resetting database (migrate)...'	×
85	code = await runCommand('pnpm', ['run', 'db:migrate'])	×
86	if (code === 0) {	×
87	spinner.succeed('Database reset completed')	×
88	} else {
89	spinner.fail('Database reset failed during migrate')	×
90	}
91
92	return code	×
93	}
94
UNCOV 95	export const runDevSeedRelay = async (): Promise<number> => {	×
96	return runWithSpinner('Seeding relay data...', 'Relay seed completed', 'Relay seed failed', () =>	×
97	runCommand('pnpm', ['run', 'db:seed']),	×
98	)
99	}
100
UNCOV 101	export const runDevDockerClean = async (options: DevOptions): Promise<number> => {	×
102	const confirmed = await ensureConfirmed('Run docker system prune and docker volume prune?', options.yes)	×
103	if (!confirmed) {	×
104	return 1	×
105	}
106
107	let code = await runStop({ all: true }, [])	×
108	if (code !== 0) {	×
109	return code	×
110	}
111
112	code = await runCommand('docker', ['system', 'prune', '-a', '-f'])	×
113	if (code !== 0) {	×
114	return code	×
115	}
116
117	return runCommand('docker', ['volume', 'prune', '-f'])	×
118	}
119
UNCOV 120	export const runDevTestUnit = async (): Promise<number> => {	×
121	return runWithSpinner('Running unit tests...', 'Unit tests completed', 'Unit tests failed', () =>	×
122	runCommand('pnpm', ['run', 'test:unit']),	×
123	)
124	}
125
UNCOV 126	export const runDevTestCli = async (): Promise<number> => {	×
127	return runWithSpinner('Running CLI tests...', 'CLI tests completed', 'CLI tests failed', () =>	×
128	runCommand('pnpm', ['run', 'test:cli']),	×
129	)
130	}
131
UNCOV 132	export const runDevTestIntegration = async (): Promise<number> => {	×
133	return runWithSpinner(	×
134	'Running integration tests...',
135	'Integration tests completed',
136	'Integration tests failed',
137	() => runCommand('pnpm', ['run', 'test:integration']),	×
138	)
139	}
140
UNCOV 141	export const runDevTestPerfConnection = async (): Promise<number> => {	×
142	return runWithSpinner(	×
143	'Running connection rate limit performance test...',
144	'Connection rate limit test completed',
145	'Connection rate limit test failed',
146	() => runCommand('k6', ['run', 'test/performance/connection-limiting-k6.ts']),	×
147	)
148	}
149
UNCOV 150	export const runDevTestPerfMessage = async (): Promise<number> => {	×
151	return runWithSpinner(	×
152	'Running message rate limit performance test...',
153	'Message rate limit test completed',
154	'Message rate limit test failed',
155	() => runCommand('k6', ['run', 'test/performance/message-limiting-k6.ts']),	×
156	)
157	}

cameri / nostream / 25601018106

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous