FilesExpand file tree

main

/

agent-session-runtime-end-record.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

174 lines (150 loc) · 7 KB

main

/

agent-session-runtime-end-record.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

174 lines (150 loc) · 7 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

// Record starts and graceful ends; only a known start without an end implies crash, never an unreadable record.

import { existsSync } from 'node:fs'

import { mkdir, mkdtemp, readdir, rm, utimes, writeFile } from 'node:fs/promises'

import { tmpdir } from 'node:os'

import { join } from 'node:path'

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

import type * as DurableFileWrite from '../durable-file-write'

const writes = vi.hoisted(() => ({ fail: false }))

vi.mock('../durable-file-write', async (importOriginal) => {

const actual = await importOriginal<typeof DurableFileWrite>()

return {

...actual,

writeFileDurableSync: (...args: Parameters<typeof actual.writeFileDurableSync>) => {

if (writes.fail) {

throw new Error('ENOSPC: no space left on device')

}

actual.writeFileDurableSync(...args)

}

}

})

import {

beginAgentSessionRuntimeRecord,

readAgentSessionRuntimeEnds,

recordAgentSessionRuntimeEnd,

recordAgentSessionRuntimeEndOnExit

} from './agent-session-runtime-end-record'

import {

tearDownRuntime,

type InstalledRuntime

} from './agent-session/structured-agent-session-runtime-teardown'

const RUNTIME_A = '0000000a-0000-4000-8000-000000000000'

const RUNTIME_B = '0000000b-0000-4000-8000-000000000000'

let directory: string

beforeEach(async () => {

writes.fail = false

directory = await mkdtemp(join(tmpdir(), 'orca-runtime-end-'))

})

afterEach(async () => {

await rm(directory, { recursive: true, force: true })

})

function runtimesDirectory(): string {

return join(directory, 'agent-session-runtimes')

}

describe('what a runtime records about itself', () => {

it('reads as a crash once it started and never ended', () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe('crash')

})

it.each(['quit', 'update'] as const)('reads as the %s it recorded as it ended', (trigger) => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

recordAgentSessionRuntimeEnd(trigger, 2)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe(trigger)

})

it('keeps the first end it recorded', () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

recordAgentSessionRuntimeEnd('update', 2)

recordAgentSessionRuntimeEnd('quit', 3)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe('update')

})

it('names no cause for a runtime it has no record of', () => {

expect(readAgentSessionRuntimeEnds(directory)).toEqual(new Map())

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

expect(readAgentSessionRuntimeEnds(directory)?.has(RUNTIME_B)).toBe(false)

})

it('names no cause for a record it cannot read, and the next start writes its own', async () => {

await mkdir(runtimesDirectory(), { recursive: true })

await writeFile(join(runtimesDirectory(), `${RUNTIME_A}.json`), '{not json')

expect(readAgentSessionRuntimeEnds(directory)?.has(RUNTIME_A)).toBe(false)

beginAgentSessionRuntimeRecord(directory, RUNTIME_B, 1)

recordAgentSessionRuntimeEnd('quit', 2)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_B)).toBe('quit')

})

it('names no cause when the records cannot be listed', async () => {

await writeFile(runtimesDirectory(), 'not a directory')

expect(readAgentSessionRuntimeEnds(directory)).toBeNull()

})

it('keeps only the newest records, so a pruned runtime names no cause', async () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

await utimes(join(runtimesDirectory(), `${RUNTIME_A}.json`), 1, 1)

for (let index = 0; index < 16; index += 1) {

beginAgentSessionRuntimeRecord(

directory,

`00000000-0000-4000-8000-${String(index).padStart(12, '0')}`,

index

)

}

const ends = readAgentSessionRuntimeEnds(directory)

expect(ends?.size).toBe(16)

expect(ends?.has(RUNTIME_A)).toBe(false)

})

it("never loses another runtime's record to its own writes", () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

beginAgentSessionRuntimeRecord(directory, RUNTIME_B, 2)

recordAgentSessionRuntimeEnd('quit', 3)

expect(readAgentSessionRuntimeEnds(directory)).toEqual(

new Map([

[RUNTIME_A, 'crash'],

[RUNTIME_B, 'quit']

])

)

})

it('never fails the exit when it cannot be written', async () => {

await writeFile(runtimesDirectory(), 'not a directory')

expect(() => beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)).not.toThrow()

expect(() => recordAgentSessionRuntimeEnd('quit', 2)).not.toThrow()

})

it('keeps its end when the same runtime records its start again during the quit', () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

recordAgentSessionRuntimeEnd('update', 2)

// Reinstallation during quit must not erase the already-recorded end.

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 3)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe('update')

})

it('names no cause, rather than a crash, when its end could not be written', () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

writes.fail = true

recordAgentSessionRuntimeEnd('quit', 2)

expect(readAgentSessionRuntimeEnds(directory)?.has(RUNTIME_A)).toBe(false)

})

it('reads a clean process exit nothing else recorded as a quit, and any other exit as nothing', () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

expect(process.listeners('exit')).toContain(recordAgentSessionRuntimeEndOnExit)

recordAgentSessionRuntimeEndOnExit(1)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe('crash')

recordAgentSessionRuntimeEndOnExit(0)

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe('quit')

})

it('leaves no temp files behind', async () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

recordAgentSessionRuntimeEnd('quit', 2)

expect(await readdir(runtimesDirectory())).toEqual([`${RUNTIME_A}.json`])

})

})

describe('a quit', () => {

it('records its end before it waits on anything, so a quit that never finishes is still a quit', () => {

beginAgentSessionRuntimeRecord(directory, RUNTIME_A, 1)

const installed = {

host: { stopDelivery: vi.fn(), flushAllStreamedEvents: vi.fn() },

adapter: { closeAll: vi.fn() },

journalDatabase: { stateDirectory: directory, close: vi.fn() },

// A stuck recovery reaches the process quit deadline.

waitForRecovery: () => new Promise<void>(() => {})

}

// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: teardown reads only the members stubbed above before it parks on the recovery wait.

void tearDownRuntime(installed as unknown as InstalledRuntime, 'update')

expect(readAgentSessionRuntimeEnds(directory)?.get(RUNTIME_A)).toBe('update')

expect(installed.host.flushAllStreamedEvents).not.toHaveBeenCalled()

expect(existsSync(join(runtimesDirectory(), `${RUNTIME_A}.json`))).toBe(true)

})

})