| import type { Args } from 'claude-code' |
| import { describe, expect, mock, test, tier } from 'claude-code/testing' |
|
|
| import Fixtures from './fixtures' |
|
|
| tier('builtin') |
|
|
| describe('register', () => { |
| test( |
| 'a $.telemetry.log call from a plugin posts one first-party row', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| mock.env(on, { USER_TYPE: 'ant' }) |
|
|
| const posts = Fixtures.firstPartySession(on) |
|
|
| expect( |
| await $.command.run(Fixtures.record(Fixtures.surveyAnswer())), |
| ).toEqual({ text: 'sent' }) |
|
|
| expect( |
| posts.map(post => [post.url, post.init?.method, post.init?.auth]), |
| ).toEqual([ |
| [ |
| 'https://api.anthropic.com/api/event_logging/v2/batch', |
| 'POST', |
| 'the-handle', |
| ], |
| ]) |
|
|
| expect(posts.map(Fixtures.rowOf)).toEqual([ |
| { |
| event_type: 'ClaudeCodeInternalEvent', |
| hasTimestamp: true, |
| event_name: 'tengu_plugin_survey_answered', |
| session_id: 'the-session', |
| model: 'the-model', |
| user_type: 'ant', |
| metadata: { answer: 2, page: 'ready', seen: true }, |
| }, |
| ]) |
| }, |
| ) |
|
|
| test( |
| 'a row already named tengu_ is sent under its own name', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| mock.env(on, {}) |
|
|
| const posts = Fixtures.firstPartySession(on) |
|
|
| await $.command.run( |
| Fixtures.record({ |
| ...Fixtures.surveyAnswer(), |
| event: 'tengu_repl_diff_panel_shown', |
| }), |
| ) |
|
|
| expect(posts.map(Fixtures.batchOf)).toMatchObject([ |
| { |
| events: [ |
| { |
| event_data: { |
| event_name: 'tengu_repl_diff_panel_shown', |
| user_type: 'external', |
| }, |
| }, |
| ], |
| }, |
| ]) |
| }, |
| ) |
|
|
| test( |
| 'nothing is sent where any switch has analytics off', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| let environment: Readonly<Record<string, string>> = {} |
|
|
| on('env.get', ($, e) => ({ value: environment[e.name] })) |
|
|
| const posts = Fixtures.firstPartySession(on) |
| const answers: (string | undefined)[] = [] |
|
|
| for (const off of Fixtures.ANALYTICS_OFF_ENVIRONMENTS) { |
| environment = { USER_TYPE: 'ant', ...off } |
|
|
| answers.push( |
| (await $.command.run(Fixtures.record(Fixtures.surveyAnswer()))).text, |
| ) |
| } |
|
|
| const withheld = posts.length |
|
|
| environment = { USER_TYPE: 'ant' } |
|
|
| await $.command.run(Fixtures.record(Fixtures.surveyAnswer())) |
|
|
| expect(answers).toEqual( |
| Fixtures.ANALYTICS_OFF_ENVIRONMENTS.map(() => 'sent'), |
| ) |
|
|
| expect(withheld, 'nothing posted while any switch was off').toBe(0) |
| expect(posts, 'then one row once every switch is clear').toHaveLength(1) |
| }, |
| ) |
|
|
| test( |
| 'a third-party provider the host manages sends nothing too', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| mock.env(on, { |
| CLAUDE_CODE_USE_BEDROCK: '1', |
| CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: '1', |
| }) |
|
|
| const posts = Fixtures.firstPartySession(on) |
|
|
| const { text } = await $.command.run( |
| Fixtures.record(Fixtures.surveyAnswer()), |
| ) |
|
|
| expect({ text, posts }).toEqual({ text: 'sent', posts: [] }) |
| }, |
| ) |
|
|
| test( |
| 'a $.telemetry.mark call posts the feature row by its own name', |
| { plugins: [Fixtures.marking] }, |
| async ($, on) => { |
| mock.env(on, { USER_TYPE: 'ant' }) |
|
|
| const posts = Fixtures.firstPartySession(on) |
| const answers: (string | undefined)[] = [] |
|
|
| for (const entry of [ |
| { feature: 'learn_page', kind: 'ok' }, |
| { feature: 'learn_page', kind: 'sad', reason: 'blocked' }, |
| { feature: 'suggest_learning', kind: 'bad', reason: 'api_error' }, |
| ]) { |
| answers.push((await $.command.run(Fixtures.mark(entry))).text) |
| } |
|
|
| expect(answers).toEqual(['sent', 'sent', 'sent']) |
|
|
| expect( |
| posts.map(Fixtures.rowOf), |
| 'the feature events by their own names, no plugin prefix', |
| ).toMatchObject([ |
| { |
| event_name: 'tengu_feature_ok', |
| metadata: { feature_name: 'learn_page' }, |
| }, |
| { |
| event_name: 'tengu_feature_sad', |
| metadata: { feature_name: 'learn_page', error_code: 'blocked' }, |
| }, |
| { |
| event_name: 'tengu_feature_bad', |
| metadata: { |
| feature_name: 'suggest_learning', |
| error_code: 'api_error', |
| }, |
| }, |
| ]) |
| }, |
| ) |
|
|
| test( |
| 'a mark with a bad kind or a wrong reason is refused, nothing sent', |
| { plugins: [Fixtures.marking] }, |
| async ($, on) => { |
| mock.env(on, { USER_TYPE: 'ant' }) |
|
|
| const posts = Fixtures.firstPartySession(on) |
|
|
| const refusalFor = async (entry: unknown) => |
| (await $.command.run(Fixtures.mark(entry))).text |
|
|
| expect( |
| await refusalFor({ feature: 'learn_page', kind: 'meh' }), |
| ).toEndWith("$.telemetry.mark: kind: 'ok', 'sad' or 'bad'") |
|
|
| expect( |
| await refusalFor({ feature: 'learn_page', kind: 'bad' }), |
| ).toEndWith( |
| '$.telemetry.mark: reason: a bad mark names why, a snake_case token', |
| ) |
|
|
| expect( |
| await refusalFor({ feature: 'learn_page', kind: 'ok', reason: 'x' }), |
| ).toEndWith('$.telemetry.mark: reason: an ok mark carries none') |
|
|
| expect(await refusalFor({ feature: 'Learn Page', kind: 'ok' })).toEndWith( |
| '$.telemetry.mark: takes a feature name, a snake_case token', |
| ) |
|
|
| expect(await refusalFor('x')).toEndWith( |
| '$.telemetry.mark: takes one entry, { feature, kind, reason?, props? }', |
| ) |
|
|
| expect(posts).toEqual([]) |
| }, |
| ) |
|
|
| test( |
| 'a session with no first-party credential is refused, nothing sent', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| mock.env(on, {}) |
|
|
| const posts = Fixtures.firstPartySession(on, null) |
|
|
| const { text } = await $.command.run( |
| Fixtures.record(Fixtures.surveyAnswer()), |
| ) |
|
|
| expect(text).toEndWith( |
| '$.telemetry.log: this session has no first-party credential to ' + |
| 'authorize', |
| ) |
|
|
| expect(posts).toEqual([]) |
| }, |
| ) |
|
|
| test( |
| "the ingest's refusal rejects the caller's promise", |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| mock.env(on, {}) |
|
|
| const posts = Fixtures.firstPartySession( |
| on, |
| Fixtures.BEARER, |
| Fixtures.REFUSED, |
| ) |
|
|
| const { text } = await $.command.run( |
| Fixtures.record(Fixtures.surveyAnswer()), |
| ) |
|
|
| expect(text).toEndWith('$.telemetry.log: the ingest answered 500') |
| expect(posts).toHaveLength(1) |
| }, |
| ) |
|
|
| test( |
| 'free text and a malformed entry are refused, nothing sent', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| mock.env(on, {}) |
|
|
| const posts = Fixtures.firstPartySession(on) |
|
|
| const refusalFor = async (entry: unknown) => |
| ( |
| await $.command.run({ |
| ...Fixtures.record(Fixtures.surveyAnswer()), |
| args: JSON.stringify(entry), |
| }) |
| ).text |
|
|
| expect( |
| await refusalFor({ event: 'x', props: { note: 'hello world' } }), |
| ).toEndWith( |
| '$.telemetry.log: props.note: free text is refused; a string is a ' + |
| 'Choice, { value, of: [...] }', |
| ) |
|
|
| expect( |
| await refusalFor({ |
| event: 'x', |
| props: { page: { value: 'elsewhere', of: ['ready', 'later'] } }, |
| }), |
| ).toEndWith( |
| '$.telemetry.log: props.page.value: one of the members of `of`', |
| ) |
|
|
| expect(await refusalFor({ event: 'Survey' })).toEndWith( |
| '$.telemetry.log: takes an event name, a snake_case token', |
| ) |
|
|
| expect( |
| await refusalFor({ event: 'x', props: { 'a path': 1 } }), |
| ).toEndWith('$.telemetry.log: props: every key is a snake_case token') |
|
|
| expect(await refusalFor('x')).toEndWith( |
| '$.telemetry.log: takes one entry, { event, props? }', |
| ) |
|
|
| expect(posts).toEqual([]) |
| }, |
| ) |
|
|
| test( |
| 'a number that is not finite is refused, nothing sent', |
| { |
| plugins: [ |
| { |
| name: 'counting', |
| register(on) { |
| on('command.run', { command: 'count' }, $ => |
| $.telemetry.log({ event: 'x', props: { n: Number.NaN } }).then( |
| () => ({ text: 'sent' }), |
| (error: unknown) => ({ text: String(error) }), |
| ), |
| ) |
| }, |
| }, |
| ], |
| }, |
| async ($, on) => { |
| mock.env(on, {}) |
|
|
| const posts = Fixtures.firstPartySession(on) |
|
|
| const { text } = await $.command.run({ |
| command: 'count', |
| args: '', |
| origin: { kind: 'composer' }, |
| presentation: Fixtures.FULLSCREEN, |
| }) |
|
|
| expect(text).toEndWith('$.telemetry.log: props.n: a number is finite') |
| expect(posts).toEqual([]) |
| }, |
| ) |
|
|
| test( |
| 'a failed authorize is not memoized; a retry sends', |
| { plugins: [Fixtures.recording] }, |
| async ($, on) => { |
| const posts: Args<'http.fetch'>[] = [] |
|
|
| let authorizations = 0 |
|
|
| mock.env(on, {}) |
| on('session.id', () => ({ value: 'the-session' })) |
| on('session.model', () => ({ value: 'the-model' })) |
|
|
| on('session.authorize', () => { |
| authorizations += 1 |
|
|
| const isFirstAuthorization = authorizations === 1 |
|
|
| return isFirstAuthorization |
| ? { deny: 'transient' } |
| : { value: Fixtures.BEARER } |
| }) |
|
|
| on('http.fetch', ($, e) => { |
| posts.push(e) |
|
|
| return { value: Fixtures.ACCEPTED } |
| }) |
|
|
| const first = await $.command.run(Fixtures.record({ event: 'x' })) |
| const postsAfterFirst = posts.length |
| const second = await $.command.run(Fixtures.record({ event: 'x' })) |
|
|
| expect(first.text).toContain('transient') |
| expect(postsAfterFirst).toBe(0) |
| expect(second.text).toBe('sent') |
| expect(posts).toHaveLength(1) |
| }, |
| ) |
| }) |
|
|
