Zakaria
400 lines
17 KiB
TypeScript
400 lines
17 KiB
TypeScript
import {describe, expect, test} from 'bun:test'
|
|
import {AwsLogsAdapter} from './AwsLogsAdapter'
|
|
|
|
/**
|
|
* Stubs the SDK client's `send`, dispatching on the command's constructor name.
|
|
* Matching the real SDK's *name* rather than the wire shape is deliberate — see
|
|
* .claude/memory/aws-sdk-error-names-differ-from-wire-codes.md.
|
|
*/
|
|
function stubClient(handlers: Record<string, (input: Record<string, unknown>) => unknown>) {
|
|
const calls: Array<{command: string; input: Record<string, unknown>}> = []
|
|
const client = {
|
|
async send(command: {constructor: {name: string}; input: Record<string, unknown>}) {
|
|
const name = command.constructor.name
|
|
calls.push({command: name, input: command.input})
|
|
const handler = handlers[name]
|
|
if (!handler) throw new Error(`unexpected command ${name}`)
|
|
return handler(command.input)
|
|
},
|
|
}
|
|
return {client: client as never, calls}
|
|
}
|
|
|
|
describe('AwsLogsAdapter resources', () => {
|
|
test('normalizes log groups as cloud resources', async () => {
|
|
const {client} = stubClient({
|
|
DescribeLogGroupsCommand: () => ({
|
|
logGroups: [{
|
|
logGroupName: '/floci/probe',
|
|
creationTime: 1785260691820,
|
|
arn: 'arn:aws:logs:us-east-1:000000000000:log-group:/floci/probe',
|
|
storedBytes: 0,
|
|
metricFilterCount: 0,
|
|
}],
|
|
}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.list()).resolves.toMatchObject([{
|
|
id: '/floci/probe',
|
|
name: '/floci/probe',
|
|
cloud: 'aws',
|
|
service: 'logs',
|
|
type: 'log-group',
|
|
createdAt: new Date(1785260691820).toISOString(),
|
|
}])
|
|
})
|
|
|
|
// The runtime filters natively by prefix, so `search` must not be a
|
|
// client-side contains — that would silently disagree with the field label.
|
|
test('search is sent as logGroupNamePrefix', async () => {
|
|
const {client, calls} = stubClient({DescribeLogGroupsCommand: () => ({logGroups: []})})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await adapter.list({search: '/floci'})
|
|
|
|
expect(calls[0].input).toMatchObject({logGroupNamePrefix: '/floci'})
|
|
})
|
|
|
|
test('get returns null for a group the runtime does not have', async () => {
|
|
const {client} = stubClient({DescribeLogGroupsCommand: () => ({logGroups: []})})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.get('/nope')).resolves.toBeNull()
|
|
})
|
|
|
|
// DescribeLogGroups is a prefix match, so a longer name starting with the
|
|
// requested one would otherwise be returned as if it were an exact hit.
|
|
test('get matches the name exactly, not by prefix', async () => {
|
|
const {client} = stubClient({
|
|
DescribeLogGroupsCommand: () => ({logGroups: [{logGroupName: '/floci/probe-two', creationTime: 1}]}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.get('/floci/probe')).resolves.toBeNull()
|
|
})
|
|
|
|
test('create and delete issue the right commands', async () => {
|
|
const {client, calls} = stubClient({
|
|
CreateLogGroupCommand: () => ({}),
|
|
DeleteLogGroupCommand: () => ({}),
|
|
DescribeLogGroupsCommand: () => ({logGroups: [{logGroupName: '/floci/new', creationTime: 1}]}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.create({values: {name: '/floci/new'}})).resolves.toMatchObject({id: '/floci/new'})
|
|
await adapter.delete('/floci/new')
|
|
|
|
expect(calls.map((call) => call.command)).toEqual([
|
|
'CreateLogGroupCommand',
|
|
'DescribeLogGroupsCommand',
|
|
'DeleteLogGroupCommand',
|
|
])
|
|
})
|
|
|
|
/**
|
|
* `creationTime` is the field the SDK models and real AWS returns. The
|
|
* local runtime sends `createdTime`, which the SDK deserializer discards —
|
|
* so createdAt is legitimately null against the emulator, and a stub that
|
|
* feeds `createdTime` is testing a shape the SDK can never produce. That
|
|
* mistake shipped here once already; this pins the real contract.
|
|
*/
|
|
test('reads the creation timestamp the SDK actually models', async () => {
|
|
const {client} = stubClient({
|
|
DescribeLogGroupsCommand: () => ({logGroups: [{logGroupName: '/a', creationTime: 1785260691820}]}),
|
|
})
|
|
|
|
await expect(new AwsLogsAdapter(client).list()).resolves.toMatchObject([
|
|
{createdAt: new Date(1785260691820).toISOString()},
|
|
])
|
|
})
|
|
|
|
test('a group with no modelled timestamp reports null rather than a bogus date', async () => {
|
|
const {client} = stubClient({
|
|
DescribeLogGroupsCommand: () => ({logGroups: [{logGroupName: '/a'}]}),
|
|
})
|
|
|
|
await expect(new AwsLogsAdapter(client).list()).resolves.toMatchObject([{createdAt: null}])
|
|
})
|
|
|
|
test('create rejects a blank name before calling the runtime', async () => {
|
|
const {client, calls} = stubClient({})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.create({values: {name: ' '}})).rejects.toThrow()
|
|
expect(calls).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('AwsLogsAdapter queryLogs', () => {
|
|
test('starts a query and maps result fields into row objects', async () => {
|
|
const {client, calls} = stubClient({
|
|
StartQueryCommand: () => ({queryId: 'q-1'}),
|
|
GetQueryResultsCommand: () => ({
|
|
status: 'Complete',
|
|
results: [
|
|
[{field: '@timestamp', value: '2026-01-01 00:00:00.000'}, {field: '@message', value: 'hello'}],
|
|
],
|
|
}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
const result = await adapter.queryLogs('/floci/probe', {
|
|
queryString: 'fields @timestamp, @message',
|
|
startTime: 1000,
|
|
endTime: 2000,
|
|
limit: 20,
|
|
})
|
|
|
|
expect(result).toEqual({
|
|
queryId: 'q-1',
|
|
status: 'Complete',
|
|
rows: [{'@timestamp': '2026-01-01 00:00:00.000', '@message': 'hello'}],
|
|
})
|
|
expect(calls[0]).toMatchObject({
|
|
command: 'StartQueryCommand',
|
|
input: {logGroupName: '/floci/probe', startTime: 1000, endTime: 2000, queryString: 'fields @timestamp, @message', limit: 20},
|
|
})
|
|
expect(calls[1].command).toBe('GetQueryResultsCommand')
|
|
})
|
|
|
|
// FLOCI_SERVICES_CLOUDWATCHLOGS_QUERY_COMPLETION_DELAY_MS defaults to 0, so a
|
|
// real completion normally takes one GetQueryResults call — but a positive
|
|
// delay (or real AWS) makes the first call(s) come back Running, so the
|
|
// adapter must keep polling rather than returning a stale in-progress result.
|
|
test('polls until the query leaves Running/Scheduled', async () => {
|
|
let getCalls = 0
|
|
const {client, calls} = stubClient({
|
|
StartQueryCommand: () => ({queryId: 'q-2'}),
|
|
GetQueryResultsCommand: () => {
|
|
getCalls += 1
|
|
if (getCalls < 3) return {status: getCalls === 1 ? 'Scheduled' : 'Running', results: []}
|
|
return {status: 'Complete', results: [[{field: '@message', value: 'done'}]]}
|
|
},
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
const result = await adapter.queryLogs('/floci/probe', {queryString: 'fields @message', startTime: 0, endTime: 1})
|
|
|
|
expect(result).toEqual({queryId: 'q-2', status: 'Complete', rows: [{'@message': 'done'}]})
|
|
expect(calls.filter((call) => call.command === 'GetQueryResultsCommand')).toHaveLength(3)
|
|
})
|
|
|
|
// The P1 this test pins: if the poll deadline is hit while the query is
|
|
// still Running/Scheduled, the caller must still get the queryId back —
|
|
// dropping it here would make that still-running query unrecoverable, even
|
|
// though Floci (or real AWS) keeps executing it server-side.
|
|
test('still returns the query id when the poll deadline is hit before completion', async () => {
|
|
const {client} = stubClient({
|
|
StartQueryCommand: () => ({queryId: 'q-3'}),
|
|
GetQueryResultsCommand: () => ({status: 'Running', results: []}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client, {timeoutMs: 30, intervalMs: 10})
|
|
|
|
const result = await adapter.queryLogs('/floci/probe', {queryString: 'fields @message', startTime: 0, endTime: 1})
|
|
|
|
expect(result.queryId).toBe('q-3')
|
|
expect(result.status).toBe('Running')
|
|
})
|
|
|
|
test('rejects a blank query string before calling the runtime', async () => {
|
|
const {client, calls} = stubClient({})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.queryLogs('/floci/probe', {queryString: ' ', startTime: 0, endTime: 1}))
|
|
.rejects.toThrow()
|
|
expect(calls).toEqual([])
|
|
})
|
|
|
|
test('raises when the runtime does not hand back a query id', async () => {
|
|
const {client} = stubClient({StartQueryCommand: () => ({})})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.queryLogs('/floci/probe', {queryString: 'fields @message', startTime: 0, endTime: 1}))
|
|
.rejects.toThrow()
|
|
})
|
|
})
|
|
|
|
describe('AwsLogsAdapter filterLogEvents', () => {
|
|
test('filters across streams and preserves event identity and pagination', async () => {
|
|
const {client, calls} = stubClient({
|
|
FilterLogEventsCommand: () => ({
|
|
events: [{eventId: 'event-1', logStreamName: 'stream-a', timestamp: 1785260000000, message: 'ERROR failed', ingestionTime: 1785260001000}],
|
|
nextToken: 'page-2',
|
|
}),
|
|
})
|
|
|
|
const page = await new AwsLogsAdapter(client).filterLogEvents('/floci/probe', {
|
|
filterPattern: 'ERROR',
|
|
logStreamNames: ['stream-a'],
|
|
startTime: 1000,
|
|
endTime: 2000,
|
|
}, {cursor: 'page-1', limit: 25})
|
|
|
|
expect(calls[0]).toMatchObject({command: 'FilterLogEventsCommand', input: {
|
|
logGroupName: '/floci/probe', filterPattern: 'ERROR', logStreamNames: ['stream-a'],
|
|
startTime: 1000, endTime: 2000, nextToken: 'page-1', limit: 25,
|
|
}})
|
|
expect(page).toEqual({
|
|
items: [{
|
|
id: 'event-1', collectionId: 'stream-a', timestamp: new Date(1785260000000).toISOString(),
|
|
body: {message: 'ERROR failed'}, metadata: {ingestionTime: new Date(1785260001000).toISOString()},
|
|
}],
|
|
nextCursor: 'page-2',
|
|
})
|
|
})
|
|
|
|
test('retains a continuation token on an empty page', async () => {
|
|
const {client} = stubClient({FilterLogEventsCommand: () => ({events: [], nextToken: 'keep-going'})})
|
|
await expect(new AwsLogsAdapter(client).filterLogEvents('/floci/probe', {}))
|
|
.resolves.toEqual({items: [], nextCursor: 'keep-going'})
|
|
})
|
|
})
|
|
|
|
describe('AwsLogsAdapter documents', () => {
|
|
test('lists log streams as collections, newest activity first', async () => {
|
|
const {client, calls} = stubClient({
|
|
DescribeLogStreamsCommand: () => ({
|
|
logStreams: [{
|
|
logStreamName: 'stream-a',
|
|
arn: 'arn:aws:logs:us-east-1:000000000000:log-group:/floci/probe:log-stream:stream-a',
|
|
creationTime: 1785260702176,
|
|
storedBytes: 70,
|
|
firstEventTimestamp: 1785260000000,
|
|
lastEventTimestamp: 1785260001000,
|
|
}],
|
|
nextToken: 'page-2',
|
|
}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
const page = await adapter.documents.listCollections('/floci/probe')
|
|
|
|
expect(page).toMatchObject({
|
|
items: [{id: 'stream-a', name: 'stream-a', parentId: '/floci/probe'}],
|
|
nextCursor: 'page-2',
|
|
})
|
|
expect(calls[0].input).toMatchObject({
|
|
logGroupName: '/floci/probe',
|
|
orderBy: 'LastEventTime',
|
|
descending: true,
|
|
})
|
|
})
|
|
|
|
/**
|
|
* Real AWS caps DescribeLogStreams Limit at 50 and rejects anything higher
|
|
* with a ValidationException. The SPI defaults to 100 and permits 1000, and
|
|
* the local runtime does not enforce the cap — so an unclamped value passes
|
|
* every local test and 400s in production. Encode the provider's rule.
|
|
*/
|
|
test('clamps the stream page size to the AWS maximum of 50', async () => {
|
|
const {client, calls} = stubClient({DescribeLogStreamsCommand: () => ({logStreams: []})})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await adapter.documents.listCollections('/floci/probe')
|
|
await adapter.documents.listCollections('/floci/probe', {limit: 1000})
|
|
await adapter.documents.listCollections('/floci/probe', {limit: 25})
|
|
|
|
expect(calls.map((call) => call.input.limit)).toEqual([50, 50, 25])
|
|
})
|
|
|
|
test('reads log events as items, oldest first', async () => {
|
|
const {client, calls} = stubClient({
|
|
GetLogEventsCommand: () => ({
|
|
events: [
|
|
{timestamp: 1785260000000, message: 'hello one', ingestionTime: 1785260702192},
|
|
{timestamp: 1785260001000, message: 'hello two', ingestionTime: 1785260702192},
|
|
],
|
|
nextForwardToken: 'f/2',
|
|
nextBackwardToken: 'b/0',
|
|
}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
const page = await adapter.documents.listItems('/floci/probe', 'stream-a')
|
|
|
|
// Real AWS gives events no id, so it is derived from timestamp and
|
|
// position. Two events sharing a millisecond still get distinct ids.
|
|
expect(page.items).toMatchObject([
|
|
{
|
|
id: '1785260000000-0',
|
|
collectionId: 'stream-a',
|
|
timestamp: new Date(1785260000000).toISOString(),
|
|
body: {message: 'hello one'},
|
|
},
|
|
{id: '1785260001000-1', collectionId: 'stream-a'},
|
|
])
|
|
expect(page.nextCursor).toBe('f/2')
|
|
// Without startFromHead the runtime returns the newest page, so paging
|
|
// forward from a fresh cursor would skip the history.
|
|
expect(calls[0].input).toMatchObject({startFromHead: true})
|
|
})
|
|
|
|
/**
|
|
* The termination rule. GetLogEvents echoes the supplied token back when
|
|
* there is nothing further, so a cursor loop that trusts a non-null token
|
|
* never ends. Verified against the runtime on 2026-07-28.
|
|
*/
|
|
test('stops paging when the runtime echoes the cursor back', async () => {
|
|
const {client} = stubClient({
|
|
GetLogEventsCommand: () => ({events: [], nextForwardToken: 'f/2', nextBackwardToken: 'b/2'}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
const page = await adapter.documents.listItems('/floci/probe', 'stream-a', {cursor: 'f/2'})
|
|
|
|
expect(page.items).toEqual([])
|
|
expect(page.nextCursor).toBeNull()
|
|
})
|
|
|
|
test('an empty first page terminates too', async () => {
|
|
const {client} = stubClient({
|
|
GetLogEventsCommand: () => ({events: [], nextForwardToken: 'f/0', nextBackwardToken: 'b/0'}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.documents.listItems('/floci/probe', 'stream-a')).resolves.toMatchObject({nextCursor: null})
|
|
})
|
|
|
|
test('creates and deletes a log stream', async () => {
|
|
const {client, calls} = stubClient({
|
|
CreateLogStreamCommand: () => ({}),
|
|
DeleteLogStreamCommand: () => ({}),
|
|
DescribeLogStreamsCommand: () => ({
|
|
logStreams: [{logStreamName: 'stream-b', creationTime: 1785260702176}],
|
|
}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.documents.createCollection!('/floci/probe', {values: {name: 'stream-b'}}))
|
|
.resolves.toMatchObject({id: 'stream-b', parentId: '/floci/probe'})
|
|
await adapter.documents.deleteCollection!('/floci/probe', 'stream-b')
|
|
|
|
expect(calls.map((call) => call.command)).toEqual([
|
|
'CreateLogStreamCommand',
|
|
'DescribeLogStreamsCommand',
|
|
'DeleteLogStreamCommand',
|
|
])
|
|
})
|
|
|
|
// Provider behaviour, verified: a missing group raises, a missing stream
|
|
// returns an empty page. The contract mirrors that rather than smoothing it.
|
|
test('a missing stream yields an empty page rather than an error', async () => {
|
|
const {client} = stubClient({
|
|
GetLogEventsCommand: () => ({events: [], nextForwardToken: 'f/0', nextBackwardToken: 'b/0'}),
|
|
})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
await expect(adapter.documents.listItems('/floci/probe', 'nope')).resolves.toEqual({items: [], nextCursor: null})
|
|
})
|
|
|
|
test('the store advertises no item writes', () => {
|
|
const {client} = stubClient({})
|
|
const adapter = new AwsLogsAdapter(client)
|
|
|
|
expect(adapter.documents.putItem).toBeUndefined()
|
|
expect(adapter.documents.deleteItem).toBeUndefined()
|
|
expect(adapter.documents.queryItems).toBeUndefined()
|
|
})
|
|
})
|