@contember/engine-actions 2.2.0-alpha.2 → 2.2.0-alpha.4

package/tests/cases/unit/variablesManager.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from 'bun:test'
+import { createConnectionMock, ExpectedQuery } from '@contember/database-tester'
+import { DatabaseContext, DatabaseContextFactory } from '@contember/engine-system-api'
+import { VariablesManager } from '../../../src/model/VariablesManager.js'
+import { testUuid } from '../../src/uuid.js'
+
+const selectVariables = (rows: { name: string; value: string }[]): ExpectedQuery => ({
+	sql: 'select * from "system"."actions_variable"',
+	parameters: [],
+	response: { rows },
+})
+
+const transaction = (...queries: ExpectedQuery[]): ExpectedQuery[] => [
+	{ sql: 'BEGIN;', response: { rowCount: 1 } },
+	{ sql: 'SET TRANSACTION ISOLATION LEVEL REPEATABLE READ', response: { rowCount: 1 } },
+	...queries,
+	{ sql: 'COMMIT;', response: { rowCount: 1 } },
+]
+
+const createDb = (queries: ExpectedQuery[]): DatabaseContext =>
+	new DatabaseContextFactory('system', { uuid: () => testUuid(1) }).create(createConnectionMock(queries))
+
+describe('variables from the environment', () => {
+	test('a project-scoped env variable overrides a stored row', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb([selectVariables([{ name: 'API_KEY', value: 'from-db' }])])
+
+		expect(await manager.fetchVariables(db, 'my-project')).toEqual({ API_KEY: 'from-env' })
+	})
+
+	test('a project-scoped env variable works without any stored row', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb([selectVariables([])])
+
+		expect(await manager.fetchVariables(db, 'my-project')).toEqual({ API_KEY: 'from-env' })
+	})
+
+	test('the shared DEFAULT_ value applies to every project, the project-scoped one wins', async () => {
+		const manager = new VariablesManager({
+			DEFAULT_ACTIONS_VARIABLE_API_KEY: 'shared',
+			DEFAULT_ACTIONS_VARIABLE_BASE_URL: 'https://example.com',
+			MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'mine',
+		})
+		const db = createDb([selectVariables([])])
+
+		expect(await manager.fetchVariables(db, 'my-project')).toEqual({
+			API_KEY: 'mine',
+			BASE_URL: 'https://example.com',
+		})
+	})
+
+	test('another project and unrelated env variables are ignored', async () => {
+		const manager = new VariablesManager({
+			OTHER_ACTIONS_VARIABLE_API_KEY: 'not-mine',
+			MY_PROJECT_ACTIONS_VARIABLE_: 'no-name',
+			MY_PROJECT_ACTIONS_VARIABLE_BLANK: '',
+			CONTEMBER_ROOT_TOKEN: 'unrelated',
+		})
+		const db = createDb([selectVariables([{ name: 'API_KEY', value: 'from-db' }])])
+
+		expect(await manager.fetchVariables(db, 'my-project')).toEqual({ API_KEY: 'from-db' })
+	})
+
+	test('a stored variable is unaffected when the environment supplies nothing', async () => {
+		const manager = new VariablesManager({})
+		const db = createDb([selectVariables([{ name: 'API_KEY', value: 'from-db' }, { name: 'baseUrl', value: 'http://localhost' }])])
+
+		expect(await manager.fetchVariables(db, 'my-project')).toEqual({ API_KEY: 'from-db', baseUrl: 'http://localhost' })
+	})
+
+	test('listing reports where each value comes from, sorted by name', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb([selectVariables([{ name: 'API_KEY', value: 'from-db' }, { name: 'baseUrl', value: 'http://localhost' }])])
+
+		expect(await manager.listVariables(db, 'my-project')).toEqual([
+			{ name: 'API_KEY', value: null, source: 'ENVIRONMENT' },
+			{ name: 'baseUrl', value: 'http://localhost', source: 'DATABASE' },
+		])
+	})
+
+	test('listing never returns an environment value, not even the one it shadows', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb([selectVariables([{ name: 'API_KEY', value: 'from-db' }])])
+
+		const listed = JSON.stringify(await manager.listVariables(db, 'my-project'))
+		expect(listed).not.toContain('from-env')
+		expect(listed).not.toContain('from-db')
+	})
+
+	test('a stored variable named after an Object prototype member is still listed and writable', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb([selectVariables([{ name: 'toString', value: 'from-db' }])])
+
+		expect(await manager.listVariables(db, 'my-project')).toEqual([
+			{ name: 'API_KEY', value: null, source: 'ENVIRONMENT' },
+			{ name: 'toString', value: 'from-db', source: 'DATABASE' },
+		])
+	})
+})
+
+describe('setVariables', () => {
+	test('rejects a name supplied by the environment without touching the database', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb([])
+
+		await expect(manager.setVariables(db, { variables: [{ name: 'API_KEY', value: 'attempted' }] }, 'my-project')).rejects.toThrow(
+			'Variables supplied by the environment are read-only: API_KEY',
+		)
+	})
+
+	test('does not mistake an Object prototype member for an environment variable', async () => {
+		const manager = new VariablesManager({})
+		const db = createDb(transaction(
+			selectVariables([]),
+			{
+				sql:
+					'insert into "system"."actions_variable" ("id", "name", "value") values (?, ?, ?) on conflict ("name") do update set "value" = ?, "updated_at" = NOW()',
+				parameters: [testUuid(1), 'toString', 'plain', 'plain'],
+				response: { rowCount: 1 },
+			},
+		))
+
+		await manager.setVariables(db, { variables: [{ name: 'toString', value: 'plain' }] }, 'my-project')
+	})
+
+	test('writes a variable the environment does not supply', async () => {
+		const manager = new VariablesManager({ MY_PROJECT_ACTIONS_VARIABLE_API_KEY: 'from-env' })
+		const db = createDb(transaction(
+			selectVariables([]),
+			{
+				sql:
+					'insert into "system"."actions_variable" ("id", "name", "value") values (?, ?, ?) on conflict ("name") do update set "value" = ?, "updated_at" = NOW()',
+				parameters: [testUuid(1), 'baseUrl', 'http://localhost', 'http://localhost'],
+				response: { rowCount: 1 },
+			},
+		))
+
+		await manager.setVariables(db, { variables: [{ name: 'baseUrl', value: 'http://localhost' }] }, 'my-project')
+	})
+
+	test('SET mode drops the stored rows that are not submitted', async () => {
+		const manager = new VariablesManager({})
+		const db = createDb(transaction(
+			selectVariables([{ name: 'baseUrl', value: 'http://localhost' }, { name: 'stale', value: 'gone' }]),
+			{
+				sql: 'delete from "system"."actions_variable" where "name" in (?)',
+				parameters: ['stale'],
+				response: { rowCount: 1 },
+			},
+		))
+
+		await manager.setVariables(db, { variables: [{ name: 'baseUrl', value: 'http://localhost' }], mode: 'SET' }, 'my-project')
+	})
+})

package/tests/cases/unit/webhookHandler.test.ts

@@ -2,37 +2,16 @@ import { describe, expect, test } from 'bun:test'
 import { WebhookTargetHandler } from '../../../src/dispatch/WebhookTargetHandler.js'
 import { FetcherResponse } from '../../../src/dispatch/WebhookFetcher.js'
 import { createLogger, Logger, TestLoggerHandler } from '@contember/logger'
-import { EventRow } from '../../../src/model/types.js'
-import { Actions, ActionsPayload } from '@contember/schema'
+import { Actions } from '@contember/schema'
 import { HandledEvent } from '../../../src/dispatch/types.js'
 import { testUuid } from '../../src/uuid.js'
+import { createTestEvent, testEventTime } from '../../src/event.js'
 
 const assert = {
 	equal: (a: any, b: any) => expect(a).toEqual(b),
 	deepStrictEqual: (a: any, b: any) => expect(a).toStrictEqual(b),
 }
-const now = new Date('2024-06-20T12:00:00Z')
-const createTestEvent = (i = 0, row: Partial<EventRow> = {}): EventRow => ({
-	created_at: now,
-	id: testUuid(i * 10 + 1),
-	trigger: 'test',
-	target: 'test_target',
-	last_state_change: now,
-	log: [],
-	num_retries: 0,
-	resolved_at: null,
-	transaction_id: testUuid(i * 10 + 2),
-	stage_id: testUuid(i * 10 + 3),
-	visible_at: now,
-	payload: { foo: 'bar' } as unknown as ActionsPayload.AnyEventPayload,
-	priority: 1,
-	schema_id: 1,
-	state: 'created',
-	identity_id: testUuid(i * 10 + 4),
-	ip_address: '127.0.0.1',
-	user_agent: 'test-agent',
-	...row,
-})
+const now = testEventTime
 
 const dropDuration = (events: HandledEvent[]): HandledEvent[] => {
 	return events.map(it => ({ ...it, result: { ...it.result, durationMs: -1 } }))
@@ -208,6 +187,7 @@ describe('webhook response', () => {
 				},
 			},
 		])
+		assert.deepStrictEqual(testLoggerHandler.messages, [])
 	})
 
 	test('error response', async () => {
@@ -269,6 +249,17 @@ describe('webhook response', () => {
 				},
 			},
 		])
+
+		const warnings = testLoggerHandler.messages.filter(it => it.level.name === 'warn')
+		assert.equal(warnings.length, 1)
+		assert.equal(warnings[0].message, 'Webhook target responded with an error status')
+		// exact match: neither the URL nor the headers may end up in the log
+		assert.deepStrictEqual(warnings[0].ownAttributes, {
+			target: 'test_target',
+			status: 500,
+			statusText: 'Err',
+			events: [event1.id, event2.id],
+		})
 	})
 
 	test('invalid partial response', async () => {
@@ -330,6 +321,60 @@ describe('webhook response', () => {
 				},
 			},
 		])
+
+		const warnings = testLoggerHandler.messages.filter(it => it.level.name === 'warn')
+		assert.equal(warnings.length, 1)
+		assert.equal(warnings[0].message, 'Webhook target returned a malformed response')
+		// exact match: the parser message quotes the payload and must not reach the log
+		assert.deepStrictEqual(warnings[0].ownAttributes, {
+			target: 'test_target',
+			status: 200,
+			events: [event1.id, event2.id],
+		})
+	})
+
+	test('response naming events outside the batch', async () => {
+		const testLoggerHandler = new TestLoggerHandler()
+		const logger = createLogger(testLoggerHandler)
+
+		const webhookHandler = new WebhookTargetHandler({
+			fetch(): Promise<FetcherResponse> {
+				return Promise.resolve({
+					ok: true,
+					headers: new Headers([['content-type', 'application/json']]),
+					responseText: `{"failures": [{"eventId": "${testUuid(999)}"}]}`,
+					status: 200,
+					statusText: 'OK',
+				})
+			},
+		})
+
+		const target: Actions.AnyTarget = {
+			name: 'test_target',
+			type: 'webhook',
+			url: 'http://localhost',
+		}
+
+		const event1 = createTestEvent(0)
+		const event2 = createTestEvent(1)
+		const result = await webhookHandler.handle({
+			logger,
+			target: target,
+			events: [event1, event2],
+			variables: {},
+		})
+		assert.equal(result.every(it => !it.result.ok), true)
+
+		const warnings = testLoggerHandler.messages.filter(it => it.level.name === 'warn')
+		assert.equal(warnings.length, 1)
+		assert.equal(warnings[0].message, 'Webhook target reported failures for event ids outside the batch')
+		// exact match: the unknown ids are strings the target chose, only their count may be logged
+		assert.deepStrictEqual(warnings[0].ownAttributes, {
+			target: 'test_target',
+			status: 200,
+			unknownEventIds: 1,
+			events: [event1.id, event2.id],
+		})
 	})
 
 	test('ignored invalid response', async () => {
@@ -387,6 +432,7 @@ describe('webhook response', () => {
 				},
 			},
 		])
+		assert.deepStrictEqual(testLoggerHandler.messages, [])
 	})
 
 	test('partially successful response', async () => {
@@ -445,5 +491,15 @@ describe('webhook response', () => {
 				},
 			},
 		])
+
+		const warnings = testLoggerHandler.messages.filter(it => it.level.name === 'warn')
+		assert.equal(warnings.length, 1)
+		assert.equal(warnings[0].message, 'Webhook target reported failed events')
+		// exact match: only the events the target rejected, never the reasons it gave
+		assert.deepStrictEqual(warnings[0].ownAttributes, {
+			target: 'test_target',
+			status: 200,
+			events: [event1.id],
+		})
 	})
 })

package/tests/src/event.ts

@@ -0,0 +1,27 @@
+import { ActionsPayload } from '@contember/schema'
+import { EventRow } from '../../src/model/types.js'
+import { testUuid } from './uuid.js'
+
+export const testEventTime = new Date('2024-06-20T12:00:00Z')
+
+export const createTestEvent = (i = 0, row: Partial<EventRow> = {}): EventRow => ({
+	created_at: testEventTime,
+	id: testUuid(i * 10 + 1),
+	trigger: 'test',
+	target: 'test_target',
+	last_state_change: testEventTime,
+	log: [],
+	num_retries: 0,
+	resolved_at: null,
+	transaction_id: testUuid(i * 10 + 2),
+	stage_id: testUuid(i * 10 + 3),
+	visible_at: testEventTime,
+	payload: { foo: 'bar' } as unknown as ActionsPayload.AnyEventPayload,
+	priority: 1,
+	schema_id: 1,
+	state: 'created',
+	identity_id: testUuid(i * 10 + 4),
+	ip_address: '127.0.0.1',
+	user_agent: 'test-agent',
+	...row,
+})